@forgeax/engine-pack 0.1.28 → 0.1.30

package/src/__tests__/material-cook-schema.unit.test.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { deriveStandardLayerPlan } from '@forgeax/engine-types';
+import { deriveStandardLayerPlan, type MaterialProgramAbi } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import {
   type CookedMaterialRecord,
@@ -82,6 +82,23 @@ const record: CookedMaterialRecord = {
   },
 };
 
+const submissionAbi: MaterialProgramAbi = {
+  directEntry: 'vs_main',
+  sceneIndexEntry: 'vs_scene_index',
+  materialRow: { byteLength: 16, fields: ['baseColor'] },
+  resourceSlots: [],
+  uvSets: [],
+  vertexInputs: [{ semantic: 'position', location: 0, format: 'float32x3' }],
+  alphaMask: { cutoff: 'alphaCutoff', source: 'baseColor.a' },
+  reflection: {
+    layoutIdentity: 'sha256:layout',
+    resourceSlots: [],
+    vertexInputs: [{ semantic: 'position', location: 0, format: 'float32x3' }],
+  },
+  receiptIdentity: 'custom/layout',
+  generation: 1,
+};
+
 function seal(value: CookedMaterialRecord): CookedMaterialRecord {
   return {
     ...value,
@@ -215,6 +232,80 @@ describe('cooked material schema', () => {
     expect(validateCookedMaterialRecord(shared)).toMatchObject({ ok: true });
   });
 
+  it('keeps direct and scene-index selections unique under one published ABI', () => {
+    const primary = record.programs[0] as MaterialCookProgram;
+    const context = primary.selections[0]?.context;
+    if (context === undefined) throw new Error('fixture context is missing');
+    const modern = seal({
+      ...record,
+      programs: [
+        {
+          ...primary,
+          selections: [
+            {
+              pass: 'forward',
+              context,
+              address: 'direct',
+              entry: submissionAbi.directEntry,
+              abi: submissionAbi,
+            },
+            {
+              pass: 'forward',
+              context,
+              address: 'scene-index',
+              entry: submissionAbi.sceneIndexEntry,
+              abi: submissionAbi,
+            },
+          ],
+        },
+      ],
+    });
+    expect(validateCookedMaterialRecord(modern)).toMatchObject({ ok: true });
+    expect(
+      validateCookedMaterialRecord({
+        ...modern,
+        programs: [{ ...modern.programs[0], selections: [modern.programs[0]?.selections[0]] }],
+      }),
+    ).toMatchObject({
+      ok: false,
+      error: { detail: { actual: expect.stringContaining('incomplete submission address pair') } },
+    });
+  });
+
+  it('rejects a partially modern publication instead of assigning missing address facts to direct', () => {
+    const primary = record.programs[0] as MaterialCookProgram;
+    const context = primary.selections[0]?.context;
+    if (context === undefined) throw new Error('fixture context is missing');
+    const passes = [...record.resolved.passes, { name: 'second', program: { module: 'other' } }];
+    const modern = seal({
+      ...record,
+      resolved: { ...record.resolved, passes },
+      programs: [
+        {
+          ...primary,
+          selections: [
+            {
+              pass: 'forward',
+              context,
+              address: 'direct',
+              entry: submissionAbi.directEntry,
+              abi: submissionAbi,
+            },
+            { pass: 'second', context },
+          ],
+        },
+      ],
+    });
+    expect(validateCookedMaterialRecord(modern)).toMatchObject({
+      ok: false,
+      error: {
+        detail: {
+          actual: expect.stringContaining('modern material publications require address'),
+        },
+      },
+    });
+  });
+
   it('rejects ambiguous selections, unpublished passes and unknown context axes', () => {
     const primary = record.programs[0] as MaterialCookProgram;
     expect(

package/src/__tests__/pack-authoring.unit.test.ts

@@ -38,8 +38,7 @@ describe('ScriptablePack and Pack authoring', () => {
         ok({
           'scene/main': {
             kind: 'scene',
-            entities: [],
-            mounts: [],
+            entities: {},
             source: AssetGuid.format(AssetGuid.derive(subjectId, 'mesh/main')),
           },
         }),
@@ -62,8 +61,7 @@ describe('ScriptablePack and Pack authoring', () => {
         ok({
           'scene/main': {
             kind: 'scene',
-            entities: values.segments >= 0 ? [] : [],
-            mounts: [],
+            entities: values.segments >= 0 ? {} : {},
           },
         }),
     });

package/src/__tests__/pack.unit.test.ts

@@ -628,7 +628,7 @@ const V1_WHITELIST = new Set([
     type: 'object',
     additionalProperties: false,
     required: ['parent'],
-    properties: { parent: { type: 'integer', minimum: 0 } },
+    properties: { parent: { type: 'string', minLength: 1 } },
   } as const;
   const componentSchemas: Record<string, object> = {
     Transform: TRANSFORM_SCHEMA,
@@ -639,58 +639,62 @@ const V1_WHITELIST = new Set([
 
   describe('scene-schema.test.ts', () => {
     describe('SceneAsset payload schema - positive cases (w4 / D-P4)', () => {
-      it('accepts a valid 3-node payload (Transform + MeshFilter + ChildOf)', () => {
+      it('accepts a valid keyed payload (Transform + MeshFilter + ChildOf)', () => {
         const payload = {
           kind: 'scene',
-          entities: [
-            {
-              localId: 0,
+          entities: {
+            root: {
               components: {
                 Transform: { pos: [1, 2, 3] },
                 MeshFilter: { mesh: 'cube' },
               },
             },
-            {
-              localId: 1,
-              components: { Transform: { pos: [0, 0, 0] }, ChildOf: { parent: 0 } },
+            child: { components: { Transform: { pos: [0, 0, 0] }, ChildOf: { parent: 'root' } } },
+            grandchild: {
+              components: { Transform: { pos: [5, 5, 5] }, ChildOf: { parent: 'child' } },
             },
-            {
-              localId: 2,
-              components: { Transform: { pos: [5, 5, 5] }, ChildOf: { parent: 1 } },
-            },
-          ],
+          },
         };
         const ok = sceneValidate(payload);
         expect(ok).toBe(true);
         expect(sceneValidate.errors ?? []).toEqual([]);
       });
+
+      it('accepts explicit skin dependency refs in the keyed payload', () => {
+        const payload = {
+          kind: 'scene',
+          skinGuids: ['skin-guid', 0],
+          entities: { root: { components: {} } },
+        };
+        expect(sceneValidate(payload)).toBe(true);
+      });
     });
 
     describe('SceneAsset payload schema - typo field name (AC-08(b))', () => {
       it('rejects Transform with typo field `pozX`, ajv error mentions additional properties', () => {
         const payload = {
           kind: 'scene',
-          entities: [
-            { localId: 0, components: { Transform: { pos: [1, 2, 3] } } },
-            { localId: 1, components: { Transform: { pos: [0, 0, 0] } } },
-            { localId: 2, components: { Transform: { pozX: 7, pos: [0, 0, 0] } } },
-          ],
+          entities: {
+            root: { components: { Transform: { pos: [1, 2, 3] } } },
+            child: { components: { Transform: { pos: [0, 0, 0] } } },
+            broken: { components: { Transform: { pozX: 7, pos: [0, 0, 0] } } },
+          },
         };
         const ok = sceneValidate(payload);
         expect(ok).toBe(false);
         const errors = sceneValidate.errors ?? [];
         expect(errors.length).toBeGreaterThan(0);
         const e = errors[0];
-        expect(e?.instancePath ?? '').toContain('/entities/2/components/Transform');
+        expect(e?.instancePath ?? '').toContain('/entities/broken/components/Transform');
         expect(e?.message ?? '').toContain('additional properties');
       });
     });
 
     describe('SceneAsset payload schema - ChildOf.parent type guard', () => {
-      it('rejects ChildOf.parent that is not a non-negative integer', () => {
+      it('rejects ChildOf.parent that is not a non-empty entity key', () => {
         const payload = {
           kind: 'scene',
-          entities: [{ localId: 0, components: { ChildOf: { parent: -1 } } }],
+          entities: { root: { components: { ChildOf: { parent: 3 } } } },
         };
         const ok = sceneValidate(payload);
         expect(ok).toBe(false);
@@ -703,7 +707,7 @@ const V1_WHITELIST = new Set([
       it('rejects a SceneEntity.components key not in the registered schema map', () => {
         const payload = {
           kind: 'scene',
-          entities: [{ localId: 0, components: { MysteryComponent: { foo: 1 } } }],
+          entities: { root: { components: { MysteryComponent: { foo: 1 } } } },
         };
         const ok = sceneValidate(payload);
         expect(ok).toBe(false);
@@ -713,135 +717,93 @@ const V1_WHITELIST = new Set([
         expect(e?.message ?? '').toContain('additional properties');
       });
     });
+
+    it('rejects an empty authored entity key', () => {
+      const payload = { kind: 'scene', entities: { '': { components: {} } } };
+      expect(sceneValidate(payload)).toBe(false);
+      expect(
+        (sceneValidate.errors ?? []).some((e) => (e?.message ?? '').includes('property name')),
+      ).toBe(true);
+    });
   });
 
-  describe('mount-override-schema.test.ts', () => {
-    // feat-20260713-mount-override-component-add-and-shared-ref-round M1 / w1
-    // (AC-03). `mountOverrideSchema.field` is now optional so the override shape
-    // carries an implicit component-granular discriminant: an override WITH
-    // `field` patches one field (legacy 4-key), an override WITHOUT `field`
-    // adds/upserts the whole component (new 3-key). The schema accepts both;
-    // `localId` / `comp` / `value` stay required; `additionalProperties: false`
-    // rejects any op-tag discriminant (OOS: no `switch (op)` fan-out downstream).
-    function makeMountPayload(override: Record<string, unknown>): Record<string, unknown> {
+  describe('scene-instance-schema.test.ts', () => {
+    type MutableInstanceEntity = {
+      instance: { overrides: Array<Record<string, unknown>> };
+    };
+
+    function makeInstancePayload(override: Record<string, unknown>): Record<string, unknown> {
       return {
         kind: 'scene',
-        entities: [{ localId: 0, components: { Transform: { pos: [0, 0, 0] } } }],
-        mounts: [
-          {
-            localId: 1,
-            source: 0,
-            memberFirst: 2,
-            memberCount: 1,
-            overrides: [override],
+        entities: {
+          root: { components: {} },
+          child: {
+            components: {},
+            instance: {
+              source: 'child-guid',
+              overrides: [{ target: ['leaf'], components: override }],
+            },
           },
-        ],
+        },
       };
     }
 
-    it('accepts the 4-key patch shape (with field)', () => {
-      const ok = sceneValidate(
-        makeMountPayload({ localId: 2, comp: 'Transform', field: 'pos', value: [1, 2, 3] }),
-      );
+    it('accepts a keyed nested instance with component fields', () => {
+      const ok = sceneValidate(makeInstancePayload({ Transform: { pos: [1, 2, 3] } }));
       expect(ok).toBe(true);
       expect(sceneValidate.errors ?? []).toEqual([]);
     });
 
-    it('accepts the 3-key add shape (without field)', () => {
+    it('accepts an ordered override with multiple components', () => {
       const ok = sceneValidate(
-        makeMountPayload({ localId: 2, comp: 'Transform', value: { pos: [1, 2, 3] } }),
+        makeInstancePayload({
+          Transform: { pos: [1, 2, 3] },
+          MeshFilter: { mesh: 'cube' },
+        }),
       );
       expect(ok).toBe(true);
       expect(sceneValidate.errors ?? []).toEqual([]);
     });
 
-    it('rejects an override missing localId', () => {
-      const ok = sceneValidate(makeMountPayload({ comp: 'Transform', value: [1, 2, 3] }));
-      expect(ok).toBe(false);
-      expect((sceneValidate.errors ?? []).length).toBeGreaterThan(0);
+    it('rejects an override missing target', () => {
+      const payload = makeInstancePayload({ Transform: { pos: [1, 2, 3] } });
+      const instance = (payload.entities as Record<string, MutableInstanceEntity>).child.instance;
+      instance.overrides = [{ components: { Transform: { pos: [1, 2, 3] } } }];
+      expect(sceneValidate(payload)).toBe(false);
     });
 
-    it('rejects an override missing comp', () => {
-      const ok = sceneValidate(makeMountPayload({ localId: 2, value: [1, 2, 3] }));
-      expect(ok).toBe(false);
-      expect((sceneValidate.errors ?? []).length).toBeGreaterThan(0);
+    it('rejects an override missing components', () => {
+      const payload = makeInstancePayload({ Transform: { pos: [1, 2, 3] } });
+      const instance = (payload.entities as Record<string, MutableInstanceEntity>).child.instance;
+      instance.overrides = [{ target: ['leaf'] }];
+      expect(sceneValidate(payload)).toBe(false);
     });
 
-    it('rejects an override missing value', () => {
-      const ok = sceneValidate(makeMountPayload({ localId: 2, comp: 'Transform', field: 'pos' }));
-      expect(ok).toBe(false);
-      expect((sceneValidate.errors ?? []).length).toBeGreaterThan(0);
+    it('rejects an instance missing source', () => {
+      const payload = makeInstancePayload({ Transform: { pos: [1, 2, 3] } });
+      const child = (payload.entities as Record<string, MutableInstanceEntity>).child;
+      child.instance = { overrides: [{ target: ['leaf'], components: {} }] };
+      expect(sceneValidate(payload)).toBe(false);
     });
 
-    it('rejects an override carrying an op discriminant field (additionalProperties:false)', () => {
-      const ok = sceneValidate(
-        makeMountPayload({ localId: 2, comp: 'Transform', value: [1, 2, 3], op: 'add' }),
-      );
-      expect(ok).toBe(false);
-      const errors = sceneValidate.errors ?? [];
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors.some((e) => (e?.message ?? '').includes('additional properties'))).toBe(true);
+    it('rejects an override carrying an op discriminant field', () => {
+      const payload = makeInstancePayload({ Transform: { pos: [1, 2, 3] } });
+      const instance = (payload.entities as Record<string, MutableInstanceEntity>).child.instance;
+      instance.overrides = [{ target: ['leaf'], components: {}, op: 'add' }];
+      expect(sceneValidate(payload)).toBe(false);
+      expect(
+        (sceneValidate.errors ?? []).some((e) =>
+          (e?.message ?? '').includes('additional properties'),
+        ),
+      ).toBe(true);
     });
 
-    // ═════════════════════════════════════════════════════════════════════════
-    // w22 — AC-03 / D-9: serialize→validate round-trip on fold-produced overrides
-    //
-    // The M5 collect fold emits component-add overrides (no `field`) whose value
-    // is a per-field map that may carry shared<T> GUID strings (e.g. the added
-    // AnimationPlayer.clips = [GUID, 0, 0, 0]). ajv's mountOverrideSchema must
-    // accept that fold-produced shape, and a serialize→validate→deserialize
-    // round-trip must not drop the override data. The override value is a free-
-    // form object (`value: {}`) at the schema layer — runtime type checks live
-    // in the ecs apply path (setSceneOverride / _validateMountOverrides).
-    // ═════════════════════════════════════════════════════════════════════════
-
-    const W22_CLIP = 'f1e2d3c4-b5a6-4b7c-8d9e-0f1a2b3c4d5e';
-
-    it('(w22-a) accepts a fold-produced add-override with a shared-field GUID array value', () => {
-      const payload = makeMountPayload({
-        localId: 2,
-        comp: 'Transform',
-        // component-add form (no field); value carries a positional array with a
-        // GUID string at slot 0 and NULL-sentinel placeholders — the exact shape
-        // the fold + serialize wiring emits for AnimationPlayer.clips.
-        value: { clips: [W22_CLIP, 0, 0, 0] },
-      });
-      const ok = sceneValidate(payload);
-      expect(ok).toBe(true);
-      expect(sceneValidate.errors ?? []).toEqual([]);
-    });
-
-    it('(w22-b) accepts an add-override whose value has no shared field at all', () => {
-      // component-add with a plain scalar-only value map (the minimal add shape).
-      const ok = sceneValidate(
-        makeMountPayload({ localId: 2, comp: 'Transform', value: { pos: [9, 9, 9] } }),
-      );
-      expect(ok).toBe(true);
-      expect(sceneValidate.errors ?? []).toEqual([]);
-    });
-
-    it('(w22-c) round-trip: JSON serialize → validate → parse preserves override data', () => {
-      const override = {
-        localId: 2,
-        comp: 'Transform',
-        value: { clips: [W22_CLIP, 0, 0, 0], pos: [1, 2, 3] },
-      };
-      const payload = makeMountPayload(override);
-
-      // Simulate the on-disk pack path: JSON.stringify → fetch → JSON.parse.
+    it('round-trips keyed instance override data through JSON', () => {
+      const payload = makeInstancePayload({ Transform: { pos: [1, 2, 3] } });
       const roundTripped = JSON.parse(JSON.stringify(payload)) as Record<string, unknown>;
-      const ok = sceneValidate(roundTripped);
-      expect(ok).toBe(true);
-      expect(sceneValidate.errors ?? []).toEqual([]);
-
-      // No data lost: the override survives the round-trip byte-for-byte.
-      const mounts = roundTripped.mounts as Array<Record<string, unknown>>;
-      const overrides = mounts[0]?.overrides as Array<Record<string, unknown>>;
-      expect(overrides).toHaveLength(1);
-      expect(overrides[0]).toEqual(override);
-      const value = overrides[0]?.value as Record<string, unknown>;
-      expect(value.clips).toEqual([W22_CLIP, 0, 0, 0]);
-      expect(value.pos).toEqual([1, 2, 3]);
+      expect(sceneValidate(roundTripped)).toBe(true);
+      const child = (roundTripped.entities as Record<string, MutableInstanceEntity>).child;
+      expect(child.instance.overrides[0]?.target).toEqual(['leaf']);
     });
   });
 }

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

@@ -0,0 +1,36 @@
+import { expect, it } from 'vitest';
+import { createRuntimePackPublication } from '../runtime-publication.js';
+
+it('preserves declared source keys in derived publication rows and their digest', () => {
+  const input = {
+    pack: {
+      assets: [
+        { guid: 'WALL-GUID', kind: 'volume', payload: {} },
+        { guid: 'CONTROL-GUID', kind: 'mesh', payload: {} },
+      ],
+    },
+    scopeId: 'lab',
+    sourcePath: 'wall.pack.json',
+    sourceRevision: 'source-1',
+    packageUrl: '/wall.pack.json',
+  };
+  const before = createRuntimePackPublication(input);
+  const after = createRuntimePackPublication({
+    ...input,
+    sourceKeys: new Map([['wall-guid', 'wall/main']]),
+  });
+  expect(after.publication.outputs.map(({ guid, sourceKey }) => [guid, sourceKey])).toEqual([
+    ['wall-guid', 'wall/main'],
+    ['control-guid', 'control-guid'],
+  ]);
+  expect(after.pack.digest).toBe(before.pack.digest);
+  expect(after.pack.outputSetDigest).not.toBe(before.pack.outputSetDigest);
+  expect(after.publication.receipt.outputSetDigest).toBe(after.pack.outputSetDigest);
+  // Explicit producer output rows remain authoritative when provided.
+  const explicit = createRuntimePackPublication({
+    ...input,
+    sourceKeys: new Map([['wall-guid', 'ignored']]),
+    outputs: after.publication.outputs,
+  });
+  expect(explicit.publication.outputs).toEqual(after.publication.outputs);
+});

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

@@ -0,0 +1,92 @@
+// Scanner dependency-cycle coverage for keyed SceneAsset instances.
+
+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';
+
+function sceneAssetPack(guid: string, source?: string): unknown {
+  return {
+    schemaVersion: '1.0.0',
+    kind: 'internal-text-package',
+    assets: [
+      {
+        guid,
+        kind: 'scene',
+        refs: source === undefined ? [] : [source],
+        payload: {
+          kind: 'scene',
+          entities:
+            source === undefined
+              ? { root: { components: {} } }
+              : { child: { components: {}, instance: { source: 0 } } },
+        },
+      },
+    ],
+  };
+}
+
+describe('scanner keyed SceneAsset instance cycle detection', () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), 'pack-instance-cycle-'));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it('accepts an acyclic instance chain A -> B -> C', async () => {
+    await writeFile(
+      join(dir, 'a.pack.json'),
+      JSON.stringify(sceneAssetPack(GUID_A, GUID_B)),
+      'utf8',
+    );
+    await writeFile(
+      join(dir, 'b.pack.json'),
+      JSON.stringify(sceneAssetPack(GUID_B, GUID_C)),
+      'utf8',
+    );
+    await writeFile(join(dir, 'c.pack.json'), JSON.stringify(sceneAssetPack(GUID_C)), 'utf8');
+    expect((await scan([dir])).ok).toBe(true);
+  });
+
+  it.each([
+    ['two', [GUID_A, GUID_B]],
+    ['three', [GUID_A, GUID_B, GUID_C]],
+  ])('rejects a %s-asset instance cycle', async (_name, cycle) => {
+    const [a, b, c] = cycle;
+    await writeFile(join(dir, 'a.pack.json'), JSON.stringify(sceneAssetPack(a, b)), 'utf8');
+    await writeFile(join(dir, 'b.pack.json'), JSON.stringify(sceneAssetPack(b, c ?? a)), 'utf8');
+    if (c !== undefined)
+      await writeFile(join(dir, 'c.pack.json'), JSON.stringify(sceneAssetPack(c, a)), 'utf8');
+    const result = await scan([dir]);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('pack-cyclic-reference');
+    const detail = result.error.detail as { kind?: string; cycle?: readonly string[] };
+    expect(detail.kind).toBe('mount-asset');
+    const found = detail.cycle ?? [];
+    expect(found[0]).toBe(found[found.length - 1]);
+    for (const guid of cycle) expect(found).toContain(guid);
+  });
+
+  it('rejects a self-instance', async () => {
+    await writeFile(
+      join(dir, 'a.pack.json'),
+      JSON.stringify(sceneAssetPack(GUID_A, GUID_A)),
+      'utf8',
+    );
+    const result = await scan([dir]);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('pack-cyclic-reference');
+    expect((result.error.detail as { kind?: string }).kind).toBe('mount-asset');
+  });
+});

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

@@ -95,7 +95,7 @@ describe('engine-pack scanner inventory contract', () => {
             default: {
               schemaVersion: '2.0.0',
               packageId: scriptablePackageId,
-              build: () => ({ ok: true, value: { effect: { kind: 'scene', entities: [] } } }),
+              build: () => ({ ok: true, value: { effect: { kind: 'scene', entities: {} } } }),
             },
           }),
         },
@@ -143,7 +143,7 @@ describe('engine-pack scanner inventory contract', () => {
             default: {
               schemaVersion: '2.0.0',
               packageId,
-              build: () => ({ ok: true, value: { effect: { kind: 'scene', entities: [] } } }),
+              build: () => ({ ok: true, value: { effect: { kind: 'scene', entities: {} } } }),
             },
           }),
           dispose: async () => {

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

@@ -1,12 +1,46 @@
 // @perf-budget-skip: intentional ScriptablePack CLI integration gate.
 
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { err } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { runCliAsset } from '../cli-asset.js';
+import { loadScriptablePack } from '../scriptable-pack-node.js';
 
 describe('ScriptablePack CLI Meta inspection', () => {
+  it('executes TypeScript re-export closures using JavaScript specifiers and directory indexes', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-ts-closure-'));
+    try {
+      await mkdir(join(root, 'nested'));
+      await writeFile(join(root, 'nested/index.ts'), 'export const count: number = 7;');
+      await writeFile(join(root, 'barrel.ts'), "export * from './nested';");
+      const source = join(root, 'shape.pack.ts');
+      await writeFile(
+        source,
+        `import { count } from './barrel.js';
+        export default { schemaVersion: '2.0.0',
+          packageId: new Uint8Array([1,159,250,151,139,57,122,210,132,204,39,50,104,89,26,180]),
+          build() { return { ok: true, value: { 'scene/main': { kind: 'scene', entities: [], mounts: [], count } } }; }
+        };`,
+      );
+      const loaded = await loadScriptablePack(source);
+      expect(loaded.ok).toBe(true);
+      if (!loaded.ok) throw loaded.error;
+      const built = await loaded.value.build({
+        packageId: loaded.value.packageId,
+        values: {},
+        readByGuid: async () => err('unused'),
+      });
+      expect(built).toMatchObject({
+        ok: true,
+        value: { 'scene/main': { kind: 'scene', count: 7 } },
+      });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   it('loads the definition without invoking build', async () => {
     const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-'));
     try {