import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import assert from "node:assert/strict";
import test, { type TestContext } from "node:test";
import {
  canonicalJsonBytes,
  canonicalZipBytes,
  BASE_LIMITS,
  computeSceneRevision,
  DuplicateKeyError,
  parseCanonicalJson,
  parseStrictJson,
  preflightAggregateCompressionRatio,
  preflightArchiveMemberSizes,
  preflightGlb,
  preflightGlbCounts,
  preflightInputArchiveSize,
  preflightMemberCompressionRatio,
  preflightZipBytes,
  profileCross,
  profileF32Bits,
  profileNormalize,
  issue,
  report,
  sha256,
  validateConnectorBinding,
  validateEntityAsset,
  validateNormalizedProduct,
  validatePresentation,
  validateSceneManifest,
  validateScenePackage,
  computePackageBudgetTotals,
  jsonResourceIssues,
  packageBudgetIssues,
  resourceCountIssues,
  withSceneRevision,
  type SceneResourceLimits,
} from "../src/index.js";
import { validateSceneSchema, validateSchemaPointer, type SchemaArtifact } from "../src/schema.js";
import {
  applySceneFieldCase,
  corpusBlobs,
  sceneShapeFacts,
  type ExpectedIssue,
  type PackageCase,
  type SceneFieldCase,
  type SceneShapeCase,
} from "./corpus-support.js";

interface ValidationCase { name: string; valid: boolean; expected: ExpectedIssue | null; payload_base64: string }
interface GlbCase { name: string; valid: boolean; error: string | null; expected_kind: "triangle" | "line"; kind: "triangle" | "line" | null; payload_base64: string }
interface ZipCase { name: string; valid: boolean; error: string | null; used_deflate: boolean | null; payload_base64: string }
interface NumericVector { name: string; operation: "f32" | "cross" | "normalize"; input_bits: string[] | string[][]; expected_bits?: string | string[]; error?: string; valid: boolean }
interface ResourceCase { name: string; operation: string; parameters: Record<string, unknown>; valid: boolean; error?: string | null; expected?: ExpectedIssue | null }
interface Artifact { base64: string; sha256: string; uri?: string; revision?: string }
interface RevisionVector { name: string; canonical_base64: string; draft_base64: string; revision: string; sha256: string }
interface SchemaMutation { operation: "delete" | "set"; path: (string | number)[]; value?: unknown }
interface SchemaFieldMatrix {
  artifact: SchemaArtifact;
  base: Record<string, unknown>;
  cases: { mutations: SchemaMutation[]; name: string; valid: boolean }[];
  schema_pointer: string;
  variant: string;
}
interface Corpus {
  format_version: string;
  artifacts: Record<string, Artifact>;
  blobs: Record<string, string>;
  jcs_vectors: { name: string; input: unknown; canonical_base64: string; sha256: string }[];
  manifest_cases: ValidationCase[];
  entity_cases: ValidationCase[];
  presentation_cases: ValidationCase[];
  connector_binding_cases: ValidationCase[];
  normalized_product_cases: ValidationCase[];
  package_cases: PackageCase[];
  glb_cases: GlbCase[];
  numeric_vectors: NumericVector[];
  resource_cases: ResourceCase[];
  resource_limits: Record<string, number>;
  revision_vectors: RevisionVector[];
  scene_field_cases: SceneFieldCase[];
  scene_shape_cases: SceneShapeCase[];
  schema_field_matrices: SchemaFieldMatrix[];
  zip_cases: ZipCase[];
}

const here = dirname(fileURLToPath(import.meta.url));
const corpusPath = resolve(here, "../../../test/fixtures/scene-contract/corpus.json");
const corpus = parseStrictJson(readFileSync(corpusPath)) as Corpus;
const decode = (value: string) => Buffer.from(value, "base64");

test("shared corpus has every Scene 1.0 parity section", () => {
  assert.equal(corpus.format_version, "1.0");
  for (const section of [
    corpus.jcs_vectors,
    corpus.manifest_cases,
    corpus.entity_cases,
    corpus.presentation_cases,
    corpus.connector_binding_cases,
    corpus.normalized_product_cases,
    corpus.package_cases,
    corpus.glb_cases,
    corpus.numeric_vectors,
    corpus.resource_cases,
    corpus.revision_vectors,
    corpus.scene_field_cases,
    corpus.scene_shape_cases,
    corpus.schema_field_matrices,
    corpus.zip_cases,
  ]) assert.ok(section.length > 0);
});

function applySchemaMutations(base: Record<string, unknown>, mutations: SchemaMutation[]): Record<string, unknown> {
  const result = structuredClone(base);
  for (const mutation of mutations) {
    let current: Record<string | number, unknown> = result;
    for (const part of mutation.path.slice(0, -1)) current = current[part] as Record<string | number, unknown>;
    const field = mutation.path.at(-1)!;
    if (mutation.operation === "delete") delete current[field];
    else current[field] = structuredClone(mutation.value);
  }
  return result;
}

test("all closed schema records and discriminator variants replay shared field matrices", async (context) => {
  for (const matrix of corpus.schema_field_matrices) await context.test(
    `${matrix.artifact}:${matrix.schema_pointer}:${matrix.variant}`,
    async (matrixContext) => {
      for (const item of matrix.cases) await matrixContext.test(item.name, () => {
        const value = applySchemaMutations(matrix.base, item.mutations);
        assert.equal(validateSchemaPointer(matrix.artifact, matrix.schema_pointer, value), item.valid);
      });
    },
  );
});

