@forgeax/engine-import 0.1.20 → 0.1.23

package/src/scriptable-pack-host.ts

@@ -1,29 +1,43 @@
-import { createHash } from 'node:crypto';
 import { stat } from 'node:fs/promises';
-import { isAbsolute, relative, resolve } from 'node:path';
 import { createAcceptedPublication } from '@forgeax/engine-ddc';
+import { normalizeMeshPayload } from '@forgeax/engine-geometry';
 import {
-  type AuthoredPackInput,
   finalizePackageTransportSource,
-  loadAssetConfig,
   type PackageFinalizePolicy,
+  type PackageProductAsset,
+  packageTransportRevision,
   resolveAssetSource,
-  upgradeLegacyAuthoredPack,
 } from '@forgeax/engine-pack/build';
-import { AssetGuid } from '@forgeax/engine-pack/guid';
-import { type NativeCooker, NativeCookerRegistry } from '@forgeax/engine-pack/native-cooker';
-import type { ScanSourceDeclaration } from '@forgeax/engine-pack/scanner';
+import { BUILTIN_MESH_ASSETS } from '@forgeax/engine-pack/builtin';
+import { AssetGuid, PackageId, type PackageId as PackageIdType } from '@forgeax/engine-pack/guid';
 import {
+  type NativeCookDraft,
+  type NativeCooker,
+  NativeCookerRegistry,
+} from '@forgeax/engine-pack/native-cooker';
+import type {
+  LegacyPackInventoryDocument,
+  ScanSourceDeclaration,
+} from '@forgeax/engine-pack/scanner';
+import {
+  type AnyParameterizedPackDefinition,
+  type DirectPackAssetProjection,
+  isScriptablePackAssetKind,
+  parseParameterizedPackJson,
+  projectDirectPackJson,
   projectScriptablePackSceneComponents,
-  type ScriptablePackDefinition,
   type ScriptablePackSourceClosureEntry,
 } from '@forgeax/engine-pack/source';
-import { inventoryScriptablePackSource } from '@forgeax/engine-pack/source-node';
+import { isEngineMaterial } from '@forgeax/engine-shader';
 import type {
   Asset,
   AssetGuid as AssetGuidType,
   AssetPublicationEnvelope,
   AssetPublicationOutput,
+  AssetRef,
+  ImportedArtifactBody,
+  ImportedAsset,
+  MaterialAsset,
   ResourceRevision,
   Result,
 } from '@forgeax/engine-types';
@@ -31,43 +45,63 @@ 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 type { ScriptablePackDomainError, ScriptablePackStagedOutput } from './scriptable-pack.js';
-import { createStandardAssetOutputProducerRegistry } from './scriptable-pack-output-producers.js';
 import {
-  createScriptablePackStagedAssetSnapshotSource,
-  type ScriptablePackStagedOwner,
-} from './scriptable-pack-staged-snapshot.js';
+  buildParameterizedScriptablePack,
+  buildParameterizedScriptablePackWorklist,
+  type ParameterizedScriptablePackBuildProduct,
+  type ParameterizedScriptablePackWorkItem,
+} from './parameterized-scriptable-pack.js';
+import type {
+  ScriptablePackAssetSnapshotSource,
+  ScriptablePackDomainError,
+  ScriptablePackStagedOutput,
+} from './scriptable-pack.js';
 import {
-  produceScriptableSourcePackage,
-  type ScriptableSourcePackageProduct,
-  type ScriptableSourcePackageResult,
-} from './scriptable-source-package.js';
+  createPreExternalizedSceneAssetOutputProducer,
+  createStandardAssetOutputProducerRegistry,
+} from './scriptable-pack-output-producers.js';
 import { produceSourcePackage } from './source-package.js';
 
 type FinalizedPackageTransport = Awaited<ReturnType<typeof finalizePackageTransportSource>>;
 
