@forgeax/engine-pack 0.1.2

package/src/__tests__/producer-contract-schema.unit.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { validateProducerContract, validateProducerOutputs } from '../producer-contract.js';
+import { validateMeta, validatePack } from '../schema-compiled.js';
+
+const GUID = '01890000-0000-7000-8000-aaaaaaaaaaaa';
+
+function producerFields(): Record<string, unknown> {
+  return {
+    packageId: 'pkg/fixture',
+    provenance: { provider: 'fixture-provider', version: '1.0.0' },
+    revision: { digest: 'sha256:fixture', observedAt: 123, rootId: 'root-a' },
+    diagnostics: [
+      {
+        code: 'fixture-warning',
+        severity: 'warning',
+        subject: { type: 'package', id: 'pkg/fixture' },
+        expected: 'one stable source key',
+        hint: 'declare sourceKey on every imported output',
+      },
+    ],
+  };
+}
+
+describe('producer contract schema and semantic validation', () => {
+  it('accepts open provider and asset kinds with producer facts', () => {
+    const meta = {
+      schemaVersion: 1,
+      kind: 'external-asset-package',
+      importer: 'host-provider',
+      ...producerFields(),
+      importSettings: {},
+      subAssets: [{ guid: GUID, sourceIndex: 0, sourceKey: 'blob/main', kind: 'host/blob' }],
+    };
+    expect(validateMeta(meta)).toBe(true);
+    expect(validateProducerContract(meta).ok).toBe(true);
+  });
+
+  it('keeps sourceIndex valid without using it to invent sourceKey', () => {
+    const declaration = { guid: GUID, sourceIndex: 0, kind: 'host/blob' };
+    const result = validateProducerContract(declaration);
+    expect(result).toEqual({
+      ok: false,
+      error: expect.objectContaining({ code: 'missing-source-key' }),
+    });
+  });
+
+  it('accepts structured fields on internal pack assets', () => {
+    const pack = {
+      schemaVersion: '1.0.0',
+      kind: 'internal-text-package',
+      ...producerFields(),
+      assets: [
+        {
+          guid: GUID,
+          kind: 'host/blob',
+          execution: 'direct',
+          sourceKey: 'blob/main',
+          sourceIndex: 0,
+          payload: {},
+          refs: [],
+        },
+      ],
+    };
+    expect(validatePack(pack)).toBe(true);
+    expect(validateProducerContract(pack.assets[0]).ok).toBe(true);
+  });
+
+  it('rejects an authoring Pack asset without explicit execution', () => {
+    const pack = {
+      schemaVersion: '2.0.0',
+      kind: 'internal-text-package',
+      packageId: 'pkg/authoring',
+      assets: [{ guid: GUID, kind: 'host/blob', payload: {}, refs: [], artifacts: {} }],
+    };
+    expect(validatePack(pack)).toBe(false);
+  });
+
+  it('rejects duplicate and sourceIndex-only imported output declarations', () => {
+    const outputs = [
+      { guid: GUID, sourceIndex: 0, sourceKey: 'blob/main', kind: 'host/blob' },
+      { guid: `${GUID.slice(0, -1)}b`, sourceIndex: 1, sourceKey: 'blob/main', kind: 'host/blob' },
+    ];
+    const duplicate = validateProducerOutputs(outputs);
+    expect(duplicate.ok).toBe(false);
+    if (!duplicate.ok) expect(duplicate.error.code).toBe('duplicate-source-key');
+    const sourceIndexOnly = validateProducerOutputs(
+      outputs.map(({ sourceKey: _sourceKey, ...output }) => output),
+    );
+    expect(sourceIndexOnly.ok).toBe(false);
+    if (!sourceIndexOnly.ok) expect(sourceIndexOnly.error.code).toBe('source-index-ambiguous');
+  });
+});

package/src/__tests__/resolve-asset-source.test.ts