test("shared positive case names cannot drift to negative expectations", () => {
  const positiveNames: string[] = [];
  for (const [sectionName, value] of Object.entries(corpus)) {
    if (!Array.isArray(value)) continue;
    for (const item of value) {
      if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
      const record = item as Record<string, unknown>;
      if (
        typeof record.name !== "string"
        || (!record.name.startsWith("valid_") && record.name !== "nullable_fields_nonnull")
      ) continue;
      const label = `${sectionName}:${record.name}`;
      positiveNames.push(label);
      assert.equal(record.valid, true, label);
      if (Object.hasOwn(record, "expected")) assert.equal(record.expected, null, label);
      if (Object.hasOwn(record, "error")) assert.equal(record.error, null, label);
    }
  }
  assert.equal(positiveNames.length, 30);
});

test("strict JSON rejects duplicate keys and protects ordinary object semantics", () => {
  assert.throws(() => parseStrictJson(Buffer.from('{"a":1,"a":2}')), DuplicateKeyError);
  const value = parseStrictJson(Buffer.from('{"__proto__":{"polluted":true}}')) as Record<string, unknown>;
  assert.equal(Object.hasOwn(value, "__proto__"), true);
  assert.equal(({} as { polluted?: boolean }).polluted, undefined);
});

test("canonical JSON accepts finite numbers and rejects non-finite numbers", () => {
  assert.equal(canonicalJsonBytes(1e30).toString("utf8"), "1e+30");
  for (const value of [Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]) {
    assert.throws(() => canonicalJsonBytes(value), /finite/);
  }
  assert.equal(canonicalJsonBytes(1.25).toString("utf8"), "1.25");
});

test("strict parsing accepts valid noncanonical JSON while canonical parsing rejects it", () => {
  const bytes = Buffer.from('{"b":1, "a":2}');
  assert.equal((parseStrictJson(bytes) as Record<string, unknown>).a, 2);
  assert.throws(() => parseCanonicalJson(bytes), /canonical/);
});

test("public validator resource overflows remain budget issues", () => {
  const scene = validScene();
  const sceneBytes = canonicalJsonBytes(scene);
  const collectionResult = validateSceneManifest(scene, { ...BASE_LIMITS, definitions: 0 });
  const serializedResult = validateSceneManifest(scene, {
    ...BASE_LIMITS,
    scene_json_bytes: sceneBytes.length - 1,
  });

  assert.deepEqual(
    collectionResult.firstError === null
      ? null
      : [collectionResult.firstError.code, collectionResult.firstError.phase, collectionResult.firstError.path],
    ["resource_limit_exceeded", "budget", "/definitions"],
  );
  assert.deepEqual(
    serializedResult.firstError === null
      ? null
      : [serializedResult.firstError.code, serializedResult.firstError.phase, serializedResult.firstError.path],
    ["resource_limit_exceeded", "budget", ""],
  );
});

test("reports are deterministic by phase, UTF-8 rule ID, and UTF-8 pointer", () => {
  const result = report([
    issue("z", "/b", "later path", "semantic"),
    issue("a", "/z", "later code", "semantic"),
    issue("a", "/a", "earlier pointer", "semantic"),
    issue("z", "/z", "structure first", "structure"),
    issue("a", "/a", "duplicate is ignored", "semantic"),
  ]);
  assert.deepEqual(
    result.issues.map(({ phase, code, path }) => [phase, code, path]),
    [
      ["structure", "z", "/z"],
      ["semantic", "a", "/a"],
      ["semantic", "a", "/z"],
      ["semantic", "z", "/b"],
    ],
  );
});

test("RFC 8785 vectors reproduce exact bytes and hashes", async (context) => {
  for (const vector of corpus.jcs_vectors) await context.test(vector.name, () => {
    const canonical = canonicalJsonBytes(vector.input);
    assert.deepEqual(canonical, decode(vector.canonical_base64));
    assert.equal(sha256(canonical), vector.sha256);
  });
});

test("scene artifact revision and content hash are exact", () => {
  const bytes = decode(corpus.artifacts.scene.base64);
  const scene = parseStrictJson(bytes) as Record<string, unknown>;
  assert.equal(computeSceneRevision(scene), corpus.artifacts.scene.revision);
  assert.equal(sha256(bytes), corpus.artifacts.scene.sha256);
});

test("all manifest cases match validity and expected first issue", async (context) => {
  for (const item of corpus.manifest_cases) await context.test(item.name, () => {
    const result = validateSceneManifest(decode(item.payload_base64));
    assert.equal(result.valid, item.valid);
    if (item.expected !== null) {
      assert.equal(result.firstError?.code, item.expected.code);
      assert.equal(result.firstError?.path, item.expected.path);
    }
  });
});

test("all entity cases match validity and expected first issue", async (context) => {
  for (const item of corpus.entity_cases) await context.test(item.name, () => {
    const result = validateEntityAsset(decode(item.payload_base64));
    assert.equal(result.valid, item.valid);
    if (item.expected !== null) {
      assert.equal(result.firstError?.code, item.expected.code);
      assert.equal(result.firstError?.path, item.expected.path);
    }
  });
});

async function assertValidationCases(
  context: TestContext,
  cases: ValidationCase[],
  validate: (value: unknown) => ReturnType<typeof validateSceneManifest>,
): Promise<void> {
  for (const item of cases) await context.test(item.name, () => {
    const result = validate(decode(item.payload_base64));
    assert.equal(result.valid, item.valid);
    if (item.expected !== null) {
      assert.equal(result.firstError?.code, item.expected.code);
      assert.equal(result.firstError?.path, item.expected.path);
    }
  });
}

test("all presentation cases match validity and expected first issue", async (context) => {
  await assertValidationCases(context, corpus.presentation_cases, validatePresentation);
});

test("all connector binding cases match validity and expected first issue", async (context) => {
  await assertValidationCases(context, corpus.connector_binding_cases, validateConnectorBinding);
});

