@forgeax/engine-import 0.1.21 → 0.1.23

package/src/__tests__/parameterized-scriptable-pack.unit.test.ts

@@ -0,0 +1,270 @@
+import { AssetGuid, definePack, definePackageId, PackageId } from '@forgeax/engine-pack/source';
+import { err, ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  buildParameterizedScriptablePack,
+  buildParameterizedScriptablePackWorklist,
+} from '../parameterized-scriptable-pack.js';
+import type { ScriptablePackAssetSnapshotSource } from '../scriptable-pack.js';
+import { AssetOutputProducerRegistry } from '../scriptable-pack.js';
+import { produceParameterizedScriptablePackProducts } from '../scriptable-pack-host.js';
+
+function id(value: string) {
+  const result = PackageId.parse(value);
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+function scene() {
+  return { kind: 'scene' as const, entities: [], mounts: [] };
+}
+
+function producers() {
+  const registry = new AssetOutputProducerRegistry();
+  registry.register({
+    kind: 'scene',
+    version: 'test',
+    produce: ({ asset }) => ok({ payload: asset as never, refs: [], artifacts: {} }),
+  });
+  return registry;
+}
+
+describe('parameterized ScriptablePack import bridge', () => {
+  it('uses the subject packageId and dynamic sourceKey output map', async () => {
+    const packageId = definePackageId('01900000-0000-7000-8000-000000000040');
+    const definition = definePack({
+      schemaVersion: '2.0.0',
+      packageId,
+      parameters: [{ name: 'count', type: 'u32', default: 1, minimum: 1 }] as const,
+      build: ({ values }) =>
+        ok(
+          Object.fromEntries(
+            Array.from({ length: values.count }, (_, index) => [`scene/${index}`, scene()]),
+          ),
+        ),
+    });
+    const result = await buildParameterizedScriptablePack({
+      definition,
+      sourcePath: 'assets/param.pack.ts',
+      values: { count: 2 },
+      outputs: producers(),
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.product.assets.map((asset) => asset.guid)).toEqual([
+      AssetGuid.format(AssetGuid.derive(packageId, 'scene/0')),
+      AssetGuid.format(AssetGuid.derive(packageId, 'scene/1')),
+    ]);
+    expect(result.value.stagedOutputs.map((output) => output.sourceKey)).toEqual([
+      'scene/0',
+      'scene/1',
+    ]);
+  });
+
+  it('retries forward content reads until the internal worklist makes progress', async () => {
+    const firstId = id('01900000-0000-7000-8000-000000000050');
+    const secondId = id('01900000-0000-7000-8000-000000000051');
+    const first = definePack({
+      schemaVersion: '2.0.0',
+      packageId: firstId,
+      build: () => ok({ 'scene/first': scene() }),
+    });
+    const dependencyGuid = AssetGuid.derive(firstId, 'scene/first');
+    const second = definePack({
+      schemaVersion: '2.0.0',
+      packageId: secondId,
+      build: async ({ readByGuid }) => {
+        const dependency = await readByGuid(dependencyGuid);
+        if (!dependency.ok) return err(dependency.error);
+        return ok({ 'scene/second': scene() });
+      },
+    });
+    const result = await buildParameterizedScriptablePackWorklist({
+      subjects: [
+        // Keep the dependency consumer first even after the worklist applies
+        // its stable source-path ordering, so this proves a real retry pass.
+        { definition: second, sourcePath: 'assets/a-second.pack.ts' },
+        { definition: first, sourcePath: 'assets/z-first.pack.ts' },
+      ],
+      outputs: producers(),
+    });
+    expect(result).toMatchObject({ ok: true, value: { iterations: 2 } });
+    if (result.ok) expect(result.value.products).toHaveLength(2);
+  });
+
+  it('returns a structured stall when no subject can satisfy a content read', async () => {
+    const missing = AssetGuid.derive(id('01900000-0000-7000-8000-000000000060'), 'scene/missing');
+    const definition = definePack({
+      schemaVersion: '2.0.0',
+      packageId: id('01900000-0000-7000-8000-000000000061'),
+      build: async ({ readByGuid }) => {
+        const dependency = await readByGuid(missing);
+        if (!dependency.ok) return err(dependency.error);
+        return ok({ 'scene/main': scene() });
+      },
+    });
+    const result = await buildParameterizedScriptablePackWorklist({
+      subjects: [{ definition, sourcePath: 'assets/missing.pack.ts' }],
+      outputs: producers(),
+    });
+    expect(result).toMatchObject({ ok: false, error: { code: 'pack-content-dependency-stalled' } });
+  });
+
+  it('uses the published asset source when a dynamic build reads a non-staged dependency', async () => {
+    const packageId = id('01900000-0000-7000-8000-000000000062');
+    const dependencyPackageId = id('01900000-0000-7000-8000-000000000063');
+    const dependencyGuid = AssetGuid.derive(dependencyPackageId, 'sampler/main');
+    const dependency = {
+      kind: 'sampler' as const,
+      magFilter: 'linear' as const,
+      minFilter: 'linear' as const,
+      mipmapFilter: 'linear' as const,
+      addressModeU: 'repeat' as const,
+      addressModeV: 'repeat' as const,
+      addressModeW: 'repeat' as const,
+    };
+    const assetSource: ScriptablePackAssetSnapshotSource = {
+      async readByGuid(guid) {
+        return AssetGuid.equals(guid, dependencyGuid)
+          ? ok({ asset: dependency, generation: 7, digest: 'sha256:published' })
+          : err({
+              code: 'asset-not-found',
+              expected: 'the published dependency',
+              hint: 'publish the dependency before rebuilding',
+            });
+      },
+    };
+    const definition = definePack({
+      schemaVersion: '2.0.0',
+      packageId,
+      build: async ({ readByGuid }) => {
+        const read = await readByGuid(dependencyGuid);
+        if (!read.ok) return err(read.error);
+        return ok({ 'scene/main': scene() });
+      },
+    });
+    const result = await produceParameterizedScriptablePackProducts({
+      sources: [
+        {
+          sourcePath: 'assets/consumer.pack.ts',
+          displaySourcePath: 'assets/consumer.pack.ts',
+          definition,
+          sourceClosure: [],
+          publicationGeneration: 1,
+          policy: {
+            base: '/',
+            packagePath: 'assets/consumer.pack.json',
+            artifactPath: (guid, key) => `artifacts/${guid}/${key}`,
+          },
+        },
+      ],
+      assetSource,
+    });
+    expect(result).toMatchObject({ ok: true });
+    if (!result.ok) return;
+    expect(result.value.get('assets/consumer.pack.ts')?.product.externalEvidence).toEqual([
+      {
+        guid: AssetGuid.format(dependencyGuid),
+        usage: 'content',
+        generation: 7,
+        digest: 'sha256:published',
+      },
+    ]);
+    const revision = result.value.get('assets/consumer.pack.ts')?.revision;
+    expect(revision?.observedAt).toBe(0);
+  });
+
+  it('does not replace a staged read failure with a published value', async () => {
+    const packageId = id('01900000-0000-7000-8000-000000000064');
+    const dependencyGuid = AssetGuid.derive(packageId, 'scene/dependency');
+    const assetSource: ScriptablePackAssetSnapshotSource = {
+      async readByGuid() {
+        return err({
+          code: 'asset-fetch-failed',
+          expected: 'the staged dependency read to succeed',
+          hint: 'repair the staged generation before retrying',
+        });
+      },
+    };
+    const definition = definePack({
+      schemaVersion: '2.0.0',
+      packageId,
+      build: async ({ readByGuid }) => {
+        const read = await readByGuid(dependencyGuid);
+        if (!read.ok) return err(read.error);
+        return ok({ 'scene/main': scene() });
+      },
+    });
+    const result = await produceParameterizedScriptablePackProducts({
+      sources: [
+        {
+          sourcePath: 'assets/failing-consumer.pack.ts',
+          displaySourcePath: 'assets/failing-consumer.pack.ts',
+          definition,
+          sourceClosure: [],
+          publicationGeneration: 1,
+          policy: {
+            base: '/',
+            packagePath: 'assets/failing-consumer.pack.json',
+            artifactPath: (guid, key) => `artifacts/${guid}/${key}`,
+          },
+        },
+      ],
+      assetSource,
+    });
+    expect(result).toMatchObject({ ok: false, error: { code: 'asset-fetch-failed' } });
+  });
+
+  it('converts a throwing output producer into a structured import failure', async () => {
+    const outputs = new AssetOutputProducerRegistry();
+    outputs.register({
+      kind: 'scene',
+      version: 'test',
+      produce: () => {
+        throw new Error('producer exploded');
+      },
+    });
+    const result = await buildParameterizedScriptablePack({
+      definition: definePack({
+        schemaVersion: '2.0.0',
+        packageId: id('01900000-0000-7000-8000-000000000065'),
+        build: () => ok({ 'scene/main': scene() }),
+      }),
+      sourcePath: 'assets/throwing-producer.pack.ts',
+      outputs,
+    });
+    expect(result).toMatchObject({ ok: false, error: { code: 'import-internal-error' } });
+  });
+
+  it('rejects malformed output producer products at the import boundary', async () => {
+    const outputs = new AssetOutputProducerRegistry();
+    outputs.register({
+      kind: 'scene',
+      version: 'test',
+      produce: () => ({ ok: true, value: null }) as never,
+    });
+    const result = await buildParameterizedScriptablePack({
+      definition: definePack({
+        schemaVersion: '2.0.0',
+        packageId: id('01900000-0000-7000-8000-000000000066'),
+        build: () => ok({ 'scene/main': scene() }),
+      }),
+      sourcePath: 'assets/malformed-producer.pack.ts',
+      outputs,
+    });
+    expect(result).toMatchObject({ ok: false, error: { code: 'pack-parameter-invalid' } });
+  });
+
+  it('converts a malformed Pack build result into a structured import failure', async () => {
+    const result = await buildParameterizedScriptablePack({
+      definition: definePack({
+        schemaVersion: '2.0.0',
+        packageId: id('01900000-0000-7000-8000-000000000067'),
+        build: () => null as never,
+      }),
+      sourcePath: 'assets/malformed-build.pack.ts',
+      outputs: producers(),
+    });
+    expect(result).toMatchObject({ ok: false, error: { code: 'import-internal-error' } });
+  });
+});

package/src/__tests__/scriptable-pack-file-snapshot.unit.test.ts

@@ -0,0 +1,177 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { AssetGuid as AssetGuidType } from '@forgeax/engine-types';
+import { afterEach, describe, expect, it } from 'vitest';
+import { createScriptablePackFileAssetSnapshotSource } from '../index.js';
+
+function guid(value: string): AssetGuidType {
+  const parsed = AssetGuid.parse(value);
+  if (!parsed.ok) throw parsed.error;
+  return parsed.value;
+}
+
+function pack(
+  assets: readonly {
+    readonly guid: string;
+    readonly kind: string;
+    readonly payload: Record<string, unknown>;
+  }[],
+): string {
+  return JSON.stringify({
+    schemaVersion: '1.0.0',
+    kind: 'internal-text-package',
+    assets: assets.map((asset) => ({ ...asset, refs: [] })),
+  });
+}
+
+const ROOT_GUID = '019ffa97-2000-7000-8000-000000000011';
+const SECOND_GUID = '019ffa97-2000-7000-8000-000000000012';
+const MISSING_GUID = guid('019ffa97-2000-7000-8000-000000000099');
+const temporaryRoots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })),
+  );
+});
+
+async function temporaryRoot(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-file-source-'));
+  temporaryRoots.push(root);
+  return root;
+}
+
+describe('ScriptablePack file asset snapshot source', () => {
+  it('indexes ordinary Pack JSON by GUID and returns deterministic private snapshots', async () => {
+    const root = await temporaryRoot();
+    const nested = join(root, 'nested');
+    await mkdir(nested);
+    await writeFile(
+      join(root, 'root.pack.json'),
+      pack([{ guid: ROOT_GUID, kind: 'video', payload: { url: '/root.webm' } }]),
+    );
+    await writeFile(
+      join(nested, 'second.pack.json'),
+      pack([{ guid: SECOND_GUID, kind: 'video', payload: { url: '/second.webm' } }]),
+    );
+
+    const source = createScriptablePackFileAssetSnapshotSource({ assetRoots: [root] });
+    const first = await source.readByGuid(guid(ROOT_GUID));
+    const second = await source.readByGuid(guid(ROOT_GUID));
+
+    expect(first).toMatchObject({
+      ok: true,
+      value: {
+        asset: { kind: 'video', url: '/root.webm' },
+        generation: expect.any(Number),
+        digest: expect.stringMatching(/^sha256:[0-9a-f]{64}$/),
+      },
+    });
+    expect(second).toEqual(first);
+    if (!first.ok) return;
+    expect(first.value.generation).toBeGreaterThan(0);
+    (first.value.asset as { url: string }).url = '/mutated.webm';
+
+    const reread = await source.readByGuid(guid(ROOT_GUID));
+    expect(reread).toMatchObject({ ok: true, value: { asset: { url: '/root.webm' } } });
+  });
+
+  it('keeps generation and digest stable when roots and JSON key order change', async () => {
+    const firstRoot = await temporaryRoot();
+    const secondRoot = await temporaryRoot();
+    await writeFile(
+      join(firstRoot, 'first.pack.json'),
+      pack([{ guid: ROOT_GUID, kind: 'video', payload: { url: '/root.webm', loop: true } }]),
+    );
+    await writeFile(
+      join(secondRoot, 'second.pack.json'),
+      pack([{ guid: SECOND_GUID, kind: 'video', payload: { loop: false, url: '/second.webm' } }]),
+    );
+
+    const first = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [firstRoot, secondRoot],
+    }).readByGuid(guid(ROOT_GUID));
+    const second = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [secondRoot, firstRoot],
+    }).readByGuid(guid(ROOT_GUID));
+
+    expect(second).toEqual(first);
+  });
+
+  it('returns structured failures for malformed packages, collisions, and missing GUIDs', async () => {
+    const malformedRoot = await temporaryRoot();
+    await writeFile(join(malformedRoot, 'broken.pack.json'), '{not-json');
+    const malformed = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [malformedRoot],
+    }).readByGuid(MISSING_GUID);
+    expect(malformed).toMatchObject({
+      ok: false,
+      error: {
+        code: 'scriptable-pack-file-json-invalid',
+        detail: { path: join(malformedRoot, 'broken.pack.json') },
+      },
+    });
+
+    const invalidRoot = await temporaryRoot();
+    await writeFile(
+      join(invalidRoot, 'invalid.pack.json'),
+      JSON.stringify({ schemaVersion: '1.0.0', kind: 'internal-text-package' }),
+    );
+    const invalid = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [invalidRoot],
+    }).readByGuid(MISSING_GUID);
+    expect(invalid).toMatchObject({
+      ok: false,
+      error: {
+        code: 'scriptable-pack-file-invalid',
+        detail: { path: join(invalidRoot, 'invalid.pack.json') },
+      },
+    });
+
+    const collisionRoot = await temporaryRoot();
+    await writeFile(
+      join(collisionRoot, 'a.pack.json'),
+      pack([{ guid: ROOT_GUID, kind: 'video', payload: { url: '/a.webm' } }]),
+    );
+    await writeFile(
+      join(collisionRoot, 'b.pack.json'),
+      pack([{ guid: ROOT_GUID, kind: 'video', payload: { url: '/b.webm' } }]),
+    );
+    const collision = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [collisionRoot],
+    }).readByGuid(guid(ROOT_GUID));
+    expect(collision).toMatchObject({
+      ok: false,
+      error: {
+        code: 'scriptable-pack-file-guid-collision',
+        detail: {
+          guid: ROOT_GUID,
+          paths: [join(collisionRoot, 'a.pack.json'), join(collisionRoot, 'b.pack.json')],
+        },
+      },
+    });
+
+    const emptyRoot = await temporaryRoot();
+    const missing = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [emptyRoot],
+    }).readByGuid(MISSING_GUID);
+    expect(missing).toMatchObject({
+      ok: false,
+      error: { code: 'asset-not-found', detail: { guid: AssetGuid.format(MISSING_GUID) } },
+    });
+  });
+
+  it('fails closed when an asset root cannot be read', async () => {
+    const root = join(await temporaryRoot(), 'missing');
+    const result = await createScriptablePackFileAssetSnapshotSource({
+      assetRoots: [root],
+    }).readByGuid(MISSING_GUID);
+
+    expect(result).toMatchObject({
+      ok: false,
+      error: { code: 'scriptable-pack-file-root-unreadable', detail: { root } },
+    });
+  });
+});

