@forgeax/engine-pack 0.1.21 → 0.1.24

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

@@ -0,0 +1,266 @@
+import { ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { AssetGuid, PackageId } from '../guid.js';
+import {
+  definePack,
+  definePackageId,
+  type PackParameterInheritanceSubject,
+  parsePackSourceJson,
+  projectDirectPackJson,
+  resolvePackParameterInheritance,
+  resolvePackParameterValues,
+  validatePackDefinition,
+} from '../pack-authoring.js';
+
+const NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+function packageId(value: string) {
+  const result = PackageId.parse(value);
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+describe('ScriptablePack and Pack authoring', () => {
+  it('derives the RFC 4122 UUIDv5 vector and keeps PackageId branded separately', () => {
+    const namespace = packageId(NAMESPACE);
+    expect(AssetGuid.format(AssetGuid.derive(namespace, 'www.widgets.com'))).toBe(
+      '21f7f8de-8051-5b89-8680-0195ef798b6a',
+    );
+    expect(PackageId.format(namespace)).toBe(NAMESPACE);
+    expect(AssetGuid.derive(namespace, 'mesh/a')).not.toBe(namespace);
+  });
+
+  it('derives an explicit context shape for zero-parameter and parameter-bearing ScriptablePacks', async () => {
+    const zero = definePack({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000001'),
+      build: ({ packageId: subjectId }) =>
+        ok({
+          'scene/main': {
+            kind: 'scene',
+            entities: [],
+            mounts: [],
+            source: AssetGuid.format(AssetGuid.derive(subjectId, 'mesh/main')),
+          },
+        }),
+    });
+    expect('parameters' in zero).toBe(false);
+    const zeroResult = await zero.build({
+      packageId: zero.packageId,
+      readByGuid: async () => ok(null as never),
+    });
+    expect(zeroResult.ok).toBe(true);
+
+    const withParameters = definePack({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000002'),
+      parameters: [
+        { name: 'segments', type: 'u32', default: 12, minimum: 3, maximum: 128 },
+        { name: 'style', type: 'enum', values: ['oak', 'pine'], default: 'oak' },
+      ] as const,
+      build: ({ values }) =>
+        ok({
+          'scene/main': {
+            kind: 'scene',
+            entities: values.segments >= 0 ? [] : [],
+            mounts: [],
+          },
+        }),
+    });
+    const values = resolvePackParameterValues(withParameters, { segments: 24 });
+    expect(values).toMatchObject({ ok: true, value: { segments: 24, style: 'oak' } });
+    expect(resolvePackParameterValues(withParameters, { unknown: true })).toMatchObject({
+      ok: false,
+      error: { code: 'pack-parameter-invalid' },
+    });
+
+    const bounded = definePack({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000003'),
+      parameters: [
+        { name: 'unsigned', type: 'u32', default: 0 },
+        { name: 'signed', type: 'i32', default: 0 },
+        { name: 'float', type: 'f32', default: 0 },
+      ] as const,
+      build: () => ok({}),
+    });
+    expect(resolvePackParameterValues(bounded, { unsigned: 0x1_0000_0000 })).toMatchObject({
+      ok: false,
+      error: { code: 'pack-parameter-invalid' },
+    });
+    expect(resolvePackParameterValues(bounded, { signed: 0x8000_0000 })).toMatchObject({
+      ok: false,
+      error: { code: 'pack-parameter-invalid' },
+    });
+    expect(resolvePackParameterValues(bounded, { float: Number.MAX_VALUE })).toMatchObject({
+      ok: false,
+      error: { code: 'pack-parameter-invalid' },
+    });
+  });
+
+  it('validates and preserves optional scene component schemas without exposing output identity', () => {
+    const definition = definePack({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000004'),
+      sceneComponents: [
+        { name: 'Transform', fields: { pos: { type: 'vec3' }, quat: 'quat' } },
+        { name: 'Name', fields: { value: 'string' } },
+      ],
+      build: () => ok({}),
+    });
+    expect(definition.sceneComponents).toEqual([
+      { name: 'Transform', fields: { pos: { type: 'vec3' }, quat: 'quat' } },
+      { name: 'Name', fields: { value: 'string' } },
+    ]);
+    expect(Object.isFrozen(definition.sceneComponents)).toBe(true);
+    expect(Object.isFrozen(definition.sceneComponents?.[0])).toBe(true);
+    expect(Object.isFrozen(definition.sceneComponents?.[0]?.fields)).toBe(true);
+
+    const duplicate = validatePackDefinition({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000005'),
+      sceneComponents: [
+        { name: 'Transform', fields: {} },
+        { name: 'Transform', fields: {} },
+      ],
+      build: () => ok({}),
+    });
+    expect(duplicate).toMatchObject({
+      ok: false,
+      error: {
+        code: 'pack-parameter-invalid',
+        detail: { reason: 'scene component names must be unique' },
+      },
+    });
+    const malformed = validatePackDefinition({
+      schemaVersion: '2.0.0',
+      packageId: definePackageId('01900000-0000-7000-8000-000000000006'),
+      sceneComponents: [{ name: 'Transform', fields: { pos: { type: '' } } }],
+      build: () => ok({}),
+    });
+    expect(malformed).toMatchObject({
+      ok: false,
+      error: {
+        code: 'pack-parameter-invalid',
+        detail: { reason: 'scene component field schema is malformed' },
+      },
+    });
+  });
+
+  it('parses direct and instance JSON without accepting GUID fields', () => {
+    const direct = parsePackSourceJson({
+      schemaVersion: '3.0.0',
+      packageId: '01900000-0000-7000-8000-000000000010',
+      assets: {
+        'scene/main': { kind: 'scene', payload: {}, refs: [] },
+      },
+    });
+    expect(direct.ok).toBe(true);
+    if (direct.ok && direct.value.format === 'direct') {
+      const projected = projectDirectPackJson(direct.value);
+      expect(projected).toMatchObject({
+        ok: true,
+        value: {
+          packageId: '01900000-0000-7000-8000-000000000010',
+          assets: [{ sourceKey: 'scene/main', guid: expect.any(String) }],
+        },
+      });
+    }
+    expect(
+      parsePackSourceJson({
+        schemaVersion: '3.0.0',
+        packageId: '01900000-0000-7000-8000-000000000010',
+        assets: { 'scene/main': { guid: NAMESPACE, kind: 'scene', payload: {}, refs: [] } },
+      }),
+    ).toMatchObject({ ok: false, error: { code: 'pack-parameter-invalid' } });
+    expect(
+      parsePackSourceJson({
+        schemaVersion: '3.0.0',
+        packageId: '01900000-0000-7000-8000-000000000020',
+        parent: '01900000-0000-7000-8000-000000000002',
+        values: { segments: 24 },
+      }),
+    ).toMatchObject({ ok: true, value: { format: 'instance' } });
+  });
+
+  it('rejects legacy static output fields in the v2 source definition', () => {
+    expect(() =>
+      definePack({
+        schemaVersion: '2.0.0',
+        packageId: definePackageId('01900000-0000-7000-8000-000000000021'),
+        assets: [],
+        build: () => ok({}),
+      } as never),
+    ).toThrow(/repair the parameter declaration|authoring/);
+    expect(() =>
+      definePack({
+        schemaVersion: '2.0.0',
+        packageId: definePackageId('01900000-0000-7000-8000-000000000022'),
+        externalAssets: [],
+        build: () => ok({}),
+      } as never),
+    ).toThrow();
+  });
+
+  it('rejects unknown parameter descriptor fields instead of carrying a second schema', () => {
+    expect(() =>
+      definePack({
+        schemaVersion: '2.0.0',
+        packageId: definePackageId('01900000-0000-7000-8000-000000000023'),
+        parameters: [{ name: 'count', type: 'u32', default: 1, editor: 'slider' }] as never,
+        build: () => ok({}),
+      }),
+    ).toThrow();
+  });
+
+  it('resolves finite shallow inheritance and reports missing parent and cycle', async () => {
+    const rootId = packageId('01900000-0000-7000-8000-000000000030');
+    const middleId = packageId('01900000-0000-7000-8000-000000000031');
+    const leafId = packageId('01900000-0000-7000-8000-000000000032');
+    const root: PackParameterInheritanceSubject = {
+      format: 'source',
+      packageId: rootId,
+      parameters: [{ name: 'segments', type: 'u32', default: 12, minimum: 3 }],
+    };
+    const middle: PackParameterInheritanceSubject = {
+      format: 'instance',
+      packageId: middleId,
+      parent: rootId,
+      values: { segments: 24 },
+    };
+    const leaf: PackParameterInheritanceSubject = {
+      format: 'instance',
+      packageId: leafId,
+      parent: middleId,
+      values: {},
+    };
+    const subjects = new Map<string, PackParameterInheritanceSubject>([
+      [PackageId.format(rootId), root],
+      [PackageId.format(middleId), middle],
+    ]);
+    const resolved = await resolvePackParameterInheritance(leaf, (id) =>
+      subjects.get(PackageId.format(id)),
+    );
+    expect(resolved).toMatchObject({
+      ok: true,
+      value: {
+        values: { segments: 24 },
+        parentChain: [PackageId.format(middleId), PackageId.format(rootId)],
+      },
+    });
+
+    const missing = await resolvePackParameterInheritance(leaf, () => undefined);
+    expect(missing).toMatchObject({ ok: false, error: { code: 'pack-parent-not-found' } });
+
+    const cycleA: PackParameterInheritanceSubject = {
+      format: 'instance',
+      packageId: middleId,
+      parent: leafId,
+      values: {},
+    };
+    const cycle = await resolvePackParameterInheritance(cycleA, (id) =>
+      PackageId.format(id) === PackageId.format(leafId) ? leaf : cycleA,
+    );
+    expect(cycle).toMatchObject({ ok: false, error: { code: 'pack-parent-cycle' } });
+  });
+});

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

@@ -0,0 +1,123 @@
+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 { scanEntries } from '../cli-asset.js';
+import { scanInventory } from '../scanner.js';
+
+const SOURCE_PACKAGE = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const INSTANCE_PACKAGE = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
+const DIRECT_PACKAGE = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
+
+const roots: string[] = [];
+
+afterEach(async () => {
+  const root = roots.pop();
+  if (root !== undefined) await rm(root, { recursive: true, force: true });
+});
+
+describe('ScriptablePack and Pack source scanner', () => {
+  it('indexes direct v3 output keys as derived GUIDs without requiring entry GUIDs', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-scan-'));
+    roots.push(root);
+    const path = join(root, 'direct.pack.json');
+    await writeFile(
+      path,
+      JSON.stringify({
+        schemaVersion: '3.0.0',
+        packageId: DIRECT_PACKAGE,
+        assets: {
+          'scene/main': {
+            kind: 'scene',
+            payload: { kind: 'scene', nodes: [] },
+            refs: [],
+          },
+        },
+      }),
+    );
+
+    const result = await scanInventory([root]);
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.inventory).toMatchObject([
+      {
+        kind: 'scene',
+        sourcePath: path,
+        sourceKey: 'scene/main',
+        sourceIndex: 0,
+      },
+    ]);
+    expect(result.value.inventory[0]?.guid).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+    );
+
+    const stdout: string[] = [];
+    const stderr: string[] = [];
+    const listed = await scanEntries([root], {
+      stdoutWrite: (line) => stdout.push(line),
+      stderrWrite: (line) => stderr.push(line),
+    });
+    expect(listed).toMatchObject({
+      ok: true,
+      value: [{ guid: result.value.inventory[0]?.guid, name: 'scene/main' }],
+    });
+    expect(stderr).toEqual([]);
+  });
+
+  it('captures a ScriptablePack source as metadata and resolves an instance parent', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-source-scan-'));
+    roots.push(root);
+    await writeFile(
+      join(root, 'source.pack.ts'),
+      [
+        'const packageId = new Uint8Array(16);',
+        'packageId.set([170, 170, 170, 170, 170, 170, 74, 170, 138, 170, 170, 170, 170, 170, 170, 170]);',
+        'export default {',
+        "  schemaVersion: '2.0.0',",
+        '  packageId,',
+        "  parameters: [{ name: 'count', type: 'u32', default: 1 }],",
+        "  build: ({ values }) => ({ ok: true, value: { ['mesh/' + values.count]: { kind: 'mesh', materialSlots: [] } } }),",
+        '};',
+      ].join('\n'),
+    );
+    await writeFile(
+      join(root, 'instance.pack.json'),
+      JSON.stringify({
+        schemaVersion: '3.0.0',
+        packageId: INSTANCE_PACKAGE,
+        parent: SOURCE_PACKAGE,
+        values: { count: 2 },
+      }),
+    );
+
+    const result = await scanInventory([root]);
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const declaration = result.value.declarations.get(join(root, 'source.pack.ts'));
+    expect(declaration?.format).toBe('pack.ts');
+    expect(result.value.inventory).toEqual([]);
+  });
+
+  it('fails closed when an instance parent is missing', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-parent-scan-'));
+    roots.push(root);
+    await writeFile(
+      join(root, 'missing.pack.json'),
+      JSON.stringify({
+        schemaVersion: '3.0.0',
+        packageId: INSTANCE_PACKAGE,
+        parent: SOURCE_PACKAGE,
+        values: { count: 2 },
+      }),
+    );
+
+    const result = await scanInventory([root]);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('pack-malformed-pack');
+    expect(result.error.detail).toMatchObject({ reason: 'pack-parent-not-found' });
+  });
+});

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