test("all normalized product cases match validity and expected first issue", async (context) => {
  await assertValidationCases(context, corpus.normalized_product_cases, validateNormalizedProduct);
});

test("presentation rejects a non-rigid camera transform", () => {
  const valid = corpus.presentation_cases.find((item) => item.valid);
  assert.ok(valid !== undefined);
  const presentation = asRecord(parseStrictJson(decode(valid.payload_base64)));
  const camera = asRecords(presentation.cameras)[0];
  asRecord(camera.transform).x_axis = [2, 0, 0];
  const result = validatePresentation(presentation);
  assert.equal(result.firstError?.code, "transform_invalid");
  assert.equal(result.firstError?.path, "/cameras/0/transform");
});

function artifactBlobs(): Map<string, Buffer> {
  const result = new Map<string, Buffer>();
  for (const artifact of Object.values(corpus.artifacts)) {
    if (artifact.uri !== undefined) result.set(artifact.uri, decode(artifact.base64));
  }
  return result;
}

type JsonRecord = Record<string, unknown>;

function asRecord(value: unknown): JsonRecord {
  assert.ok(value !== null && typeof value === "object" && !Array.isArray(value));
  return value as JsonRecord;
}

function asRecords(value: unknown): JsonRecord[] {
  assert.ok(Array.isArray(value));
  return value.map(asRecord);
}

function validScene(): JsonRecord {
  return asRecord(parseStrictJson(decode(corpus.artifacts.scene.base64)));
}

function validEntities(): JsonRecord {
  return asRecord(parseStrictJson(decode(corpus.artifacts.entities.base64)));
}

function operationSource(path: string, callText: string): JsonRecord {
  const source: JsonRecord = {
    schema_version: "1.0",
    path,
    path_kind: "project_relative",
    line: 1,
    column: 7,
    end_line: 1,
    end_column: 7 + Array.from(callText).length,
    call_text: callText,
    callsite_id: "",
    assignment_targets: ["body"],
  };
  const material = [
    source.path,
    source.line,
    source.column,
    source.end_line,
    source.end_column,
    source.call_text,
  ].map(String).join("\x1f");
  source.callsite_id = `callsite_${sha256(Buffer.from(material, "utf8")).slice("sha256:".length, "sha256:".length + 16)}`;
  return source;
}

function embeddedSourcePackage(): {
  blobs: Map<string, Buffer>;
  manifest: JsonRecord;
  model: JsonRecord;
  sourcePath: string;
  sourceUri: string;
} {
  const scene = validScene();
  const sidecar = validEntities();
  makeModelScene(scene, sidecar, "shape");

  const definition = asRecords(scene.definitions)[0];
  const definitionId = "definition/root/shape/model/graph/node/0";
  definition.definition_id = definitionId;
  asRecords(scene.nodes)[0].definition_id = definitionId;
  sidecar.definition_id = definitionId;

  const callText = "scad.make_box_rsolid(width=1)";
  const sourcePath = "models/box.py";
  const sourceUri = `sources/${sourcePath}`;
  const sourceBytes = Buffer.from(`body = ${callText}\n`, "utf8");
  const model: JsonRecord = {
    schema_version: "2.0",
    graph: {
      graph_id: "graph",
      nodes: [{
        node_id: "node",
        op: "make_box_rsolid",
        params: { width: 1 },
        inputs: [],
        output_count: 1,
        source: operationSource(sourcePath, callText),
      }],
    },
    leaf_ids: ["node"],
  };
  const modelBytes = canonicalJsonBytes(model);
  scene.source = {
    kind: "model",
    graph_id: "graph",
    model_schema_version: "2.0",
    artifact_hash: sha256(modelBytes),
    embedded_artifact_uri: "model/model.json",
    embedded_artifact_byte_length: modelBytes.length,
    source_files: [{
      path: sourcePath,
      uri: sourceUri,
      media_type: "text/x-python; charset=utf-8",
      byte_length: sourceBytes.length,
      content_hash: sha256(sourceBytes),
    }],
  };
  asRecord(scene.compile_options).embed_source = true;
  const replaced = replaceEntitySidecar(scene, sidecar);
  replaced.blobs.set("model/model.json", modelBytes);
  replaced.blobs.set(sourceUri, sourceBytes);
  scene.revision = computeSceneRevision(scene);
  return { blobs: replaced.blobs, manifest: scene, model, sourcePath, sourceUri };
}

function replaceEmbeddedModel(
  fixture: ReturnType<typeof embeddedSourcePackage>,
): void {
  const payload = canonicalJsonBytes(fixture.model);
  fixture.blobs.set("model/model.json", payload);
  const source = asRecord(fixture.manifest.source);
  source.artifact_hash = sha256(payload);
  source.embedded_artifact_byte_length = payload.length;
  fixture.manifest.revision = computeSceneRevision(fixture.manifest);
}

function replaceEntitySidecar(
  scene: JsonRecord,
  sidecar: JsonRecord,
): { manifest: Buffer; blobs: Map<string, Buffer>; entityUri: string } {
  const entityBytes = canonicalJsonBytes(sidecar);
  const entityHash = sha256(entityBytes);
  const entityUri = `entities/sha256-${entityHash.slice("sha256:".length)}.json`;
  const entityRecord = asRecords(scene.entity_assets)[0];
  const oldUri = entityRecord.uri as string;
  Object.assign(entityRecord, {
    byte_length: entityBytes.length,
    content_hash: entityHash,
    entity_asset_id: entityHash,
    uri: entityUri,
  });
  asRecords(scene.definitions)[0].entity_asset_id = entityHash;
  scene.revision = computeSceneRevision(scene);
  const blobs = artifactBlobs();
  blobs.delete(oldUri);
  blobs.set(entityUri, entityBytes);
  return { manifest: canonicalJsonBytes(scene), blobs, entityUri };
}

