@forgeax/engine-pack 0.1.23 → 0.1.24

package/src/__tests__/{parameterized-pack-authoring-gateway.unit.test.ts → pack-authoring-gateway.unit.test.ts}

@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
 import { AssetGuid, PackageId } from '../guid.js';
-import { createFileSystemParameterizedPackAuthoringGateway } from '../parameterized-pack-node.js';
+import { createFileSystemPackAuthoringGateway } from '../pack-authoring-node.js';
 
 const DIRECT_PACKAGE = '01900000-0000-7000-8000-000000000070';
 const CLONE_PACKAGE = '01900000-0000-7000-8000-000000000071';
@@ -23,11 +23,11 @@ afterEach(async () => {
   if (root !== undefined) await rm(root, { recursive: true, force: true });
 });
 
-describe('parameterized Pack authoring gateway', () => {
+describe('Pack authoring gateway', () => {
   it('writes guid-less direct JSON, derives identity, and makes mutations idempotent', async () => {
     const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-gateway-direct-'));
     roots.push(root);
-    const gateway = createFileSystemParameterizedPackAuthoringGateway({ gameRoot: root });
+    const gateway = createFileSystemPackAuthoringGateway({ gameRoot: root });
     const operation = {
       operation: 'asset-source.create' as const,
       requestId: 'create-direct',
@@ -72,7 +72,7 @@ describe('parameterized Pack authoring gateway', () => {
     });
     expect(unresolved).toMatchObject({ ok: false, error: { code: 'asset-not-ready' } });
 
-    const publishedGateway = createFileSystemParameterizedPackAuthoringGateway({
+    const publishedGateway = createFileSystemPackAuthoringGateway({
       gameRoot: root,
       materialized: () => [
         {
@@ -121,10 +121,10 @@ describe('parameterized Pack authoring gateway', () => {
     expect(cloneResolved).toMatchObject({ ok: true, value: { status: 'identity' } });
   });
 
-  it('creates parameterized source and instance documents with CAS-protected value edits', async () => {
+  it('creates ScriptablePack source and Pack instance documents with CAS-protected value edits', async () => {
     const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-gateway-instance-'));
     roots.push(root);
-    const gateway = createFileSystemParameterizedPackAuthoringGateway({ gameRoot: root });
+    const gateway = createFileSystemPackAuthoringGateway({ gameRoot: root });
     const source = await gateway.execute({
       operation: 'asset-source.create',
       requestId: 'create-source',
@@ -188,7 +188,7 @@ describe('parameterized Pack authoring gateway', () => {
   it('fails closed when the current materialized projection violates derived identity', async () => {
     const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-gateway-projection-'));
     roots.push(root);
-    const gateway = createFileSystemParameterizedPackAuthoringGateway({
+    const gateway = createFileSystemPackAuthoringGateway({
       gameRoot: root,
       materialized: () => [
         {
@@ -216,7 +216,7 @@ describe('parameterized Pack authoring gateway', () => {
   it('does not fall back from a missing sourcePath to another package locator', async () => {
     const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-gateway-locator-'));
     roots.push(root);
-    const gateway = createFileSystemParameterizedPackAuthoringGateway({ gameRoot: root });
+    const gateway = createFileSystemPackAuthoringGateway({ gameRoot: root });
     await gateway.execute({
       operation: 'asset-source.create',
       requestId: 'create-locator-source',
@@ -237,7 +237,7 @@ describe('parameterized Pack authoring gateway', () => {
   it('converts a broken materialized projection callback into a structured error', async () => {
     const root = await mkdtemp(join(tmpdir(), 'forgeax-pack-gateway-projection-callback-'));
     roots.push(root);
-    const gateway = createFileSystemParameterizedPackAuthoringGateway({
+    const gateway = createFileSystemPackAuthoringGateway({
       gameRoot: root,
       materialized: () => {
         throw new Error('projection unavailable');

package/src/__tests__/{parameterized-pack.unit.test.ts → pack-authoring.unit.test.ts}

@@ -5,12 +5,12 @@ import {
   definePack,
   definePackageId,
   type PackParameterInheritanceSubject,
-  parseParameterizedPackJson,
+  parsePackSourceJson,
   projectDirectPackJson,
   resolvePackParameterInheritance,
   resolvePackParameterValues,
   validatePackDefinition,
-} from '../parameterized-pack.js';
+} from '../pack-authoring.js';
 
 const NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
 
@@ -20,7 +20,7 @@ function packageId(value: string) {
   return result.value;
 }
 
-describe('parameterized Pack authoring', () => {
+describe('ScriptablePack and Pack authoring', () => {
   it('derives the RFC 4122 UUIDv5 vector and keeps PackageId branded separately', () => {
     const namespace = packageId(NAMESPACE);
     expect(AssetGuid.format(AssetGuid.derive(namespace, 'www.widgets.com'))).toBe(
@@ -30,7 +30,7 @@ describe('parameterized Pack authoring', () => {
     expect(AssetGuid.derive(namespace, 'mesh/a')).not.toBe(namespace);
   });
 
-  it('derives an explicit context shape for zero-parameter and parameterized Packs', async () => {
+  it('derives an explicit context shape for zero-parameter and parameter-bearing ScriptablePacks', async () => {
     const zero = definePack({
       schemaVersion: '2.0.0',
       packageId: definePackageId('01900000-0000-7000-8000-000000000001'),
@@ -51,7 +51,7 @@ describe('parameterized Pack authoring', () => {
     });
     expect(zeroResult.ok).toBe(true);
 
-    const parameterized = definePack({
+    const withParameters = definePack({
       schemaVersion: '2.0.0',
       packageId: definePackageId('01900000-0000-7000-8000-000000000002'),
       parameters: [
@@ -67,9 +67,9 @@ describe('parameterized Pack authoring', () => {
           },
         }),
     });
-    const values = resolvePackParameterValues(parameterized, { segments: 24 });
+    const values = resolvePackParameterValues(withParameters, { segments: 24 });
     expect(values).toMatchObject({ ok: true, value: { segments: 24, style: 'oak' } });
-    expect(resolvePackParameterValues(parameterized, { unknown: true })).toMatchObject({
+    expect(resolvePackParameterValues(withParameters, { unknown: true })).toMatchObject({
       ok: false,
       error: { code: 'pack-parameter-invalid' },
     });
@@ -148,7 +148,7 @@ describe('parameterized Pack authoring', () => {
   });
 
   it('parses direct and instance JSON without accepting GUID fields', () => {
-    const direct = parseParameterizedPackJson({
+    const direct = parsePackSourceJson({
       schemaVersion: '3.0.0',
       packageId: '01900000-0000-7000-8000-000000000010',
       assets: {
@@ -167,14 +167,14 @@ describe('parameterized Pack authoring', () => {
       });
     }
     expect(
-      parseParameterizedPackJson({
+      parsePackSourceJson({
         schemaVersion: '3.0.0',
         packageId: '01900000-0000-7000-8000-000000000010',
         assets: { 'scene/main': { guid: NAMESPACE, kind: 'scene', payload: {}, refs: [] } },
       }),
     ).toMatchObject({ ok: false, error: { code: 'pack-parameter-invalid' } });
     expect(
-      parseParameterizedPackJson({
+      parsePackSourceJson({
         schemaVersion: '3.0.0',
         packageId: '01900000-0000-7000-8000-000000000020',
         parent: '01900000-0000-7000-8000-000000000002',

package/src/__tests__/{parameterized-pack-scanner.unit.test.ts → pack-scanner.unit.test.ts}

@@ -16,9 +16,9 @@ afterEach(async () => {
   if (root !== undefined) await rm(root, { recursive: true, force: true });
 });
 
-describe('parameterized Pack scanner', () => {
+describe('ScriptablePack and Pack source scanner', () => {
   it('indexes direct v3 output keys as derived GUIDs without requiring entry GUIDs', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'forgeax-parameterized-scan-'));
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-scan-'));
     roots.push(root);
     const path = join(root, 'direct.pack.json');
     await writeFile(
@@ -65,8 +65,8 @@ describe('parameterized Pack scanner', () => {
     expect(stderr).toEqual([]);
   });
 
-  it('captures a parameterized source as metadata and resolves an instance parent', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'forgeax-parameterized-source-scan-'));
+  it('captures a ScriptablePack source as metadata and resolves an instance parent', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-source-scan-'));
     roots.push(root);
     await writeFile(
       join(root, 'source.pack.ts'),
@@ -96,12 +96,12 @@ describe('parameterized Pack scanner', () => {
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const declaration = result.value.declarations.get(join(root, 'source.pack.ts'));
-    expect(declaration?.format).toBe('pack.ts-parameterized');
+    expect(declaration?.format).toBe('pack.ts');
     expect(result.value.inventory).toEqual([]);
   });
 
   it('fails closed when an instance parent is missing', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'forgeax-parameterized-parent-scan-'));
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-scriptable-pack-parent-scan-'));
     roots.push(root);
     await writeFile(
       join(root, 'missing.pack.json'),

package/src/__tests__/scanner-inventory.contract.test.ts

@@ -117,16 +117,14 @@ describe('engine-pack scanner inventory contract', () => {
     });
     const scriptableDeclaration = result.value.declarations.get(scriptablePath);
     expect(scriptableDeclaration).toMatchObject({
-      format: 'pack.ts-parameterized',
+      format: 'pack.ts',
       sourcePath: scriptablePath,
       value: {
         packageId: '019e3969-1d48-7c3b-ac24-6d68f4570662',
       },
     });
     expect(
-      scriptableDeclaration?.format === 'pack.ts-parameterized'
-        ? scriptableDeclaration.value
-        : undefined,
+      scriptableDeclaration?.format === 'pack.ts' ? scriptableDeclaration.value : undefined,
     ).not.toHaveProperty('subAssets');
   });
 

package/src/__tests__/scanner-inventory.test.ts

@@ -44,11 +44,11 @@ describe('AssetInventory', () => {
     const { inventory, sourcePath } = getFixture();
     const declaration = inventory.declarations.get(sourcePath);
     expect(declaration).toMatchObject({
-      format: 'pack.ts-parameterized',
+      format: 'pack.ts',
       sourcePath,
       value: {
         schemaVersion: '2.0.0',
-        kind: 'parameterized-pack-source',
+        kind: 'scriptable-pack-source',
         packageId: '00000000-0000-0000-0000-000000000001',
         source: sourcePath,
       },
@@ -59,7 +59,7 @@ describe('AssetInventory', () => {
     const { inventory, sourcePath } = getFixture();
     const declaration = inventory.declarations.get(sourcePath);
     expect(
-      declaration?.format === 'pack.ts-parameterized'
+      declaration?.format === 'pack.ts'
         ? declaration.sourceClosure.map((entry) => entry.path)
         : undefined,
     ).toEqual([await realpath(sourcePath)]);
@@ -69,9 +69,10 @@ describe('AssetInventory', () => {
     const { inventory, sourcePath } = getFixture();
     const declaration = inventory.declarations.get(sourcePath);
     expect(inventory.inventory).toEqual([]);
-    expect(
-      declaration?.format === 'pack.ts-parameterized' ? declaration.definition : undefined,
-    ).toMatchObject({ packageId: expect.any(Uint8Array), schemaVersion: '2.0.0' });
+    expect(declaration?.format === 'pack.ts' ? declaration.definition : undefined).toMatchObject({
+      packageId: expect.any(Uint8Array),
+      schemaVersion: '2.0.0',
+    });
   });
 
   it('keeps semantic identity stable when the source path is renamed', () => {

package/src/__tests__/scriptable-pack-cli.integration.test.ts

@@ -31,7 +31,7 @@ describe('ScriptablePack CLI Meta inspection', () => {
       expect(code).toBe(0);
       expect(stderr).toEqual([]);
       expect(JSON.parse(stdout[0] ?? '{}')).toMatchObject({
-        kind: 'parameterized-pack-source',
+        kind: 'scriptable-pack-source',
         source,
         packageId: '019ffa97-8b39-7ad2-84cc-273268591ab4',
       });

package/src/build.ts

@@ -94,6 +94,13 @@ export {
   type MeshBinHeaderV4,
   writeMeshBinHeader,
 } from './mesh-bin-contract.js';
+export * from './pack-authoring.js';
+export {
+  createFileSystemPackAuthoringGateway,
+  createFileSystemPackAuthoringPort,
+  type FileSystemPackAuthoringOptions,
+  type PackAuthoringMaterializedAsset,
+} from './pack-authoring-node.js';
 export {
   type FinalizedPackageProduct,
   finalizePackageProduct,
@@ -106,13 +113,6 @@ export {
   type PackageProductAsset,
   packageTransportRevision,
 } from './package-finalizer.js';
-export * from './parameterized-pack.js';
-export {
-  createFileSystemParameterizedPackAuthoringGateway,
-  createFileSystemParameterizedPackAuthoringPort,
-  type FileSystemParameterizedPackAuthoringOptions,
-  type ParameterizedPackMaterializedAsset,
-} from './parameterized-pack-node.js';
 export { validateProducerContract, validateProducerOutputs } from './producer-contract.js';
 export { resolveAssetSource } from './resolve-asset-source.js';
 export { parsePackV2, validateMeta, validatePack, validatePackV2 } from './runtime.js';
@@ -129,7 +129,7 @@ export {
   type LegacyPackInventoryDocument,
   type PackInventoryAsset,
   type PackInventoryDocument,
-  type ParameterizedPackInventoryDocument,
+  type PackSourceInventoryDocument,
   type ScanInventory,
   type ScanOptions,
   type ScanSourceDeclaration,

package/src/catalog-builder.ts

@@ -6,7 +6,7 @@ import {
   projectPackageCatalog,
 } from './catalog-projection.js';
 import { deriveAssetName } from './deriveAssetName.js';
-import { parseParameterizedPackJson, projectDirectPackJson } from './parameterized-pack.js';
+import { parsePackSourceJson, projectDirectPackJson } from './pack-authoring.js';
 import { resolveAssetSource } from './resolve-asset-source.js';
 import {
   type MetaInventoryDocument,
@@ -201,7 +201,7 @@ function projectSource(
   declarations: Map<string, CatalogImportMeta>,
   sourceIdentityFor: CatalogBuildProjectionOptions['sourceIdentityFor'],
 ): { readonly entries: PackIndexEntry[]; readonly error?: CatalogBuildError } {
-  if (sourceDeclaration.format === 'pack.ts-parameterized') {
+  if (sourceDeclaration.format === 'pack.ts') {
     // A source declaration is an authoring identity and parameter contract,
     // not a materialized output set. Dynamic build owns publication after its
     // fixed-point worklist converges; Catalog scanning must not invent rows.
@@ -233,7 +233,7 @@ function projectSource(
   const parsed = sourceDeclaration.value;
   const sourcePath = catalogSourcePathFor(cwd, path, sourceIdentityFor);
   if (parsed.schemaVersion === '3.0.0') {
-    const authoring = parseParameterizedPackJson(parsed);
+    const authoring = parsePackSourceJson(parsed);
     if (!authoring.ok) {
       return {
         entries: [],

package/src/cli-asset.ts

@@ -26,9 +26,9 @@ import {
 import { readSourceInventory } from './evidence/source-inventory.js';
 import { isValidAssetGuidString } from './guid.js';
 import { parsePackV2 } from './index.js';
-import { projectParameterizedPackMeta } from './parameterized-pack.js';
+import { projectScriptablePackMeta } from './pack-authoring.js';
 import { type ScanSourceDeclaration, scanInventory } from './scanner.js';
-import { loadParameterizedScriptablePack } from './scriptable-pack-node.js';
+import { loadScriptablePack } from './scriptable-pack-node.js';
 
 export interface PackEntry {
   readonly guid: string;
@@ -81,7 +81,7 @@ export async function scanEntries(
     return { ok: false };
   }
   const entries: PackEntry[] = [];
-  // The scanner is the single identity projection for Pack JSON. Parameterized
+  // The scanner is the single identity projection for Pack JSON. ScriptablePack
   // source modules deliberately contribute no rows until a build generation.
   for (const declaration of result.value.declarations.values()) {
     if (declaration.format !== 'meta.json') continue;
@@ -233,11 +233,11 @@ async function runMeta(rest: string[], ctx: AssetCtx): Promise<number> {
     });
   }
   const cwd = ctx.cwd ?? process.cwd();
-  const loaded = await loadParameterizedScriptablePack(absolutePath(source, cwd), {
+  const loaded = await loadScriptablePack(absolutePath(source, cwd), {
     metadataOnly: true,
   });
   if (!loaded.ok) return emitError(ctx, loaded.error);
-  ctx.stdoutWrite(JSON.stringify(projectParameterizedPackMeta(loaded.value, source)));
+  ctx.stdoutWrite(JSON.stringify(projectScriptablePackMeta(loaded.value, source)));
   return 0;
 }
 

package/src/evidence/material-cook.ts

@@ -7,7 +7,7 @@ import type {
   MaterialValue,
   Result,
 } from '@forgeax/engine-types';
-import { err, MATERIAL_TEXTURE_SLOTS, ok } from '@forgeax/engine-types';
+import { deriveStandardLayerPlan, err, MATERIAL_TEXTURE_SLOTS, ok } from '@forgeax/engine-types';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { bytesToHex } from '@noble/hashes/utils.js';
 
@@ -56,7 +56,11 @@ export interface MaterialCookReceipt {
   readonly profile: string;
   readonly compilerVersion: string;
   readonly identity: MaterialCookIdentity;
-  readonly derivedInterface: { readonly layoutIdentity: string };
+  readonly derivedInterface: {
+    readonly layoutIdentity: string;
+    /** Build-time Standard physical lowering identity, when the root is Standard. */
+    readonly layerPlanIdentity?: string;
+  };
 }
 
 export interface MaterialParameterContract {
@@ -101,6 +105,36 @@ export interface MaterialCookIdentityExpectation {
   readonly inputDigest?: string;
 }
 
+const STANDARD_ROOT_MODULES = new Set([
+  'forgeax::default-standard-pbr',
+  'forgeax::pbr-skin',
+  'forgeax_material::standard',
+  'forgeax_material::pbr-skin',
+]);
+
+/** Shared ownership predicate for the built-in Standard material root. */
+export function isStandardRootModule(module: string): boolean {
+  return STANDARD_ROOT_MODULES.has(module);
+}
+
+export function isStandardMaterialRecord(record: Pick<CookedMaterialRecord, 'resolved'>): boolean {
+  return record.resolved.passes.some((pass) => isStandardRootModule(pass.program.module));
+}
+
+/**
+ * Recompute the Standard layer identity from the admitted resolved root.
+ * Material admission and runtime loading share this owner so a stale receipt
+ * cannot select a different physical layer plan after cooking.
+ */
+export function materialLayerPlanIdentity(
+  record: Pick<CookedMaterialRecord, 'resolved'>,
+): string | undefined {
+  if (!isStandardMaterialRecord(record)) {
+    return undefined;
+  }
+  return deriveStandardLayerPlan(record.resolved.parameters, record.resolved.passes).identity;
+}
+
 function unique(values: readonly string[]): readonly string[] {
   return [...new Set(values)].sort();
 }
@@ -286,6 +320,16 @@ export function validateMaterialCookReceipt(
   if (derivedInterface.layoutIdentity !== identity.layoutIdentity) {
     return invalid('receipt.derivedInterface.layoutIdentity', derivedInterface.layoutIdentity);
   }
+  if (
+    derivedInterface.layerPlanIdentity !== undefined &&
+    (typeof derivedInterface.layerPlanIdentity !== 'string' ||
+      derivedInterface.layerPlanIdentity.length === 0)
+  ) {
+    return invalid(
+      'receipt.derivedInterface.layerPlanIdentity',
+      derivedInterface.layerPlanIdentity,
+    );
+  }
   for (const field of ['sourceClosure', 'profile', 'compilerVersion']) {
     const fieldValue = candidate[field];
     if (
@@ -320,7 +364,12 @@ export function validateMaterialCookReceipt(
     profile: candidate.profile as string,
     compilerVersion: candidate.compilerVersion as string,
     identity,
-    derivedInterface: { layoutIdentity: derivedInterface.layoutIdentity as string },
+    derivedInterface: {
+      layoutIdentity: derivedInterface.layoutIdentity as string,
+      ...(derivedInterface.layerPlanIdentity === undefined
+        ? {}
+        : { layerPlanIdentity: derivedInterface.layerPlanIdentity as string }),
+    },
   });
 }
 
@@ -380,6 +429,33 @@ export function validateCookedMaterialRecord(
     artifactDigest: artifact.digest as string,
   });
   if (!receiptResult.ok) return receiptResult;
+  const resolved = candidate.resolved as Record<string, unknown>;
+  if (!Array.isArray(resolved.passes)) return invalid('resolved.passes', resolved.passes);
+  if (!Array.isArray(resolved.parameters))
+    return invalid('resolved.parameters', resolved.parameters);
+  if (
+    resolved.values === null ||
+    typeof resolved.values !== 'object' ||
+    Array.isArray(resolved.values)
+  )
+    return invalid('resolved.values', resolved.values);
+  let expectedLayerPlanIdentity: string | undefined;
+  try {
+    expectedLayerPlanIdentity = materialLayerPlanIdentity({
+      resolved: resolved as unknown as CookedMaterialRecord['resolved'],
+    });
+  } catch (error) {
+    return invalid('resolved.layerPlanIdentity', error instanceof Error ? error.message : error);
+  }
+  if (
+    expectedLayerPlanIdentity !== undefined &&
+    receiptResult.value.derivedInterface.layerPlanIdentity !== expectedLayerPlanIdentity
+  ) {
+    return invalid(
+      'receipt.derivedInterface.layerPlanIdentity',
+      receiptResult.value.derivedInterface.layerPlanIdentity,
+    );
+  }
   if (candidate.artifactDigest !== undefined && candidate.artifactDigest !== artifact.digest)
     return invalid('artifactDigest', candidate.artifactDigest);
   if (

package/src/evidence/source-inventory.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { readdir, readFile } from 'node:fs/promises';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import type { SourceDeclarationEvidence } from '@forgeax/engine-types';
-import { parseParameterizedPackJson, projectDirectPackJson } from '../parameterized-pack.js';
+import { parsePackSourceJson, projectDirectPackJson } from '../pack-authoring.js';
 import { SCANNER_BLACKLIST, scan } from '../scanner.js';
 
 /** Project root and GUID used to locate an authoritative source declaration. */
@@ -149,7 +149,7 @@ export async function readSourceInventory(
   let authored: SourceDeclarationEvidence | undefined;
   for (const path of paths) {
     if (path.endsWith('.pack.ts')) {
-      // Parameterized source identity is a build result, not a declaration
+      // ScriptablePack source identity is a build result, not a declaration
       // table. The source index therefore records the source only after the
       // producer publishes its materialized Pack output.
       continue;
@@ -166,7 +166,7 @@ export async function readSourceInventory(
     }
     if (path.endsWith('.pack.json')) {
       if (parsed.schemaVersion === '3.0.0') {
-        const direct = parseParameterizedPackJson(parsed);
+        const direct = parsePackSourceJson(parsed);
         if (direct.ok && direct.value.format === 'direct') {
           const projected = projectDirectPackJson(direct.value);
           if (

package/src/index.ts

@@ -7,6 +7,8 @@ export {
   collectMaterialCookRefs,
   createMaterialArtifactDigest,
   createMaterialCookIdentity,
+  isStandardMaterialRecord,
+  isStandardRootModule,
   type MaterialCookArtifact,
   type MaterialCookIdentity,
   type MaterialCookIdentityExpectation,
@@ -15,6 +17,7 @@ export {
   type MaterialCookRecordError,
   type MaterialCookRefs,
   type MaterialCookWasmProvenance,
+  materialLayerPlanIdentity,
   projectCookedMaterialRecord,
   serializeCookedMaterialRecord,
   serializeMaterialCookReceipt,
@@ -40,7 +43,7 @@ export {
   type MeshBinHeaderV4,
   writeMeshBinHeader,
 } from './mesh-bin-contract.js';
-export * from './parameterized-pack.js';
+export * from './pack-authoring.js';
 export { validateProducerContract, validateProducerOutputs } from './producer-contract.js';
 export {
   type AssetReader,

package/src/material-cook.ts

@@ -8,6 +8,7 @@ export {
   type MaterialCookRecordError,
   type MaterialCookRefs,
   type MaterialCookWasmProvenance,
+  materialLayerPlanIdentity,
   projectCookedMaterialRecord,
   serializeCookedMaterialRecord,
   serializeMaterialCookReceipt,