package/src/__tests__/scriptable-pack-host.unit.test.ts

@@ -1,5 +1,11 @@
-import { AssetGuid } from '@forgeax/engine-pack/guid';
-import type { ScanSourceDeclaration } from '@forgeax/engine-pack/scanner';
+import { resolve } from 'node:path';
+import { AssetGuid, PackageId } from '@forgeax/engine-pack/guid';
+import type { NativeCooker } from '@forgeax/engine-pack/native-cooker';
+import type {
+  ParameterizedPackInventoryDocument,
+  ScanSourceDeclaration,
+} from '@forgeax/engine-pack/scanner';
+import { parseParameterizedPackJson, projectDirectPackJson } from '@forgeax/engine-pack/source';
 import type {
   Asset,
   AssetGuid as AssetGuidType,
@@ -8,7 +14,10 @@ import type {
 } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { ImporterRegistry } from '../importer-registry.js';
-import { declaredPackExternalOutputs } from '../scriptable-pack-host.js';
+import {
+  declaredPackExternalOutputs,
+  prepareDirectPackTransport,
+} from '../scriptable-pack-host.js';
 
 const GUID = '019ffa97-0000-7000-8000-000000000001';
 
@@ -69,7 +78,6 @@ describe('ScriptablePack external Meta staging', () => {
         fsForImport: {
           readSource: async () => ({ ok: true as const, value: new Uint8Array([1, 2, 3]) }),
         },
-        assetPaths: {},
       },
     );
 
@@ -83,4 +91,188 @@ describe('ScriptablePack external Meta staging', () => {
       0, 1, 2,
     ]);
   });