function entityIndex(sidecar: JsonRecord, kind: string): number {
  const index = asRecords(sidecar.entities).findIndex((entity) => entity.kind === kind);
  assert.notEqual(index, -1);
  return index;
}

function assertFirstIssue(
  result: ReturnType<typeof validateSceneManifest>,
  code: string,
  path: string,
): void {
  assert.equal(result.valid, false);
  assert.equal(result.firstError?.code, code);
  assert.equal(result.firstError?.path, path);
}

test("scene semantic references and content identities reject independent mutations", async (context) => {
  const missingHash = `sha256:${"f".repeat(64)}`;
  const cases: [string, (scene: JsonRecord) => void, string, string][] = [
    ["missing definition appearance", (scene) => {
      asRecords(scene.definitions)[0].appearance_id = `appearance/evaluated/${"f".repeat(64)}`;
    }, "reference_missing", "/definitions/0/appearance_id"],
    ["missing definition geometry asset", (scene) => {
      asRecords(scene.definitions)[0].geometry_asset_id = missingHash;
    }, "reference_missing", "/definitions"],
    ["missing node appearance override", (scene) => {
      asRecords(scene.nodes)[0].appearance_override_id = `appearance/evaluated/${"f".repeat(64)}`;
    }, "reference_missing", "/nodes/0/appearance_override_id"],
    ["geometry asset ID differs from content hash", (scene) => {
      asRecords(scene.geometry_assets)[0].content_hash = missingHash;
    }, "source_matrix_invalid", "/geometry_assets/0/asset_id"],
    ["entity asset ID differs from content hash", (scene) => {
      asRecords(scene.entity_assets)[0].content_hash = missingHash;
    }, "source_matrix_invalid", "/entity_assets/0/entity_asset_id"],
    ["entity asset URI is not content-derived", (scene) => {
      asRecords(scene.entity_assets)[0].uri = "entities/noncanonical.json";
    }, "source_matrix_invalid", "/entity_assets/0/uri"],
    ["geometry tessellation differs from compile options", (scene) => {
      asRecord(asRecords(scene.geometry_assets)[0].tessellation).linear_tolerance = 0.02;
    }, "source_matrix_invalid", "/geometry_assets/0/tessellation/linear_tolerance"],
    ["appearance ID is not content-derived", (scene) => {
      const appearanceId = `appearance/evaluated/${"f".repeat(64)}`;
      asRecords(scene.appearances)[0].appearance_id = appearanceId;
      asRecords(scene.definitions)[0].appearance_id = appearanceId;
    }, "source_matrix_invalid", "/appearances/0/appearance_id"],
    ["manual source cannot request embedding", (scene) => {
      asRecord(scene.compile_options).embed_source = true;
    }, "source_matrix_invalid", "/source"],
    ["definition ID must be source-derived", (scene) => {
      asRecord(scene.source).source_id = "other";
      asRecord(asRecords(scene.definitions)[0].source).source_id = "other";
    }, "source_matrix_invalid", "/definitions/0/definition_id"],
  ];
  for (const [name, mutate, code, path] of cases) await context.test(name, () => {
    const scene = validScene();
    mutate(scene);
    scene.revision = computeSceneRevision(scene);
    assertFirstIssue(validateSceneManifest(scene), code, path);
  });
});

function addSceneCamera(scene: JsonRecord): JsonRecord {
  const camera = {
    camera_id: "camera/test",
    name: "Test camera",
    projection: "perspective",
    parent_node_id: null,
    transform: structuredClone(asRecords(scene.nodes)[0].transform),
    near: 1,
    far: 10,
    vertical_fov_degrees: 45,
  };
  assert.ok(Array.isArray(scene.cameras));
  scene.cameras.push(camera);
  return camera;
}

test("scene cameras reject dangling parents and reversed clipping bounds independently", async (context) => {
  await context.test("dangling parent", () => {
    const scene = validScene();
    addSceneCamera(scene).parent_node_id = "instance/missing";
    scene.revision = computeSceneRevision(scene);
    assertFirstIssue(validateSceneManifest(scene), "reference_missing", "/cameras/0/parent_node_id");
  });
  await context.test("far does not exceed near", () => {
    const scene = validScene();
    addSceneCamera(scene).far = 1;
    scene.revision = computeSceneRevision(scene);
    assertFirstIssue(validateSceneManifest(scene), "bounds_invalid", "/cameras/0/far");
  });
});

test("entity kind, frame, status, position, and bounds semantics reject independent mutations", async (context) => {
  const cases: [string, string, (entity: JsonRecord) => void, string, (index: number) => string][] = [
    ["geometry kind", "solid", (entity) => {
      entity.geometry = { type: "point", position: [0, 0, 0] };
    }, "entity_topology_invalid", (index) => `/entities/${index}/geometry/type`],
    ["required connector frame", "face", (entity) => {
      entity.sdk_connector_frame = null;
    }, "connector_invalid", (index) => `/entities/${index}/sdk_connector_frame`],
    ["render status", "vertex", (entity) => {
      entity.render_status = "degenerate";
    }, "entity_topology_invalid", (index) => `/entities/${index}/render_status`],
    ["vertex property position", "vertex", (entity) => {
      const position = [...(asRecord(entity.properties).position as number[])];
      position[0] += 1;
      asRecord(entity.properties).position = position;
    }, "bounds_invalid", (index) => `/entities/${index}/properties/position`],
    ["reversed bounds", "solid", (entity) => {
      const bounds = asRecord(asRecord(entity.properties).bounds);
      const maximum = bounds.max as number[];
      const minimum = [...(bounds.min as number[])];
      minimum[0] = maximum[0] + 1;
      bounds.min = minimum;
    }, "bounds_invalid", (index) => `/entities/${index}/properties/bounds`],
  ];
  for (const [name, kind, mutate, code, path] of cases) await context.test(name, () => {
    const sidecar = validEntities();
    const index = entityIndex(sidecar, kind);
    mutate(asRecords(sidecar.entities)[index]);
    assertFirstIssue(validateEntityAsset(sidecar), code, path(index));
  });
});

