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

package/src/__tests__/package-finalizer.contract.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+import {
+  finalizePackageProduct,
+  type PackageProduct,
+  packageTransportRevision,
+} from '../package-finalizer.js';
+
+const GUID = '019e3969-1d48-7c3b-ac24-6d68f457065f';
+
+function product(overrides: Partial<PackageProduct> = {}): PackageProduct {
+  return {
+    assets: [
+      {
+        guid: GUID,
+        kind: 'texture',
+        payload: { kind: 'texture', width: 1, height: 1 },
+        refs: [],
+        artifacts: {
+          source: { mediaType: 'image/png', bytes: new Uint8Array([1, 2, 3]) },
+        },
+      },
+    ],
+    receipts: [
+      {
+        guid: GUID,
+        origin: 'sourceMeta',
+        status: 'succeeded',
+        inputFingerprint: 'sha256:source',
+      },
+    ],
+    diagnostics: [],
+    sourceRevision: 'sha256:source',
+    sourceKey: 'texture/source',
+    ...overrides,
+  };
+}
+
+describe('engine-pack terminal product and finalizer contract', () => {
+  it('finalizes one complete product with source identity and receipts', async () => {
+    const result = await finalizePackageProduct(product(), {
+      base: '/assets',
+      packagePath: 'packages/texture.pack.json',
+      artifactPath: (guid, key) => `artifacts/${guid}/${key}.bin`,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.pack.assets).toHaveLength(1);
+    expect(result.value.digest).toMatch(/^sha256:/);
+    expect(result.value.receipts).toHaveLength(1);
+    expect(result.value.sourceRevision).toBe('sha256:source');
+    expect(result.value.sourceKey).toBe('texture/source');
+  });
+
+  it('fails closed on duplicate GUIDs and incomplete receipt evidence', async () => {
+    const firstAsset = product().assets[0];
+    if (firstAsset === undefined) throw new Error('test product asset is missing');
+    const duplicate = product({ assets: [firstAsset, firstAsset] });
+    const duplicateResult = await finalizePackageProduct(duplicate, {
+      base: '/',
+      packagePath: 'packages/duplicate.pack.json',
+      artifactPath: (guid, key) => `${guid}/${key}.bin`,
+    });
+    expect(duplicateResult.ok).toBe(false);
+
+    const missingReceipt = product({ receipts: [] });
+    const missingReceiptResult = await finalizePackageProduct(missingReceipt, {
+      base: '/',
+      packagePath: 'packages/missing-receipt.pack.json',
+      artifactPath: (guid, key) => `${guid}/${key}.bin`,
+    });
+    expect(missingReceiptResult.ok).toBe(false);
+  });
+
+  it('hashes and transports large artifact bodies without JSON-expanding the bytes', async () => {
+    const body = new Uint8Array(4 * 1024 * 1024);
+    const artifact = { mediaType: 'application/octet-stream', bytes: body };
+    const asset = product().assets[0];
+    if (asset === undefined) throw new Error('test product asset is missing');
+    const large = product({
+      assets: [{ ...asset, artifacts: { body: artifact } }],
+    });
+
+    const revision = packageTransportRevision(large);
+    expect(revision).toMatch(/^[0-9a-f]{64}$/);
+
+    const writes = new Map<string, Uint8Array>();
+    const result = await finalizePackageProduct(large, {
+      base: '/',
+      packagePath: 'large.pack.json',
+      artifactPath: (guid, key) => `${guid}/${key}.bin`,
+      sink: (path, bytes) => {
+        writes.set(path, bytes);
+      },
+    });
+    expect(result.ok).toBe(true);
+    const packageBytes = writes.get('large.pack.json');
+    expect(packageBytes).toBeDefined();
+    const published = JSON.parse(new TextDecoder().decode(packageBytes)) as {
+      assets: readonly [{ artifacts: { body: { byteLength: number } } }];
+    };
+    expect(published.assets[0]?.artifacts.body.byteLength).toBe(body.byteLength);
+    expect(writes.get(`${GUID}/body.bin`)).toBe(body);
+  });
+});

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__/runtime.browser.test.ts

@@ -0,0 +1,15 @@
+import { parsePackV2 } from '@forgeax/engine-pack/runtime';
+import { describe, expect, it } from 'vitest';
+
+describe('Pack runtime entry', () => {
+  it('parses a Pack v2 envelope in a browser without the Node scanner barrel', () => {
+    const result = parsePackV2({
+      schemaVersion: '2.0.0',
+      kind: 'internal-text-package',
+      packageId: 'browser-runtime',
+      assets: [],
+    });
+
+    expect(result.ok).toBe(true);
+  });
+});

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

@@ -0,0 +1,167 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { AssetGuid } from '../guid.js';
+import { scan, scanInventory } from '../scanner.js';
+
+const GUID = '019e3969-1d48-7c3b-ac24-6d68f457065f';
+
+function guid(value: string): Uint8Array {
+  const parsed = AssetGuid.parse(value);
+  if (!parsed.ok) throw parsed.error;
+  return parsed.value;
+}
+
+describe('engine-pack scanner inventory contract', () => {
+  const roots: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+  });
+
+  it('returns one inventory declaration with source identity before finalization', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-inventory-'));
+    roots.push(root);
+    await writeFile(
+      join(root, 'hero.pack.json'),
+      JSON.stringify({
+        schemaVersion: '2.0.0',
+        kind: 'internal-text-package',
+        assets: [
+          {
+            guid: GUID,
+            kind: 'texture',
+            payload: { kind: 'texture', width: 1, height: 1 },
+            refs: [],
+            sourceKey: 'hero/albedo',
+            sourceIndex: 0,
+          },
+        ],
+      }),
+    );
+
+    const result = await scanInventory([root]);
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.inventory).toHaveLength(1);
+    expect(result.value.inventory[0]).toMatchObject({
+      guid: GUID,
+      sourceKey: 'hero/albedo',
+      sourceIndex: 0,
+    });
+  });
+
+  it('returns the parsed Meta, Pack, and ScriptablePack declarations from one scan pass', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-declarations-'));
+    roots.push(root);
+
+    const metaPath = join(root, 'hero.meta.json');
+    const packPath = join(root, 'environment.pack.json');
+    const scriptablePath = join(root, 'effects.pack.ts');
+    const meta = {
+      schemaVersion: '1.0.0',
+      kind: 'external-asset-package',
+      importer: 'image',
+      source: 'hero.png',
+      importSettings: {},
+      subAssets: [
+        { guid: '019e3969-1d48-7c3b-ac24-6d68f4570660', sourceIndex: 0, kind: 'texture' },
+      ],
+    } as const;
+    const pack = {
+      schemaVersion: '2.0.0',
+      kind: 'internal-text-package',
+      assets: [
+        {
+          guid: '019e3969-1d48-7c3b-ac24-6d68f4570661',
+          kind: 'texture',
+          payload: { kind: 'texture', width: 1, height: 1 },
+          refs: [],
+        },
+      ],
+    } as const;
+    await writeFile(join(root, 'hero.png'), 'source');
+    await writeFile(metaPath, JSON.stringify(meta));
+    await writeFile(packPath, JSON.stringify(pack));
+    await writeFile(scriptablePath, '// scanner fixture');
+
+    const scriptablePackageId = guid('019e3969-1d48-7c3b-ac24-6d68f4570662');
+    const scriptableAssetGuid = guid('019e3969-1d48-7c3b-ac24-6d68f4570663');
+    const result = await scanInventory([root], {
+      scriptablePack: {
+        executor: {
+          load: async () => ({
+            default: {
+              schemaVersion: '1.0.0',
+              packageId: scriptablePackageId,
+              assets: { effect: { guid: scriptableAssetGuid, kind: 'scene' } },
+              externalAssets: {},
+              build: () => ({ ok: true, value: {} }),
+            },
+          }),
+        },
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.declarations.size).toBe(3);
+    expect(result.value.declarations.get(metaPath)).toMatchObject({
+      format: 'meta.json',
+      sourcePath: metaPath,
+      value: meta,
+    });
+    expect(result.value.declarations.get(packPath)).toMatchObject({
+      format: 'pack.json',
+      sourcePath: packPath,
+      value: pack,
+    });
+    const scriptableDeclaration = result.value.declarations.get(scriptablePath);
+    expect(scriptableDeclaration).toMatchObject({
+      format: 'pack.ts',
+      sourcePath: scriptablePath,
+      value: {
+        importer: 'pack-ts',
+        packageId: '019e3969-1d48-7c3b-ac24-6d68f4570662',
+        subAssets: [{ sourceKey: 'effect', kind: 'scene' }],
+      },
+    });
+    expect(
+      scriptableDeclaration?.format === 'pack.ts' ? scriptableDeclaration.meta : undefined,
+    ).toBe(scriptableDeclaration?.format === 'pack.ts' ? scriptableDeclaration.value : undefined);
+  });
+
+  it('releases the ScriptablePack loader for the path-only scan contract', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-scan-release-'));
+    roots.push(root);
+    const scriptablePath = join(root, 'effects.pack.ts');
+    await writeFile(scriptablePath, '// scanner fixture');
+
+    const packageId = guid('019e3969-1d48-7c3b-ac24-6d68f4570664');
+    const assetGuid = guid('019e3969-1d48-7c3b-ac24-6d68f4570665');
+    let disposals = 0;
+    const result = await scan([root], {
+      scriptablePack: {
+        executor: {
+          load: async () => ({
+            default: {
+              schemaVersion: '1.0.0',
+              packageId,
+              assets: { effect: { guid: assetGuid, kind: 'scene' } },
+              externalAssets: {},
+              build: () => ({ ok: true, value: {} }),
+            },
+          }),
+          dispose: async () => {
+            disposals += 1;
+          },
+        },
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    expect(disposals).toBe(1);
+  });
+});

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

@@ -0,0 +1,76 @@
+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.declarations.get(sourcePath);
+    expect(declaration).toMatchObject({
+      format: 'pack.ts',
+      sourcePath,
+      meta: {
+        importer: 'pack-ts',
+        subAssets: [{ guid, sourceKey: 'mesh', kind: 'mesh' }],
+      },
+    });
+  });
+
+  it('projects source closure evidence', async () => {
+    const { inventory, sourcePath } = getFixture();
+    const declaration = inventory.declarations.get(sourcePath);
+    expect(
+      declaration?.format === 'pack.ts'
+        ? declaration.sourceClosure.map((entry) => entry.path)
+        : undefined,
+    ).toEqual([await realpath(sourcePath)]);
+  });
+
+  it('indexes the ScriptablePack declaration without a second metadata registry', () => {
+    const { inventory, sourcePath } = getFixture();
+    const declaration = inventory.declarations.get(sourcePath);
+    expect(inventory.inventory).toEqual([]);
+    expect(declaration?.format === 'pack.ts' ? declaration.meta.subAssets : undefined).toEqual([
+      { guid, sourceIndex: 0, sourceKey: 'mesh', kind: 'mesh' },
+    ]);
+  });
+});