+
+  it('cooks direct producer-backed outputs before exposing them to a dynamic Pack', async () => {
+    const packageId = PackageId.parse('019ffa97-0000-7000-8000-000000000010');
+    if (!packageId.ok) throw packageId.error;
+    const outputGuid = AssetGuid.format(AssetGuid.derive(packageId.value, 'vfx/main'));
+    const materialGuid = '019ffa97-0000-7000-8000-000000000099';
+    const value: ParameterizedPackInventoryDocument = {
+      schemaVersion: '3.0.0',
+      packageId: PackageId.format(packageId.value),
+      assets: {
+        'vfx/main': {
+          kind: 'particle-effect',
+          payload: {
+            schemaVersion: 2,
+            emitters: [
+              {
+                id: 'main',
+                program: { module: 'main.vfx.wgsl' },
+                renderers: [],
+              },
+            ],
+          },
+          refs: [materialGuid],
+        },
+      },
+    };
+    let cookCalls = 0;
+    const cooker: NativeCooker = {
+      key: 'particle-effect',
+      cook(input) {
+        cookCalls += 1;
+        const source = input as { readonly guid: string };
+        return {
+          guid: source.guid,
+          payload: {
+            kind: 'particle-effect',
+            schemaVersion: 2,
+            programFingerprint: 'sha256:cooked',
+            emitters: [],
+            program: {
+              format: 'forgeax-vfx-program-2',
+              fingerprint: 'sha256:cooked',
+              emitters: [],
+            },
+          },
+          refs: [materialGuid],
+          artifacts: {
+            'particle-effect/program.json': {
+              mediaType: 'application/json',
+              bytes: new TextEncoder().encode('{"program":"cooked"}'),
+            },
+          },
+          inputFingerprint: 'sha256:cooked',
+        };
+      },
+    };
+    const declaration = {
+      format: 'pack.json',
+      sourcePath: resolve(process.cwd(), 'src/__tests__/scriptable-pack-host.unit.test.ts'),
+      sourceRevision: 'sha256:direct',
+      sourceText: JSON.stringify(value),
+      value,
+    } satisfies Extract<ScanSourceDeclaration, { readonly format: 'pack.json' }>;
+
+    const outputs = await declaredPackExternalOutputs(
+      new Map([[declaration.sourcePath, declaration]]),
+      [cooker],
+      [parseGuid(outputGuid), parseGuid(materialGuid)],
+    );
+
+    expect(cookCalls).toBe(1);
+    expect(outputs).toHaveLength(1);
+    expect(outputs[0]).toMatchObject({
+      sourceKey: 'vfx/main',
+      asset: {
+        kind: 'particle-effect',
+        programFingerprint: 'sha256:cooked',
+        program: { format: 'forgeax-vfx-program-2' },
+      },
+    });
+  });
+
+  it('keeps a direct non-Engine POD as direct transport', async () => {
+    const packageId = PackageId.parse('019ffa97-0000-0000-8000-000000000010');
+    if (!packageId.ok) throw packageId.error;
+    const outputGuid = AssetGuid.format(AssetGuid.derive(packageId.value, 'ui/main'));
+    const value: ParameterizedPackInventoryDocument = {
+      schemaVersion: '3.0.0',
+      packageId: PackageId.format(packageId.value),
+      assets: {
+        'ui/main': {
+          kind: 'ui',
+          payload: { html: '<main>direct</main>', css: ':host{display:block}' },
+          refs: [],
+        },
+      },
+    };
+    const declaration = {
+      format: 'pack.json',
+      sourcePath: resolve(process.cwd(), 'src/__tests__/scriptable-pack-host.unit.test.ts'),
+      sourceRevision: 'sha256:ui',
+      sourceText: JSON.stringify(value),
+      value,
+    } satisfies Extract<ScanSourceDeclaration, { readonly format: 'pack.json' }>;
+
+    const outputs = await declaredPackExternalOutputs(
+      new Map([[declaration.sourcePath, declaration]]),
+      [],
+      [parseGuid(outputGuid)],
+    );
+
+    expect(outputs).toHaveLength(1);
+    expect(outputs[0]?.asset).toEqual({
+      kind: 'ui',
+      guid: outputGuid,
+      html: '<main>direct</main>',
+      css: ':host{display:block}',
+    });
+  });
+
+  it('leaves Engine-owned material modules on the runtime registry path', async () => {
+    const packageId = PackageId.parse('019ffa97-0000-0000-8000-000000000011');
+    if (!packageId.ok) throw packageId.error;
+    const value = {
+      schemaVersion: '3.0.0' as const,
+      packageId: PackageId.format(packageId.value),
+      assets: {
+        'material/base': {
+          kind: 'material',
+          payload: {
+            passes: [
+              { name: 'Forward', program: { module: 'forgeax::default-unlit' } },
+              { name: 'ShadowCaster', program: { module: 'forgeax::default-shadow-caster' } },
+            ],
+            values: { baseColor: [0.6, 0.6, 0.6, 1] },
+          },
+          refs: [],
+        },
+      },
+    };
+    const parsed = parseParameterizedPackJson(value);
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok || parsed.value.format !== 'direct') return;
+    const projected = projectDirectPackJson(parsed.value);
+    expect(projected.ok).toBe(true);
+    if (!projected.ok) return;
+    let cookCalls = 0;
+    const sourcePath = resolve(process.cwd(), 'src/__tests__/scriptable-pack-host.unit.test.ts');
+    const result = await prepareDirectPackTransport({
+      projected: projected.value,
+      sourcePath,
+      sourceRevision: 'sha256:direct-engine-material',
+      cookers: [
+        {
+          key: 'material',
+          cook() {
+            cookCalls += 1;
+            throw new Error('Engine-owned material must not enter the project cooker');
+          },
+        } satisfies NativeCooker,
+      ],
+      policy: {
+        base: '/',
+        packagePath: 'assets/base-material.pack.json',
+        artifactPath: (guid, key) => `${guid}/${key}.bin`,
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    expect(cookCalls).toBe(0);
+    if (!result.ok) return;
+    expect(result.value.finalized.pack.assets).toMatchObject([
+      {
+        kind: 'material',
+        payload: {
+          passes: [
+            { program: { module: 'forgeax::default-unlit' } },
+            { program: { module: 'forgeax::default-shadow-caster' } },
+          ],
+        },
+        artifacts: {},
+      },
+    ]);
+  });
 });

package/src/__tests__/scriptable-pack-production-producers.unit.test.ts

@@ -174,6 +174,7 @@ describe('standard ScriptablePack output producers', () => {
       audio: 'ordinary-pod/1',
       equirect: 'ordinary-pod/1',
       font: 'ordinary-pod/1',
+      'ies-profile': 'ordinary-pod/1',
       material: 'material-pack/1',
       mesh: 'mesh-binary/4',
       'particle-effect': 'ordinary-pod/1',
@@ -206,6 +207,7 @@ describe('standard ScriptablePack output producers', () => {
       'animation-clip',
       'animation-graph',
       'audio',
+      'ies-profile',
       'particle-effect',
     ] as const;