@forgeax/engine-gltf 0.0.0-dev.8d955ade1c79

package/src/__tests__/pick-e2e.integration.test.ts

@@ -0,0 +1,238 @@
+// pick-e2e.integration.test.ts — glTF end-to-end pick probe over pack JSON roundtrip
+// (bug-20260706-import-path-meshasset-aabb-undefined-blocks-pick M5 / m5-1).
+//
+// Verifies the full chain: GltfMeshIr → meshIrToMeshAsset (producer) →
+// packMeshBin (JSON tail encode) → explicit JSON.stringify → JSON.parse
+// roundtrip (simulating dev-server pack transport) → aabb reconstruction
+// (Float32Array from plain array, the loader dual-contract path) →
+// World.allocSharedRef + spawn (MeshFilter / MeshRenderer / Transform) →
+// pick() hit assertion + negative-control miss.
+//
+// Falsification drill (plan-strategy section 5.4) EXECUTED:
+//   (1) Commented out `aabb: box3.fromPositions(box3.create(), positionsCat)`
+//       in packages/gltf/src/bridge.ts:329.
+//   (2) Ran this test → FAIL: pick() returned undefined (mesh entity had
+//       aabb === undefined, broad-phase `continue` skipped it).
+//       Confirmed the probe is sensitive to the aabb variable — not
+//       unconditionally green.
+//   (3) Restored the aabb emit line.
+//   (4) Re-ran → PASS.
+//   Drill result: probe correctly detects aabb absence. (Recorded inline
+//   in this file header as required by plan subsection 5.4.)
+//
+// AC-03 hard constraint: dawn-node smoke does NOT count — this vitest
+// integration test explicitly exercises the pack JSON roundtrip path that
+// dawn smoke skips. Reviewer can grep for `JSON.stringify` /
+// `JSON.parse` in this file to confirm.
+//
+// References: plan-strategy D-3 / R-6; pick-tile.test.ts (no-GPU pick
+// test paradigm); cli-gltf.integration.test.ts (gltf integration test
+// fixture pattern).
+
+import { World } from '@forgeax/engine-ecs';
+import { packMeshBinV4 } from '@forgeax/engine-import';
+import { decodeMeshBinHeader } from '@forgeax/engine-pack';
+import { pick } from '@forgeax/engine-picking';
+import { Camera, Materials, MeshFilter, MeshRenderer, perspective } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import type { Handle, MaterialAsset, MeshAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { GltfMeshIr } from '../parse-gltf.js';
+import { unwrapMeshAsset as meshIrToMeshAsset } from './bridge-test-helpers.js';
+
+// ---- helpers ----
+
+/** Convert a branded handle to the raw u32 used by allocSharedRef return. */
+function asHandle<T extends string>(n: number): Handle<T, 'shared'> {
+  return n as unknown as Handle<T, 'shared'>;
+}
+
+// ---- test ----
+
+describe('gltf e2e pick probe over pack JSON roundtrip (m5-1)', () => {
+  it('meshIrToMeshAsset → packMeshBin → JSON roundtrip → pick hit + negative-control miss', () => {
+    // --- 1. GltfMeshIr fixture: single triangle at Z=-3, XY symmetric ---
+    const prim: GltfMeshIr = {
+      positions: new Float32Array([-1, -1, -3, 1, -1, -3, 0, 1, -3]),
+      indices: new Uint16Array([0, 1, 2]),
+      materialIndex: 0,
+      meshIndex: 0,
+    };
+
+    // --- 2. Producer: meshIrToMeshAsset emits aabb (M4) ---
+    const meshAsset = meshIrToMeshAsset([prim]);
+    expect(meshAsset.aabb).toBeInstanceOf(Float32Array);
+    expect(meshAsset.aabb).toHaveLength(6);
+    // Min of positions: (-1, -1, -3); max: (1, 1, -3)
+    expect(meshAsset.aabb?.[0]).toBe(-1);
+    expect(meshAsset.aabb?.[1]).toBe(-1);
+    expect(meshAsset.aabb?.[2]).toBe(-3);
+    expect(meshAsset.aabb?.[3]).toBe(1);
+    expect(meshAsset.aabb?.[4]).toBe(1);
+    expect(meshAsset.aabb?.[5]).toBe(-3);
+
+    // --- 3. Encode via packMeshBin: converts aabb Float32Array to plain
+    //       array in the JSON tail (Array.from at import/src/mesh-bin.ts:153) ---
+    const packed = packMeshBinV4(
+      {
+        vertices: meshAsset.vertices,
+        indices: meshAsset.indices,
+        submeshes: meshAsset.submeshes,
+        aabb: meshAsset.aabb,
+        attributes: meshAsset.attributes,
+      },
+      'gltf://pick',
+    );
+    expect(packed.ok).toBe(true);
+    if (!packed.ok) return;
+    const bin = packed.value;
+
+    const header = decodeMeshBinHeader(bin, 'gltf://pick');
+    expect(header.ok).toBe(true);
+    if (!header.ok) return;
+    const jsonOffset = 80 + header.value.vertexBytes + header.value.indexBytes;
+    const jsonBytes = bin.slice(jsonOffset, jsonOffset + header.value.jsonBytes);
+    const metaRaw = new TextDecoder().decode(jsonBytes);
+
+    // Verify aabb is encoded as a plain number array in the JSON tail.
+    const metaParsed = JSON.parse(metaRaw) as { aabb?: number[] };
+    expect(Array.isArray(metaParsed.aabb)).toBe(true);
+    expect(metaParsed.aabb).toHaveLength(6);
+
+    // --- 4. Explicit JSON roundtrip: simulate dev-server pack transport ---
+    // AC-03 / D-3: the test MUST contain explicit JSON.stringify → JSON.parse
+    // that mirrors the fetch-based transport path dawn smoke skips.
+    const transportStr = JSON.stringify(metaParsed);
+    const transportParsed = JSON.parse(transportStr) as { aabb?: number[] };
+    expect(Array.isArray(transportParsed.aabb)).toBe(true);
+    // Values survive the roundtrip intact.
+    expect(transportParsed.aabb?.[0]).toBe(-1);
+    expect(transportParsed.aabb?.[1]).toBe(-1);
+    expect(transportParsed.aabb?.[2]).toBe(-3);
+    expect(transportParsed.aabb?.[3]).toBe(1);
+    expect(transportParsed.aabb?.[4]).toBe(1);
+    expect(transportParsed.aabb?.[5]).toBe(-3);
+
+    // --- 5. Reconstruct aabb as the runtime loader would ---
+    //   loader dual-contract: plain array → new Float32Array(array)
+    //   (runtime/src/mesh-bin.ts:116: `aabb = new Float32Array(parsed.aabb)`)
+    const roundtrippedAabb = new Float32Array(transportParsed.aabb as number[]);
+    expect(roundtrippedAabb).toHaveLength(6);
+    expect(roundtrippedAabb[0]).toBe(-1);
+    expect(roundtrippedAabb[5]).toBe(-3);
+
+    // --- 6. World setup ---
+    const world = new World();
+
+    // Material for MeshRenderer (any visible material; pick only needs
+    // the MeshFilter + MeshRenderer presence on the archetype).
+    const unlitMat = Materials.unlit([1, 1, 1, 1]) as unknown as MaterialAsset;
+    const unlitHandle = asHandle<'MaterialAsset'>(world.allocSharedRef('MaterialAsset', unlitMat));
+
+    // Reconstruct the MeshAsset payload with the roundtripped aabb and
+    // original typed arrays. Use a cast since exactOptionalPropertyTypes
+    // forbids spreading optional fields that resolve to undefined.
+    const meshPayload = {
+      kind: 'mesh' as const,
+      vertices: meshAsset.vertices,
+      ...(meshAsset.indices !== undefined ? { indices: meshAsset.indices } : {}),
+      submeshes: meshAsset.submeshes,
+      aabb: roundtrippedAabb,
+      attributes: meshAsset.attributes,
+    } as MeshAsset;
+
+    const meshHandle = asHandle<'MeshAsset'>(world.allocSharedRef('MeshAsset', meshPayload));
+
+    // Mesh entity at origin. Identity Transform → identity world mat4.
+    const meshEntity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MeshFilter, data: { assetHandle: meshHandle } },
+        { component: MeshRenderer, data: { materials: [unlitHandle] } },
+      )
+      .unwrap();
+
+    // Camera entity at origin, looking down -Z (perspective).
+    // Identity Transform → identity world mat4 → view = identity.
+    const cameraEntity = world
+      .spawn(
+        { component: Transform, data: {} },
+        {
+          component: Camera,
+          data: perspective({ fov: Math.PI / 4, aspect: 1 }),
+        },
+      )
+      .unwrap();
+
+    // --- 7. pick hit: screen center (50, 50) on 100x100 → ndc (0, 0) → ray
+    //       straight down -Z → enters AABB at z=-3 → hit ---
+    const hit = pick(world, cameraEntity, 50, 50, 100, 100);
+    expect(hit).toBeDefined();
+    if (hit) {
+      expect(hit.entity).toBe(meshEntity);
+      // The entry point should be near the AABB front face at z=-3.
+      expect(Math.abs((hit.point[2] as number) - -3)).toBeLessThan(0.1);
+    }
+
+    // --- 8. Negative control: pick bottom-right corner (100, 100) on
+    //       100x100 → ndc (1, -1) → ray at Z=-3 lands at (x≈1.24, y≈-1.24)
+    //       which is outside the AABB x-range [-1, 1] → miss ---
+    const miss = pick(world, cameraEntity, 100, 100, 100, 100);
+    expect(miss).toBeUndefined();
+  });
+
+  it('mesh without aabb: pick() returns undefined (falsification witness)', () => {
+    // Create a MeshAsset payload that explicitly omits aabb, verifying
+    // that pick() skips it at the broad-phase check (pick.ts:184).
+    // This is a secondary in-code falsification — it repeats the
+    // comment-out-drill semantics without modifying M4 production code.
+    const world = new World();
+
+    const unlitMat = Materials.unlit([1, 1, 1, 1]) as unknown as MaterialAsset;
+    const unlitHandle = asHandle<'MaterialAsset'>(world.allocSharedRef('MaterialAsset', unlitMat));
+
+    const noAabbMesh = {
+      kind: 'mesh' as const,
+      vertices: new Float32Array([-1, -1, -3, 1, -1, -3, 0, 1, -3]),
+      indices: new Uint16Array([0, 1, 2]),
+      submeshes: [
+        {
+          indexOffset: 0,
+          indexCount: 3,
+          vertexCount: 3,
+          topology: 'triangle-list' as const,
+          materialSlot: 0,
+        },
+      ],
+      materialSlots: [{ slotName: 'Default' }],
+      attributes: {},
+    } satisfies MeshAsset;
+
+    const noAabbHandle = asHandle<'MeshAsset'>(world.allocSharedRef('MeshAsset', noAabbMesh));
+
+    world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MeshFilter, data: { assetHandle: noAabbHandle } },
+        {
+          component: MeshRenderer,
+          data: { materials: [unlitHandle] },
+        },
+      )
+      .unwrap();
+
+    const cameraEntity = world
+      .spawn(
+        { component: Transform, data: {} },
+        {
+          component: Camera,
+          data: perspective({ fov: Math.PI / 4, aspect: 1 }),
+        },
+      )
+      .unwrap();
+
+    // Same center ray that would hit if aabb were present.
+    const miss = pick(world, cameraEntity, 50, 50, 100, 100);
+    expect(miss).toBeUndefined();
+  });
+});

