@forgeax/engine-import 0.1.21 → 0.1.23

package/src/scriptable-pack-output-producers.ts

@@ -8,6 +8,7 @@ import type {
   AudioClipAsset,
   EquirectAsset,
   FontAsset,
+  IesProfileAsset,
   ImportedArtifactBody,
   MaterialAsset,
   MaterialTextureReference,
@@ -172,6 +173,13 @@ function meshProduct(input: AssetOutputInput): AssetOutputProduct {
       sourceField: { fieldName: 'materialSlots', arrayIndex: slotIndex },
     });
   }
+  const seenRefs = new Set(refs.map((reference) => reference.guid.toLowerCase()));
+  for (const [lodIndex, lod] of (mesh.lods ?? []).entries()) {
+    const guid = formatGuid(lod.mesh);
+    if (seenRefs.has(guid.toLowerCase())) continue;
+    seenRefs.add(guid.toLowerCase());
+    refs.push({ guid, sourceField: { fieldName: 'lods', arrayIndex: lodIndex } });
+  }
   return {
     payload: mesh,
     refs,
@@ -217,6 +225,34 @@ function sceneProduct(
   };
 }
 
+function containsAssetGuid(value: unknown): boolean {
+  if (typeof value === 'string') return AssetGuid.parse(value).ok;
+  if (Array.isArray(value)) return value.some(containsAssetGuid);
+  if (value !== null && typeof value === 'object') {
+    return Object.values(value as Record<string, unknown>).some(containsAssetGuid);
+  }
+  return false;
+}
+
+/**
+ * Direct v3 scenes migrated from Pack v2 already carry runtime ref indices in
+ * their component payload. There is no component-schema authority in a JSON
+ * direct entry, so preserve that transport shape and let the entry's explicit
+ * refs provide the closure. A GUID-bearing scene is still sent through the
+ * schema-backed producer and therefore fails closed when no schema is present.
+ */
+function preExternalizedSceneProduct(input: AssetOutputInput): AssetOutputProduct {
+  if (input.asset.kind !== 'scene') throw new TypeError('expected SceneAsset');
+  if (containsAssetGuid(input.asset)) {
+    throw new TypeError('direct scene payload must use explicit refs with runtime indices');
+  }
+  return {
+    payload: { ...(input.asset as SceneAsset), kind: 'scene' },
+    refs: [],
+    artifacts: {},
+  };
+}
+
 function createSafeProducer(
   kind: AssetOutputProducer['kind'],
   version: string,
@@ -440,6 +476,20 @@ function ordinaryPodProduct(input: AssetOutputInput): AssetOutputProduct {
         },
       };
     }
+    case 'ies-profile': {
+      const profile = asset as IesProfileAsset;
+      return {
+        payload: profile,
+        refs: [],
+        artifacts: {
+          body: {
+            mediaType: 'application/octet-stream',
+            assetCodec: { name: 'forgeax-ies-profile', version: '1' },
+            bytes: bytes(profile.data),
+          },
+        },
+      };
+    }
     case 'material':
     case 'mesh':
     case 'scene':
@@ -468,6 +518,10 @@ export function createSceneAssetOutputProducer(
   return createSafeProducer('scene', 'scene-pack/3', (input) => sceneProduct(input, schemas));
 }
 
+export function createPreExternalizedSceneAssetOutputProducer(): AssetOutputProducer {
+  return createSafeProducer('scene', 'scene-pack/3', preExternalizedSceneProduct);
+}
+
 export function createStandardAssetOutputProducerRegistry(
   sceneComponents: readonly ScriptablePackSceneComponent[] = [],
 ): AssetOutputProducerRegistry {
@@ -489,6 +543,7 @@ export function createStandardAssetOutputProducerRegistry(
     'animation-graph',
     'audio',
     'particle-effect',
+    'ies-profile',
   ] as const) {
     registry.register(createSafeProducer(kind, 'ordinary-pod/1', ordinaryPodProduct));
   }

package/src/scriptable-pack-staged-snapshot.ts

@@ -1,5 +1,5 @@
 import { AssetGuid } from '@forgeax/engine-pack/guid';
-import type { ScriptablePackError } from '@forgeax/engine-pack/source';
+import type { PackAuthoringError } from '@forgeax/engine-pack/source';
 import type { Asset, AssetGuid as AssetGuidType, ImportError, Result } from '@forgeax/engine-types';
 import { AssetError, err, ok } from '@forgeax/engine-types';
 import type {
@@ -12,7 +12,7 @@ import type {
 export type ScriptablePackSnapshotError =
   | AssetError
   | ImportError
-  | ScriptablePackError
+  | PackAuthoringError
   | ScriptablePackDomainError;
 
 export interface ScriptablePackStagedOwner {
@@ -50,21 +50,22 @@ async function assetDigest(asset: Asset): Promise<string> {
   return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('')}`;
 }
 
-function cycleError(stack: readonly string[], owner: string, guid: string): ScriptablePackError {
+function cycleError(
+  stack: readonly string[],
+  owner: string,
+  guid: string,
+): ScriptablePackDomainError {
   const cycleStart = stack.indexOf(owner);
   const cycle = [...stack.slice(cycleStart), owner];
   return {
-    code: 'pack-source-build-cycle',
-    expected: 'an acyclic graph of ScriptablePack content dependencies',
-    actual: cycle.join(' -> '),
-    hint: 'break one content read edge or convert it to a reference-only dependency',
-    retryable: false,
-    recoveryActions: ['inspect-content-dependency-graph', 'edit-source'],
-    detail: { sourcePath: owner, sourceKey: guid, incomingRefs: cycle },
+    code: 'pack-content-dependency-stalled',
+    expected: 'the content dependency worklist to make progress',
+    hint: 'inspect the waiting GUID and pending subjects, then break the content-read cycle',
+    detail: { waitingGuids: [guid], pendingSubjects: cycle, iterations: 1 },
   };
 }
 
-function missingOutputError(owner: string, guid: string): ScriptablePackError {
+function missingOutputError(owner: string, guid: string): ScriptablePackDomainError {
   return {
     code: 'pack-source-output-invalid',
     expected: `owner ${owner} to stage every declared output including ${guid}`,