@forgeax/engine-import 0.1.23 → 0.1.25

package/src/{parameterized-scriptable-pack.ts → scriptable-pack-build.ts}

@@ -1,6 +1,7 @@
 import { BUILTIN_MESH_ASSETS } from '@forgeax/engine-pack/builtin';
+import { type NativeCooker, NativeCookerRegistry } from '@forgeax/engine-pack/native-cooker';
 import {
-  type AnyParameterizedPackDefinition,
+  type AnyScriptablePackDefinition,
   AssetGuid,
   isScriptablePackAssetKind,
   isValidPackSourceKey,
@@ -12,6 +13,7 @@ import {
   type PackParameterValue,
   resolvePackParameterValues,
 } from '@forgeax/engine-pack/source';
+import { DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
 import type {
   Asset,
   AssetGuid as AssetGuidType,
@@ -28,16 +30,16 @@ import {
 import type {
   AssetOutputProducer,
   AssetOutputProducerRegistry,
+  PackBuildProduct,
   ScriptablePackAssetSnapshotSource,
-  ScriptablePackBuildProduct,
   ScriptablePackDomainError,
   ScriptablePackExternalEvidence,
   ScriptablePackSourceClosureEntry,
   ScriptablePackStagedOutput,
 } from './scriptable-pack.js';
 
-export interface ParameterizedScriptablePackBuildOptions {
-  readonly definition: AnyParameterizedPackDefinition;
+export interface ScriptablePackBuildOptions {
+  readonly definition: AnyScriptablePackDefinition;
   readonly sourcePath: string;
   /** Instance identity. Omitted for a root source and defaults to definition.packageId. */
   readonly subjectPackageId?: PackageId;
@@ -47,6 +49,8 @@ export interface ParameterizedScriptablePackBuildOptions {
   readonly inheritedValues?: Readonly<Record<string, PackParameterValue>>;
   readonly assetSource?: ScriptablePackAssetSnapshotSource;
   readonly outputs: AssetOutputProducerRegistry;
+  /** Optional build-time cookers for authored producer outputs that need artifacts. */
+  readonly cookers?: readonly NativeCooker[];
   readonly sourceClosure?: readonly ScriptablePackSourceClosureEntry[];
   readonly authoringContractVersion?: string;
   /** Known published GUIDs used for the optional global reference gate. */
@@ -56,12 +60,12 @@ export interface ParameterizedScriptablePackBuildOptions {
   readonly publication?: AssetPublicationEnvelope;
 }
 
-export interface ParameterizedScriptablePackBuildProduct extends ScriptablePackBuildProduct {
+export interface ScriptablePackBuildProduct extends PackBuildProduct {
   readonly publication?: AssetPublicationEnvelope;
 }
 
-export type ParameterizedScriptablePackBuildResult = Result<
-  ParameterizedScriptablePackBuildProduct,
+export type ScriptablePackBuildResult = Result<
+  ScriptablePackBuildProduct,
   | PackAuthoringError
   | ScriptablePackDomainError
   | AssetError
@@ -89,6 +93,23 @@ function isAsset(value: unknown): value is Asset {
   return record(value) && typeof value.kind === 'string' && isScriptablePackAssetKind(value.kind);
 }
 
+function needsMaterialCook(asset: Asset): asset is Extract<Asset, { readonly kind: 'material' }> {
+  if (asset.kind !== 'material' || !Array.isArray(asset.passes)) return false;
+  return asset.passes.some((pass) => {
+    const module = pass.program.module;
+    const surface = pass.program.moduleSlots?.surface;
+    return (
+      surface !== undefined &&
+      surface !== DEFAULT_STANDARD_SURFACE_MODULE &&
+      (module === 'forgeax_material::standard' ||
+        module === 'forgeax::default-standard-pbr' ||
+        module === 'forgeax_material::pbr-skin' ||
+        module === 'forgeax::pbr-skin' ||
+        module === 'forgeax::default-standard-pbr-skin')
+    );
+  });
+}
+
 function clone<T>(value: T): T {
   return structuredClone(value);
 }
@@ -289,9 +310,9 @@ function normalizedGuidSet(value: ReadonlySet<string> | undefined): Set<string>
  * Execute a v2 Pack source and project its dynamic output map through the
  * existing importer producers. No output GUID or output manifest is read.
  */
-export async function buildParameterizedScriptablePack(
-  options: ParameterizedScriptablePackBuildOptions,
-): Promise<ParameterizedScriptablePackBuildResult> {
+export async function buildScriptablePack(
+  options: ScriptablePackBuildOptions,
+): Promise<ScriptablePackBuildResult> {
   const subjectPackageId = options.subjectPackageId ?? options.definition.packageId;
   const availableGuids = normalizedGuidSet(options.availableGuids);
   const observed = observedReader(options.assetSource);
@@ -319,8 +340,8 @@ export async function buildParameterizedScriptablePack(
       PackageId.format(options.definition.packageId).toLowerCase()
   ) {
     return err({
-      code: 'pack-parent-not-parameterized',
-      expected: 'a parameterized Pack source for an independent instance packageId',
+      code: 'pack-parent-has-no-parameters',
+      expected: 'a ScriptablePack source with parameters for an independent instance packageId',
       hint: 'use clone for a zero-parameter Pack instead of building it as an instance',
       detail: {
         sourcePath: options.sourcePath,
@@ -384,6 +405,9 @@ export async function buildParameterizedScriptablePack(
   const imported: ImportedAsset<unknown>[] = [];
   const stagedOutputs: ScriptablePackStagedOutput[] = [];
   const localGuids = new Set<string>();
+  const materialCookerRegistry = new NativeCookerRegistry();
+  for (const cooker of options.cookers ?? []) materialCookerRegistry.register(cooker);
+  const nativeFingerprints = new Map<string, string>();
   for (const sourceKey of Object.keys(built.value).sort()) {
     if (!isValidPackSourceKey(sourceKey))
       return err(sourceKeyFailure(options.sourcePath, sourceKey));
@@ -459,12 +483,40 @@ export async function buildParameterizedScriptablePack(
     const invalidProduct = productError(options.sourcePath, sourceKey, producer, produced.value);
     if (invalidProduct !== undefined) return err(invalidProduct);
     const product = produced.value as ImportAssetProduct<unknown>;
+    let payload = product.payload;
+    let artifacts = product.artifacts;
+    if (needsMaterialCook(asset) && materialCookerRegistry.get('material') !== undefined) {
+      const cooked = await materialCookerRegistry.runDraft('material', {
+        guid,
+        source: asset,
+        sourceKey,
+        sourcePath: options.sourcePath,
+        refs: product.refs.map((reference) => reference.guid),
+      });
+      if (!cooked.ok) return err(cooked.error);
+      if (cooked.value.guid.toLowerCase() !== normalizedGuid) {
+        return err({
+          code: 'pack-source-output-invalid',
+          expected: 'the authored material cooker to preserve the derived AssetGuid',
+          hint: 'repair the native material cooker output GUID and rebuild the Pack',
+          detail: {
+            sourcePath: options.sourcePath,
+            sourceKey,
+            expectedGuid: guid,
+            actualGuid: cooked.value.guid,
+          },
+        });
+      }
+      payload = cooked.value.payload;
+      artifacts = cooked.value.artifacts;
+      nativeFingerprints.set(sourceKey, cooked.value.inputFingerprint);
+    }
     imported.push({
       guid,
       kind: asset.kind,
-      payload: product.payload,
+      payload,
       refs: product.refs,
-      artifacts: product.artifacts,
+      artifacts,
     });
     stagedOutputs.push({
       guid: AssetGuid.derive(subjectPackageId, sourceKey),
@@ -499,7 +551,7 @@ export async function buildParameterizedScriptablePack(
         digest: read.digest,
       }),
     );
-  const inputFingerprint = await digest({
+  const authoredInputFingerprint = await digest({
     packageId: PackageId.format(subjectPackageId),
     sourcePath: options.sourcePath,
     sourceClosure: options.sourceClosure ?? [],
@@ -509,9 +561,18 @@ export async function buildParameterizedScriptablePack(
       usage,
       digest: evidenceDigest,
     })),
-    authoringContractVersion: options.authoringContractVersion ?? 'parameterized-pack/1',
+    authoringContractVersion: options.authoringContractVersion ?? 'scriptable-pack/1',
     producerVersions: options.outputs.versions(),
   });
+  const inputFingerprint =
+    nativeFingerprints.size === 0
+      ? authoredInputFingerprint
+      : await digest({
+          sourceRevision: authoredInputFingerprint,
+          nativeCookers: [...nativeFingerprints.entries()].sort(([left], [right]) =>
+            left.localeCompare(right),
+          ),
+        });
   const refs = imported.flatMap((asset) => asset.refs);
   const artifacts = Object.fromEntries(
     imported.flatMap((asset) =>
@@ -543,8 +604,8 @@ export async function buildParameterizedScriptablePack(
   });
 }
 
-export interface ParameterizedScriptablePackWorkItem {
-  readonly definition: AnyParameterizedPackDefinition;
+export interface ScriptablePackBuildWorkItem {
+  readonly definition: AnyScriptablePackDefinition;
   readonly sourcePath: string;
   readonly subjectPackageId?: PackageId;
   readonly values?: Readonly<Record<string, unknown>>;
@@ -552,18 +613,20 @@ export interface ParameterizedScriptablePackWorkItem {
   readonly sourceClosure?: readonly ScriptablePackSourceClosureEntry[];
 }
 
-export interface ParameterizedScriptablePackWorklistOptions {
-  readonly subjects: readonly ParameterizedScriptablePackWorkItem[];
+export interface ScriptablePackBuildWorklistOptions {
+  readonly subjects: readonly ScriptablePackBuildWorkItem[];
   readonly outputs: AssetOutputProducerRegistry;
+  /** Optional build-time cookers forwarded to each authored Pack subject. */
+  readonly cookers?: readonly NativeCooker[];
   readonly assetSource?: ScriptablePackAssetSnapshotSource;
   readonly availableGuids?: ReadonlySet<string>;
   readonly incomingRefs?: ReadonlyMap<string, readonly string[]>;
   readonly maxPasses?: number;
 }
 
-export interface ParameterizedScriptablePackWorklistProduct {
+export interface ScriptablePackBuildWorklistProduct {
   readonly products: readonly TerminalImportProduct<unknown>[];
-  readonly buildProducts: readonly ParameterizedScriptablePackBuildProduct[];
+  readonly buildProducts: readonly ScriptablePackBuildProduct[];
   readonly stagedOutputs: readonly ScriptablePackStagedOutput[];
   readonly iterations: number;
 }
@@ -597,11 +660,11 @@ function stagedSource(
 }
 
 /** Build subjects in stable passes; content reads may wait for a later subject. */
-export async function buildParameterizedScriptablePackWorklist(
-  options: ParameterizedScriptablePackWorklistOptions,
+export async function buildScriptablePackWorklist(
+  options: ScriptablePackBuildWorklistOptions,
 ): Promise<
   Result<
-    ParameterizedScriptablePackWorklistProduct,
+    ScriptablePackBuildWorklistProduct,
     | PackAuthoringError
     | ScriptablePackDomainError
     | AssetError
@@ -621,7 +684,7 @@ export async function buildParameterizedScriptablePackWorklist(
     orderedSubjects.map((subject, index) => [`${index}:${subject.sourcePath}`, subject]),
   );
   const staged = new Map<string, ScriptablePackStagedOutput>();
-  const results = new Map<string, ParameterizedScriptablePackBuildProduct>();
+  const results = new Map<string, ScriptablePackBuildProduct>();
   const availableGuids = new Set([
     ...(normalizedGuidSet(options.availableGuids) ?? []),
     ...BUILTIN_MESH_ASSETS.map((asset) => asset.guid.toLowerCase()),
@@ -632,7 +695,7 @@ export async function buildParameterizedScriptablePackWorklist(
     let progress = false;
     const waiting = new Set<string>();
     for (const [key, subject] of pending) {
-      const result = await buildParameterizedScriptablePack({
+      const result = await buildScriptablePack({
         definition: subject.definition,
         sourcePath: subject.sourcePath,
         ...(subject.subjectPackageId === undefined
@@ -644,6 +707,7 @@ export async function buildParameterizedScriptablePackWorklist(
           : { inheritedValues: subject.inheritedValues }),
         ...(subject.sourceClosure === undefined ? {} : { sourceClosure: subject.sourceClosure }),
         outputs: options.outputs,
+        ...(options.cookers === undefined ? {} : { cookers: options.cookers }),
         assetSource: stagedSource(staged, options.assetSource),
         availableGuids: new Set([...availableGuids, ...staged.keys()]),
         deferReferenceValidation: true,

package/src/scriptable-pack-host.ts

@@ -20,10 +20,10 @@ import type {
   ScanSourceDeclaration,
 } from '@forgeax/engine-pack/scanner';
 import {
-  type AnyParameterizedPackDefinition,
+  type AnyScriptablePackDefinition,
   type DirectPackAssetProjection,
   isScriptablePackAssetKind,
-  parseParameterizedPackJson,
+  parsePackSourceJson,
   projectDirectPackJson,
   projectScriptablePackSceneComponents,
   type ScriptablePackSourceClosureEntry,
@@ -45,17 +45,17 @@ import { AssetError, err, ok } from '@forgeax/engine-types';
 import type { DdcPack, ImportRunnerFs, RunImportMeta } from './import-runner.js';
 import type { ImporterRegistry } from './importer-registry.js';
 import { projectImportProductForBuild } from './pack-projection.js';
-import {
-  buildParameterizedScriptablePack,
-  buildParameterizedScriptablePackWorklist,
-  type ParameterizedScriptablePackBuildProduct,
-  type ParameterizedScriptablePackWorkItem,
-} from './parameterized-scriptable-pack.js';
 import type {
   ScriptablePackAssetSnapshotSource,
   ScriptablePackDomainError,
   ScriptablePackStagedOutput,
 } from './scriptable-pack.js';
+import {
+  buildScriptablePack,
+  buildScriptablePackWorklist,
+  type ScriptablePackBuildProduct,
+  type ScriptablePackBuildWorkItem,
+} from './scriptable-pack-build.js';
 import {
   createPreExternalizedSceneAssetOutputProducer,
   createStandardAssetOutputProducerRegistry,
@@ -64,15 +64,15 @@ import { produceSourcePackage } from './source-package.js';
 
 type FinalizedPackageTransport = Awaited<ReturnType<typeof finalizePackageTransportSource>>;
 
-export interface ParameterizedScriptablePackInput {
+export interface ScriptablePackInput {
   readonly sourcePath: string;
   readonly displaySourcePath: string;
-  readonly definition: AnyParameterizedPackDefinition;
+  readonly definition: AnyScriptablePackDefinition;
   readonly sourceClosure: readonly ScriptablePackSourceClosureEntry[];
   readonly publicationGeneration: number;
   readonly policy:
     | PackageFinalizePolicy
-    | ((product: ParameterizedScriptablePackBuildProduct) => PackageFinalizePolicy);
+    | ((product: ScriptablePackBuildProduct) => PackageFinalizePolicy);
   readonly subjectPackageId?: PackageIdType;
   readonly values?: Readonly<Record<string, unknown>>;
   readonly inheritedValues?: Readonly<
@@ -80,18 +80,20 @@ export interface ParameterizedScriptablePackInput {
   >;
 }
 
-export interface PreparedParameterizedScriptablePack {
-  readonly product: ParameterizedScriptablePackBuildProduct;
+export interface PreparedScriptablePack {
+  readonly product: ScriptablePackBuildProduct;
   readonly finalized: FinalizedPackageTransport;
   readonly facts: ScriptablePackPublicationFacts;
   readonly revision: ResourceRevision;
   readonly publication: AssetPublicationEnvelope;
 }
 
-export interface ParameterizedScriptablePackProductionOptions {
-  readonly sources: readonly ParameterizedScriptablePackInput[];
+export interface ScriptablePackProductionOptions {
+  readonly sources: readonly ScriptablePackInput[];
   readonly declaredExternalOutputs?: readonly ScriptablePackStagedOutput[];
   readonly assetSource?: ScriptablePackAssetSnapshotSource;
+  /** Build-time producers used for custom or otherwise uncooked asset rows. */
+  readonly cookers?: readonly NativeCooker[];
   readonly availableGuids?: ReadonlySet<string>;
   readonly incomingRefs?: ReadonlyMap<string, readonly string[]>;
   readonly maxPasses?: number;
@@ -211,7 +213,7 @@ export async function declaredPackExternalOutputs(
     }
     if (declaration.format !== 'pack.json') continue;
     if (declaration.value.schemaVersion === '3.0.0') {
-      const parsed = parseParameterizedPackJson(declaration.value);
+      const parsed = parsePackSourceJson(declaration.value);
       if (!parsed.ok || parsed.value.format !== 'direct') continue;
       const projected = projectDirectPackJson(parsed.value);
       if (!projected.ok) continue;
@@ -299,6 +301,13 @@ export async function readCookedAuthoredPack(
       continue;
     }
     if (isEngineOwnedMaterial(asset)) {
+      // Engine-owned material payloads are already cooked, but a legacy Pack
+      // source still needs to be projected into the runtime transport route.
+      // Mark the package as cooked so prepareLegacyPackTransport stages a
+      // published body instead of falling back to the source URL, which the
+      // dev route intentionally rejects for cooked v2 inputs.
+      hasCookedAsset = true;
+      refsByGuid.set(asset.guid.toLowerCase(), [...asset.refs]);
       assets.push({
         guid: asset.guid,
         kind: asset.kind,
@@ -352,7 +361,7 @@ export interface DirectPackTransport {
     readonly packageId: string;
     readonly assets: readonly DirectPackAssetProjection[];
   };
-  readonly product: ParameterizedScriptablePackBuildProduct;
+  readonly product: ScriptablePackBuildProduct;
   readonly finalized: FinalizedPackageTransport;
   readonly facts: ScriptablePackPublicationFacts;
   readonly revision: ResourceRevision;
@@ -429,9 +438,7 @@ function importedAssetArtifacts(
   );
 }
 
-function rawDirectProduct(
-  input: DirectPackTransportInput,
-): ParameterizedScriptablePackBuildProduct {
+function rawDirectProduct(input: DirectPackTransportInput): ScriptablePackBuildProduct {
   const inputFingerprint = `sha256:${packageTransportRevision({
     packageId: input.projected.packageId,
     sourceRevision: input.sourceRevision,
@@ -623,7 +630,7 @@ export async function prepareDirectPackTransport(
       projectImportProductForBuild(raw.product),
       input.policy,
     );
-    const facts = projectParameterizedPackPublication(raw);
+    const facts = projectScriptablePackPublication(raw);
     if (!facts.ok) return facts;
     const displaySourcePath = input.displaySourcePath ?? input.sourcePath;
     const revision = await scriptablePackResourceRevision(displaySourcePath, raw.inputFingerprint, [
@@ -654,10 +661,10 @@ export async function prepareDirectPackTransport(
           ]),
         ),
       ),
-  } as AnyParameterizedPackDefinition;
+  } as AnyScriptablePackDefinition;
   const outputs = createStandardAssetOutputProducerRegistry();
   outputs.register(createPreExternalizedSceneAssetOutputProducer());
-  const built = await buildParameterizedScriptablePack({
+  const built = await buildScriptablePack({
     definition,
     sourcePath: input.sourcePath,
     outputs,
@@ -702,7 +709,7 @@ export async function prepareDirectPackTransport(
     asset: directAssetForProducer(asset),
     digest: `sha256:${packageTransportRevision({ kind: asset.kind, payload: asset.payload })}`,
   }));
-  const product: ParameterizedScriptablePackBuildProduct = {
+  const product: ScriptablePackBuildProduct = {
     ...built.value,
     inputFingerprint,
     stagedOutputs,
@@ -722,7 +729,7 @@ export async function prepareDirectPackTransport(
     projectImportProductForBuild(product.product),
     input.policy,
   );
-  const facts = projectParameterizedPackPublication(product);
+  const facts = projectScriptablePackPublication(product);
   if (!facts.ok) return facts;
   const displaySourcePath = input.displaySourcePath ?? input.sourcePath;
   const revision = await scriptablePackResourceRevision(
@@ -761,8 +768,8 @@ export async function prepareLegacyPackTransport(
 }
 
 /** Materialize a dynamic Pack product through the same dev transport seam. */
-export async function materializePreparedParameterizedScriptablePack(
-  prepared: PreparedParameterizedScriptablePack,
+export async function materializePreparedScriptablePack(
+  prepared: PreparedScriptablePack,
   paths: ScriptablePackTransportPaths,
   sink: ScriptablePackTransportSink,
 ): Promise<ReadonlyMap<string, string>> {
@@ -793,8 +800,8 @@ export async function materializePreparedParameterizedScriptablePack(
   return receipts;
 }
 
-function projectParameterizedPackPublication(
-  product: ParameterizedScriptablePackBuildProduct,
+function projectScriptablePackPublication(
+  product: ScriptablePackBuildProduct,
 ): Result<ScriptablePackPublicationFacts, ScriptablePackDomainError> {
   const assets = new Map(product.product.assets.map((asset) => [asset.guid.toLowerCase(), asset]));
   const outputs: AssetPublicationOutput[] = [];
@@ -804,7 +811,7 @@ function projectParameterizedPackPublication(
     if (asset === undefined || staged.digest === undefined || staged.sourceKey === undefined) {
       return err({
         code: 'pack-source-output-invalid',
-        expected: `parameterized Pack publication output ${guid} to include a product, sourceKey, and digest`,
+        expected: `ScriptablePack publication output ${guid} to include a product, sourceKey, and digest`,
         hint: 'repair the dynamic Pack output and rebuild the current generation',
         detail: { stage: 'publication', guid },
       });
@@ -857,7 +864,7 @@ function snapshotSourceForStagedOutputs(
   };
 }
 
-function composeParameterizedAssetSource(
+function composeScriptablePackAssetSource(
   staged: import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined,
   published: import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined,
 ): import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined {
@@ -873,16 +880,16 @@ function composeParameterizedAssetSource(
 }
 
 /**
- * Build parameterized sources in one generation and hand their terminal
+ * Build ScriptablePack sources in one generation and hand their terminal
  * products to the ordinary Pack v2 finalizer. The worklist is deliberately
  * below publication: it only decides which current-generation products exist.
  */
-export async function produceParameterizedScriptablePackProducts(
-  options: ParameterizedScriptablePackProductionOptions,
-): Promise<Result<ReadonlyMap<string, PreparedParameterizedScriptablePack>, unknown>> {
+export async function produceScriptablePackProducts(
+  options: ScriptablePackProductionOptions,
+): Promise<Result<ReadonlyMap<string, PreparedScriptablePack>, unknown>> {
   if (options.sources.length === 0) return ok(new Map());
   const external = options.declaredExternalOutputs ?? [];
-  const assetSource = composeParameterizedAssetSource(
+  const assetSource = composeScriptablePackAssetSource(
     snapshotSourceForStagedOutputs(external),
     options.assetSource,
   );
@@ -890,7 +897,7 @@ export async function produceParameterizedScriptablePackProducts(
     ...(options.availableGuids ?? []),
     ...external.map((output) => AssetGuid.format(output.guid).toLowerCase()),
   ]);
-  const workItems: ParameterizedScriptablePackWorkItem[] = options.sources.map((source) => ({
+  const workItems: ScriptablePackBuildWorkItem[] = options.sources.map((source) => ({
     definition: source.definition,
     sourcePath: source.sourcePath,
     ...(source.subjectPackageId === undefined ? {} : { subjectPackageId: source.subjectPackageId }),
@@ -898,13 +905,14 @@ export async function produceParameterizedScriptablePackProducts(
     ...(source.inheritedValues === undefined ? {} : { inheritedValues: source.inheritedValues }),
     sourceClosure: source.sourceClosure,
   }));
-  const worklist = await buildParameterizedScriptablePackWorklist({
+  const worklist = await buildScriptablePackWorklist({
     subjects: workItems,
     outputs: createStandardAssetOutputProducerRegistry(
       options.sources.flatMap((source) =>
         projectScriptablePackSceneComponents(source.definition.sceneComponents),
       ),
     ),
+    ...(options.cookers === undefined ? {} : { cookers: options.cookers }),
     ...(assetSource === undefined ? {} : { assetSource }),
     availableGuids,
     ...(options.incomingRefs === undefined ? {} : { incomingRefs: options.incomingRefs }),
@@ -917,7 +925,7 @@ export async function produceParameterizedScriptablePackProducts(
       .filter((product) => product.product.sourceKey !== undefined)
       .map((product) => [product.product.sourceKey as string, product]),
   );
-  const prepared = new Map<string, PreparedParameterizedScriptablePack>();
+  const prepared = new Map<string, PreparedScriptablePack>();
   for (const source of options.sources) {
     const product = productsBySource.get(source.sourcePath);
     if (product === undefined) {
@@ -933,7 +941,7 @@ export async function produceParameterizedScriptablePackProducts(
       projectImportProductForBuild(product.product),
       policy,
     );
-    const facts = projectParameterizedPackPublication(product);
+    const facts = projectScriptablePackPublication(product);
     if (!facts.ok) return facts;
     const revision = await scriptablePackResourceRevision(
       source.displaySourcePath,

package/src/scriptable-pack.ts

@@ -136,7 +136,8 @@ export interface ScriptablePackExternalEvidence {
   readonly digest?: string;
 }
 
-export interface ScriptablePackBuildProduct {
+/** Shared terminal product envelope for every Pack source form. */
+export interface PackBuildProduct {
   readonly product: TerminalImportProduct<unknown>;
   readonly stagedOutputs: readonly ScriptablePackStagedOutput[];
   readonly externalEvidence: readonly ScriptablePackExternalEvidence[];