test("analytic geometry coordinates enforce the scene coordinate limit", async (context) => {
  const cases: [string, string, (geometry: JsonRecord) => void][] = [
    ["point.position", "vertex", (geometry) => { geometry.position = [1e12 + 1, 0, 0]; }],
    ["line.origin", "edge", (geometry) => { geometry.origin = [0, -(1e12 + 1), 0]; }],
    ["plane.origin", "face", (geometry) => { geometry.origin = [0, 0, 1e12 + 1]; }],
    ["circle.center", "edge", (geometry) => {
      for (const key of Object.keys(geometry)) delete geometry[key];
      Object.assign(geometry, {
        type: "circle",
        center: [1e12 + 1, 0, 0],
        normal: [0, 0, 1],
        x_direction: [1, 0, 0],
        radius: 1,
      });
    }],
  ];
  for (const [name, kind, mutate] of cases) await context.test(name, () => {
    const sidecar = validEntities();
    const index = entityIndex(sidecar, kind);
    const geometry = asRecord(asRecords(sidecar.entities)[index].geometry);
    mutate(geometry);
    const result = validateEntityAsset(sidecar);
    assert.equal(result.valid, false);
    assert.ok(result.issues.some((item) =>
      item.code === "analytic_geometry_invalid" &&
      item.path === `/entities/${index}/geometry/${name.split(".")[1]}`
    ));
  });
});

test("package checks entity geometry engine version against the manifest", () => {
  const scene = validScene();
  const sidecar = validEntities();
  asRecord(sidecar.geometry_engine).version = "different";
  const { manifest, blobs } = replaceEntitySidecar(scene, sidecar);
  const result = validateScenePackage(manifest, blobs);
  assert.ok(result.issues.some((item) =>
    item.code === "source_matrix_invalid" && item.path === "/definitions/0/entity_asset_id"
  ));
});

test("package rejects entity source variants incompatible with the scene source", () => {
  const scene = validScene();
  const sidecar = validEntities();
  asRecords(sidecar.entities)[0].source = {
    kind: "imported_primitive",
    source_element_id: "element",
  };
  const { manifest, blobs, entityUri } = replaceEntitySidecar(scene, sidecar);
  const result = validateScenePackage(manifest, blobs);
  assert.ok(result.issues.some((item) =>
    item.code === "source_matrix_invalid" && item.path === `/${entityUri}/entities/0/source`
  ));
});

function makeModelScene(scene: JsonRecord, sidecar: JsonRecord, definitionKind: "shape" | "part"): void {
  scene.source = {
    kind: "model",
    graph_id: "graph",
    model_schema_version: "2.0",
    artifact_hash: `sha256:${"1".repeat(64)}`,
  };
  const definition = asRecords(scene.definitions)[0];
  definition.kind = definitionKind;
  definition.source = definitionKind === "part"
    ? {
        kind: "product_model",
        root_id: "root",
        semantic_type: "Part",
        semantic_id: "Part",
        graph_id: "graph",
        node_id: "node",
        output_slot: 0,
      }
    : {
        kind: "model_output",
        root_id: "root",
        graph_id: "graph",
        node_id: "node",
        output_slot: 0,
      };
  for (const entity of asRecords(sidecar.entities)) {
    entity.source = {
      kind: "model_output",
      graph_id: "graph",
      node_id: "node",
      output_slot: 0,
    };
  }
}

test("package checks model entity source ownership fields", () => {
  const scene = validScene();
  const sidecar = validEntities();
  makeModelScene(scene, sidecar, "shape");
  asRecord(asRecords(sidecar.entities)[0].source).node_id = "other-node";
  const { manifest, blobs, entityUri } = replaceEntitySidecar(scene, sidecar);
  const result = validateScenePackage(manifest, blobs);
  assert.ok(result.issues.some((item) =>
    item.code === "source_matrix_invalid" && item.path === `/${entityUri}/entities/0/source`
  ));
});

test("embedded model and Python source package validates", () => {
  const fixture = embeddedSourcePackage();
  const result = validateScenePackage(fixture.manifest, fixture.blobs);
  assert.equal(result.valid, true, JSON.stringify(result.issues));
});

test("manifest rejects archive-unsafe embedded Python paths", () => {
  const fixture = embeddedSourcePackage();
  const sourceFile = asRecords(asRecord(fixture.manifest.source).source_files)[0];
  sourceFile.path = "models/../box.py";
  sourceFile.uri = "sources/models/../box.py";
  fixture.manifest.revision = computeSceneRevision(fixture.manifest);

  const result = validateSceneManifest(fixture.manifest);
  assert.ok(result.issues.some((item) =>
    item.code === "source_matrix_invalid" && item.path === "/source/source_files/0/path"
  ));
});

test("package rejects malformed operation source mappings", () => {
  const fixture = embeddedSourcePackage();
  const graph = asRecord(fixture.model.graph);
  const source = asRecord(asRecords(graph.nodes)[0].source);
  delete source.callsite_id;
  replaceEmbeddedModel(fixture);

  const result = validateScenePackage(fixture.manifest, fixture.blobs);
  assert.ok(result.issues.some((item) =>
    item.code === "source_matrix_invalid" && item.path === "/model/model.json/graph/nodes/0/source"
  ));
});