@@ -0,0 +1,121 @@
+// @ts-nocheck — PackErrorDetail is a discriminated union narrowed by runtime .code
+// checks; TS cannot follow the narrowing through PackError.detail.
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { resolveAssetSource } from '../resolve-asset-source.js';
+
+describe('resolveAssetSource — omit derivation (w4)', () => {
+  const metaDir = '/project/assets';
+
+  it('omitted source derives companion file from meta filename (AC-2)', () => {
+    const metaPath = resolve(metaDir, 'foo.png.meta.json');
+    const result = resolveAssetSource(metaPath, undefined, {});
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe(resolve(metaDir, 'foo.png'));
+    }
+  });
+
+  it('renamed audio meta derives correct companion (AC-3)', () => {
+    const metaPath = resolve(metaDir, 'bleep.wav.meta.json');
+    const result = resolveAssetSource(metaPath, undefined, {});
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe(resolve(metaDir, 'bleep.wav'));
+    }
+  });
+
+  it('derivation is a single rule: strip .meta.json suffix only', () => {
+    const cases = [
+      { meta: 'model.glb.meta.json', expected: 'model.glb' },
+      { meta: 'sprite.png.meta.json', expected: 'sprite.png' },
+      { meta: 'font.ttf.meta.json', expected: 'font.ttf' },
+      { meta: 'bgm.mp3.meta.json', expected: 'bgm.mp3' },
+    ];
+    for (const { meta, expected } of cases) {
+      const metaPath = resolve(metaDir, meta);
+      const result = resolveAssetSource(metaPath, undefined, {});
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value).toBe(resolve(metaDir, expected));
+      }
+    }
+  });
+});
+
+describe('resolveAssetSource — @name/ path + boundary + legacy (w5)', () => {
+  const metaDir = '/project/assets';
+  const metaPath = resolve(metaDir, 'foo.png.meta.json');
+
+  it('resolves @name/rest to absolute path via paths table (AC-5)', () => {
+    const paths = { shared: '/lib/assets' };
+    const result = resolveAssetSource(metaPath, '@shared/foo.png', paths);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe(resolve('/lib/assets', 'foo.png'));
+    }
+  });
+
+  it('returns pack-unknown-path for undeclared @name (AC-8)', () => {
+    const paths = { shared: '/lib/assets' };
+    const result = resolveAssetSource(metaPath, '@nope/x.png', paths);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('pack-unknown-path');
+      expect(result.error.detail.pathName).toBe('nope');
+      expect(result.error.detail.knownNames).toEqual(['shared']);
+    }
+  });
+
+  it('returns pack-malformed-path-ref for bare @ with no name or rest (AC-9)', () => {
+    const result = resolveAssetSource(metaPath, '@', { shared: '/lib/assets' });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('pack-malformed-path-ref');
+      expect(result.error.detail.rawSource).toBe('@');
+      if (result.error.detail.code === 'pack-malformed-path-ref') {
+        expect(result.error.detail.reason).toBe('format');
+      }
+    }
+  });
+
+  it('returns pack-malformed-path-ref for @onlyname with no /rest (AC-9)', () => {
+    const result = resolveAssetSource(metaPath, '@onlyname', { shared: '/lib/assets' });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('pack-malformed-path-ref');
+      expect(result.error.detail.rawSource).toBe('@onlyname');
+    }
+  });
+
+  it('returns pack-malformed-path-ref for ../ escape (AC-11)', () => {
+    const paths = { shared: '/data/shared' };
+    const result = resolveAssetSource(metaPath, '@shared/../escape.png', paths);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('pack-malformed-path-ref');
+      expect(result.error.detail.rawSource).toBe('@shared/../escape.png');
+      if (result.error.detail.code === 'pack-malformed-path-ref') {
+        expect(result.error.detail.reason).toBe('escape');
+      }
+    }
+  });
+
+  it('resolves legacy relative path unchanged', () => {
+    const result = resolveAssetSource(metaPath, 'sub/foo.png', {});
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe(resolve(metaDir, 'sub/foo.png'));
+    }
+  });
+
+  it('returns pack-unknown-path for @name/ when paths is empty', () => {
+    const result = resolveAssetSource(metaPath, '@any/x.png', {});
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('pack-unknown-path');
+      expect(result.error.detail.pathName).toBe('any');
+      expect(result.error.detail.knownNames).toEqual([]);
+    }
+  });
+});

