@forgeax/engine-import 0.1.7 → 0.1.20

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

@@ -23,7 +23,13 @@ import type {
   TilesetAsset,
   VideoAsset,
 } from '@forgeax/engine-types';
-import { err, ImportError, MATERIAL_TEXTURE_SLOTS, ok } from '@forgeax/engine-types';
+import {
+  deriveTextureLayout,
+  err,
+  ImportError,
+  MATERIAL_TEXTURE_SLOTS,
+  ok,
+} from '@forgeax/engine-types';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { bytesToHex } from '@noble/hashes/utils.js';
 import { packMeshBinV4 } from './mesh-bin.js';
@@ -246,23 +252,50 @@ function bytes(value: Uint8Array | Uint8ClampedArray): Uint8Array {
   return Uint8Array.from(value);
 }
 
+function textureProduct(input: AssetOutputInput): AssetOutputProduct {
+  if (input.asset.kind !== 'texture') throw new TypeError('expected TextureAsset');
+  const texture = input.asset as TextureAsset;
+  const layout = deriveTextureLayout({
+    shape: texture.shape,
+    format: texture.format,
+    mips: texture.mips,
+    actualByteLength: texture.data.byteLength,
+    order: 'mip-major,image-major,row-major',
+  });
+  if (!layout.ok) {
+    const expectedBytes =
+      layout.error.code === 'texture-packing-invalid'
+        ? layout.error.detail.expectedBytes
+        : texture.data.byteLength;
+    const actualBytes =
+      layout.error.code === 'texture-packing-invalid'
+        ? layout.error.detail.actualBytes
+        : texture.data.byteLength;
+    throw new TypeError(
+      `texture data is not canonical: expected ${expectedBytes} bytes, got ${actualBytes}`,
+    );
+  }
+  return {
+    payload: texture,
+    refs: [],
+    artifacts: {
+      body: {
+        mediaType:
+          texture.format === 'r8unorm'
+            ? 'application/x-forgeax-r8'
+            : `application/x-forgeax-${texture.format}`,
+        assetCodec: { name: texture.format, version: '1' },
+        bytes: bytes(texture.data),
+      },
+    },
+  };
+}
+
 function ordinaryPodProduct(input: AssetOutputInput): AssetOutputProduct {
   const asset = input.asset;
   switch (asset.kind) {
-    case 'texture': {
-      const texture = asset as TextureAsset;
-      return {
-        payload: texture,
-        refs: [],
-        artifacts: {
-          body: {
-            mediaType: 'image/raw',
-            assetCodec: { name: 'raw-image', version: '1' },
-            bytes: bytes(texture.data),
-          },
-        },
-      };
-    }
+    case 'texture':
+      return textureProduct(input);
     case 'equirect': {
       const equirect = asset as EquirectAsset;
       return {
@@ -418,6 +451,11 @@ export const materialAssetOutputProducer = createSafeProducer(
   materialProduct,
 );
 export const meshAssetOutputProducer = createSafeProducer('mesh', 'mesh-binary/4', meshProduct);
+export const textureAssetOutputProducer = createSafeProducer(
+  'texture',
+  'texture-pack/1',
+  textureProduct,
+);
 
 export function createSceneAssetOutputProducer(
   sceneComponents: readonly ScriptablePackSceneComponent[] = [],
@@ -434,9 +472,9 @@ export function createStandardAssetOutputProducerRegistry(
   const registry = new AssetOutputProducerRegistry();
   registry.register(materialAssetOutputProducer);
   registry.register(meshAssetOutputProducer);
+  registry.register(textureAssetOutputProducer);
   registry.register(createSceneAssetOutputProducer(sceneComponents));
   for (const kind of [
-    'texture',
     'equirect',
     'sampler',
     'font',

package/src/source-package-errors.ts

@@ -118,10 +118,45 @@ function importFailureCode(error: ImportError): SourcePackageErrorCode {
   }
 }
 
+const IMPORT_ERROR_CODES = new Set([
+  'importer-not-registered',
+  'source-read-failed',
+  'import-produced-no-assets',
+  'guid-mismatch',
+  'mesh-material-slot-topology-change',
+  'import-internal-error',
+  'source-validation-failed',
+  'unknown-source-key',
+  'duplicate-source-key',
+  'invalid-source-overrides',
+  'invalid-source-override-payload',
+]);
+
+function findNormalizableCause(error: unknown, seen = new Set<unknown>()): unknown {
+  if (error === null || typeof error !== 'object' || seen.has(error)) return undefined;
+  seen.add(error);
+  if (isSourcePackageError(error) || isScriptablePackFailure(error) || isImportError(error)) {
+    return error;
+  }
+  const cause = (error as { readonly cause?: unknown }).cause;
+  return cause === undefined ? undefined : findNormalizableCause(cause, seen);
+}
+
+/** Return whether an error chain contains a source-package/import contract error. */
+export function containsSourcePackageError(error: unknown, seen = new Set<unknown>()): boolean {
+  if (error === null || typeof error !== 'object' || seen.has(error)) return false;
+  seen.add(error);
+  if (isSourcePackageError(error) || isImportError(error)) return true;
+  const cause = (error as { readonly cause?: unknown }).cause;
+  return cause !== undefined && containsSourcePackageError(cause, seen);
+}
+
 export function normalizeSourcePackageError(
   error: unknown,
   context: SourcePackageErrorContext,
 ): SourcePackageError {
+  const cause = findNormalizableCause(error);
+  if (cause !== undefined && cause !== error) return normalizeSourcePackageError(cause, context);
   if (isSourcePackageError(error)) return error;
   if (isScriptablePackFailure(error)) {
     return sourcePackageError('source-package-conversion-failed', context, {
@@ -174,6 +209,8 @@ function isImportError(error: unknown): error is ImportError {
     error !== null &&
     typeof error === 'object' &&
     'code' in error &&
+    typeof error.code === 'string' &&
+    IMPORT_ERROR_CODES.has(error.code) &&
     'expected' in error &&
     'hint' in error &&
     'detail' in error

package/src/source-path.ts

@@ -0,0 +1,36 @@
+import { resolve } from 'node:path';
+import { catalogSourcePathFor } from '@forgeax/engine-pack/build';
+import type { ScanSourceDeclaration } from '@forgeax/engine-pack/scanner';
+
+function normalizeCatalogPath(path: string): string {
+  return path.replaceAll('\\', '/').replace(/^\.\//, '');
+}
+
+export interface CatalogSourceDeclaration {
+  readonly sourcePath: string;
+  readonly declaration: ScanSourceDeclaration;
+}
+
+/**
+ * Resolve a Catalog row's logical source locator back to its physical scanner
+ * declaration. Catalog rows are host identities; declaration maps remain
+ * physical because production still has to read those files from disk.
+ */
+export function sourceDeclarationForCatalogPath(
+  sourcePath: string,
+  declarations: ReadonlyMap<string, ScanSourceDeclaration>,
+  sourceIdentityFor?: (sourcePath: string) => string,
+  cwd = process.cwd(),
+): CatalogSourceDeclaration | undefined {
+  const normalized = normalizeCatalogPath(sourcePath);
+  const direct = declarations.get(resolve(cwd, sourcePath));
+  if (direct !== undefined) {
+    return { sourcePath: resolve(cwd, sourcePath), declaration: direct };
+  }
+  for (const [physicalPath, declaration] of declarations) {
+    if (catalogSourcePathFor(cwd, physicalPath, sourceIdentityFor) === normalized) {
+      return { sourcePath: physicalPath, declaration };
+    }
+  }
+  return undefined;
+}