@forgeax/engine-import 0.1.23 → 0.1.25

package/dist/index.mjs

@@ -3,20 +3,21 @@ export { IMPORT_ERROR_HINTS, ImportError } from '@forgeax/engine-types';
 import { resolve, dirname, isAbsolute, relative } from 'path';
 import { resolveAssetSource, finalizePackageTransportSource, packageTransportRevision, catalogSourcePathFor, buildCatalogProjection, projectPackageCatalog, createRuntimePackPublication, metaPathForGuid } from '@forgeax/engine-pack/build';
 import { AssetGuid as AssetGuid$1, PackageId as PackageId$1 } from '@forgeax/engine-pack/guid';
-import { resolvePackParameterValues, PackageId, isValidPackSourceKey, AssetGuid, parseParameterizedPackJson, projectDirectPackJson, isScriptablePackAssetKind, projectScriptablePackSceneComponents, resolvePackParameterInheritance } from '@forgeax/engine-pack/source';
-import { loadParameterizedScriptablePack } from '@forgeax/engine-pack/source-node';
+import { resolvePackParameterValues, PackageId, isValidPackSourceKey, AssetGuid, parsePackSourceJson, projectDirectPackJson, isScriptablePackAssetKind, projectScriptablePackSceneComponents, resolvePackParameterInheritance } from '@forgeax/engine-pack/source';
+import { loadScriptablePack } from '@forgeax/engine-pack/source-node';
 import { stat, readFile, mkdir, writeFile, rename, rm, readdir } from 'fs/promises';
-import { createAcceptedPublication, ddcOutputDigest, DdcGenerationSession, DdcLifecycle } from '@forgeax/engine-ddc';
+import { createAcceptedPublication, ddcOutputDigest, DdcLifecycle, DdcGenerationSession } from '@forgeax/engine-ddc';
 import { deriveVertexLayoutProjection, normalizeMeshPayload } from '@forgeax/engine-geometry';
 import { BUILTIN_MESH_ASSETS } from '@forgeax/engine-pack/builtin';
 import { NativeCookerRegistry } from '@forgeax/engine-pack/native-cooker';