package/src/__tests__/runtime-projection.unit.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+
+import { projectRuntimePack } from '../runtime-projection.js';
+
+const artifact = {
+  path: 'mesh.bin',
+  mediaType: 'application/octet-stream',
+  contentEncoding: 'identity' as const,
+  byteLength: 3,
+  integrity: { algorithm: 'sha256' as const, digest: 'sha256:mesh' },
+};
+
+const asset = {
+  guid: '019e2cc6-0c86-79da-aa76-b0984c86d45a',
+  kind: 'mesh',
+  payload: { kind: 'mesh' },
+  refs: [],
+  artifacts: { mesh: artifact },
+};
+
+describe('runtime Pack projection', () => {
+  it('preserves the material payload and artifact tuple without a runtime adapter', () => {
+    const material = {
+      guid: '019e2cc6-0c86-79da-aa76-b0984c86d45b',
+      kind: 'material',
+      payload: {
+        kind: 'material',
+        passes: [{ name: 'forward', program: { module: 'forgeax::standard' } }],
+        values: { baseColor: [1, 1, 1, 1] },
+      },
+      refs: [],
+      artifacts: {},
+    };
+    const result = projectRuntimePack({
+      scopeId: 'material-session',
+      generation: 1,
+      digest: 'sha256:material-pack',
+      outputSetDigest: 'sha256:material-outputs',
+      assets: [material],
+    });
+
+    expect(result).toMatchObject({ ok: true, value: { assets: [material] } });
+  });
+
+  it('publishes one atomic tuple and one Pack v2 envelope', () => {
+    const result = projectRuntimePack({
+      scopeId: 'play-session',
+      generation: 7,
+      digest: 'sha256:pack',
+      outputSetDigest: 'sha256:outputs',
+      assets: [asset],
+    });
+
+    expect(result).toEqual({
+      ok: true,
+      value: {
+        schemaVersion: '2.0.0',
+        kind: 'internal-text-package',
+        scopeId: 'play-session',
+        generation: 7,
+        digest: 'sha256:pack',
+        outputSetDigest: 'sha256:outputs',
+        assets: [asset],
+      },
+    });
+  });
+
+  it('rejects legacy and duplicate-row input before publication', () => {
+    const legacy = projectRuntimePack({ schemaVersion: '1.0.0', assets: [asset] });
+    expect(legacy).toMatchObject({
+      ok: false,
+      error: { code: 'pack-v2-envelope-invalid', detail: { expected: 'runtime Pack v2' } },
+    });
+
+    const duplicate = projectRuntimePack({
+      scopeId: 'play-session',
+      generation: 7,
+      digest: 'sha256:pack',
+      outputSetDigest: 'sha256:outputs',
+      assets: [asset, asset],
+    });
+    expect(duplicate).toMatchObject({
+      ok: false,
+      error: { code: 'pack-v2-duplicate-guid', detail: { guid: asset.guid } },
+    });
+  });
+});

package/src/__tests__/scanner-inventory.test.ts