-export interface ScriptablePackInput {
+export interface ParameterizedScriptablePackInput {
   readonly sourcePath: string;
   readonly displaySourcePath: string;
-  readonly definition: Readonly<ScriptablePackDefinition>;
+  readonly definition: AnyParameterizedPackDefinition;
   readonly sourceClosure: readonly ScriptablePackSourceClosureEntry[];
   readonly publicationGeneration: number;
-  readonly policy: ScriptablePackTransportPolicy;
+  readonly policy:
+    | PackageFinalizePolicy
+    | ((product: ParameterizedScriptablePackBuildProduct) => PackageFinalizePolicy);
+  readonly subjectPackageId?: PackageIdType;
+  readonly values?: Readonly<Record<string, unknown>>;
+  readonly inheritedValues?: Readonly<
+    Record<string, import('@forgeax/engine-pack/source').PackParameterValue>
+  >;
 }
 
-export interface ScriptablePackPublicationFacts {
-  readonly outputs: readonly AssetPublicationOutput[];
-  readonly refs: ReadonlyMap<string, readonly string[]>;
-}
-
-export interface PreparedScriptablePack {
-  readonly product: ScriptableSourcePackageProduct;
+export interface PreparedParameterizedScriptablePack {
+  readonly product: ParameterizedScriptablePackBuildProduct;
   readonly finalized: FinalizedPackageTransport;
   readonly facts: ScriptablePackPublicationFacts;
   readonly revision: ResourceRevision;
   readonly publication: AssetPublicationEnvelope;
 }
 
+export interface ParameterizedScriptablePackProductionOptions {
+  readonly sources: readonly ParameterizedScriptablePackInput[];
+  readonly declaredExternalOutputs?: readonly ScriptablePackStagedOutput[];
+  readonly assetSource?: ScriptablePackAssetSnapshotSource;
+  readonly availableGuids?: ReadonlySet<string>;
+  readonly incomingRefs?: ReadonlyMap<string, readonly string[]>;
+  readonly maxPasses?: number;
+}
+
+export interface ScriptablePackPublicationFacts {
+  readonly outputs: readonly AssetPublicationOutput[];
+  readonly refs: ReadonlyMap<string, readonly string[]>;
+}
+
 export interface ScriptablePackTransportPaths {
   readonly packagePath: string;
   readonly artifactPath: (path: string) => string;
@@ -80,31 +114,10 @@ export interface ScriptablePackTransportSink {
   writeReceipt(path: string, body: string): void | Promise<void>;
 }
 
-export type ScriptablePackTransportPolicy =
-  | PackageFinalizePolicy
-  | ((product: ScriptableSourcePackageProduct) => PackageFinalizePolicy);
-
-type ScriptablePackHostError =
-  ScriptableSourcePackageResult extends Result<unknown, infer E> ? E : never;
-
-export interface CookedAuthoredPack {
-  readonly logicalPackage: DdcPack;
-  readonly refsByGuid: ReadonlyMap<string, readonly string[]>;
-}
-
-export interface AuthoredPackTransport {
-  readonly pack: AuthoredPackInput;
-  readonly firstGuid?: string;
-  readonly cooked?: CookedAuthoredPack;
-  readonly finalized?: FinalizedPackageTransport;
-}
-
-/** Build-time capabilities required to expose ordinary Meta products to a ScriptablePack. */
+/** Build-time capabilities required to expose ordinary Meta products to a Pack. */
 export interface ScriptablePackExternalImportOptions {
   readonly importerRegistry: ImporterRegistry;
   readonly fsForImport: ImportRunnerFs;
-  /** Package path aliases from forgeax.assets.paths; defaults to the current project config. */
-  readonly assetPaths?: Readonly<Record<string, string>>;
 }
 
 export function canonicalScriptableSourcePath(sourcePath: string): string {
@@ -114,127 +127,7 @@ export function canonicalScriptableSourcePath(sourcePath: string): string {
   return markerIndex < 0 ? normalized : normalized.slice(markerIndex + 1);
 }
 
-export function scriptablePackInputs(
-  sourcePaths: readonly string[],
-  declarations: ReadonlyMap<string, ScanSourceDeclaration>,
-  cwd: string,
-  generationFor: (displaySourcePath: string) => number,
-  policyFor: (displaySourcePath: string) => ScriptablePackTransportPolicy,
-  sourceIdentityFor?: (sourcePath: string) => string,
-): ScriptablePackInput[] {
-  return sourcePaths.flatMap((sourcePath) => {
-    const declaration = declarations.get(resolve(cwd, sourcePath));
-    if (declaration?.format !== 'pack.ts') return [];
-    const projected = sourceIdentityFor?.(sourcePath);
-    const catalogSourcePath =
-      projected === undefined || isAbsolute(projected) ? relative(cwd, sourcePath) : projected;
-    const displaySourcePath = canonicalScriptableSourcePath(catalogSourcePath);
-    return [
-      {
-        sourcePath: resolve(cwd, sourcePath),
-        displaySourcePath,
-        definition: declaration.definition,
-        sourceClosure: declaration.sourceClosure,
-        publicationGeneration: generationFor(displaySourcePath),
-        policy: policyFor(displaySourcePath),
-      },
-    ];
-  });
-}
-
-/** Materialize one accepted ScriptablePack without duplicating dev/build loops. */
-export async function materializePreparedScriptablePack(
-  prepared: PreparedScriptablePack,
-  paths: ScriptablePackTransportPaths,
-  sink: ScriptablePackTransportSink,
-): Promise<ReadonlyMap<string, string>> {
-  const { product, finalized } = prepared;
-  await sink.writePackage(paths.packagePath, JSON.stringify(finalized.pack));
-  for (const artifact of finalized.artifacts) {
-    await sink.writeArtifact(
-      paths.artifactPath(artifact.path),
-      artifact.bytes,
-      artifact.path.endsWith('.json') ? 'application/json' : artifact.mediaType,
-    );
-  }
-  const receipts = new Map<string, string>();
-  for (const guid of product.declaredGuids) {
-    const path = paths.receiptPath(guid);
-    await sink.writeReceipt(
-      path,
-      JSON.stringify({
-        guid,
-        origin: 'sourceMeta',
-        status: 'succeeded',
-        inputFingerprint: product.inputFingerprint,
-        outputDigest: finalized.digest,
-      }),
-    );
-    receipts.set(guid, path);
-  }
-  return receipts;
-}
-
-export async function readCookedAuthoredPack(
-  authoredPack: AuthoredPackInput,
-  cookers: readonly NativeCooker[] = [],
-  sourcePath?: string,
-): Promise<CookedAuthoredPack | undefined> {
-  const parsed = upgradeLegacyAuthoredPack(authoredPack);
-  if (parsed.schemaVersion !== '2.0.0' || parsed.assets === undefined) return undefined;
-  const registry = new NativeCookerRegistry();
-  for (const cooker of cookers) registry.register(cooker);
-  const assets: DdcPack['assets'][number][] = [];
-  const refsByGuid = new Map<string, readonly string[]>();
-  let hasCookedAsset = false;
-  for (const asset of parsed.assets) {
-    const shouldCook = asset.execution === 'cooked';
-    if (!shouldCook) {
-      assets.push({
-        guid: asset.guid,
-        kind: asset.kind,
-        ...(asset.name === undefined ? {} : { name: asset.name }),
-        ...(asset.sourceKey === undefined ? {} : { sourceKey: asset.sourceKey }),
-        ...(asset.sourceIndex === undefined ? {} : { sourceIndex: asset.sourceIndex }),
-        ...(asset.relations === undefined ? {} : { relations: asset.relations }),
-        payload: asset.payload,
-        refs: asset.refs ?? [],
-        artifacts: {},
-      });
-      continue;
-    }
-    hasCookedAsset = true;
-    const result = await registry.runDraft(asset.kind, {
-      guid: asset.guid,
-      source: asset.payload,
-      ...(asset.sourceKey === undefined ? {} : { sourceKey: asset.sourceKey }),
-      ...(sourcePath === undefined ? {} : { sourcePath }),
-      refs: asset.refs ?? [],
-    });
-    if (!result.ok) throw result.error;
-    const draft = result.value;
-    const refs = [...draft.refs];
-    refsByGuid.set(asset.guid.toLowerCase(), refs);
-    assets.push({
-      guid: draft.guid,
-      kind: asset.kind,
-      ...(asset.name === undefined ? {} : { name: asset.name }),
-      ...(asset.sourceKey === undefined ? {} : { sourceKey: asset.sourceKey }),
-      ...(asset.sourceIndex === undefined ? {} : { sourceIndex: asset.sourceIndex }),
-      ...(asset.relations === undefined ? {} : { relations: asset.relations }),
-      payload: draft.payload as Record<string, unknown>,
-      refs,
-      artifacts: draft.artifacts,
-    });
-  }
-  return hasCookedAsset
-    ? {
-        logicalPackage: { schemaVersion: '2.0.0', kind: 'internal-text-package', assets },
-        refsByGuid,
-      }
-    : undefined;
-}
-
+/** Stage materialized outputs owned by Meta or an already-cooked Pack v2 document. */
 export async function declaredPackExternalOutputs(
   declarations: ReadonlyMap<string, ScanSourceDeclaration>,
   cookers: readonly NativeCooker[] = [],
@@ -243,6 +136,15 @@ export async function declaredPackExternalOutputs(
 ): Promise<readonly ScriptablePackStagedOutput[]> {
   if (requiredGuids.length === 0) return [];
   const required = new Set(requiredGuids.map((guid) => AssetGuid.format(guid).toLowerCase()));
+  const available = new Set(required);
+  for (const declaration of declarations.values()) {
+    if (declaration.format !== 'meta.json') continue;
+    for (const asset of declaration.value.subAssets) {
+      const parsed = AssetGuid.parse(asset.guid);
+      if (!parsed.ok) throw parsed.error;
+      available.add(AssetGuid.format(parsed.value).toLowerCase());
+    }
+  }
   const outputs: ScriptablePackStagedOutput[] = [];
   for (const declaration of declarations.values()) {
     if (declaration.format === 'meta.json') {
@@ -250,22 +152,10 @@ export async function declaredPackExternalOutputs(
       if (!declaration.value.subAssets.some((asset) => required.has(asset.guid.toLowerCase()))) {
         continue;
       }
-      const assetPaths = externalImport.assetPaths ?? loadAssetConfig(process.cwd()).paths;
-      const resolved = resolveAssetSource(
-        declaration.sourcePath,
-        declaration.value.source,
-        assetPaths,
-      );
-      if (!resolved.ok) {
-        throw new AssetError({
-          code: 'asset-not-imported',
-          expected: `a resolvable source for Meta dependency ${declaration.sourcePath}`,
-          hint: 'repair the Meta source path before rebuilding the ScriptablePack',
-        });
-      }
+      const resolved = resolveAssetSource(declaration.sourcePath, declaration.value.source);
       const meta: RunImportMeta = {
         importer: declaration.value.importer,
-        source: resolved.value,
+        source: resolved,
         sourceRevision: declaration.sourceRevision,
         ...(declaration.value.packageId === undefined
           ? {}
@@ -299,81 +189,629 @@ export async function declaredPackExternalOutputs(
       if (!sourcePackage.ok) {
         throw new AssetError({
           code: 'asset-not-imported',
-          expected: `the ${declaration.value.importer} importer to produce Meta dependency outputs`,
-          hint: `repair ${declaration.sourcePath} before rebuilding the ScriptablePack`,
+          expected: 'the Meta importer to produce the requested dependency',
+          hint: 'repair the Meta source and rerun the Pack build',
+          detail: { sourcePath: declaration.sourcePath },
         });
       }
       for (const asset of sourcePackage.value.product.assets) {
-        const key = asset.guid.toLowerCase();
-        if (!required.has(key)) continue;
+        if (!required.has(asset.guid.toLowerCase())) continue;
         const parsed = AssetGuid.parse(asset.guid);
         if (!parsed.ok) throw parsed.error;
+        const declared = declaration.value.subAssets.find(
+          (candidate) => candidate.guid.toLowerCase() === asset.guid.toLowerCase(),
+        );
         outputs.push({
           guid: parsed.value,
-          asset: { kind: asset.kind, ...(asset.payload as Record<string, unknown>) } as Asset,
+          sourceKey: declared?.sourceKey ?? asset.guid,
+          asset: { ...(asset.payload as Record<string, unknown>), kind: asset.kind } as Asset,
         });
       }
       continue;
     }
     if (declaration.format !== 'pack.json') continue;
-    const declaredAssets = declaration.value.assets.filter((asset) =>
-      required.has(asset.guid.toLowerCase()),
-    );
-    if (declaredAssets.length === 0) continue;
+    if (declaration.value.schemaVersion === '3.0.0') {
+      const parsed = parseParameterizedPackJson(declaration.value);
+      if (!parsed.ok || parsed.value.format !== 'direct') continue;
+      const projected = projectDirectPackJson(parsed.value);
+      if (!projected.ok) continue;
+      const prepared = await prepareDirectPackTransport({
+        projected: projected.value,
+        sourcePath: declaration.sourcePath,
+        sourceRevision: declaration.sourceRevision,
+        availableGuids: available,
+        ...(cookers.length === 0 ? {} : { cookers }),
+        policy: {
+          base: '/',
+          packagePath: `assets/${projected.value.packageId}.pack.json`,
+          artifactPath: (assetGuid, key) => `${assetGuid}/${key}.bin`,
+          sink: () => {},
+        },
+      });
+      if (!prepared.ok) throw prepared.error;
+      const cookedByGuid = new Map(
+        prepared.value.finalized.pack.assets.map((asset) => [asset.guid.toLowerCase(), asset]),
+      );
+      for (const asset of projected.value.assets) {
+        if (!required.has(asset.guid.toLowerCase())) continue;
+        const parsedGuid = AssetGuid.parse(asset.guid);
+        if (!parsedGuid.ok) throw parsedGuid.error;
+        const cooked = cookedByGuid.get(asset.guid.toLowerCase());
+        if (cooked === undefined) {
+          throw new AssetError({
+            code: 'asset-not-imported',
+            expected: 'the direct Pack producer to retain every declared output',
+            hint: 'repair the direct Pack output and rerun the Pack build',
+            detail: { sourcePath: declaration.sourcePath },
+          });
+        }
+        outputs.push({
+          guid: parsedGuid.value,
+          sourceKey: asset.sourceKey,
+          asset: { kind: cooked.kind, ...cooked.payload } as Asset,
+        });
+      }
+      continue;
+    }
     const cooked = await readCookedAuthoredPack(declaration.value, cookers, declaration.sourcePath);
-    for (const asset of cooked?.logicalPackage.assets.filter((item) =>
-      required.has(item.guid.toLowerCase()),
-    ) ?? declaredAssets) {
-      const parsed = AssetGuid.parse(asset.guid);
-      if (!parsed.ok) throw parsed.error;
-      outputs.push({ guid: parsed.value, asset: { kind: asset.kind, ...asset.payload } as Asset });
+    for (const asset of cooked?.logicalPackage.assets ?? declaration.value.assets) {
+      if (!required.has(asset.guid.toLowerCase())) continue;
+      const parsedGuid = AssetGuid.parse(asset.guid);
+      if (!parsedGuid.ok) throw parsedGuid.error;
+      outputs.push({
+        guid: parsedGuid.value,
+        sourceKey: asset.sourceKey ?? asset.guid,
+        asset: { ...asset.payload, kind: asset.kind } as Asset,
+      });
     }
   }
   return outputs;
 }
 
-/** Normalize one authored Pack and, when needed, run its registered cooker once. */
-export async function prepareAuthoredPackTransport(
-  authoredPack: AuthoredPackInput,
+/** Cook the explicit legacy Pack v2 transport without exposing v1 authoring APIs. */
+export async function readCookedAuthoredPack(
+  authoredPack: LegacyPackInventoryDocument,
+  cookers: readonly NativeCooker[] = [],
+  sourcePath?: string,
+): Promise<
+  | {
+      readonly logicalPackage: Pick<DdcPack, 'assets'>;
+      readonly refsByGuid: ReadonlyMap<string, readonly string[]>;
+    }
+  | undefined
+> {
+  if (authoredPack.schemaVersion !== '2.0.0') return undefined;
+  const registry = new NativeCookerRegistry();
+  for (const cooker of cookers) registry.register(cooker);
+  const assets: PackageProductAsset[] = [];
+  const refsByGuid = new Map<string, readonly string[]>();
+  let hasCookedAsset = false;
+  for (const asset of authoredPack.assets) {
+    if (asset.execution !== 'cooked') {
+      assets.push({
+        guid: asset.guid,
+        kind: asset.kind,
+        ...(asset.name === undefined ? {} : { name: asset.name }),
+        payload: asset.payload,
+        refs: asset.refs,
+        artifacts: {},
+      });
+      continue;
+    }
+    if (isEngineOwnedMaterial(asset)) {
+      assets.push({
+        guid: asset.guid,
+        kind: asset.kind,
+        ...(asset.name === undefined ? {} : { name: asset.name }),
+        payload: asset.payload,
+        refs: asset.refs,
+        artifacts: {},
+      });
+      continue;
+    }
+    hasCookedAsset = true;
+    const result = await registry.runDraft(asset.kind, {
+      guid: asset.guid,
+      // Pack v2 stores the asset kind beside payload. Native producer APIs
+      // consume the runtime Asset shape, so reconstruct that one boundary
+      // field before invoking the cooker.
+      source: nativeCookSource(asset),
+      ...(asset.sourceKey === undefined ? {} : { sourceKey: asset.sourceKey }),
+      ...(sourcePath === undefined ? {} : { sourcePath }),
+      refs: asset.refs,
+    });
+    if (!result.ok) throw result.error;
+    const draft = result.value;
+    refsByGuid.set(asset.guid.toLowerCase(), [...draft.refs]);
+    assets.push({
+      guid: draft.guid,
+      kind: asset.kind,
+      ...(asset.name === undefined ? {} : { name: asset.name }),
+      payload: draft.payload as Record<string, unknown>,
+      refs: [...draft.refs],
+      artifacts: draft.artifacts,
+    });
+  }
+  return hasCookedAsset
+    ? {
+        logicalPackage: { assets },
+        refsByGuid,
+      }
+    : undefined;
+}
+
+export interface LegacyPackTransport {
+  readonly pack: LegacyPackInventoryDocument;
+  readonly firstGuid?: string;
+  readonly cooked?: Awaited<ReturnType<typeof readCookedAuthoredPack>>;
+  readonly finalized?: FinalizedPackageTransport;
+}
+
+export interface DirectPackTransport {
+  readonly projected: {
+    readonly packageId: string;
+    readonly assets: readonly DirectPackAssetProjection[];
+  };
+  readonly product: ParameterizedScriptablePackBuildProduct;
+  readonly finalized: FinalizedPackageTransport;
+  readonly facts: ScriptablePackPublicationFacts;
+  readonly revision: ResourceRevision;
+}
+
+export interface DirectPackTransportInput {
+  readonly projected: DirectPackTransport['projected'];
+  readonly sourcePath: string;
+  readonly displaySourcePath?: string;
+  readonly sourceRevision: string;
+  readonly policy: PackageFinalizePolicy;
+  readonly availableGuids?: ReadonlySet<string>;
+  readonly cookers?: readonly NativeCooker[];
+}
+
+function directReference(guid: string): AssetRef {
+  return { guid, sourceField: { fieldName: 'refs' } };
+}
+
+function mergeDirectReferences(
+  produced: readonly AssetRef[],
+  declared: readonly string[],
+): readonly AssetRef[] {
+  const merged = [...produced];
+  const seen = new Set(produced.map((reference) => reference.guid.toLowerCase()));
+  for (const guid of declared) {
+    const parsed = AssetGuid.parse(guid);
+    if (!parsed.ok) throw parsed.error;
+    const normalized = AssetGuid.format(parsed.value);
+    if (seen.has(normalized.toLowerCase())) continue;
+    seen.add(normalized.toLowerCase());
+    merged.push(directReference(normalized));
+  }
+  return merged;
+}
+
+function directReferenceFailure(
+  sourcePath: string,
+  guids: readonly string[],
+): {
+  readonly code: 'pack-output-reference-missing';
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: { readonly sourcePath: string; readonly guids: readonly string[] };
+} {
+  return {
+    code: 'pack-output-reference-missing',
+    expected: 'every direct Pack reference to resolve to a local or published AssetGuid',
+    hint: 'publish the referenced Pack or repair the direct refs before rebuilding the Pack',
+    detail: { sourcePath, guids: [...guids].sort() },
+  };
+}
+
+function directInputFingerprint(
+  sourceRevision: string,
+  nativeFingerprints: ReadonlyMap<string, string>,
+): string {
+  if (nativeFingerprints.size === 0) return sourceRevision;
+  return `sha256:${packageTransportRevision({
+    sourceRevision,
+    nativeCookers: [...nativeFingerprints.entries()].sort(([left], [right]) =>
+      left.localeCompare(right),
+    ),
+  })}`;
+}
+
+function importedAssetArtifacts(
+  assets: readonly ImportedAsset<unknown>[],
+): Readonly<Record<string, ImportedArtifactBody>> {
+  return Object.fromEntries(
+    assets.flatMap((asset) =>
+      Object.entries(asset.artifacts).map(([key, artifact]) => [`${asset.guid}/${key}`, artifact]),
+    ),
+  );
+}
+
+function rawDirectProduct(
+  input: DirectPackTransportInput,
+): ParameterizedScriptablePackBuildProduct {
+  const inputFingerprint = `sha256:${packageTransportRevision({
+    packageId: input.projected.packageId,
+    sourceRevision: input.sourceRevision,
+    assets: input.projected.assets,
+  })}`;
+  const assets: ImportedAsset<unknown>[] = input.projected.assets.map((asset) => ({
+    guid: asset.guid,
+    kind: asset.kind,
+    ...(asset.name === undefined ? {} : { name: asset.name }),
+    payload: directRuntimePayload(asset),
+    refs: asset.refs.map(directReference),
+    artifacts: {},
+  }));
+  return {
+    product: {
+      assets,
+      sourceDependencies: [input.sourcePath],
+      refs: assets.flatMap((asset) => asset.refs),
+      artifacts: importedAssetArtifacts(assets),
+      receipts: assets.map((asset) => ({
+        guid: asset.guid,
+        origin: 'authoredPack' as const,
+        status: 'succeeded' as const,
+        inputFingerprint,
+      })),
+      diagnostics: [],
+      sourceRevision: inputFingerprint,
+      sourceKey: input.sourcePath,
+    },
+    stagedOutputs: input.projected.assets.map((asset) => ({
+      guid: directGuid(asset.guid),
+      sourceKey: asset.sourceKey,
+      asset: {
+        ...(directRuntimePayload(asset) as Record<string, unknown>),
+        kind: asset.kind,
+      } as Asset,
+      digest: `sha256:${packageTransportRevision({ kind: asset.kind, payload: asset.payload })}`,
+    })),
+    externalEvidence: [],
+    inputFingerprint,
+  };
+}
+
+function directGuid(value: string): AssetGuidType {
+  const parsed = AssetGuid.parse(value);
+  if (!parsed.ok) throw parsed.error;
+  return parsed.value;
+}
+
+function nativeRefs(refs: readonly string[]): AssetRef[] {
+  return refs.map((guid) => {
+    const parsed = AssetGuid.parse(guid);
+    if (!parsed.ok) throw parsed.error;
+    return { guid: AssetGuid.format(parsed.value) };
+  });
+}
+
+function nativeCookSource(asset: { readonly kind: string; readonly payload: unknown }): unknown {
+  if (
+    asset.kind !== 'material' ||
+    asset.payload === null ||
+    typeof asset.payload !== 'object' ||
+    Array.isArray(asset.payload)
+  ) {
+    return asset.payload;
+  }
+  return { ...(asset.payload as Record<string, unknown>), kind: asset.kind };
+}
+
+function isEngineOwnedMaterial(asset: {
+  readonly kind: string;
+  readonly payload: unknown;
+}): boolean {
+  if (
+    asset.kind !== 'material' ||
+    asset.payload === null ||
+    typeof asset.payload !== 'object' ||
+    Array.isArray(asset.payload)
+  ) {
+    return false;
+  }
+  return isEngineMaterial(asset.payload as Pick<MaterialAsset, 'passes'>);
+}
+
+function directRuntimePayload(asset: DirectPackAssetProjection): unknown {
+  if (
+    asset.kind !== 'ui' ||
+    asset.payload === null ||
+    typeof asset.payload !== 'object' ||
+    Array.isArray(asset.payload)
+  ) {
+    return asset.payload;
+  }
+  return { ...(asset.payload as Record<string, unknown>), guid: asset.guid };
+}
+
+function directAssetForProducer(asset: DirectPackAssetProjection): Asset {
+  const payload = {
+    ...(directRuntimePayload(asset) as Record<string, unknown>),
+    kind: asset.kind,
+  };
+  if (asset.kind !== 'mesh') return payload as Asset;
+  return (normalizeMeshPayload(payload, asset.refs) ?? payload) as Asset;
+}
+
+/** Cook one direct v3 Pack through the same producer/finalizer seam as pack.ts. */
+export async function prepareDirectPackTransport(
+  input: DirectPackTransportInput,
+): Promise<Result<DirectPackTransport, unknown>> {
+  const localGuids = new Set(input.projected.assets.map((asset) => asset.guid.toLowerCase()));
+  const availableGuids = new Set(
+    [...(input.availableGuids ?? []), ...BUILTIN_MESH_ASSETS.map((asset) => asset.guid)].filter(
+      (guid) => !localGuids.has(guid.toLowerCase()),
+    ),
+  );
+  const directArtifacts = input.projected.assets.find(
+    (asset) => asset.artifacts !== undefined && Object.keys(asset.artifacts).length > 0,
+  );
+  if (directArtifacts !== undefined) {
+    return err({
+      code: 'pack-parameter-invalid',
+      expected: 'direct v3 authoring entries to leave artifacts empty for the producer',
+      hint: 'remove authored artifact data and let the registered Asset producer create it',
+      detail: { sourcePath: input.sourcePath, sourceKey: directArtifacts.sourceKey },
+    });
+  }
+  const packageId = PackageId.parse(input.projected.packageId);
+  if (!packageId.ok) return err(packageId.error);
+  const cookerRegistry = new NativeCookerRegistry();
+  for (const cooker of input.cookers ?? []) cookerRegistry.register(cooker);
+  const nativeDrafts = new Map<string, NativeCookDraft>();
+  const nativeFingerprints = new Map<string, string>();
+  for (const asset of input.projected.assets) {
+    if (!isScriptablePackAssetKind(asset.kind)) continue;
+    if (cookerRegistry.get(asset.kind) === undefined) continue;
+    if (isEngineOwnedMaterial(asset)) continue;
+    const draft = await cookerRegistry.runDraft(asset.kind, {
+      guid: asset.guid,
+      // Direct v3 entries keep `kind` at the entry boundary. Reattach it for
+      // producer contracts such as MaterialAsset, whose payload is otherwise
+      // intentionally allowed to omit the discriminant.
+      source: nativeCookSource(asset),
+      sourceKey: asset.sourceKey,
+      sourcePath: input.sourcePath,
+      refs: asset.refs,
+    });
+    if (!draft.ok) return err(draft.error);
+    if (draft.value.guid.toLowerCase() !== asset.guid.toLowerCase()) {
+      return err({
+        code: 'pack-parameter-invalid',
+        expected: 'a direct Pack cooker to preserve the derived AssetGuid',
+        hint: 'repair the native cooker output GUID and rebuild the direct Pack',
+        detail: {
+          sourcePath: input.sourcePath,
+          sourceKey: asset.sourceKey,
+          expectedGuid: asset.guid,
+          actualGuid: draft.value.guid,
+        },
+      });
+    }
+    nativeDrafts.set(asset.guid.toLowerCase(), draft.value);
+    nativeFingerprints.set(asset.sourceKey, draft.value.inputFingerprint);
+  }
+  const unsupported = input.projected.assets.filter(
+    (asset) => !isScriptablePackAssetKind(asset.kind),
+  );
+  if (unsupported.length > 0 && unsupported.length !== input.projected.assets.length) {
+    return err({
+      code: 'pack-parameter-invalid',
+      expected: 'a direct Pack to contain only producer-backed Engine Assets or only direct PODs',
+      hint: 'split custom direct PODs from producer-backed Assets into separate Packs',
+      detail: {
+        sourcePath: input.sourcePath,
+        unsupportedKinds: [...new Set(unsupported.map((asset) => asset.kind))].sort(),
+      },
+    });
+  }
+  if (unsupported.length === input.projected.assets.length) {
+    const raw = rawDirectProduct(input);
+    const known = new Set([...availableGuids, ...localGuids]);
+    const missing = new Set<string>();
+    for (const asset of raw.product.assets) {
+      for (const reference of asset.refs) {
+        if (!known.has(reference.guid.toLowerCase())) missing.add(reference.guid.toLowerCase());
+      }
+    }
+    if (missing.size > 0) return err(directReferenceFailure(input.sourcePath, [...missing]));
+    const finalized = await finalizePackageTransportSource(
+      projectImportProductForBuild(raw.product),
+      input.policy,
+    );
+    const facts = projectParameterizedPackPublication(raw);
+    if (!facts.ok) return facts;
+    const displaySourcePath = input.displaySourcePath ?? input.sourcePath;
+    const revision = await scriptablePackResourceRevision(displaySourcePath, raw.inputFingerprint, [
+      { path: input.sourcePath, digest: input.sourceRevision },
+    ]);
+    return ok({
+      projected: input.projected,
+      product: raw,
+      finalized,
+      facts: facts.value,
+      revision,
+    });
+  }
+  const definition = {
+    schemaVersion: '2.0.0' as const,
+    packageId: packageId.value,
+    build: () =>
+      ok(
+        Object.fromEntries(
+          input.projected.assets.map((asset) => [
+            asset.sourceKey,
+            {
+              ...((nativeDrafts.get(asset.guid.toLowerCase())?.payload as
+                | Record<string, unknown>
+                | undefined) ?? directAssetForProducer(asset)),
+              kind: asset.kind,
+            } as Asset,
+          ]),
+        ),
+      ),
+  } as AnyParameterizedPackDefinition;
+  const outputs = createStandardAssetOutputProducerRegistry();
+  outputs.register(createPreExternalizedSceneAssetOutputProducer());
+  const built = await buildParameterizedScriptablePack({
+    definition,
+    sourcePath: input.sourcePath,
+    outputs,
+    sourceClosure: [{ path: input.sourcePath, digest: input.sourceRevision }],
+    availableGuids,
+    deferReferenceValidation: true,
+  });
+  if (!built.ok) return built;
+  const declaredByGuid = new Map(
+    input.projected.assets.map((asset) => [asset.guid.toLowerCase(), asset.refs]),
+  );
+  const assets = built.value.product.assets.map((asset) => ({
+    ...asset,
+    ...(nativeDrafts.has(asset.guid.toLowerCase())
+      ? {
+          payload: nativeDrafts.get(asset.guid.toLowerCase())?.payload as Record<string, unknown>,
+          refs: mergeDirectReferences(
+            nativeRefs(nativeDrafts.get(asset.guid.toLowerCase())?.refs ?? []),
+            declaredByGuid.get(asset.guid.toLowerCase()) ?? [],
+          ),
+          artifacts: nativeDrafts.get(asset.guid.toLowerCase())?.artifacts ?? {},
+        }
+      : {
+          refs: mergeDirectReferences(
+            asset.refs,
+            declaredByGuid.get(asset.guid.toLowerCase()) ?? [],
+          ),
+        }),
+  }));
+  const missing = new Set<string>();
+  const known = new Set([...availableGuids, ...localGuids]);
+  for (const asset of assets) {
+    for (const reference of asset.refs) {
+      if (!known.has(reference.guid.toLowerCase())) missing.add(reference.guid.toLowerCase());
+    }
+  }
+  if (missing.size > 0) return err(directReferenceFailure(input.sourcePath, [...missing]));
+  const inputFingerprint = directInputFingerprint(built.value.inputFingerprint, nativeFingerprints);
+  const stagedOutputs = input.projected.assets.map((asset) => ({
+    guid: directGuid(asset.guid),
+    sourceKey: asset.sourceKey,
+    asset: directAssetForProducer(asset),
+    digest: `sha256:${packageTransportRevision({ kind: asset.kind, payload: asset.payload })}`,
+  }));
+  const product: ParameterizedScriptablePackBuildProduct = {
+    ...built.value,
+    inputFingerprint,
+    stagedOutputs,
+    product: {
+      ...built.value.product,
+      assets,
+      refs: assets.flatMap((asset) => asset.refs),
+      artifacts: importedAssetArtifacts(assets),
+      receipts: built.value.product.receipts.map((receipt) => ({
+        ...receipt,
+        inputFingerprint,
+      })),
+      sourceRevision: inputFingerprint,
+    },
+  };
+  const finalized = await finalizePackageTransportSource(
+    projectImportProductForBuild(product.product),
+    input.policy,
+  );
+  const facts = projectParameterizedPackPublication(product);
+  if (!facts.ok) return facts;
+  const displaySourcePath = input.displaySourcePath ?? input.sourcePath;
+  const revision = await scriptablePackResourceRevision(
+    displaySourcePath,
+    product.inputFingerprint,
+    [{ path: input.sourcePath, digest: input.sourceRevision }],
+  );
+  return ok({
+    projected: input.projected,
+    product,
+    finalized,
+    facts: facts.value,
+    revision,
+  });
+}
+
+/** Normalize one explicit Pack v2 transport and invoke its registered cookers once. */
+export async function prepareLegacyPackTransport(
+  authoredPack: LegacyPackInventoryDocument,
   cookers: readonly NativeCooker[] | undefined,
   policyFor: (guid: string) => PackageFinalizePolicy,
   sourcePath?: string,
-): Promise<AuthoredPackTransport> {
-  const pack = upgradeLegacyAuthoredPack(authoredPack);
-  const firstGuid = pack.assets?.[0]?.guid?.toLowerCase();
-  if (pack.schemaVersion !== '2.0.0' || firstGuid === undefined) {
-    return { pack, ...(firstGuid === undefined ? {} : { firstGuid }) };
+): Promise<LegacyPackTransport> {
+  const firstGuid = authoredPack.assets[0]?.guid?.toLowerCase();
+  if (authoredPack.schemaVersion !== '2.0.0' || firstGuid === undefined) {
+    return { pack: authoredPack, ...(firstGuid === undefined ? {} : { firstGuid }) };
   }
-  const cooked = await readCookedAuthoredPack(pack, cookers, sourcePath);
-  if (cooked === undefined) return { pack, firstGuid };
+  const cooked = await readCookedAuthoredPack(authoredPack, cookers, sourcePath);
+  if (cooked === undefined) return { pack: authoredPack, firstGuid };
   return {
-    pack,
+    pack: authoredPack,
     firstGuid,
     cooked,
     finalized: await finalizePackageTransportSource(cooked.logicalPackage, policyFor(firstGuid)),
   };
 }
 
-/** Project one produced ScriptablePack into the publication tuple shared by dev and build. */
-export function projectScriptablePackPublication(
-  product: ScriptableSourcePackageProduct,
+/** Materialize a dynamic Pack product through the same dev transport seam. */
+export async function materializePreparedParameterizedScriptablePack(
+  prepared: PreparedParameterizedScriptablePack,
+  paths: ScriptablePackTransportPaths,
+  sink: ScriptablePackTransportSink,
+): Promise<ReadonlyMap<string, string>> {
+  const { product, finalized } = prepared;
+  await sink.writePackage(paths.packagePath, JSON.stringify(finalized.pack));
+  for (const artifact of finalized.artifacts) {
+    await sink.writeArtifact(
+      paths.artifactPath(artifact.path),
+      artifact.bytes,
+      artifact.path.endsWith('.json') ? 'application/json' : artifact.mediaType,
+    );
+  }
+  const receipts = new Map<string, string>();
+  for (const asset of product.product.assets) {
+    const path = paths.receiptPath(asset.guid);
+    await sink.writeReceipt(
+      path,
+      JSON.stringify({
+        guid: asset.guid,
+        origin: 'sourceMeta',
+        status: 'succeeded',
+        inputFingerprint: product.inputFingerprint,
+        outputDigest: finalized.digest,
+      }),
+    );
+    receipts.set(asset.guid.toLowerCase(), path);
+  }
+  return receipts;
+}
+
+function projectParameterizedPackPublication(
+  product: ParameterizedScriptablePackBuildProduct,
 ): Result<ScriptablePackPublicationFacts, ScriptablePackDomainError> {
   const assets = new Map(product.product.assets.map((asset) => [asset.guid.toLowerCase(), asset]));
   const outputs: AssetPublicationOutput[] = [];
   for (const staged of product.stagedOutputs) {
     const guid = AssetGuid.format(staged.guid).toLowerCase();
     const asset = assets.get(guid);
-    if (asset === undefined || staged.digest === undefined) {
+    if (asset === undefined || staged.digest === undefined || staged.sourceKey === undefined) {
       return err({
         code: 'pack-source-output-invalid',
-        expected: `ScriptablePack publication output ${guid} to include a product and digest`,
-        hint: 'repair the ScriptablePack producer output and rebuild',
+        expected: `parameterized Pack 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 },
       });
     }
     outputs.push({
       guid,
-      sourceKey: staged.sourceKey ?? guid,
+      sourceKey: staged.sourceKey,
       kind: asset.kind,
       digest: staged.digest,
       refs: asset.refs.map((reference) => reference.guid),
@@ -390,154 +828,132 @@ export function projectScriptablePackPublication(
   });
 }
 
-/** Project the immutable module closure into the Catalog revision contract. */
-async function scriptablePackResourceRevision(
-  displaySourcePath: string,
-  digest: string,
-  sourceClosure: readonly ScriptablePackSourceClosureEntry[],
-): Promise<ResourceRevision> {
-  const observedAt = Math.trunc(
-    Math.max(
-      ...(await Promise.all(sourceClosure.map(async (entry) => (await stat(entry.path)).mtimeMs))),
-    ),
+function snapshotSourceForStagedOutputs(
+  outputs: readonly ScriptablePackStagedOutput[],
+): import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined {
+  if (outputs.length === 0) return undefined;
+  const byGuid = new Map(
+    outputs.map((output) => [AssetGuid.format(output.guid).toLowerCase(), output]),
   );
-  return { digest, observedAt, rootId: displaySourcePath };
+  return {
+    async readByGuid(guid) {
+      const key = AssetGuid.format(guid).toLowerCase();
+      const output = byGuid.get(key);
+      if (output === undefined) {
+        return err(
+          new AssetError({
+            code: 'asset-not-found',
+            expected: `an available Asset snapshot for ${key}`,
+            hint: 'publish the referenced Pack or repair the content dependency',
+          }),
+        );
+      }
+      return ok({
+        asset: structuredClone(output.asset),
+        generation: 1,
+        digest: output.digest ?? 'sha256:staged',
+      });
+    },
+  };
 }
 
-/** Produce selected ScriptablePacks through one inventory and one staged owner boundary. */
-export async function produceScriptablePackProducts(
-  sources: readonly ScriptablePackInput[],
-  declaredExternalOutputs: readonly ScriptablePackStagedOutput[] = [],
-): Promise<Result<ReadonlyMap<string, PreparedScriptablePack>, ScriptablePackHostError>> {
-  const entries = new Map<
-    string,
-    {
-      readonly source: ScriptablePackInput;
-      readonly definition: Readonly<ScriptablePackDefinition>;
-      readonly closure: readonly ScriptablePackSourceClosureEntry[];
-    }
-  >();
-  for (const source of sources) {
-    if (entries.has(source.displaySourcePath)) continue;
-    entries.set(source.displaySourcePath, {
-      source,
-      definition: source.definition,
-      closure: source.sourceClosure,
-    });
-  }
+function composeParameterizedAssetSource(
+  staged: import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined,
+  published: import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined,
+): import('./scriptable-pack.js').ScriptablePackAssetSnapshotSource | undefined {
+  if (staged === undefined) return published;
+  if (published === undefined) return staged;
+  return {
+    async readByGuid(guid) {
+      const local = await staged.readByGuid(guid);
+      if (local.ok || local.error.code !== 'asset-not-found') return local;
+      return published.readByGuid(guid);
+    },
+  };
+}
 
-  const products = new Map<string, ScriptableSourcePackageProduct>();
-  const owners: ScriptablePackStagedOwner[] = [...entries.entries()].map(
-    ([displaySourcePath, entry]) => ({
-      id: displaySourcePath,
-      guids: Object.values(entry.definition.assets).map((asset) => asset.guid),
-      async build(source) {
-        const produced = await produceScriptableSourcePackage({
-          definition: entry.definition,
-          sourcePath: displaySourcePath,
-          assetSource: source,
-          outputs: createStandardAssetOutputProducerRegistry(
-            projectScriptablePackSceneComponents(entry.definition.sceneComponents),
-          ),
-          sourceClosure: entry.closure,
-          authoringContractVersion: 'scriptable-pack-production/1',
-        });
-        if (!produced.ok) return produced;
-        const observedClosure = await inventoryScriptablePackSource(entry.source.sourcePath);
-        if (JSON.stringify(observedClosure) !== JSON.stringify(entry.closure)) {
-          return err({
-            code: 'pack-source-load-failed',
-            expected: 'the complete ScriptablePack module closure to remain fixed during one build',
-            hint: 'retry the build after source and helper writes have settled',
-            detail: {
-              sourcePath: displaySourcePath,
-              reason: 'source-changed',
-              phase: 'build',
-              diagnostic: 'module closure changed while the staged generation was building',
-            },
-          });
-        }
-        products.set(displaySourcePath, produced.value);
-        return ok(produced.value.stagedOutputs);
-      },
-    }),
+/**
+ * Build parameterized 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>> {
+  if (options.sources.length === 0) return ok(new Map());
+  const external = options.declaredExternalOutputs ?? [];
+  const assetSource = composeParameterizedAssetSource(
+    snapshotSourceForStagedOutputs(external),
+    options.assetSource,
   );
-  const generationDigest = createHash('sha256')
-    .update(
-      JSON.stringify(
-        [...entries.values()]
-          .flatMap((entry) => entry.closure)
-          .sort((a, b) => a.path.localeCompare(b.path)),
+  const availableGuids = new Set([
+    ...(options.availableGuids ?? []),
+    ...external.map((output) => AssetGuid.format(output.guid).toLowerCase()),
+  ]);
+  const workItems: ParameterizedScriptablePackWorkItem[] = options.sources.map((source) => ({
+    definition: source.definition,
+    sourcePath: source.sourcePath,
+    ...(source.subjectPackageId === undefined ? {} : { subjectPackageId: source.subjectPackageId }),
+    ...(source.values === undefined ? {} : { values: source.values }),
+    ...(source.inheritedValues === undefined ? {} : { inheritedValues: source.inheritedValues }),
+    sourceClosure: source.sourceClosure,
+  }));
+  const worklist = await buildParameterizedScriptablePackWorklist({
+    subjects: workItems,
+    outputs: createStandardAssetOutputProducerRegistry(
+      options.sources.flatMap((source) =>
+        projectScriptablePackSceneComponents(source.definition.sceneComponents),
       ),
-    )
-    .digest();
-  const stagedSource = createScriptablePackStagedAssetSnapshotSource({
-    generation: generationDigest.readUInt32BE(0),
-    owners,
-    declaredExternalOutputs,
+    ),
+    ...(assetSource === undefined ? {} : { assetSource }),
+    availableGuids,
+    ...(options.incomingRefs === undefined ? {} : { incomingRefs: options.incomingRefs }),
+    ...(options.maxPasses === undefined ? {} : { maxPasses: options.maxPasses }),
   });
+  if (!worklist.ok) return worklist;
 
-  const prepared = new Map<string, PreparedScriptablePack>();
-  for (const source of sources) {
-    const entry = entries.get(source.displaySourcePath);
-    if (entry === undefined) {
-      return err({
-        code: 'pack-source-path-invalid',
-        expected: 'a ScriptablePack source registered in the current inventory',
-        actual: source.displaySourcePath,
-        hint: 'rebuild the source inventory before producing this path',
-        retryable: true,
-        recoveryActions: ['rebuild-source-inventory'],
-        detail: { sourcePath: source.displaySourcePath },
-      });
-    }
-    const first = Object.values(entry.definition.assets)[0];
-    if (first === undefined) {
-      return err({
-        code: 'pack-source-output-invalid',
-        expected: 'at least one declared ScriptablePack output',
-        hint: 'add an output descriptor before building the package',
-        detail: { missingGuids: [], unexpectedSourceKeys: [], kindMismatches: [] },
-      });
-    }
-    const staged = await stagedSource.readByGuid(first.guid);
-    if (!staged.ok) return err(staged.error);
-    const produced = products.get(source.displaySourcePath);
-    if (produced === undefined) {
+  const productsBySource = new Map(
+    worklist.value.buildProducts
+      .filter((product) => product.product.sourceKey !== undefined)
+      .map((product) => [product.product.sourceKey as string, product]),
+  );
+  const prepared = new Map<string, PreparedParameterizedScriptablePack>();
+  for (const source of options.sources) {
+    const product = productsBySource.get(source.sourcePath);
+    if (product === undefined) {
       return err({
         code: 'pack-source-output-invalid',
-        expected: 'the staged owner build to retain its source-package product',
-        hint: 'retry the ScriptablePack production attempt',
-        detail: {
-          missingGuids: [AssetGuid.format(first.guid)],
-          unexpectedSourceKeys: [],
-          kindMismatches: [],
-        },
+        expected: 'one terminal dynamic Pack product for every source subject',
+        hint: 'rerun the bounded generation worklist and inspect its subject map',
+        detail: { sourcePath: source.sourcePath },
       });
     }
-    const transportPolicy =
-      typeof source.policy === 'function' ? source.policy(produced) : source.policy;
-    const logicalPackage = projectImportProductForBuild(produced.product);
-    const finalized = await finalizePackageTransportSource(logicalPackage, transportPolicy);
-    const facts = projectScriptablePackPublication(produced);
-    if (!facts.ok) return err(facts.error);
+    const policy = typeof source.policy === 'function' ? source.policy(product) : source.policy;
+    const finalized = await finalizePackageTransportSource(
+      projectImportProductForBuild(product.product),
+      policy,
+    );
+    const facts = projectParameterizedPackPublication(product);
+    if (!facts.ok) return facts;
     const revision = await scriptablePackResourceRevision(
       source.displaySourcePath,
-      produced.inputFingerprint,
+      product.inputFingerprint,
       source.sourceClosure,
     );
     const publication = createAcceptedPublication({
       sourcePath: source.displaySourcePath,
-      sourceRevision: produced.inputFingerprint,
+      sourceRevision: product.inputFingerprint,
       generation: source.publicationGeneration,
       digest: finalized.digest,
       packageUrl: finalized.packageUrl,
-      inputFingerprint: produced.inputFingerprint,
+      inputFingerprint: product.inputFingerprint,
       outputs: facts.value.outputs,
-      externalEvidence: produced.externalEvidence,
+      externalEvidence: product.externalEvidence,
     });
     prepared.set(source.displaySourcePath, {
-      product: produced,
+      product: {
+        ...product,
+      },
       finalized,
       facts: facts.value,
       revision,
@@ -546,3 +962,34 @@ export async function produceScriptablePackProducts(
   }
   return ok(prepared);
 }
+
+/** Project the immutable module closure into the Catalog revision contract. */
+async function scriptablePackResourceRevision(
+  displaySourcePath: string,
+  digest: string,
+  sourceClosure: readonly ScriptablePackSourceClosureEntry[],
+): Promise<ResourceRevision> {
+  const mtimes = await Promise.all(
+    sourceClosure.map(async (entry) => {
+      try {
+        return (await stat(entry.path)).mtimeMs;
+      } catch (error) {
+        // Direct Pack declarations may be supplied with a logical source path
+        // and sourceText rather than a file-backed module. The digest remains
+        // the authoritative revision in that case; preserve filesystem errors
+        // other than a missing path so real source failures stay visible.
+        if (
+          error !== null &&
+          typeof error === 'object' &&
+          'code' in error &&
+          (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+        ) {
+          return 0;
+        }
+        throw error;
+      }
+    }),
+  );
+  const observedAt = mtimes.length === 0 ? 0 : Math.trunc(Math.max(...mtimes));
+  return { digest, observedAt, rootId: displaySourcePath };
+}