test("package rejects invalid UTF-8 Python source bytes", () => {
  const fixture = embeddedSourcePackage();
  const payload = Buffer.from([0xff]);
  fixture.blobs.set(fixture.sourceUri, payload);
  const sourceFile = asRecords(asRecord(fixture.manifest.source).source_files)[0];
  sourceFile.byte_length = payload.length;
  sourceFile.content_hash = sha256(payload);
  fixture.manifest.revision = computeSceneRevision(fixture.manifest);

  const result = validateScenePackage(fixture.manifest, fixture.blobs);
  assert.ok(result.issues.some((item) =>
    item.code === "invalid_utf8" && item.path === `/${fixture.sourceUri}`
  ));
});

test("package binding status rules follow Python precedence", async (context) => {
  await context.test("solid is always not_applicable", () => {
    const scene = validScene();
    const sidecar = validEntities();
    const index = entityIndex(sidecar, "solid");
    asRecords(sidecar.entities)[index].connector_binding_status = "supported";
    const { manifest, blobs, entityUri } = replaceEntitySidecar(scene, sidecar);
    const result = validateScenePackage(manifest, blobs);
    const found = result.issues.find((item) => item.code === "connector_invalid" && item.path === `/${entityUri}/entities/${index}/connector_binding_status`);
    assert.match(found?.message ?? "", /not_applicable/);
  });

  await context.test("non-part owner precedes scene source", () => {
    const scene = validScene();
    const sidecar = validEntities();
    const index = entityIndex(sidecar, "face");
    asRecords(sidecar.entities)[index].connector_binding_status = "source_not_model";
    const { manifest, blobs, entityUri } = replaceEntitySidecar(scene, sidecar);
    const result = validateScenePackage(manifest, blobs);
    const found = result.issues.find((item) => item.code === "connector_invalid" && item.path === `/${entityUri}/entities/${index}/connector_binding_status`);
    assert.match(found?.message ?? "", /owner_not_part/);
  });

  await context.test("non-model part requires source_not_model", () => {
    const scene = validScene();
    const sidecar = validEntities();
    const definition = asRecords(scene.definitions)[0];
    definition.kind = "part";
    definition.source = {
      kind: "product_manual",
      root_id: "root",
      semantic_type: "Part",
      semantic_id: "Part",
    };
    const entities = asRecords(sidecar.entities);
    for (const entity of entities) {
      if (entity.kind !== "solid") entity.connector_binding_status = "source_not_model";
    }
    const index = entityIndex(sidecar, "face");
    entities[index].connector_binding_status = "supported";
    const { manifest, blobs, entityUri } = replaceEntitySidecar(scene, sidecar);
    const result = validateScenePackage(manifest, blobs);
    const found = result.issues.find((item) => item.code === "connector_invalid" && item.path === `/${entityUri}/entities/${index}/connector_binding_status`);
    assert.match(found?.message ?? "", /source_not_model/);
  });

  await context.test("model part null frame requires frame_undefined", () => {
    const scene = validScene();
    const sidecar = validEntities();
    makeModelScene(scene, sidecar, "part");
    const entities = asRecords(sidecar.entities);
    for (const entity of entities) {
      if (entity.kind !== "solid") entity.connector_binding_status = "supported";
    }
    const index = entityIndex(sidecar, "edge");
    entities[index].sdk_connector_frame = null;
    entities[index].connector_binding_status = "owner_not_part";
    const { manifest, blobs, entityUri } = replaceEntitySidecar(scene, sidecar);
    const result = validateScenePackage(manifest, blobs);
    const found = result.issues.find((item) => item.code === "connector_invalid" && item.path === `/${entityUri}/entities/${index}/connector_binding_status`);
    assert.match(found?.message ?? "", /frame_undefined/);
  });
});

test("all package cases match validity and expected first issue", async (context) => {
  for (const item of corpus.package_cases) await context.test(item.name, () => {
    const result = validateScenePackage(
      decode(item.manifest_base64),
      corpusBlobs(corpus.blobs, item),
    );
    assert.equal(result.valid, item.valid);
    if (item.expected !== null) {
      assert.equal(result.firstError?.code, item.expected.code);
      assert.equal(result.firstError?.path, item.expected.path);
  }
});

test("accepted package fixtures cover every connector binding status", () => {
  const statuses = new Set<string>();
  for (const item of [...corpus.package_cases, ...corpus.scene_shape_cases]) {
    if (!item.valid) continue;
    for (const [uri, payload] of corpusBlobs(corpus.blobs, item)) {
      if (!uri.startsWith("entities/")) continue;
      const sidecar = asRecord(parseCanonicalJson(payload));
      for (const entity of asRecords(sidecar.entities)) {
        statuses.add(String(entity.connector_binding_status));
      }
    }
  }
  assert.deepEqual([...statuses].sort(), [
    "frame_undefined",
    "not_applicable",
    "owner_not_part",
    "selector_ambiguous",
    "selector_unstable",
    "source_not_model",
    "supported",
  ]);
});
});

test("scene field matrix replays independently", async (context) => {
  const scene = validScene();
  for (const item of corpus.scene_field_cases) await context.test(item.name, () => {
    const result = validateSceneManifest(
      canonicalJsonBytes(applySceneFieldCase(scene, item)),
    );
    assert.equal(result.valid, item.valid);
    assert.equal(result.firstError?.code, item.expected?.code);
    assert.equal(result.firstError?.path, item.expected?.path);
  });
});

