@forgeax/engine-pack 0.1.7 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-pack",
-  "version": "0.1.7",
+  "version": "0.1.19",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -108,7 +108,7 @@
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "tsup": "^8.3.5",
-    "vitest": "4.0.18"
+    "vitest": "4.1.11"
   },
   "forgeax": {
     "metrics": {
@@ -136,7 +136,7 @@
     }
   },
   "dependencies": {
-    "@forgeax/engine-types": "0.1.7",
+    "@forgeax/engine-types": "0.1.19",
     "@noble/hashes": "^2.2.0",
     "fast-glob": "^3.3.3",
     "typescript": "^5.8.3",

package/src/__tests__/material-cook-dependencies.unit.test.ts

@@ -25,6 +25,50 @@ describe('material cook dependency closure', () => {
     });
   });
 
+  it('collects transmission and thickness texture dependencies', () => {
+    expect(
+      collectMaterialCookRefs({
+        parameters: [
+          { name: 'transmissionTexture', type: 'texture' },
+          { name: 'thicknessTexture', type: 'texture' },
+        ],
+        values: {
+          transmissionTexture: { texture: 'texture/transmission', sampler: 'sampler/linear' },
+          thicknessTexture: { texture: 'texture/thickness', sampler: 'sampler/linear' },
+        },
+      }),
+    ).toEqual({
+      parent: [],
+      textures: ['texture/thickness', 'texture/transmission'],
+      samplers: ['sampler/linear'],
+      modules: [],
+    });
+  });
+
+  it('keeps authored Standard values with both texture dependency edges', () => {
+    const refs = collectMaterialCookRefs({
+      passes: [{ name: 'Forward', program: { module: 'forgeax::default-standard-pbr' } }],
+      parameters: [
+        { name: 'transmissionTexture', type: 'texture' },
+        { name: 'thicknessTexture', type: 'texture' },
+      ],
+      values: {
+        transmission: 0.8,
+        ior: 1.45,
+        thickness: 0.25,
+        transmissionTexture: { texture: 'texture/transmission', sampler: 'sampler/linear' },
+        thicknessTexture: { texture: 'texture/thickness', sampler: 'sampler/linear' },
+      },
+    });
+
+    expect(refs).toEqual({
+      parent: [],
+      textures: ['texture/thickness', 'texture/transmission'],
+      samplers: ['sampler/linear'],
+      modules: ['forgeax::default-standard-pbr'],
+    });
+  });
+
   it('collects string shorthands only from declared texture parameters', () => {
     expect(
       collectMaterialCookRefs({

package/src/build.ts

@@ -33,6 +33,7 @@ export {
   type CatalogBuildResult,
   type CatalogImporterPolicy,
   type CatalogProducerVisibility,
+  catalogSourcePathFor,
   metaPathForGuid,
 } from './catalog-builder.js';
 export { calculateCatalogDelta } from './catalog-delta.js';

package/src/catalog-builder.ts

@@ -1,4 +1,4 @@
-import { relative } from 'node:path';
+import { isAbsolute, relative } from 'node:path';
 import type { PackIndexEntry, ProviderProvenance } from '@forgeax/engine-types';
 import {
   findReservedAssetKindConflict,
@@ -75,12 +75,38 @@ export interface CatalogBuildProjectionOptions {
   readonly scanOptions?: ScanOptions;
   readonly importerPolicy: (importer: string) => CatalogImporterPolicy;
   readonly visibility?: CatalogProducerVisibility;
+  /**
+   * Project physical source paths into a stable host-owned logical identity.
+   * Scanner/declaration maps retain physical paths for I/O; only Catalog rows
+   * use this projection so symlink farms cannot change publication identity.
+   */
+  readonly sourceIdentityFor?: (sourcePath: string) => string;
 }
 
 function sourcePathFor(cwd: string, path: string): string {
   return relative(cwd, path).replace(/\\/g, '/');
 }
 
+/**
+ * Project one physical source path into the catalog's browser-safe logical
+ * locator. Physical paths remain the scanner/declaration keys; only catalog
+ * rows use this projection.
+ */
+export function catalogSourcePathFor(
+  cwd: string,
+  path: string,
+  sourceIdentityFor: CatalogBuildProjectionOptions['sourceIdentityFor'],
+): string {
+  const projected = sourceIdentityFor?.(path);
+  // A host may intentionally leave paths outside its logical roots untouched.
+  // Keep the catalog's existing cwd-relative URL contract for that fallback;
+  // an absolute physical path is a valid dependency identity, but not a
+  // browser-served catalog locator.
+  const catalogPath =
+    projected === undefined || isAbsolute(projected) ? sourcePathFor(cwd, path) : projected;
+  return catalogPath.replaceAll('\\', '/').replace(/^\.\//, '');
+}
+
 export function metaPathForGuid(
   declarations: ReadonlyMap<string, CatalogImportMeta>,
   guid: string,
@@ -115,6 +141,7 @@ function projectMeta(
   assetPaths: Record<string, string>,
   importerPolicy: (importer: string) => CatalogImporterPolicy,
   sourceDeclaration: Extract<ScanSourceDeclaration, { readonly format: 'meta.json' }>,
+  sourceIdentityFor: CatalogBuildProjectionOptions['sourceIdentityFor'],
 ): {
   readonly entries: PackIndexEntry[];
   readonly declaration?: CatalogImportMeta;
@@ -136,7 +163,7 @@ function projectMeta(
       },
     };
   }
-  const sourcePath = sourcePathFor(cwd, resolved.value);
+  const sourcePath = catalogSourcePathFor(cwd, resolved.value, sourceIdentityFor);
   const packageUrl = `${base}/__forgeax-ddc/${meta.subAssets[0]?.guid?.toLowerCase() ?? 'pack'}.pack.json`;
   const declaration: CatalogImportMeta = {
     importer: meta.importer,
@@ -184,6 +211,7 @@ function projectSource(
   visibility: CatalogBuildProjectionOptions['visibility'],
   sourceDeclaration: ScanSourceDeclaration,
   declarations: Map<string, CatalogImportMeta>,
+  sourceIdentityFor: CatalogBuildProjectionOptions['sourceIdentityFor'],
 ): { readonly entries: PackIndexEntry[]; readonly error?: CatalogBuildError } {
   if (sourceDeclaration.format === 'pack.ts') {
     const meta = { ...sourceDeclaration.meta, source: sourcePathFor(cwd, path) };
@@ -193,7 +221,7 @@ function projectSource(
       : {
           entries: projectExternalCatalogEntries(
             meta,
-            sourcePathFor(cwd, path),
+            catalogSourcePathFor(cwd, path, sourceIdentityFor),
             `${base}/__forgeax-ddc/${anchorGuid}.pack.json`,
             meta.subAssets,
             (output) => deriveAssetName(path, meta.subAssets.length, output.name),
@@ -212,12 +240,20 @@ function projectSource(
     ) {
       return { entries: [] };
     }
-    const projected = projectMeta(path, cwd, base, assetPaths, importerPolicy, sourceDeclaration);
+    const projected = projectMeta(
+      path,
+      cwd,
+      base,
+      assetPaths,
+      importerPolicy,
+      sourceDeclaration,
+      sourceIdentityFor,
+    );
     if (projected.declaration !== undefined) declarations.set(path, projected.declaration);
     return projected;
   }
   const parsed = sourceDeclaration.value;
-  const sourcePath = sourcePathFor(cwd, path);
+  const sourcePath = catalogSourcePathFor(cwd, path, sourceIdentityFor);
   const provenance =
     parsed.provenance ??
     ({ provider: 'pack', version: parsed.schemaVersion } satisfies ProviderProvenance);
@@ -297,6 +333,7 @@ export async function buildCatalogProjection(
       options.visibility,
       sourceDeclaration,
       declarations,
+      options.sourceIdentityFor,
     );
     entries.push(...projected.entries);
     if (projected.error !== undefined) errors.push(projected.error);

package/src/scriptable-pack-node.ts

@@ -670,7 +670,10 @@ export async function loadScriptablePack(
   sourcePath: string,
   options: LoadScriptablePackOptions = {},
 ): Promise<Result<Readonly<ScriptablePackDefinition>, ScriptablePackError>> {
-  const timeoutMs = options.timeoutMs ?? 5_000;
+  // Module initialization includes transpiling the trusted TypeScript source
+  // closure in a fresh Worker. A cold SDK workspace can legitimately exceed
+  // the build execution budget before any authored build() code has run.
+  const timeoutMs = options.timeoutMs ?? 15_000;
   const buildTimeoutMs = options.buildTimeoutMs ?? 5_000;
   const executor = options.executor ?? new WorkerScriptablePackExecutor();
   let disposeReason: 'complete' | 'timeout' | 'failure' | undefined;