@forgeax/engine-pack 0.1.20 → 0.1.23

package/src/scriptable-pack-worker.ts

@@ -20,9 +20,8 @@ type LoadedDefinition = {
   readonly schemaVersion?: unknown;
   readonly packageId?: unknown;
   readonly name?: unknown;
-  readonly assets?: unknown;
+  readonly parameters?: unknown;
   readonly sceneComponents?: unknown;
-  readonly externalAssets?: unknown;
   readonly build?: unknown;
 };
 let definition: LoadedDefinition | undefined;
@@ -43,6 +42,25 @@ function failure(error: unknown): unknown {
   };
 }
 
+function serializableSceneComponents(value: unknown): unknown {
+  if (!Array.isArray(value)) return undefined;
+  return value.map((component) => {
+    const candidate = component as { readonly name?: unknown; readonly fields?: unknown };
+    const fields =
+      candidate.fields !== null &&
+      typeof candidate.fields === 'object' &&
+      !Array.isArray(candidate.fields)
+        ? Object.fromEntries(
+            Object.entries(candidate.fields as Record<string, unknown>).map(([name, field]) => [
+              name,
+              typeof field === 'string' ? field : (field as { readonly type?: unknown })?.type,
+            ]),
+          )
+        : undefined;
+    return { name: candidate.name, fields };
+  });
+}
+
 const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs', '.cjs'] as const;
 
 function resolveRelativeImport(importer: string, specifier: string): string | undefined {
@@ -71,15 +89,19 @@ function resolveBareImport(importer: string, specifier: string): string | undefi
     }
   ).resolve;
   if (resolver === undefined) return undefined;
-  try {
-    const resolved = resolver(specifier, pathToFileURL(importer).href);
-    return resolved.startsWith('file:') ? fileURLToPath(resolved) : undefined;
-  } catch {
-    // Type-only or optional imports may not be installed in the game project.
-    // Preserve them for TypeScript to erase or let Node report the real load
-    // failure instead of guessing a workspace root.
-    return undefined;
+  // Resolve consumer dependencies from the source file first, then resolve
+  // Engine self-references from this worker's package. A compiled source
+  // closure lives in /tmp, so using only its path makes
+  // @forgeax/engine-pack/source disappear from Node's lookup ancestry.
+  for (const parent of [pathToFileURL(importer).href, import.meta.url]) {
+    try {
+      const resolved = resolver(specifier, parent);
+      if (resolved.startsWith('file:')) return fileURLToPath(resolved);
+    } catch {
+      // Try the loader package before treating the import as unavailable.
+    }
   }
+  return undefined;
 }
 
 function resolvedModuleSpecifier(
@@ -231,10 +253,11 @@ async function loadDefinition(task: {
         : {
             schemaVersion: definition.schemaVersion,
             packageId: definition.packageId,
-            name: definition.name,
-            assets: definition.assets,
-            sceneComponents: definition.sceneComponents,
-            externalAssets: definition.externalAssets,
+            ...(definition.name === undefined ? {} : { name: definition.name }),
+            ...(definition.parameters === undefined ? {} : { parameters: definition.parameters }),
+            ...(definition.sceneComponents === undefined
+              ? {}
+              : { sceneComponents: serializableSceneComponents(definition.sceneComponents) }),
           },
   });
 }
@@ -275,13 +298,22 @@ async function handleMessage(message: unknown): Promise<void> {
     return;
   }
   try {
-    const result = await definition.build({
+    const context =
+      value.context !== null && typeof value.context === 'object'
+        ? (value.context as { readonly packageId?: unknown; readonly values?: unknown })
+        : undefined;
+    const buildContext = {
+      ...(Array.isArray(context?.packageId)
+        ? { packageId: new Uint8Array(context.packageId as number[]) }
+        : {}),
+      ...(context?.values !== undefined ? { values: context.values } : {}),
       readByGuid(guid: Uint8Array): Promise<unknown> {
         const readId = nextReadId++;
         port.postMessage({ kind: 'asset-read', buildId: value.buildId, readId, guid });
         return new Promise((resolve) => reads.set(readId, resolve));
       },
-    });
+    };
+    const result = await definition.build(buildContext);
     port.postMessage({
       kind: 'build-result',
       buildId: value.buildId,