@forgeax/engine-pack 0.1.23 → 0.1.25

package/src/__tests__/material-declaration-boundary.unit.test.ts

@@ -0,0 +1,35 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../');
+const CONFIG_PATH = resolve(REPO_ROOT, 'packages/pack/tsconfig.json');
+
+async function declarationProjectInputs(): Promise<readonly string[]> {
+  const source = await readFile(CONFIG_PATH, 'utf8');
+  const parsed = ts.parseJsonConfigFileContent(
+    JSON.parse(source),
+    ts.sys,
+    dirname(CONFIG_PATH),
+    undefined,
+    CONFIG_PATH,
+  );
+  return parsed.fileNames.map((fileName) => relative(REPO_ROOT, fileName));
+}
+
+describe('Pack declaration project boundary', () => {
+  it('keeps tests and emitted declarations out of production inputs', async () => {
+    const inputs = await declarationProjectInputs();
+    const config = JSON.parse(await readFile(CONFIG_PATH, 'utf8')) as {
+      readonly exclude?: readonly string[];
+    };
+
+    expect(config.exclude).toEqual(expect.arrayContaining(['src/**/__tests__/**', 'dist/**']));
+    expect(inputs.some((fileName) => fileName.startsWith('packages/pack/src/__tests__/'))).toBe(
+      false,
+    );
+    expect(inputs.some((fileName) => fileName.startsWith('packages/pack/dist/'))).toBe(false);
+  });
+});

package/src/__tests__/material-surface-consumer-census.test.ts

@@ -0,0 +1,24 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const packageRoots = ['packages/pack/src', 'packages/vite-plugin-pack/src', 'packages/render/src'];
+
+describe('Surface consumer census', () => {
+  it('keeps the runtime and Pack consumers on the existing MaterialAsset wire', async () => {
+    const sources = await Promise.all(
+      packageRoots.map(async (root) => {
+        const path = resolve(process.cwd(), root, 'index.ts');
+        try {
+          return await readFile(path, 'utf8');
+        } catch {
+          return '';
+        }
+      }),
+    );
+    const source = sources.join('\n');
+    expect(source).not.toContain('SurfaceAsset');
+    expect(source).not.toContain('surfaceModule');
+    expect(source).not.toContain('shadingModel');
+  });
+});

package/src/__tests__/material-surface-publication.unit.test.ts