test("scene shapes validate, round trip, and characterize asset reuse", async (context) => {
  for (const item of corpus.scene_shape_cases) await context.test(item.name, () => {
    const manifest = decode(item.manifest_base64);
    const scene = asRecord(parseCanonicalJson(manifest));
    const result = validateScenePackage(manifest, corpusBlobs(corpus.blobs, item));
    assert.equal(result.valid, item.valid);
    assert.equal(result.firstError?.code, item.expected?.code);
    assert.equal(result.firstError?.path, item.expected?.path);
    assert.deepEqual(canonicalJsonBytes(scene), manifest);
    assert.deepEqual(
      canonicalJsonBytes(sceneShapeFacts(scene)),
      canonicalJsonBytes(item.expected_shape),
    );

    const definitions = new Map(
      asRecords(scene.definitions).map((definition) => [
        String(definition.definition_id),
        definition,
      ]),
    );
    for (const [definitionId, count] of Object.entries(
      item.expected_shape.definition_occurrence_counts,
    )) {
      if (count <= 1) continue;
      const occurrences = asRecords(scene.nodes).filter(
        (node) => node.definition_id === definitionId,
      );
      assert.equal(occurrences.length, count);
      assert.equal(new Set(occurrences.map((node) => node.definition_id)).size, 1);
      assert.notEqual(definitions.get(definitionId)?.geometry_asset_id, null);
    }
  });
});

test("two-pass revision vectors reproduce exact drafts, revisions, and bytes", async (context) => {
  for (const vector of corpus.revision_vectors) await context.test(vector.name, () => {
    const draftBytes = decode(vector.draft_base64);
    const draft = asRecord(parseCanonicalJson(draftBytes));
    const sceneBytes = decode(vector.canonical_base64);
    const scene = withSceneRevision(draft);
    assert.deepEqual(canonicalJsonBytes(draft), draftBytes);
    assert.equal(scene.revision, vector.revision);
    assert.deepEqual(canonicalJsonBytes(scene), sceneBytes);
    assert.equal(sha256(sceneBytes), vector.sha256);
  });
});

test("all GLB cases match acceptance, kind, and exact rejection", async (context) => {
  for (const item of corpus.glb_cases) await context.test(item.name, () => {
    if (item.valid) {
      const result = preflightGlb(decode(item.payload_base64), item.expected_kind);
      assert.equal(result.kind, item.kind);
    } else {
      assert.throws(() => preflightGlb(decode(item.payload_base64), item.expected_kind), (error) => {
        assert.equal((error as Error).message, item.error);
        return true;
      });
    }
  });
});

test("all ZIP cases match acceptance, deflate use, and exact rejection", async (context) => {
  for (const item of corpus.zip_cases) await context.test(item.name, () => {
    if (item.valid) {
      const result = preflightZipBytes(decode(item.payload_base64));
      assert.equal(result.usedDeflate, item.used_deflate);
    } else {
      assert.throws(() => preflightZipBytes(decode(item.payload_base64)), (error) => {
        assert.equal((error as Error).message, item.error);
        return true;
      });
    }
  });
});

function f64FromHex(value: string): number {
  return Buffer.from(value, "hex").readDoubleBE(0);
}

function f64Hex(value: number): string {
  const bytes = Buffer.allocUnsafe(8);
  bytes.writeDoubleBE(value, 0);
  return bytes.toString("hex");
}

test("numeric profile vectors reproduce exact IEEE-754 results", async (context) => {
  for (const vector of corpus.numeric_vectors) await context.test(vector.name, () => {
    try {
      let actual: string | string[];
      if (vector.operation === "f32") {
        const input = vector.input_bits as string[];
        actual = profileF32Bits(f64FromHex(input[0])).toString(16).padStart(8, "0");
      } else if (vector.operation === "cross") {
        const [left, right] = (vector.input_bits as string[][]).map(
          (input) => input.map(f64FromHex) as [number, number, number],
        );
        actual = profileCross(left, right).map(f64Hex);
      } else {
        const input = (vector.input_bits as string[][])[0].map(f64FromHex) as [number, number, number];
        actual = profileNormalize(input).map((component) =>
          profileF32Bits(component).toString(16).padStart(8, "0")
        );
      }
      assert.equal(vector.valid, true);
      assert.deepEqual(actual, vector.expected_bits);
    } catch (error) {
      assert.equal(vector.valid, false);
      assert.equal((error as Error).message, vector.error);
    }
  });
});