-import { isEngineMaterial } from '@forgeax/engine-shader';
+import { isEngineMaterial, DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
 import { externalizeSceneAsset } from '@forgeax/engine-scene';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { bytesToHex } from '@noble/hashes/utils.js';
 import { MESH_BIN_HEADER_V4_BYTES, writeMeshBinHeader } from '@forgeax/engine-pack/mesh-bin-contract';
-import { randomUUID, createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { validatePack, isScriptablePackAssetKind as isScriptablePackAssetKind$1 } from '@forgeax/engine-pack';
+import { canonicalDdcJson } from '@forgeax/engine-ddc/key';
 
 // src/index.ts
 function invalidProduct(field) {
@@ -784,6 +785,14 @@ function record(value) {
 function isAsset(value) {
   return record(value) && typeof value.kind === "string" && isScriptablePackAssetKind(value.kind);
 }
+function needsMaterialCook(asset) {
+  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 !== void 0 && 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(value) {
   return structuredClone(value);
 }
@@ -923,7 +932,7 @@ function errorCode(value) {
 function normalizedGuidSet(value) {
   return value === void 0 ? void 0 : new Set([...value].map((guid) => guid.toLowerCase()));
 }
-async function buildParameterizedScriptablePack(options) {
+async function buildScriptablePack(options) {
   const subjectPackageId = options.subjectPackageId ?? options.definition.packageId;
   const availableGuids = normalizedGuidSet(options.availableGuids);
   const observed = observedReader(options.assetSource);
@@ -947,8 +956,8 @@ async function buildParameterizedScriptablePack(options) {
     );
   } else if (options.subjectPackageId !== void 0 && PackageId.format(options.subjectPackageId).toLowerCase() !== 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,
@@ -1008,6 +1017,9 @@ async function buildParameterizedScriptablePack(options) {
   const imported = [];
   const stagedOutputs = [];
   const localGuids = /* @__PURE__ */ new Set();
+  const materialCookerRegistry = new NativeCookerRegistry();
+  for (const cooker of options.cookers ?? []) materialCookerRegistry.register(cooker);
+  const nativeFingerprints = /* @__PURE__ */ new Map();
   for (const sourceKey of Object.keys(built.value).sort()) {
     if (!isValidPackSourceKey(sourceKey))
       return err(sourceKeyFailure(options.sourcePath, sourceKey));
@@ -1083,12 +1095,40 @@ async function buildParameterizedScriptablePack(options) {
     const invalidProduct2 = productError(options.sourcePath, sourceKey, producer, produced.value);
     if (invalidProduct2 !== void 0) return err(invalidProduct2);
     const product2 = produced.value;
+    let payload = product2.payload;
+    let artifacts2 = product2.artifacts;
+    if (needsMaterialCook(asset) && materialCookerRegistry.get("material") !== void 0) {
+      const cooked = await materialCookerRegistry.runDraft("material", {
+        guid,
+        source: asset,
+        sourceKey,
+        sourcePath: options.sourcePath,
+        refs: product2.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;
+      artifacts2 = cooked.value.artifacts;
+      nativeFingerprints.set(sourceKey, cooked.value.inputFingerprint);
+    }
     imported.push({
       guid,
       kind: asset.kind,
-      payload: product2.payload,
+      payload,
       refs: product2.refs,
-      artifacts: product2.artifacts
+      artifacts: artifacts2
     });
     stagedOutputs.push({
       guid: AssetGuid.derive(subjectPackageId, sourceKey),
@@ -1119,7 +1159,7 @@ async function buildParameterizedScriptablePack(options) {
       digest: read.digest
     })
   );
-  const inputFingerprint = await digest({
+  const authoredInputFingerprint = await digest({
     packageId: PackageId.format(subjectPackageId),
     sourcePath: options.sourcePath,
     sourceClosure: options.sourceClosure ?? [],
@@ -1129,9 +1169,15 @@ async function buildParameterizedScriptablePack(options) {
       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(
@@ -1186,7 +1232,7 @@ function stagedSource(staged, fallback) {
     }
   };
 }
-async function buildParameterizedScriptablePackWorklist(options) {
+async function buildScriptablePackWorklist(options) {
   const orderedSubjects = [...options.subjects].sort(
     (left, right) => left.sourcePath.localeCompare(right.sourcePath)
   );
@@ -1205,7 +1251,7 @@ async function buildParameterizedScriptablePackWorklist(options) {
     let progress = false;
     const waiting = /* @__PURE__ */ new Set();
     for (const [key, subject] of pending) {
-      const result = await buildParameterizedScriptablePack({
+      const result = await buildScriptablePack({
         definition: subject.definition,
         sourcePath: subject.sourcePath,
         ...subject.subjectPackageId === void 0 ? {} : { subjectPackageId: subject.subjectPackageId },
@@ -1213,6 +1259,7 @@ async function buildParameterizedScriptablePackWorklist(options) {
         ...subject.inheritedValues === void 0 ? {} : { inheritedValues: subject.inheritedValues },
         ...subject.sourceClosure === void 0 ? {} : { sourceClosure: subject.sourceClosure },
         outputs: options.outputs,
+        ...options.cookers === void 0 ? {} : { cookers: options.cookers },
         assetSource: stagedSource(staged, options.assetSource),
         availableGuids: /* @__PURE__ */ new Set([...availableGuids, ...staged.keys()]),
         deferReferenceValidation: true
@@ -2113,7 +2160,7 @@ async function declaredPackExternalOutputs(declarations, cookers = [], requiredG
     }
     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;
@@ -2190,6 +2237,8 @@ async function readCookedAuthoredPack(authoredPack, cookers = [], sourcePath) {
       continue;
     }
     if (isEngineOwnedMaterial(asset)) {
+      hasCookedAsset = true;
+      refsByGuid.set(asset.guid.toLowerCase(), [...asset.refs]);
       assets.push({
         guid: asset.guid,
         kind: asset.kind,
@@ -2432,7 +2481,7 @@ async function prepareDirectPackTransport(input) {
       projectImportProductForBuild(raw.product),
       input.policy
     );
-    const facts2 = projectParameterizedPackPublication(raw);
+    const facts2 = projectScriptablePackPublication(raw);
     if (!facts2.ok) return facts2;
     const displaySourcePath2 = input.displaySourcePath ?? input.sourcePath;
     const revision2 = await scriptablePackResourceRevision(displaySourcePath2, raw.inputFingerprint, [
@@ -2463,7 +2512,7 @@ async function prepareDirectPackTransport(input) {
   };
   const outputs = createStandardAssetOutputProducerRegistry();
   outputs.register(createPreExternalizedSceneAssetOutputProducer());
-  const built = await buildParameterizedScriptablePack({
+  const built = await buildScriptablePack({
     definition,
     sourcePath: input.sourcePath,
     outputs,
@@ -2526,7 +2575,7 @@ async function prepareDirectPackTransport(input) {
     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(
@@ -2556,7 +2605,7 @@ async function prepareLegacyPackTransport(authoredPack, cookers, policyFor, sour
     finalized: await finalizePackageTransportSource(cooked.logicalPackage, policyFor(firstGuid))
   };
 }
-async function materializePreparedParameterizedScriptablePack(prepared, paths, sink) {
+async function materializePreparedScriptablePack(prepared, paths, sink) {
   const { product, finalized } = prepared;
   await sink.writePackage(paths.packagePath, JSON.stringify(finalized.pack));
   for (const artifact of finalized.artifacts) {
@@ -2583,7 +2632,7 @@ async function materializePreparedParameterizedScriptablePack(prepared, paths, s
   }
   return receipts;
 }
-function projectParameterizedPackPublication(product) {
+function projectScriptablePackPublication(product) {
   const assets = new Map(product.product.assets.map((asset) => [asset.guid.toLowerCase(), asset]));
   const outputs = [];
   for (const staged of product.stagedOutputs) {
@@ -2592,7 +2641,7 @@ function projectParameterizedPackPublication(product) {
     if (asset === void 0 || staged.digest === void 0 || staged.sourceKey === void 0) {
       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 }
       });
@@ -2641,7 +2690,7 @@ function snapshotSourceForStagedOutputs(outputs) {
     }
   };
 }
-function composeParameterizedAssetSource(staged, published) {
+function composeScriptablePackAssetSource(staged, published) {
   if (staged === void 0) return published;
   if (published === void 0) return staged;
   return {
@@ -2652,10 +2701,10 @@ function composeParameterizedAssetSource(staged, published) {
     }
   };
 }
-async function produceParameterizedScriptablePackProducts(options) {
+async function produceScriptablePackProducts(options) {
   if (options.sources.length === 0) return ok(/* @__PURE__ */ new Map());
   const external = options.declaredExternalOutputs ?? [];
-  const assetSource = composeParameterizedAssetSource(
+  const assetSource = composeScriptablePackAssetSource(
     snapshotSourceForStagedOutputs(external),
     options.assetSource
   );
@@ -2671,13 +2720,14 @@ async function produceParameterizedScriptablePackProducts(options) {
     ...source.inheritedValues === void 0 ? {} : { 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 === void 0 ? {} : { cookers: options.cookers },
     ...assetSource === void 0 ? {} : { assetSource },
     availableGuids,
     ...options.incomingRefs === void 0 ? {} : { incomingRefs: options.incomingRefs },
@@ -2703,7 +2753,7 @@ async function produceParameterizedScriptablePackProducts(options) {
       projectImportProductForBuild(product.product),
       policy
     );
-    const facts = projectParameterizedPackPublication(product);
+    const facts = projectScriptablePackPublication(product);
     if (!facts.ok) return facts;
     const revision = await scriptablePackResourceRevision(
       source.displaySourcePath,
@@ -2801,21 +2851,21 @@ function dynamicFailure(context, value) {
   const candidate = value !== null && typeof value === "object" ? value : {};
   const error = candidate;
   throw context.fail({
-    code: typeof error.code === "string" ? error.code : "parameterized-pack-build-failed",
-    expected: typeof error.expected === "string" ? error.expected : "the parameterized Pack generation to produce a valid terminal result",
-    hint: typeof error.hint === "string" ? error.hint : "inspect the parameterized Pack subject and rebuild the current generation",
+    code: typeof error.code === "string" ? error.code : "pack-build-failed",
+    expected: typeof error.expected === "string" ? error.expected : "the Pack source generation to produce a valid terminal result",
+    hint: typeof error.hint === "string" ? error.hint : "inspect the Pack source subject and rebuild the current generation",
     ...error.detail === void 0 ? {} : { detail: error.detail }
   });
 }
-function parameterizedCatalogSourcePath(context, sourcePath) {
+function packCatalogSourcePath(context, sourcePath) {
   const projected = context.fsForImport.sourceIdentityFor?.(sourcePath);
   const logical = projected === void 0 || isAbsolute(projected) ? relative(context.cwd, sourcePath) : projected;
   return canonicalScriptableSourcePath(logical).replaceAll("\\", "/");
 }
-async function buildParameterizedPackages(context) {
+async function buildPackSources(context) {
   const subjects = /* @__PURE__ */ new Map();
   for (const [sourcePath, declaration] of context.inventory.sourceDeclarations) {
-    if (declaration.format === "pack.ts-parameterized") {
+    if (declaration.format === "pack.ts") {
       const key = PackageId.format(declaration.definition.packageId).toLowerCase();
       subjects.set(key, {
         kind: "source",
@@ -2829,7 +2879,7 @@ async function buildParameterizedPackages(context) {
     if (declaration.format !== "pack.json" || declaration.value.schemaVersion !== "3.0.0") {
       continue;
     }
-    const parsed = parseParameterizedPackJson(declaration.value);
+    const parsed = parsePackSourceJson(declaration.value);
     if (!parsed.ok) dynamicFailure(context, parsed.error);
     if (parsed.value.format === "direct") {
       subjects.set(PackageId.format(parsed.value.packageId).toLowerCase(), {
@@ -2881,12 +2931,12 @@ async function buildParameterizedPackages(context) {
   for (const subject of orderedSubjects) {
     if (subject.kind === "source") {
       const packageId = PackageId.format(subject.packageId);
-      const loaded = await loadParameterizedScriptablePack(subject.sourcePath);
+      const loaded = await loadScriptablePack(subject.sourcePath);
       if (!loaded.ok) dynamicFailure(context, loaded.error);
       if (PackageId.format(loaded.value.packageId) !== packageId) {
         dynamicFailure(context, {
           code: "pack-source-revision-conflict",
-          expected: "the parameterized source packageId to remain fixed during production",
+          expected: "the ScriptablePack source packageId to remain fixed during production",
           hint: "retry after source writes settle and rebuild the current generation",
           detail: {
             sourcePath: subject.sourcePath,
@@ -2897,7 +2947,7 @@ async function buildParameterizedPackages(context) {
       }
       inputs.push({
         sourcePath: subject.sourcePath,
-        displaySourcePath: parameterizedCatalogSourcePath(context, subject.sourcePath),
+        displaySourcePath: packCatalogSourcePath(context, subject.sourcePath),
         definition: loaded.value,
         sourceClosure: subject.sourceClosure,
         publicationGeneration: context.generation,
@@ -2924,18 +2974,18 @@ async function buildParameterizedPackages(context) {
     const root = sourceSubject(resolved.value.rootPackageId);
     if (root === void 0) {
       dynamicFailure(context, {
-        code: "pack-parent-not-parameterized",
-        expected: "the instance parent chain to terminate at a parameterized source",
-        hint: "point the instance at a parameterized pack.ts source",
+        code: "pack-parent-has-no-parameters",
+        expected: "the instance parent chain to terminate at a ScriptablePack source",
+        hint: "point the instance at a ScriptablePack *.pack.ts source with parameters",
         detail: { packageId: PackageId.format(subject.packageId) }
       });
     }
-    const loaded = await loadParameterizedScriptablePack(root.sourcePath);
+    const loaded = await loadScriptablePack(root.sourcePath);
     if (!loaded.ok) dynamicFailure(context, loaded.error);
     if (PackageId.format(loaded.value.packageId) !== PackageId.format(root.packageId)) {
       dynamicFailure(context, {
         code: "pack-source-revision-conflict",
-        expected: "the parameterized parent packageId to remain fixed during production",
+        expected: "the ScriptablePack parent packageId to remain fixed during production",
         hint: "retry after source writes settle and rebuild the current generation",
         detail: {
           sourcePath: root.sourcePath,
@@ -2947,7 +2997,7 @@ async function buildParameterizedPackages(context) {
     const packageId = PackageId.format(subject.packageId);
     inputs.push({
       sourcePath: subject.sourcePath,
-      displaySourcePath: parameterizedCatalogSourcePath(context, subject.sourcePath),
+      displaySourcePath: packCatalogSourcePath(context, subject.sourcePath),
       definition: loaded.value,
       sourceClosure: root.sourceClosure,
       subjectPackageId: subject.packageId,
@@ -2976,9 +3026,10 @@ async function buildParameterizedPackages(context) {
     }
   );
   const availableGuids = new Set(requiredGuids.map((guid) => AssetGuid$1.format(guid).toLowerCase()));
-  const built = await produceParameterizedScriptablePackProducts({
+  const built = await produceScriptablePackProducts({
     sources: inputs,
     declaredExternalOutputs: externalOutputs,
+    cookers: context.cookers,
     availableGuids
   });
   if (!built.ok) dynamicFailure(context, built.error);
@@ -2987,9 +3038,9 @@ async function buildParameterizedPackages(context) {
     const prepared = built.value.get(input.displaySourcePath);
     if (prepared === void 0) {
       dynamicFailure(context, {
-        code: "parameterized-pack-build-failed",
+        code: "pack-build-failed",
         expected: "the worklist to return one prepared result per source subject",
-        hint: "rerun the parameterized Pack generation from a clean inventory",
+        hint: "rerun Pack source generation from a clean inventory",
         detail: { sourcePath: input.sourcePath }
       });
     }
@@ -3105,13 +3156,13 @@ async function emitAuthoredPack(work, guidSeen, entry, availableGuids) {
     });
   }
   if (declaration.value.schemaVersion === "3.0.0") {
-    const parsed = parseParameterizedPackJson(declaration.value);
+    const parsed = parsePackSourceJson(declaration.value);
     if (!parsed.ok) dynamicFailure(work.context, parsed.error);
     if (parsed.value.format !== "direct") {
       dynamicFailure(work.context, {
         code: "catalog-declaration-missing",
         expected: "a direct v3 Pack declaration for an indexed authored output",
-        hint: "instances are built from their parameterized parent and do not have direct Catalog rows",
+        hint: "instances are built from their ScriptablePack parent and do not have direct Catalog rows",
         detail: { stage: "scan", sourcePath: packPath }
       });
     }
@@ -3210,7 +3261,7 @@ async function emitAuthoredPack(work, guidSeen, entry, availableGuids) {
     guidSeen.add(guid.toLowerCase());
   }
 }
-async function emitParameterizedPack(work, guidSeen, bundle) {
+async function emitScriptablePack(work, guidSeen, bundle) {
   const { input, prepared } = bundle;
   const packageId = PackageId.format(input.subjectPackageId ?? input.definition.packageId);
   const runtimePublication = createRuntimePackPublication({
@@ -3385,7 +3436,7 @@ async function emitBuildEntry(work, guidSeen, entry, availableGuids) {
   });
 }
 async function produceBuildAssets(context) {
-  const dynamicBundles = await buildParameterizedPackages(context);
+  const dynamicBundles = await buildPackSources(context);
   const entries = [
     ...context.inventory.entries,
     ...dynamicBundles.flatMap((bundle) => bundle.entries)
@@ -3395,7 +3446,7 @@ async function produceBuildAssets(context) {
   const guidSeen = /* @__PURE__ */ new Set();
   const work = { importedEntries, context };
   for (const bundle of dynamicBundles) {
-    await emitParameterizedPack(work, guidSeen, bundle);
+    await emitScriptablePack(work, guidSeen, bundle);
   }
   for (const entry of importedEntries) {
     if (!guidSeen.has(entry.guid.toLowerCase()))
@@ -4318,6 +4369,176 @@ function importPublicationFailure(error) {
     diagnostic: error
   };
 }
+function publicationArtifacts(transport) {
+  return Object.fromEntries(
+    (transport?.artifacts ?? []).map((artifact) => [
+      artifact.path,
+      { mediaType: artifact.mediaType, bytes: artifact.bytes }
+    ])
+  );
+}
+function publicationContext(input) {
+  return {
+    sourceMeta: "<import-publication>",
+    anchorGuid: input.guid,
+    affectedGuids: input.publishedGuids,
+    producer: "source-package/import-publication",
+    importer: "import-publication"
+  };
+}
+function validatePublicationArtifactClosure(input) {
+  const context = publicationContext(input);
+  const pack = input.pack;
+  if (pack === null || typeof pack !== "object" || pack.schemaVersion !== "2.0.0" || pack.kind !== "internal-text-package") {
+    return ok(publicationArtifacts(input.transport));
+  }
+  const assets = pack.assets;
+  if (!Array.isArray(assets)) {
+    return err(
+      sourcePackageError("source-package-publication-invalid", context, {
+        stage: "route-integrity",
+        reason: "published Pack does not contain an assets array"
+      })
+    );
+  }
+  const required = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    if (asset === null || typeof asset !== "object") {
+      return err(
+        sourcePackageError("source-package-publication-invalid", context, {
+          stage: "route-integrity",
+          reason: "published Pack contains a non-object asset row"
+        })
+      );
+    }
+    const rawArtifacts = asset.artifacts;
+    if (rawArtifacts === void 0) continue;
+    if (rawArtifacts === null || typeof rawArtifacts !== "object" || Array.isArray(rawArtifacts)) {
+      return err(
+        sourcePackageError("source-package-publication-invalid", context, {
+          stage: "route-integrity",
+          reason: "published Pack contains an invalid asset artifact map"
+        })
+      );
+    }
+    for (const [localKey, rawDescriptor] of Object.entries(
+      rawArtifacts
+    )) {
+      if (rawDescriptor === null || typeof rawDescriptor !== "object") {
+        return err(
+          sourcePackageError("source-package-publication-invalid", context, {
+            stage: "route-integrity",
+            reason: `artifact descriptor ${localKey} is not an object`
+          })
+        );
+      }
+      const descriptor = rawDescriptor;
+      const path = descriptor.path;
+      if (typeof path !== "string" || path.length === 0) {
+        return err(
+          sourcePackageError("source-package-publication-invalid", context, {
+            stage: "route-integrity",
+            reason: `artifact descriptor ${localKey} has no package-relative path`
+          })
+        );
+      }
+      const mediaType = descriptor.mediaType;
+      const byteLength = descriptor.byteLength;
+      const integrityValue = descriptor.integrity;
+      const integrity = integrityValue !== null && typeof integrityValue === "object" ? {
+        algorithm: integrityValue.algorithm,
+        digest: integrityValue.digest
+      } : void 0;
+      if (mediaType !== void 0 && typeof mediaType !== "string" || byteLength !== void 0 && (!Number.isSafeInteger(byteLength) || byteLength < 0) || integrityValue !== void 0 && (integrity === void 0 || typeof integrity.algorithm !== "string" || typeof integrity.digest !== "string")) {
+        return err(
+          sourcePackageError("source-package-publication-invalid", context, {
+            stage: "route-integrity",
+            reason: `artifact descriptor ${path} has invalid metadata`
+          })
+        );
+      }
+      if (required.has(path)) {
+        return err(
+          sourcePackageError("source-package-publication-invalid", context, {
+            stage: "route-integrity",
+            reason: `artifact path ${path} is declared more than once`
+          })
+        );
+      }
+      required.set(path, {
+        ...typeof mediaType === "string" ? { mediaType } : {},
+        ...typeof byteLength === "number" ? { byteLength } : {},
+        ...integrity !== void 0 && typeof integrity.algorithm === "string" && typeof integrity.digest === "string" ? { integrity: { algorithm: integrity.algorithm, digest: integrity.digest } } : {}
+      });
+    }
+  }
+  const available = /* @__PURE__ */ new Map();
+  const duplicatePaths = [];
+  for (const artifact of input.transport?.artifacts ?? []) {
+    if (available.has(artifact.path)) duplicatePaths.push(artifact.path);
+    available.set(artifact.path, artifact);
+  }
+  const missing = [];
+  const mismatched = [...duplicatePaths.map((path) => `${path}: duplicate body`)];
+  for (const path of available.keys()) {
+    if (!required.has(path)) mismatched.push(`${path}: unexpected body`);
+  }
+  for (const [path, descriptor] of required) {
+    const artifact = available.get(path);
+    if (artifact === void 0) {
+      missing.push(path);
+      continue;
+    }
+    if (!(artifact.bytes instanceof Uint8Array)) {
+      mismatched.push(`${path}: body is not Uint8Array`);
+      continue;
+    }
+    if (descriptor.mediaType !== void 0 && artifact.mediaType !== descriptor.mediaType) {
+      mismatched.push(`${path}: media type mismatch`);
+    }
+    if (descriptor.byteLength !== void 0 && artifact.bytes.byteLength !== descriptor.byteLength) {
+      mismatched.push(`${path}: byte length mismatch`);
+    }
+    if (descriptor.integrity !== void 0) {
+      const actualDigest = `sha256:${createHash("sha256").update(artifact.bytes).digest("hex")}`;
+      if (descriptor.integrity.algorithm !== "sha256" || descriptor.integrity.digest !== actualDigest) {
+        mismatched.push(`${path}: integrity mismatch`);
+      }
+    }
+  }
+  if (missing.length > 0 || mismatched.length > 0) {
+    return err(
+      sourcePackageError("source-package-publication-invalid", context, {
+        stage: "route-integrity",
+        reason: "Pack artifact closure is incomplete or mismatched",
+        ...missing.length === 0 ? {} : { missing },
+        ...mismatched.length === 0 ? {} : { unexpected: mismatched }
+      })
+    );
+  }
+  if (input.transport !== void 0) {
+    let transportedPack;
+    try {
+      transportedPack = JSON.parse(input.transport.body);
+    } catch {
+      return err(
+        sourcePackageError("source-package-publication-invalid", context, {
+          stage: "route-integrity",
+          reason: "transport body is not valid JSON for the published Pack"
+        })
+      );
+    }
+    if (canonicalDdcJson(transportedPack) !== canonicalDdcJson(pack)) {
+      return err(
+        sourcePackageError("source-package-publication-invalid", context, {
+          stage: "route-integrity",
+          reason: "transport body does not match the published Pack"
+        })
+      );
+    }
+  }
+  return ok(publicationArtifacts(input.transport));
+}
 function projectImportPublication(input, head, observedAt) {
   const digest3 = head.currentKey ?? input.desiredKey;
   const revision = { digest: digest3, observedAt, rootId: input.root };
@@ -4345,6 +4566,15 @@ async function publishImportPublication(input) {
   return commitImportPublication(staged.candidate);
 }
 async function stageImportPublication(input) {
+  const validatedArtifacts = validatePublicationArtifactClosure(input);
+  if (!validatedArtifacts.ok) {
+    return {
+      ok: false,
+      error: importPublicationFailure(validatedArtifacts.error),
+      head: await inspectHead(input.root, input.guid, input.desiredKey)
+    };
+  }
+  const artifacts = validatedArtifacts.value;
   const staged = await stageSourcePackageDdc({
     root: input.root,
     entry: {
@@ -4352,7 +4582,7 @@ async function stageImportPublication(input) {
       guid: input.guid,
       payload: input.pack,
       refs: [],
-      artifacts: {},
+      artifacts,
       receipt: {
         guid: input.guid,
         key: input.desiredKey,
@@ -4362,17 +4592,11 @@ async function stageImportPublication(input) {
           guid: input.guid,
           payload: input.pack,
           refs: [],
-          artifacts: {}
+          artifacts
         })
       }
     },
-    context: {
-      sourceMeta: "<import-publication>",
-      anchorGuid: input.guid,
-      affectedGuids: input.publishedGuids,
-      producer: "source-package/import-publication",
-      importer: "import-publication"
-    }
+    context: publicationContext(input)
   });
   if (!staged.ok) {
     return {
@@ -4460,6 +4684,6 @@ async function restoreImportPublication(candidate) {
   await candidate.ddc.session.restoreEntry(candidate.ddc);
 }
 
-export { AssetOutputProducerRegistry, DEFAULT_CATALOG_IMPORTER_KEYS, ImporterRegistry, SHADER_RESERVED_IMPORTER_KEY, buildCatalogResult, buildParameterizedScriptablePack, buildParameterizedScriptablePackWorklist, canonicalScriptableSourcePath, catalogImporterPolicy, commitImportPublication, containsSourcePackageError, createImportProduct, createPreExternalizedSceneAssetOutputProducer, createSceneAssetOutputProducer, createScriptablePackFileAssetSnapshotSource, createScriptablePackStagedAssetSnapshotSource, createStandardAssetOutputProducerRegistry, declaredPackExternalOutputs, deriveDefaultLodScreenCoverages, discardImportPublication, finalizeImportProducts, finalizeSourcePackage, iesImporter, materialAssetOutputProducer, materializePreparedParameterizedScriptablePack, meshAssetOutputProducer, normaliseForPack, normalizeSourcePackageError, packMeshBinV4, parseLm63TypeC, parseProducerReadiness, prepareDirectPackTransport, prepareLegacyPackTransport, produceBuildAssets, produceParameterizedScriptablePackProducts, produceSourcePackage, projectImportProductForBuild, publishImportPublication, readCookedAuthoredPack, readFloat16LE, reconcileMeshLodMeta, resampleTypeC, restoreImportPublication, runImport, sourceDeclarationForCatalogPath, sourcePackageAssetsByGuid, sourcePackageError, stageImportPublication, textureAssetOutputProducer, validateIesProfilePayload, validateMeshLodContract };
+export { AssetOutputProducerRegistry, DEFAULT_CATALOG_IMPORTER_KEYS, ImporterRegistry, SHADER_RESERVED_IMPORTER_KEY, buildCatalogResult, buildScriptablePack, buildScriptablePackWorklist, canonicalScriptableSourcePath, catalogImporterPolicy, commitImportPublication, containsSourcePackageError, createImportProduct, createPreExternalizedSceneAssetOutputProducer, createSceneAssetOutputProducer, createScriptablePackFileAssetSnapshotSource, createScriptablePackStagedAssetSnapshotSource, createStandardAssetOutputProducerRegistry, declaredPackExternalOutputs, deriveDefaultLodScreenCoverages, discardImportPublication, finalizeImportProducts, finalizeSourcePackage, iesImporter, materialAssetOutputProducer, materializePreparedScriptablePack, meshAssetOutputProducer, normaliseForPack, normalizeSourcePackageError, packMeshBinV4, parseLm63TypeC, parseProducerReadiness, prepareDirectPackTransport, prepareLegacyPackTransport, produceBuildAssets, produceScriptablePackProducts, produceSourcePackage, projectImportProductForBuild, publishImportPublication, readCookedAuthoredPack, readFloat16LE, reconcileMeshLodMeta, resampleTypeC, restoreImportPublication, runImport, sourceDeclarationForCatalogPath, sourcePackageAssetsByGuid, sourcePackageError, stageImportPublication, textureAssetOutputProducer, validateIesProfilePayload, validateMeshLodContract };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map