@@ -0,0 +1,159 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Materials } from '@forgeax/engine-render';
+import { describe, expect, it } from 'vitest';
+import { NativeCookerRegistry } from '../native-cooker-registry.js';
+
+const compilerModule = pathToFileURL(
+  resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    '../../../../packages/shader-compiler/dist/index.mjs',
+  ),
+).href;
+
+const GUID = '11111111-1111-4111-8111-111111111111';
+const ROOT_GUID = '22222222-2222-4222-8222-222222222222';
+const CHILD_GUID = '33333333-3333-4333-8333-333333333333';
+const SURFACE = `#define_import_path game_3d::rusted_iron_surface
+#import forgeax_material::surface_v1::{SurfaceData, SurfaceInput}
+fn evaluate_surface(input: SurfaceInput) -> SurfaceData {
+  return SurfaceData(vec3<f32>(0.4, 0.45, 0.47), input.geometricNormalWS, 0.0, 0.5, vec3<f32>(0.0), 1.0, 1.0, 0.0);
+}`;
+
+describe('Surface Pack publication', () => {
+  it('publishes one complete cooked record with source closure and artifact', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-surface-publication-'));
+    try {
+      const sourcePath = join(root, 'rusted-iron-surface.wgsl');
+      await writeFile(sourcePath, SURFACE);
+      const material = Materials.standard({
+        surfaceModule: 'game_3d::rusted_iron_surface',
+        parameters: [],
+        values: {},
+      });
+      const { createMaterialPackCooker } = await import(compilerModule);
+      const draft = await createMaterialPackCooker([root]).cook({
+        guid: GUID,
+        source: material,
+        sourcePath,
+      });
+      const cooked = draft.payload.cooked as {
+        readonly receipt: { readonly sourceClosure: readonly string[] };
+        readonly artifact: { readonly path: string; readonly bytes: Uint8Array };
+      };
+      expect(cooked.receipt.sourceClosure).toContain(sourcePath);
+      expect(cooked.artifact.path).toContain(GUID);
+      const artifact = draft.artifacts[cooked.artifact.path];
+      expect(artifact?.bytes.byteLength).toBeGreaterThan(0);
+      expect(Object.keys(draft.artifacts)).toContain(cooked.artifact.path);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps the accepted generation as last known good after cook failure', async () => {
+    const registry = new NativeCookerRegistry();
+    registry.register({
+      key: 'material',
+      cook: async (input: { readonly fail?: boolean }) => {
+        if (input.fail) throw new Error('surface compose failed');
+        return {
+          guid: GUID,
+          payload: { generation: 1 },
+          refs: [],
+          artifacts: {},
+          inputFingerprint: 'sha256:surface-input',
+        };
+      },
+    });
+    const first = await registry.runTransaction({ key: 'material', input: {} });
+    expect(first).toMatchObject({ ok: true, value: { generation: 1, status: 'committed' } });
+    if (!first.ok) return;
+    const failed = await registry.runTransaction({
+      key: 'material',
+      input: { fail: true },
+      previous: { draft: first.value.draft, generation: first.value.generation },
+    });
+    expect(failed).toMatchObject({
+      ok: true,
+      value: {
+        status: 'recovered',
+        lastKnownGood: { payload: { generation: 1 } },
+        lastKnownGoodGeneration: 1,
+      },
+    });
+  });
+
+  it('cold-cooks a child through the Pack-owned root table and publishes its parent ref', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'forgeax-surface-root-child-'));
+    try {
+      const rootMaterial = Materials.standard({
+        baseColor: [1, 1, 1, 1],
+        metallic: 0,
+        roughness: 0.5,
+      });
+      const child = {
+        kind: 'material' as const,
+        parent: ROOT_GUID as never,
+        values: { baseColor: [0.4, 0.45, 0.47, 1] },
+      };
+      const { createMaterialPackCooker } = await import(compilerModule);
+      const draft = await createMaterialPackCooker([root]).cook({
+        guid: CHILD_GUID,
+        source: child,
+        table: { [ROOT_GUID]: rootMaterial, [CHILD_GUID]: child },
+      });
+      const cooked = draft.payload.cooked as {
+        readonly authored: { readonly parent?: string };
+        readonly resolved: {
+          readonly parameters: readonly { readonly name: string }[];
+          readonly values: Readonly<Record<string, unknown>>;
+        };
+        readonly refs: { readonly parent: readonly string[] };
+      };
+      expect(cooked.authored.parent).toBe(ROOT_GUID);
+      expect(cooked.refs.parent).toEqual([ROOT_GUID]);
+      expect(cooked.resolved.parameters.map((parameter) => parameter.name)).toContain('baseColor');
+      expect(cooked.resolved.values.baseColor).toEqual([0.4, 0.45, 0.47, 1]);
+      expect(draft.refs).toContain(ROOT_GUID);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('does not publish an artifact when a physical material requests Deferred', async () => {
+    const { createMaterialPackCooker } = await import(compilerModule);
+    const material = {
+      kind: 'material' as const,
+      passes: [
+        {
+          name: 'forward',
+          program: {
+            module: 'forgeax_material::standard',
+            moduleSlots: { surface: 'forgeax_material::default_standard_surface' },
+          },
+        },
+        {
+          name: 'deferred',
+          program: {
+            module: 'forgeax_material::standard',
+            moduleSlots: { surface: 'forgeax_material::default_standard_surface' },
+          },
+        },
+      ],
+      parameters: [
+        { name: 'clearcoat', type: 'f32' as const },
+        { name: 'clearcoatRoughness', type: 'f32' as const },
+      ],
+      values: { clearcoat: 0, clearcoatRoughness: 0.5 },
+    };
+    await expect(
+      createMaterialPackCooker().cook({
+        guid: GUID,
+        source: material,
+      }),
+    ).rejects.toThrow('material-physical-contract-invalid');
+  });
+});

package/src/__tests__/material-surface-wire.unit.test.ts

@@ -0,0 +1,30 @@
+import { Materials } from '@forgeax/engine-render';
+import { assertMaterialAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+
+const customOptions = {
+  surfaceModule: 'game_3d::rusted_iron_surface',
+  parameters: [{ name: 'ironColor', type: 'color' as const }],
+  values: { ironColor: [0.4, 0.45, 0.47, 1] },
+};
+
+describe('custom Surface MaterialAsset wire projection', () => {
+  it('uses Standard module and the existing Surface slot wire', () => {
+    const material = Materials.standard(customOptions as never);
+    expect(material.passes?.map((pass) => pass.program.module)).toEqual([
+      'forgeax_material::standard',
+      'forgeax_material::standard',
+      'forgeax_material::standard',
+    ]);
+    expect(
+      material.passes?.every(
+        (pass) => pass.program.moduleSlots?.surface === customOptions.surfaceModule,
+      ),
+    ).toBe(true);
+    const wire = JSON.parse(JSON.stringify(material)) as Record<string, unknown>;
+    assertMaterialAsset(wire);
+    expect(wire).not.toHaveProperty('surfaceModule');
+    expect(wire).not.toHaveProperty('shadingModel');
+    expect(wire).not.toHaveProperty('surface');
+  });
+});

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

@@ -60,6 +60,8 @@ export {
   type MaterialCookReceipt,
   type MaterialCookRecordError,
   type MaterialCookRefs,
+  type MaterialCookVariant,
+  type MaterialCookVariantContext,
   projectCookedMaterialRecord,
   serializeCookedMaterialRecord,
   serializeMaterialCookReceipt,
@@ -94,6 +96,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 +115,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 +131,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;
 }