@forgeax/engine-pack 0.1.27 → 0.1.29

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-diagnostic.integration.test.ts

@@ -0,0 +1,45 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { expect, it } from 'vitest';
+import { loadScriptablePack } from '../scriptable-pack-node.js';
+
+it('keeps the source line and column for a malformed author module', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'pack-source-diagnostic-'));
+  const source = join(root, 'broken.pack.ts');
+  try {
+    await writeFile(source, 'export default {\n  build: () => { const = 1; }\n};\n');
+    const loaded = await loadScriptablePack(source);
+    expect(loaded.ok).toBe(false);
+    if (loaded.ok) return;
+    expect(JSON.stringify(loaded.error)).toContain(`${source}:2:`);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+it.each([
+  0, 17,
+])('propagates worker exit %i during a build instead of waiting for timeout', async (code) => {
+  const root = await mkdtemp(join(tmpdir(), 'pack-worker-exit-'));
+  const source = join(root, 'exit.pack.ts');
+  try {
+    await writeFile(
+      source,
+      `export default { schemaVersion: '2.0.0', packageId: new Uint8Array([121,171,30,178,252,222,65,195,145,119,233,61,213,193,142,245]), build() { process.exit(${code}); } };`,
+    );
+    const loaded = await loadScriptablePack(source, { buildTimeoutMs: 1000 });
+    expect(loaded.ok).toBe(true);
+    if (!loaded.ok) return;
+    await expect(
+      loaded.value.build({
+        packageId: loaded.value.packageId,
+        readByGuid: async () => {
+          throw new Error('unexpected read');
+        },
+      }),
+    ).rejects.toThrow(`worker exited with code ${code}`);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/atlas/run-atlas.ts

@@ -1,4 +1,4 @@
-// `forgeax-engine-remote-asset atlas` subcommand backend
+// `forgeax asset atlas` subcommand backend
 // (feat-20260521-sprite-atlas-animation M5' T-32). Replaces the v1 vite-
 // plugin idiom (PR #190 deleted `@forgeax/engine-vite-plugin-image`) with
 // a one-shot Node CLI that reads a glob of PNGs, runs the pure shelf
@@ -7,7 +7,7 @@
 //
 // Why CLI not Vite plugin (PR #190 architectural pivot):
 //   - asset importing is producer-side disk work; v2 routes the producer
-//     through the kubectl-style `forgeax-engine-remote-` plugin bin so the
+//     through the unified `forgeax asset atlas` producer so the
 //     same surface composes with `scan` / `lookup` / `verify` (charter P5
 //     producer/consumer split).
 //   - vite plugins reach for runtime-coupled hooks (buildStart / emitFile);
@@ -327,7 +327,7 @@ export async function runAtlas(rest: string[], ctx: AssetCtx): Promise<number> {
     return emitError(ctx, {
       code: 'atlas-empty-input',
       expected:
-        'forgeax-engine-remote-asset atlas --input <glob> --name <prefix> [--output <dir>] [--max-atlas-size <n>]',
+        'forgeax asset atlas --input <glob> --name <prefix> [--output <dir>] [--max-atlas-size <n>]',
       hint: argsOutcome.message,
       detail: { receivedCount: 0 },
     });

package/src/atlas/shelf-pack.ts

@@ -1,4 +1,4 @@
-// Pure-function shelf packer for the `forgeax-engine-remote-asset atlas`
+// Pure-function shelf packer for the `forgeax asset atlas`
 // subcommand (feat-20260521-sprite-atlas-animation M5' T-31). Maps a list
 // of decoded RGBA sprites to a non-overlapping atlas region map +
 // atlasWidth / atlasHeight envelope.

package/src/atlas/upng-ambient.d.ts

@@ -1,5 +1,5 @@
 // Ambient declaration for `upng-js` (PNG decoder/encoder) used by the
-// `forgeax-engine-remote-asset atlas` subcommand (run-atlas.ts) and by
+// `forgeax asset atlas` subcommand (run-atlas.ts) and by
 // its hermetic CLI integration tests under `__tests__/`. The package
 // ships without bundled `.d.ts`; consumer sites cast through local
 // interfaces to match the subset they use.

package/src/cli-asset.ts

@@ -1,10 +1,7 @@
 #!/usr/bin/env node
 
-// @forgeax/engine-pack/src/cli-asset — `forgeax-engine-remote-asset`
-// plugin bin (feat-20260516-console-dependency-inversion plan-strategy
-// section 2.9). Discovered by the base bin via the kubectl 4th-path
-// `forgeax-engine-remote-` prefix scanner; subcommands scan / lookup /
-// verify operate offline against the pack scanner.
+// @forgeax/engine-pack/src/cli-asset — Pack producer implementation used by
+// DevKit's unified `forgeax asset` command. It is not a package bin.
 //
 // stderr contract (plan-strategy section 2.3 weak-contract): every error
 // path emits a single JSON Lines record carrying `code` / `expected` /
@@ -30,6 +27,10 @@ import { projectScriptablePackMeta } from './pack-authoring.js';
 import { type ScanSourceDeclaration, scanInventory } from './scanner.js';
 import { loadScriptablePack } from './scriptable-pack-node.js';
 
+// The unified DevKit command tree reuses the producer implementation without
+// reviving the historical standalone executable as a second public surface.
+export { runAtlas } from './atlas/run-atlas.js';
+
 export interface PackEntry {
   readonly guid: string;
   readonly kind: string;
@@ -153,16 +154,14 @@ export async function scanEntries(
 
 function helpBody(): string {
   return [
-    'forgeax-engine-remote-asset — offline pack scanner / lookup / verifier / atlas builder',
+    'forgeax asset — offline pack scanner / lookup / verifier / atlas builder',
     '',
     'Usage:',
-    '  forgeax-engine-remote-asset scan [--roots <dir>]',
-    '  forgeax-engine-remote-asset lookup <guid>',
-    '  forgeax-engine-remote-asset verify',
-    '  forgeax-engine-remote-asset meta <source.pack.ts> --json',
-    '  forgeax-engine-remote-asset lookup --guid <guid> --project <dir> --catalog <path> --json',
-    '  forgeax-engine-remote-asset verify --guid <guid> --project <dir> --catalog <path> --json',
-    '  forgeax-engine-remote-asset atlas --input <glob> --name <prefix> [--output <dir>] [--max-atlas-size <n>]',
+    '  forgeax asset list --root <project> --json',
+    '  forgeax asset inspect --subject <guid> --root <project> --json',
+    '  forgeax asset verify --root <project> --json',
+    '  forgeax asset inspect --subject <source.pack.ts> --root <project> --json',
+    '  forgeax asset atlas --input <glob> --name <prefix> --root <project> [--output <dir>]',
     '',
     'AI recovery commands (host execution remains explicit):',
     '  inspect [--guid <guid>]      read subject, execution, lifecycle, authority, and sourceKey evidence',
@@ -205,7 +204,7 @@ export async function runCliAsset(rest: string[], ctx: AssetCtx): Promise<number
       return emitError(ctx, {
         code: 'unknown-subcommand',
         expected: 'subcommand in {scan, lookup, verify, atlas, meta}',
-        hint: "run 'forgeax-engine-remote-asset --help' for usage",
+        hint: "run 'forgeax help asset' for usage",
         detail: { subcommand: sub },
       });
   }
@@ -227,7 +226,7 @@ async function runMeta(rest: string[], ctx: AssetCtx): Promise<number> {
   } catch (error) {
     return emitError(ctx, {
       code: 'cli-parse-error',
-      expected: 'forgeax-engine-remote-asset meta <source.pack.ts> --json',
+      expected: 'forgeax asset inspect --subject <source.pack.ts> --root <project> --json',
       hint: 'pass one trusted ScriptablePack module path',
       detail: { message: error instanceof Error ? error.message : String(error) },
     });
@@ -277,7 +276,7 @@ async function runRecoveryCommand(
     return emitError(ctx, {
       code: 'cli-parse-error',
       expected: `${operation} [--guid <guid>]`,
-      hint: "run 'forgeax-engine-remote-asset --help' for usage",
+      hint: "run 'forgeax help asset' for usage",
       detail: { message: error instanceof Error ? error.message : String(error) },
     });
   }
@@ -297,8 +296,8 @@ async function runScan(rest: string[], ctx: AssetCtx): Promise<number> {
     const message = e instanceof Error ? e.message : String(e);
     return emitError(ctx, {
       code: 'cli-parse-error',
-      expected: 'forgeax-engine-remote-asset scan [--roots <dir>]',
-      hint: "run 'forgeax-engine-remote-asset --help' for usage",
+      expected: 'forgeax asset list --root <project> --json',
+      hint: "run 'forgeax help asset' for usage",
       detail: { message },
     });
   }
@@ -314,7 +313,7 @@ async function runLookup(rest: string[], ctx: AssetCtx): Promise<number> {
   if (typeof guid !== 'string') {
     return emitError(ctx, {
       code: 'cli-parse-error',
-      expected: 'forgeax-engine-remote-asset lookup <36-char-uuid>',
+      expected: 'forgeax asset inspect --subject <guid> --root <project> --json',
       hint: 'pass a 36-char dash-form UUID positional argument',
     });
   }
@@ -356,8 +355,8 @@ async function runVerify(rest: string[], ctx: AssetCtx): Promise<number> {
     const message = e instanceof Error ? e.message : String(e);
     return emitError(ctx, {
       code: 'cli-parse-error',
-      expected: 'forgeax-engine-remote-asset verify',
-      hint: "run 'forgeax-engine-remote-asset --help' for usage",
+      expected: 'forgeax asset verify --root <project> --json',
+      hint: "run 'forgeax help asset' for usage",
       detail: { message },
     });
   }
@@ -397,7 +396,7 @@ function parseEvidenceOptions(rest: string[], ctx: AssetCtx): EvidenceCliOptions
       emitError(ctx, {
         code: 'cli-parse-error',
         expected: '--guid <guid> --project <dir> --catalog <path> --json',
-        hint: "run 'forgeax-engine-remote-asset --help' for usage",
+        hint: "run 'forgeax help asset' for usage",
       });
       return undefined;
     }
@@ -407,7 +406,7 @@ function parseEvidenceOptions(rest: string[], ctx: AssetCtx): EvidenceCliOptions
     emitError(ctx, {
       code: 'cli-parse-error',
       expected: '--guid <guid> --project <dir> --catalog <path> --json',
-      hint: "run 'forgeax-engine-remote-asset --help' for usage",
+      hint: "run 'forgeax help asset' for usage",
       detail: { message },
     });
     return undefined;

package/src/inventory/binding.ts

@@ -15,11 +15,11 @@ export function projectAssetRefs(inventory: AuthorInventory): readonly AssetRef[
 /** Derive instance-relative scene refs from the same validated author rows. */
 export function projectSceneEntityRefs(inventory: AuthorInventory): readonly SceneEntityRef[] {
   return inventory.declarations.flatMap((row) =>
-    row.sceneBindings === undefined
+    row.sceneEntityKeys === undefined
       ? []
-      : row.sceneBindings.map((bindingKey) => ({
+      : row.sceneEntityKeys.map((address) => ({
           sceneSourceKey: row.sourceKey,
-          bindingKey,
+          address,
         })),
   );
 }

package/src/inventory/declaration.ts

@@ -6,7 +6,7 @@ export interface AuthorInventoryRow {
   readonly kind: string;
   readonly payload: Readonly<Record<string, unknown>>;
   readonly refs: readonly string[];
-  readonly sceneBindings?: readonly string[];
+  readonly sceneEntityKeys?: readonly string[];
 }
 
 export interface AuthorInventory {
@@ -102,54 +102,16 @@ export function validateAuthorInventory(value: unknown): Result<AuthorInventory,
         { guid, sourceKey },
       );
     }
-    if (row.kind === 'scene') {
-      const payload = row.payload;
-      const payloadRecord =
-        typeof payload === 'object' && payload !== null
-          ? (payload as Record<string, unknown>)
-          : undefined;
-      const entities =
-        payloadRecord !== undefined && Array.isArray(payloadRecord.entities)
-          ? payloadRecord.entities
-          : [];
-      const bindings = new Set<string>();
-      for (const entity of entities) {
-        const bindingKey =
-          typeof entity === 'object' && entity !== null && typeof entity.bindingKey === 'string'
-            ? entity.bindingKey
-            : undefined;
-        if (bindingKey !== undefined && bindingKey.length === 0) {
-          return failure(
-            'inventory-scene-binding-missing',
-            'each declared scene bindingKey is non-empty',
-            'remove the empty bindingKey or declare a stable key in the scene producer',
-            { sourceKey },
-          );
-        }
-        if (bindingKey === undefined) continue;
-        if (bindings.has(bindingKey)) {
-          return failure(
-            'inventory-scene-binding-duplicate',
-            'bindingKey values are unique within one scene',
-            'rename the duplicate bindingKey in the scene producer',
-            { sourceKey },
-          );
-        }
-        bindings.add(bindingKey);
-      }
-    }
     guids.add(normalizedGuid);
     sourceKeys.add(sourceKey);
-    const sceneBindings =
-      row.kind === 'scene' && typeof row.payload === 'object' && row.payload !== null
-        ? (row.payload as { readonly entities?: readonly unknown[] }).entities?.flatMap(
-            (entity) => {
-              if (typeof entity !== 'object' || entity === null) return [];
-              const key = (entity as { readonly bindingKey?: unknown }).bindingKey;
-              return typeof key === 'string' && key.length > 0 ? [key] : [];
-            },
-          )
-        : undefined;
+    const sceneEntityKeys = (() => {
+      if (row.kind !== 'scene' || typeof row.payload !== 'object' || row.payload === null)
+        return undefined;
+      const entities = (row.payload as { readonly entities?: unknown }).entities;
+      if (entities === null || typeof entities !== 'object' || Array.isArray(entities))
+        return undefined;
+      return Object.keys(entities);
+    })();
     declarations.push({
       guid,
       sourceKey,
@@ -161,7 +123,7 @@ export function validateAuthorInventory(value: unknown): Result<AuthorInventory,
       refs: Array.isArray(row.refs)
         ? row.refs.filter((ref): ref is string => typeof ref === 'string')
         : [],
-      ...(sceneBindings === undefined ? {} : { sceneBindings }),
+      ...(sceneEntityKeys === undefined ? {} : { sceneEntityKeys }),
     });
   }
   return ok({ declarations });

package/src/inventory/sync.ts

@@ -5,7 +5,8 @@ export type InventoryDigest = string;
 export function inventoryDigest(inventory: AuthorInventory): InventoryDigest {
   return inventory.declarations
     .map(
-      (row) => `${row.guid}\0${row.sourceKey}\0${row.kind}\0${row.sceneBindings?.join('\0') ?? ''}`,
+      (row) =>
+        `${row.guid}\0${row.sourceKey}\0${row.kind}\0${row.sceneEntityKeys?.join('\0') ?? ''}`,
     )
     .sort()
     .join('\n');
@@ -16,7 +17,7 @@ export function syncAuthorInventory(inventory: AuthorInventory): AuthorInventory
     declarations: inventory.declarations.map((row) => ({
       ...row,
       refs: [...row.refs],
-      ...(row.sceneBindings === undefined ? {} : { sceneBindings: [...row.sceneBindings] }),
+      ...(row.sceneEntityKeys === undefined ? {} : { sceneEntityKeys: [...row.sceneEntityKeys] }),
     })),
   };
 }

package/src/native-cooker-registry.ts

@@ -20,6 +20,7 @@ export interface NativeCookDraft<P = unknown> {
   readonly refs: readonly string[];
   readonly artifacts: Readonly<Record<string, NativeCookArtifact>>;
   readonly inputFingerprint: string;
+  readonly sourceDependencies?: readonly string[];
 }
 
 export interface NativeCooker<P = unknown, I = unknown> {

package/src/scanner.ts

@@ -184,7 +184,7 @@ interface ScanCapture {
  * Requirements §3.4 + §5 blacklist.
  *
  * Re-exported as `SCANNER_BLACKLIST` for cross-package reuse: the
- * `forgeax-engine-remote-asset import --check` traversal (M4 / w21 +
+ * `forgeax asset import --check` traversal (M4 / w21 +
  * plan-strategy section 2.8 path b) walks the same set of source-orphan
  * candidates as the scanner, so we share the single SSOT here.
  */
@@ -254,27 +254,35 @@ function makePackError(
 }
 
 /**
- * For scene assets with `payload.mounts[]`, return the lowercased GUID
- * each `mount.source` integer resolves to via `asset.refs[]`. Returns an
- * empty iterable for non-scene assets, scene assets without mounts, or
- * mounts with malformed `source` (out-of-range integer / non-integer) —
- * those are caught by ajv schema validation upstream. The yielded GUIDs
- * feed scanner step-6's mount-asset cycle DFS (D-1, R10).
+ * For keyed scene assets, return the lowercased GUID each nested instance
+ * source resolves to via `asset.refs[]` (or directly carries). The yielded GUIDs feed
+ * scanner step-6's scene dependency cycle DFS.
  */
-function* extractMountSourceGuids(asset: {
+function* extractInstanceSourceGuids(asset: {
   kind?: unknown;
   payload?: unknown;
   refs: readonly string[];
 }): Generator<string> {
   if (asset.kind !== 'scene') return;
-  const payload = asset.payload as { mounts?: unknown } | undefined;
-  if (!payload || !Array.isArray(payload.mounts)) return;
-  for (const rawMount of payload.mounts) {
-    const mount = rawMount as { source?: unknown };
-    const idx = mount.source;
-    if (typeof idx !== 'number' || !Number.isInteger(idx)) continue;
-    if (idx < 0 || idx >= asset.refs.length) continue;
-    const resolved = asset.refs[idx];
+  const payload = asset.payload as { entities?: unknown } | undefined;
+  if (
+    !payload ||
+    payload.entities === null ||
+    typeof payload.entities !== 'object' ||
+    Array.isArray(payload.entities)
+  )
+    return;
+  for (const rawEntity of Object.values(payload.entities as Record<string, unknown>)) {
+    if (rawEntity === null || typeof rawEntity !== 'object' || Array.isArray(rawEntity)) continue;
+    const instance = (rawEntity as { instance?: unknown }).instance;
+    if (instance === null || typeof instance !== 'object' || Array.isArray(instance)) continue;
+    const source = (instance as { source?: unknown }).source;
+    const resolved =
+      typeof source === 'number' && Number.isInteger(source)
+        ? asset.refs[source]
+        : typeof source === 'string'
+          ? source
+          : undefined;
     if (typeof resolved !== 'string') continue;
     yield resolved.toLowerCase();
   }
@@ -450,7 +458,7 @@ async function scanValidated(
           guidToPath.set(normalizedGuid, packPath);
           packRefs.set(normalizedGuid, [
             ...asset.refs.map((ref) => ref.toLowerCase()),
-            ...extractMountSourceGuids(asset),
+            ...extractInstanceSourceGuids(asset),
           ]);
         }
       }
@@ -563,20 +571,12 @@ async function scanValidated(
       }
       guidToPath.set(normalizedGuid, packPath);
 
-      // feat-20260608-scene-nesting-ecs-fication M1 / w14 (D-1):
-      // mount-payload-extract — for scene assets, redundantly inject the
-      // mount.source -> resolved GUID edge into the cycle graph alongside
-      // asset.refs[]. By the .pack.json convention mount.source is an
-      // integer index into the same asset.refs[], so the resolved GUID is
-      // already present in `existingRefs`; this defensive pass guarantees
-      // that any author-supplied mounts[] references participate in the
-      // cycle DFS even if the schema-emitter forgot to mirror them into
-      // refs[]. The `kind: 'mount-asset'` tag on the resulting
-      // pack-cyclic-reference detail is set by the cycle producer below
-      // (R10).
+      // Keyed scene instances are explicit dependency edges. Keep the
+      // producer source in the cycle graph alongside ordinary asset refs so
+      // recursive SceneAsset declarations fail before publication.
       packRefs.set(normalizedGuid, [
         ...asset.refs.map((ref) => ref.toLowerCase()),
-        ...extractMountSourceGuids(asset),
+        ...extractInstanceSourceGuids(asset),
       ]);
     }
     capture?.declarations.set(packPath, {