@@ -0,0 +1,72 @@
+import { mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { scanInventory } from '../scanner.js';
+
+describe('AssetInventory', () => {
+  const guid = '00000000-0000-0000-0000-000000000002';
+  let root: string | undefined;
+  let sourcePath: string | undefined;
+  let result: Awaited<ReturnType<typeof scanInventory>> | undefined;
+
+  beforeAll(async () => {
+    root = await mkdtemp(join(tmpdir(), 'forgeax-scanner-inventory-'));
+    sourcePath = join(root, 'generated.pack.ts');
+    await writeFile(
+      sourcePath,
+      [
+        'const packageId = new Uint8Array(16);',
+        'packageId[15] = 1;',
+        'const meshGuid = new Uint8Array(16);',
+        'meshGuid[15] = 2;',
+        'export default {',
+        "schemaVersion: '1.0.0', packageId,",
+        "assets: { mesh: { guid: meshGuid, kind: 'mesh' } }, externalAssets: {},",
+        "build: () => ({ ok: true, value: { mesh: { kind: 'mesh' } } }),",
+        '};',
+      ].join('\n'),
+    );
+    result = await scanInventory([root]);
+  });
+
+  afterAll(async () => {
+    if (root !== undefined) await rm(root, { recursive: true, force: true });
+  });
+
+  const getFixture = () => {
+    if (result === undefined || sourcePath === undefined) {
+      throw new Error('scanner fixture was not initialized');
+    }
+    if (!result.ok) throw new Error('scanner fixture failed');
+    return { inventory: result.value, sourcePath };
+  };
+
+  it('projects the ScriptablePack declaration and owner outputs', () => {
+    const { inventory, sourcePath } = getFixture();
+    const declaration = inventory.declarationsByPath.get(sourcePath);
+    expect(declaration).toMatchObject({
+      sourcePath,
+      producer: 'scriptable-pack',
+      outputs: [{ guid, sourceKey: 'mesh', kind: 'mesh', refs: [] }],
+      externalGuids: [],
+      diagnostics: [],
+    });
+  });
+
+  it('projects source closure evidence', async () => {
+    const { inventory, sourcePath } = getFixture();
+    const declaration = inventory.declarationsByPath.get(sourcePath);
+    expect(declaration?.sourceClosure?.map((entry) => entry.path)).toEqual([
+      await realpath(sourcePath),
+    ]);
+  });
+
+  it('indexes the output GUID and ScriptablePack metadata', () => {
+    const { inventory, sourcePath } = getFixture();
+    expect(inventory.sourceByGuid.get(guid)).toBe(sourcePath);
+    expect(inventory.scriptablePackMeta.get(sourcePath)?.subAssets).toEqual([
+      { guid, sourceIndex: 0, sourceKey: 'mesh', kind: 'mesh' },
+    ]);
+  });
+});

package/src/__tests__/scanner-mount-cycle.test.ts

@@ -0,0 +1,232 @@
+// scanner-mount-cycle.test - scanner step-6 mount-asset cycle coverage
+// (feat-20260608-scene-nesting-ecs-fication M1 / w13).
+//
+// Coverage (AC-12; plan-strategy D-1):
+//   (a) acyclic mount chain A -> B -> C: scanner returns Ok (no cycle).
+//   (b) two-asset cycle A -> B -> A: scanner returns
+//       Err(PackError{ code: 'pack-cyclic-reference', detail.kind: 'mount-asset',
+//       detail.cycle: GUID[] }) with the GUIDs in cycle order (first === last).
+//   (c) three-asset cycle A -> B -> C -> A: same, longer cycle.
+//   (d) self-mount A -> A: same, single-element cycle.
+//
+// The fixtures are hand-authored scene .pack.json files in a tmpdir;
+// each scene asset uses `payload.mounts[].source` as an integer index into
+// the parent scene's `refs[]` (D-1 + research Finding 11). The mount window
+// (memberFirst / memberCount) is set conservatively so the scanner step-6
+// cycle pass triggers before any mount-window collision check.
+//
+// TDD red signal: until w14 wires `payload.mounts[].source` -> `refsByGuid`
+// edge into scanner step-6, the scanner does NOT see the mount edge in the
+// DFS and the cycle assertions miss. With w14 the cycle producer surfaces
+// `pack-cyclic-reference + detail.kind: 'mount-asset'` (w8 landed the
+// detail.kind tagging at the producer).
+
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { scan } from '../scanner.js';
+
+const GUID_A = 'aa000000-0000-4000-8000-000000000aaa';
+const GUID_B = 'bb000000-0000-4000-8000-000000000bbb';
+const GUID_C = 'cc000000-0000-4000-8000-000000000ccc';
+
+interface MountSpec {
+  readonly localId: number;
+  readonly source: number;
+  readonly memberFirst: number;
+  readonly memberCount: number;
+}
+
+interface SceneAssetSpec {
+  readonly guid: string;
+  /** GUIDs the scene asset's `payload.mounts[].source` integers index into. */
+  readonly refs: readonly string[];
+  readonly mounts: readonly MountSpec[];
+}
+
+function sceneAssetPack(spec: SceneAssetSpec): unknown {
+  return {
+    schemaVersion: '1.0.0',
+    kind: 'internal-text-package',
+    assets: [
+      {
+        guid: spec.guid,
+        kind: 'scene',
+        refs: [...spec.refs],
+        payload: {
+          kind: 'scene',
+          entities: [{ localId: 0, components: {} }],
+          mounts: spec.mounts.map((m) => ({
+            localId: m.localId,
+            source: m.source,
+            memberFirst: m.memberFirst,
+            memberCount: m.memberCount,
+          })),
+        },
+      },
+    ],
+  };
+}
+
+interface CycleErrorShape {
+  readonly code: string;
+  readonly detail: {
+    readonly code?: string;
+    readonly kind?: string;
+    readonly cycle?: readonly string[];
+  };
+}
+
+describe('scanner step-6 mount-asset cycle detection (AC-12; D-1)', () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), 'pack-mount-cycle-'));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it('(a) accepts an acyclic mount chain A -> B -> C', async () => {
+    // A mounts B (source=0 in A.refs) -> B mounts C (source=0 in B.refs) ->
+    // C mounts nothing.
+    await writeFile(
+      join(dir, 'a.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_A,
+          refs: [GUID_B],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+    await writeFile(
+      join(dir, 'b.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_B,
+          refs: [GUID_C],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+    await writeFile(
+      join(dir, 'c.pack.json'),
+      JSON.stringify(sceneAssetPack({ guid: GUID_C, refs: [], mounts: [] })),
+      'utf-8',
+    );
+
+    const result = await scan([dir]);
+    expect(result.ok).toBe(true);
+  });
+
+  it('(b) rejects a two-asset cycle A -> B -> A with kind: mount-asset', async () => {
+    await writeFile(
+      join(dir, 'a.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_A,
+          refs: [GUID_B],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+    await writeFile(
+      join(dir, 'b.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_B,
+          refs: [GUID_A],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+
+    const result = await scan([dir]);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    const err = result.error as unknown as CycleErrorShape;
+    expect(err.code).toBe('pack-cyclic-reference');
+    expect(err.detail.kind).toBe('mount-asset');
+    const cycle = err.detail.cycle ?? [];
+    expect(cycle.length).toBeGreaterThanOrEqual(2);
+    expect(cycle[0]).toBe(cycle[cycle.length - 1]);
+    // Both GUIDs participate in the cycle (case-insensitive compare; scanner
+    // lowercases before storing).
+    const lower = cycle.map((g) => g.toLowerCase());
+    expect(lower).toContain(GUID_A.toLowerCase());
+    expect(lower).toContain(GUID_B.toLowerCase());
+  });
+
+  it('(c) rejects a three-asset cycle A -> B -> C -> A with kind: mount-asset', async () => {
+    await writeFile(
+      join(dir, 'a.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_A,
+          refs: [GUID_B],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+    await writeFile(
+      join(dir, 'b.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_B,
+          refs: [GUID_C],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+    await writeFile(
+      join(dir, 'c.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_C,
+          refs: [GUID_A],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+
+    const result = await scan([dir]);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    const err = result.error as unknown as CycleErrorShape;
+    expect(err.code).toBe('pack-cyclic-reference');
+    expect(err.detail.kind).toBe('mount-asset');
+    const cycle = err.detail.cycle ?? [];
+    expect(cycle.length).toBeGreaterThanOrEqual(3);
+    expect(cycle[0]).toBe(cycle[cycle.length - 1]);
+  });
+
+  it('(d) rejects a self-mount A -> A', async () => {
+    await writeFile(
+      join(dir, 'a.pack.json'),
+      JSON.stringify(
+        sceneAssetPack({
+          guid: GUID_A,
+          refs: [GUID_A],
+          mounts: [{ localId: 1, source: 0, memberFirst: 2, memberCount: 1 }],
+        }),
+      ),
+      'utf-8',
+    );
+    const result = await scan([dir]);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    const err = result.error as unknown as CycleErrorShape;
+    expect(err.code).toBe('pack-cyclic-reference');
+    expect(err.detail.kind).toBe('mount-asset');
+  });
+});

package/src/__tests__/scriptable-pack-cli.integration.test.ts

@@ -0,0 +1,47 @@
+// @perf-budget-skip: intentional ScriptablePack CLI integration gate.
+
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { runCliAsset } from '../cli-asset.js';
+
+describe('ScriptablePack CLI Meta inspection', () => {
+  it('loads the definition without invoking build', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-'));
+    try {
+      const source = join(root, 'house.pack.mjs');
+      await writeFile(
+        source,
+        `
+        const guid = (hex) => new Uint8Array(hex.match(/../g).map((byte) => Number.parseInt(byte, 16)));
+        export default {
+          schemaVersion: '1.0.0',
+          packageId: guid('019ffa978b397ad284cc273268591ab4'),
+          assets: {
+            wall: { guid: guid('019ffa97a5ee7645b613043323952808'), kind: 'mesh' }
+          },
+          externalAssets: {},
+          build() { throw new Error('META_MUST_NOT_BUILD'); }
+        };
+      `,
+      );
+      const stdout: string[] = [];
+      const stderr: string[] = [];
+      const code = await runCliAsset(['meta', source, '--json'], {
+        stdoutWrite: (line) => stdout.push(line),
+        stderrWrite: (line) => stderr.push(line),
+        cwd: root,
+      });
+      expect(code).toBe(0);
+      expect(stderr).toEqual([]);
+      expect(JSON.parse(stdout[0] ?? '{}')).toMatchObject({
+        importer: 'pack-ts',
+        source,
+        subAssets: [{ sourceKey: 'wall', kind: 'mesh' }],
+      });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});