test("resource profile and exact boundary cases match Python", async (context) => {
  assert.deepEqual(BASE_LIMITS, Object.fromEntries(Object.entries(corpus.resource_limits)));
  const scene = validScene();

  for (const item of corpus.resource_cases) await context.test(item.name, () => {
    let valid = false;
    let error: string | null = null;
    let first: ExpectedIssue | null = null;
    try {
      const parameters = item.parameters;
      const limits = { ...BASE_LIMITS, ...(parameters.limits as Partial<SceneResourceLimits> ?? {}) };
      if (item.operation === "input_archive_size") {
        preflightInputArchiveSize(parameters.size as number, limits);
        valid = true;
      } else if (item.operation === "archive_member_sizes" || item.operation === "archive_member_count") {
        let sizes: Map<string, number>;
        if (item.operation === "archive_member_sizes") {
          sizes = new Map(Object.entries(parameters.sizes as Record<string, number>));
        } else {
          sizes = new Map([["scene.json", 0]]);
          for (let index = 0; index < (parameters.count as number) - 1; index += 1) {
            sizes.set(`x/${index.toString().padStart(5, "0")}`, 0);
          }
        }
        preflightArchiveMemberSizes(sizes, limits);
        valid = true;
      } else if (item.operation === "aggregate_compression_ratio" || item.operation === "member_compression_ratio") {
        const callback = item.operation === "aggregate_compression_ratio"
          ? preflightAggregateCompressionRatio
          : preflightMemberCompressionRatio;
        callback(parameters.uncompressed_size as number, parameters.compressed_size as number, limits);
        valid = true;
      } else if (item.operation === "json_depth") {
        const value: JsonRecord = {};
        let current = value;
        for (let index = 0; index < (parameters.depth as number); index += 1) {
          current.x = {};
          current = asRecord(current.x);
        }
        const result = report(jsonResourceIssues(value, limits));
        valid = result.valid;
        first = result.firstError === null ? null : { code: result.firstError.code, path: result.firstError.path };
      } else if (item.operation === "json_domain") {
        const text = parameters.text as string;
        const kind = parameters.kind as string;
        const field = parameters.field as string | null;
        let value: JsonRecord;
        if (kind === "value") value = { value: text };
        else if (kind === "object_key") value = { [text]: 0 };
        else if (kind === "metadata_key") value = { metadata: { [text]: 0 } };
        else if (kind === "sdk_metadata_key") value = { sdk_metadata: { [text]: 0 } };
        else if (kind === "identifier") value = { [field ?? "node_id"]: text };
        else if (kind === "identifier_array") value = { [field ?? "component_path"]: [text] };
        else if (kind === "uri") value = { uri: text };
        else throw new Error(`unknown JSON domain kind: ${kind}`);
        const result = report(jsonResourceIssues(value, limits));
        valid = result.valid;
        first = result.firstError === null ? null : { code: result.firstError.code, path: result.firstError.path };
      } else if (item.operation === "resource_count") {
        const count = parameters.count as number;
        const kind = parameters.kind as string;
        const field = parameters.field as string | null;
        let value: JsonRecord;
        if (kind === "collection") value = { [field!]: Array(count).fill(null) };
        else if (kind === "hierarchy") value = { nodes: [{ source: { component_path: Array(count).fill("x") } }] };
        else if (kind === "forwarded") {
          value = {
            connectors: Array.from({ length: count }, (_unused, index) => ({
              anchor_kind: "forwarded",
              connector_snapshot_id: `c${index}`,
              forwarded_from: { source_connector_snapshot_id: `c${index + 1}` },
            })),
          };
        } else throw new Error(`unknown resource count kind: ${kind}`);
        const result = report(resourceCountIssues(value, parameters.artifact as "scene" | "entities" | "presentation", limits));
        valid = result.valid;
        first = result.firstError === null ? null : { code: result.firstError.code, path: result.firstError.path };
      } else if (item.operation === "glb_counts") {
        preflightGlbCounts(
          parameters.kind as "triangle" | "line",
          parameters.vertex_count as number,
          parameters.index_count as number,
          limits,
        );
        valid = true;
      } else if (item.operation === "package_budget") {
        const input = parameters.contributions as {
          scene_json_bytes: number;
          glb_decoded_buffer_bytes: number;
          entity_json_bytes: number;
          other_immutable_json_bytes: number;
          entity_count: number;
          entity_vertex_count: number;
          triangle_vertex_count: number;
          triangle_count: number;
          line_vertex_count: number;
          line_segment_count: number;
        };
        const totals = computePackageBudgetTotals({
          sceneJsonBytes: input.scene_json_bytes,
          glbDecodedBufferBytes: input.glb_decoded_buffer_bytes,
          entityJsonBytes: input.entity_json_bytes,
          otherImmutableJsonBytes: input.other_immutable_json_bytes,
          entityCount: input.entity_count,
          entityVertexCount: input.entity_vertex_count,
          triangleVertexCount: input.triangle_vertex_count,
          triangleCount: input.triangle_count,
          lineVertexCount: input.line_vertex_count,
          lineSegmentCount: input.line_segment_count,
        });
        const result = report(packageBudgetIssues(totals, limits), "package");
        valid = result.valid;
        first = result.firstError === null ? null : { code: result.firstError.code, path: result.firstError.path };
      } else if (item.operation === "scene_geometry_byte_length") {
        let value = structuredClone(scene);
        const byteLength = Number(parameters.value);
        asRecords(value.geometry_assets)[0].byte_length = byteLength;
        if (byteLength <= Number.MAX_SAFE_INTEGER) value = withSceneRevision(value);
        const result = validateSceneManifest(value);
        valid = result.valid;
        first = result.firstError === null ? null : { code: result.firstError.code, path: result.firstError.path };
      } else if (item.operation === "scene_compile_option") {
        const value = structuredClone(scene);
        const field = parameters.field as string;
        const number = parameters.value as number;
        asRecord(value.compile_options)[field] = number;
        asRecord(asRecords(value.geometry_assets)[0].tessellation)[field] = number;
        if (field === "linear_tolerance") asRecord(asRecords(value.edge_assets)[0].tessellation)[field] = number;
        const result = validateSceneManifest(withSceneRevision(value));
        valid = result.valid;
        first = result.firstError === null ? null : { code: result.firstError.code, path: result.firstError.path };
      } else {
        throw new Error(`unknown resource operation: ${item.operation}`);
      }
    } catch (caught) {
      valid = false;
      error = (caught as Error).message;
    }
    assert.equal(valid, item.valid);
    if (Object.hasOwn(item, "error")) assert.equal(error, item.error ?? null);
    if (item.expected !== undefined && item.expected !== null) {
      assert.equal(first?.code, item.expected.code);
      assert.equal(first?.path, item.expected.path);
    }
  });
});

test("canonical stored ZIP reproduces the exact shared vector", () => {
  const expected = decode(corpus.artifacts.canonical_zip.base64);
  const archive = preflightZipBytes(expected);
  assert.equal(archive.inputSize, archive.canonicalSize);
  assert.deepEqual(canonicalZipBytes(archive.members), expected);
  assert.equal(`sha256:${createHash("sha256").update(expected).digest("hex")}`, corpus.artifacts.canonical_zip.sha256);
});