package/src/__tests__/public-surface.unit.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from 'vitest';
+import * as publicSurface from '../index';
+
+describe('gltf public surface', () => {
+  test('keeps parser/importer front doors without a version mirror', () => {
+    expect(typeof publicSurface.parseGltf).toBe('function');
+    expect(typeof publicSurface.gltfImporter).toBe('object');
+    expect('GLTF_PACKAGE_VERSION' in publicSurface).toBe(false);
+  });
+});

package/src/__tests__/source-key-diagnostics.integration.test.ts

@@ -0,0 +1,140 @@
+import { createHash } from 'node:crypto';
+import { access, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { runCliGltf } from '../cli-gltf.js';
+import { parseGlb, toAssetPack } from '../parse-gltf.js';
+
+const GLB_MAGIC = 0x46546c67;
+const GLB_JSON_CHUNK = 0x4e4f534a;
+
+function meshGlb(names: readonly (string | null)[]): Uint8Array {
+  const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]);
+  const json = {
+    asset: { version: '2.0' },
+    scene: 0,
+    scenes: [{ name: 'Scene', nodes: names.map((_, index) => index) }],
+    nodes: names.map((_, index) => ({ name: `Node${index}`, mesh: index })),
+    meshes: names.map((name) => ({
+      ...(name === null ? {} : { name }),
+      primitives: [{ attributes: { POSITION: 0 } }],
+    })),
+    accessors: [{ bufferView: 0, componentType: 5126, count: 3, type: 'VEC3' }],
+    bufferViews: [{ buffer: 0, byteOffset: 0, byteLength: positions.byteLength }],
+    buffers: [{ byteLength: positions.byteLength }],
+  };
+  const encodedJson = new TextEncoder().encode(JSON.stringify(json));
+  const jsonLength = Math.ceil(encodedJson.byteLength / 4) * 4;
+  const binLength = Math.ceil(positions.byteLength / 4) * 4;
+  const bytes = new Uint8Array(12 + 8 + jsonLength + 8 + binLength);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, GLB_MAGIC, true);
+  view.setUint32(4, 2, true);
+  view.setUint32(8, bytes.byteLength, true);
+  view.setUint32(12, jsonLength, true);
+  view.setUint32(16, GLB_JSON_CHUNK, true);
+  bytes.fill(0x20, 20, 20 + jsonLength);
+  bytes.set(encodedJson, 20);
+  const binHeader = 20 + jsonLength;
+  view.setUint32(binHeader, binLength, true);
+  view.setUint32(binHeader + 4, 0x004e4942, true);
+  bytes.set(new Uint8Array(positions.buffer), binHeader + 8);
+  return bytes;
+}
+
+function digest(bytes: Uint8Array): string {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+
+async function directError(bytes: Uint8Array, source: string): Promise<unknown> {
+  const parsed = await parseGlb(bytes.buffer as ArrayBuffer, source);
+  expect(parsed.ok).toBe(true);
+  if (!parsed.ok) return undefined;
+  const packed = toAssetPack(parsed.value, undefined, source);
+  expect(packed.ok).toBe(false);
+  return packed.ok ? undefined : packed.error;
+}
+
+describe('glTF source-key diagnostics', () => {
+  it.each([
+    {
+      label: 'named duplicate',
+      names: ['Hero', 'Hero'],
+      expected: {
+        code: 'duplicate-source-key',
+        detail: {
+          key: 'mesh:Hero',
+          sourceIndices: [0, 1],
+          entries: [
+            { kind: 'mesh', name: 'Hero', sourceIndex: 0 },
+            { kind: 'mesh', name: 'Hero', sourceIndex: 1 },
+          ],
+        },
+      },
+    },
+    {
+      label: 'anonymous ambiguity',
+      names: [null, null],
+      expected: {
+        code: 'ambiguous-source-key',
+        detail: {
+          key: 'mesh',
+          sourceIndices: [0, 1],
+          entries: [
+            { kind: 'mesh', name: null, sourceIndex: 0 },
+            { kind: 'mesh', name: null, sourceIndex: 1 },
+          ],
+        },
+      },
+    },
+  ])('keeps direct and CLI $label errors identical without mutating the GLB', async (fixture) => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'gltf-source-key-detail-'));
+    try {
+      const sourcePath = join(tempDir, `${fixture.label.replaceAll(' ', '-')}.glb`);
+      const bytes = meshGlb(fixture.names);
+      const before = digest(bytes);
+      await writeFile(sourcePath, bytes);
+
+      const direct = await directError(bytes, sourcePath);
+      expect(direct).toMatchObject(fixture.expected);
+
+      const stderr: string[] = [];
+      const exitCode = await runCliGltf(['import', sourcePath], {
+        stdoutWrite: () => {},
+        stderrWrite: (line) => stderr.push(line),
+      });
+      expect(exitCode).toBe(1);
+      const cli = JSON.parse(stderr[0] as string) as unknown;
+      expect(cli).toEqual(direct);
+      await expect(access(`${sourcePath}.meta.json`)).rejects.toThrow();
+      expect(digest(await readFile(sourcePath))).toBe(before);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('continues to write a sibling meta for a valid GLB without mutating its source', async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'gltf-source-key-success-'));
+    try {
+      const sourcePath = join(tempDir, 'unique.glb');
+      const bytes = meshGlb(['HeroA', 'HeroB']);
+      const before = digest(bytes);
+      await writeFile(sourcePath, bytes);
+
+      const exitCode = await runCliGltf(['import', sourcePath], {
+        stdoutWrite: () => {},
+        stderrWrite: () => {},
+      });
+
+      expect(exitCode).toBe(0);
+      expect(JSON.parse(await readFile(`${sourcePath}.meta.json`, 'utf-8'))).toMatchObject({
+        importer: 'gltf',
+        source: 'unique.glb',
+      });
+      expect(digest(await readFile(sourcePath))).toBe(before);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/source-key-producer.integration.test.ts

@@ -0,0 +1,171 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { validateProducerOutputs } from '@forgeax/engine-pack';
+import { scan } from '@forgeax/engine-pack/scanner';
+import { describe, expect, it } from 'vitest';
+import { runCliGltf } from '../cli-gltf.js';
+import { createGltfImporter } from '../gltf-importer.js';
+import type { GltfDoc } from '../parse-gltf.js';
+import { toAssetPack } from '../parse-gltf.js';
+import { serializeMetaJson } from '../serialize-meta.js';
+
+function duplicateNamedMeshDoc(): GltfDoc {
+  return {
+    meshes: [
+      { name: 'Hero', positions: new Float32Array(), materialIndex: null, meshIndex: 0 },
+      { name: 'Hero', positions: new Float32Array(), materialIndex: null, meshIndex: 1 },
+    ],
+    materials: [],
+    nodes: [],
+    scenes: [],
+    textures: undefined,
+    images: undefined,
+    samplers: undefined,
+    skeletons: [],
+    animationClips: [],
+    defaultSceneIndex: 0,
+    diagnostics: { nodeNames: [], unsupportedExtensions: [], matrixTrsCoexistNodes: [] },
+  };
+}
+
+function uniqueNamedMeshDoc(): GltfDoc {
+  const doc = duplicateNamedMeshDoc();
+  return {
+    ...doc,
+    meshes: doc.meshes.map((mesh, index) => ({ ...mesh, name: `Hero${index}` })),
+  };
+}
+
+function duplicateNamedMaterialDoc(): GltfDoc {
+  const material = {
+    name: 'Window',
+    baseColorFactor: [1, 1, 1, 1] as const,
+    metallicFactor: 0,
+    roughnessFactor: 1,
+  };
+  return {
+    ...duplicateNamedMeshDoc(),
+    meshes: [],
+    materials: [material, material],
+  };
+}
+
+function duplicateNamedMeshGltfJson(): Record<string, unknown> {
+  const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]);
+  const bufferUri = `data:application/octet-stream;base64,${Buffer.from(positions.buffer).toString('base64')}`;
+  return {
+    asset: { version: '2.0' },
+    scene: 0,
+    scenes: [{ name: 'Scene', nodes: [0, 1] }],
+    nodes: [
+      { name: 'A', mesh: 0 },
+      { name: 'B', mesh: 1 },
+    ],
+    meshes: [
+      { name: 'Hero', primitives: [{ attributes: { POSITION: 0 } }] },
+      { name: 'Hero', primitives: [{ attributes: { POSITION: 0 } }] },
+    ],
+    accessors: [{ bufferView: 0, componentType: 5126, count: 3, type: 'VEC3' }],
+    bufferViews: [{ buffer: 0, byteOffset: 0, byteLength: positions.byteLength }],
+    buffers: [{ byteLength: positions.byteLength, uri: bufferUri }],
+  };
+}
+
+describe('glTF producer source-key boundary', () => {
+  it('keeps procedural runtime stubs out of the Catalog projection', () => {
+    const publish = createGltfImporter().capabilities?.catalog?.publish;
+    expect(publish).toBeTypeOf('function');
+    expect(publish?.({ importSettings: { geometry: 'procedural' }, subAssets: [] })).toBe(false);
+    expect(publish?.({ importSettings: {}, subAssets: [] })).toBe(true);
+  });
+
+  it('returns a structured conflict before publishing duplicate semantic names', () => {
+    const result = toAssetPack(duplicateNamedMeshDoc(), undefined, 'duplicate.gltf');
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('duplicate-source-key');
+    expect(result.error.detail.sourceIndices).toEqual([0, 1]);
+  });
+
+  it('applies the same preflight to duplicate material names', () => {
+    const result = toAssetPack(duplicateNamedMaterialDoc(), undefined, 'duplicate.gltf');
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('duplicate-source-key');
+    expect(result.error.detail.sourceIndices).toEqual([0, 1]);
+  });
+
+  it('publishes producer-valid output when semantic identity is unique', () => {
+    const result = toAssetPack(uniqueNamedMeshDoc(), undefined, 'unique.gltf');
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(validateProducerOutputs(result.value.subAssets).ok).toBe(true);
+  });
+
+  it('serializes a valid output that the pack scanner accepts immediately', async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'gltf-source-key-'));
+    try {
+      const result = toAssetPack(uniqueNamedMeshDoc(), undefined, 'unique.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      await writeFile(join(tempDir, 'unique.gltf'), '{}', 'utf-8');
+      await writeFile(
+        join(tempDir, 'unique.gltf.meta.json'),
+        serializeMetaJson(result.value.meta),
+        'utf-8',
+      );
+
+      const scanResult = await scan([tempDir]);
+      expect(scanResult.ok).toBe(true);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('fails before writing and preserves the previous sidecar', async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'gltf-cli-source-key-'));
+    try {
+      const sourcePath = join(tempDir, 'duplicate.gltf');
+      const metaPath = `${sourcePath}.meta.json`;
+      const previous = serializeMetaJson({
+        schemaVersion: 1,
+        kind: 'external-asset-package',
+        importer: 'gltf',
+        source: 'duplicate.gltf',
+        subAssets: [
+          {
+            guid: '01928000-7c00-7000-8000-000000000001',
+            sourceIndex: 0,
+            kind: 'mesh',
+            sourceKey: 'mesh:previous',
+          },
+        ],
+        importSettings: {
+          defaultSceneIndex: 0,
+          diagnostics: { nodeNames: [], unsupportedExtensions: [], matrixTrsCoexistNodes: [] },
+        },
+      });
+      await writeFile(sourcePath, JSON.stringify(duplicateNamedMeshGltfJson()), 'utf-8');
+      await writeFile(metaPath, previous, 'utf-8');
+      const stderr: string[] = [];
+
+      const code = await runCliGltf(['import', sourcePath], {
+        stdoutWrite: () => {},
+        stderrWrite: (line) => stderr.push(line),
+      });
+
+      expect(code).toBe(1);
+      expect(JSON.parse(stderr[0] as string)).toMatchObject({
+        code: 'duplicate-source-key',
+        detail: { sourceIndices: [0, 1] },
+      });
+      expect(await readFile(metaPath, 'utf-8')).toBe(previous);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+});