@@ -1970,7 +1970,7 @@ const V1_WHITELIST = new Set([
       expect(result.ok).toBe(true);
     });
 
-    it('AC-17: explicit source=hero.png + companion file → scan passes (backward compat)', async () => {
+    it('AC-17: explicit source=hero.png + companion file → scan passes', async () => {
       await writeFile(join(tmpDir, 'hero.png.meta.json'), makeMeta({ source: 'hero.png' }));
       await writeFile(join(tmpDir, 'hero.png'), Buffer.from('fake png'));
 
@@ -1978,241 +1978,4 @@ const V1_WHITELIST = new Set([
       expect(result.ok).toBe(true);
     });
   });
-
-  describe('w15-scanner-path-integration.test.ts — AC-5+AC-10', () => {
-    let tmpDir: string;
-
-    beforeEach(async () => {
-      tmpDir = await mkdtemp(join(tmpdir(), 'forgeax-ac5-'));
-    });
-    afterEach(async () => {
-      await rm(tmpDir, { recursive: true, force: true });
-    });
-
-    it('AC-5: @name/ path resolves correctly when file exists', async () => {
-      const libDir = join(tmpDir, 'lib');
-      await mkdir(libDir);
-      await writeFile(join(libDir, 'shared.png'), Buffer.from('fake png'));
-      const metaContent = JSON.stringify({
-        schemaVersion: '1.0.0',
-        kind: 'external-asset-package',
-        importer: 'image',
-        source: '@shared/shared.png',
-        importSettings: {},
-        subAssets: [
-          { guid: 'aaaaaaaa-bbbb-4000-8000-000000000001', sourceIndex: 0, kind: 'texture' },
-        ],
-      });
-      await writeFile(join(tmpDir, 'ref.meta.json'), metaContent);
-
-      // The scan runs inside its own process.cwd() — paths table resolution uses cwd
-      // The tmpDir is not the cwd, so @shared/ will report pack-unknown-path.
-      // AC-5: we need the path table to be configured at the scan's cwd.
-      // For a unit test, we verify instead via resolveAssetSource directly:
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const paths = { shared: libDir };
-      const result = resolveAS(join(tmpDir, 'ref.meta.json'), '@shared/shared.png', paths);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(join(libDir, 'shared.png'));
-      }
-    });
-
-    it('AC-10: path configured but file missing → pack-orphan-meta', async () => {
-      const libDir = join(tmpDir, 'lib');
-      await mkdir(libDir);
-      // Do NOT create missing.png in libDir
-      const metaContent = JSON.stringify({
-        schemaVersion: '1.0.0',
-        kind: 'external-asset-package',
-        importer: 'image',
-        source: '@shared/missing.png',
-        importSettings: {},
-        subAssets: [
-          { guid: 'aaaaaaaa-bbbb-4000-8000-000000000001', sourceIndex: 0, kind: 'texture' },
-        ],
-      });
-      await writeFile(join(tmpDir, 'ref.meta.json'), metaContent);
-
-      // resolveAssetSource resolves the path but does not stat — the resolved path will be returned ok
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const paths = { shared: libDir };
-      const result = resolveAS(join(tmpDir, 'ref.meta.json'), '@shared/missing.png', paths);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(join(libDir, 'missing.png'));
-        // The actual orphan check (stat) is done by the scanner caller
-      }
-    });
-
-    it('AC-10: scanner reports pack-orphan-meta when resolved path file does not exist', async () => {
-      const metaContent = makeMeta({ source: 'nowhere.png' });
-      await writeFile(join(tmpDir, 'orphan.meta.json'), metaContent);
-      // Do NOT create nowhere.png
-
-      const result = await scan([tmpDir]);
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.code).toBe('pack-orphan-meta');
-        if (result.error.code === 'pack-orphan-meta') {
-          expect(result.error.detail.expectedFile).toContain('nowhere.png');
-        }
-      }
-    });
-  });
-
-  describe('scanner @name/ end-to-end via cwd package.json — AC-5/AC-8', () => {
-    let tmpDir: string;
-    let originalCwd: string;
-
-    beforeEach(async () => {
-      originalCwd = process.cwd();
-      tmpDir = await mkdtemp(join(tmpdir(), 'forgeax-ac5e2e-'));
-      process.chdir(tmpDir);
-    });
-    afterEach(async () => {
-      process.chdir(originalCwd);
-      await rm(tmpDir, { recursive: true, force: true });
-    });
-
-    it('AC-5: scan() passes orphan check for @name/ meta when cwd package.json path table resolves to an existing file', async () => {
-      const sharedDir = join(tmpDir, 'shared-lib', 'assets');
-      await mkdir(sharedDir, { recursive: true });
-      await writeFile(join(sharedDir, 'cross.png'), Buffer.from('fake png'));
-      await writeFile(
-        join(tmpDir, 'package.json'),
-        JSON.stringify({
-          name: 'ac5-e2e-tmp',
-          forgeax: { assets: { paths: { shared: 'shared-lib/assets' } } },
-        }),
-      );
-      const scanRoot = join(tmpDir, 'metas');
-      await mkdir(scanRoot, { recursive: true });
-      await writeFile(
-        join(scanRoot, 'cross.png.meta.json'),
-        JSON.stringify({
-          schemaVersion: '1.0.0',
-          kind: 'external-asset-package',
-          importer: 'image',
-          source: '@shared/cross.png',
-          importSettings: {},
-          subAssets: [
-            { guid: 'aaaaaaaa-bbbb-4000-8000-000000000001', sourceIndex: 0, kind: 'texture' },
-          ],
-        }),
-      );
-
-      const result = await scan([scanRoot]);
-      expect(result.ok).toBe(true);
-    });
-
-    it('AC-8: scan() reports pack-unknown-path when @name/ references an undeclared path name', async () => {
-      await writeFile(
-        join(tmpDir, 'package.json'),
-        JSON.stringify({ name: 'ac8-e2e-tmp', forgeax: { assets: { paths: {} } } }),
-      );
-      const scanRoot = join(tmpDir, 'metas');
-      await mkdir(scanRoot, { recursive: true });
-      await writeFile(
-        join(scanRoot, 'x.png.meta.json'),
-        JSON.stringify({
-          schemaVersion: '1.0.0',
-          kind: 'external-asset-package',
-          importer: 'image',
-          source: '@nope/x.png',
-          importSettings: {},
-          subAssets: [
-            { guid: 'aaaaaaaa-bbbb-4000-8000-000000000001', sourceIndex: 0, kind: 'texture' },
-          ],
-        }),
-      );
-
-      const result = await scan([scanRoot]);
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.code).toBe('pack-unknown-path');
-      }
-    });
-  });
-}
-
-{
-  // ─── AC-1 regression w15 — resolveAssetSource explicit source backwards compat ───
-
-  describe('w15-AC-1-regression.test.ts', () => {
-    it('AC-1: explicit source=foo.png with resolveAssetSource == resolve(metaDir, foo.png)', async () => {
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const { resolve } = await import('node:path');
-      const metaPath = '/home/user/assets/foo.png.meta.json';
-      const result = resolveAS(metaPath, 'foo.png', {});
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(resolve('/home/user/assets', 'foo.png'));
-      }
-    });
-
-    it('AC-1: explicit source=sub/deep.png with resolveAssetSource == resolve(metaDir, sub/deep.png)', async () => {
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const { resolve } = await import('node:path');
-      const metaPath = '/home/user/assets/main.meta.json';
-      const result = resolveAS(metaPath, 'sub/deep.png', {});
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(resolve('/home/user/assets', 'sub/deep.png'));
-      }
-    });
-
-    it('AC-1: omitted source derives from meta filename', async () => {
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const { resolve } = await import('node:path');
-      const metaPath = '/home/user/assets/foo.png.meta.json';
-      const result = resolveAS(metaPath, undefined, {});
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(resolve('/home/user/assets', 'foo.png'));
-      }
-    });
-  });
-
-  // ─── AC-5/AC-10 source path table scanner integration (w15) ───
-
-  describe('w15-AC-5-AC-10-path-table.test.ts', () => {
-    it('AC-5: @shared/ resource resolves correctly when path table configured', async () => {
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const { resolve } = await import('node:path');
-      const metaPath = '/project/assets/ref.meta.json';
-      const paths = { shared: '/project/lib' };
-      const result = resolveAS(metaPath, '@shared/tex.png', paths);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(resolve('/project/lib', 'tex.png'));
-      }
-    });
-
-    it('AC-5: @shared/ with nested rest path', async () => {
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const { resolve } = await import('node:path');
-      const metaPath = '/project/assets/ref.meta.json';
-      const paths = { shared: '/project/lib' };
-      const result = resolveAS(metaPath, '@shared/sub/dir/tex.png', paths);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.value).toBe(resolve('/project/lib', 'sub/dir/tex.png'));
-      }
-    });
-
-    it('AC-10: @unknown/ path name → pack-unknown-path error', async () => {
-      const { resolveAssetSource: resolveAS } = await import('../resolve-asset-source.js');
-      const metaPath = '/project/assets/ref.meta.json';
-      const result = resolveAS(metaPath, '@nope/tex.png', {});
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.code).toBe('pack-unknown-path');
-        if (result.error.code === 'pack-unknown-path') {
-          expect(result.error.detail.pathName).toBe('nope');
-          expect(result.error.detail.knownNames).toEqual([]);
-        }
-      }
-    });
-  });
 }