@forgeax/engine-import 0.1.21 → 0.1.24

package/dist/index.mjs

@@ -1,20 +1,23 @@
-import { ok, validateSourceOverrideMap, ImportError, IMPORT_ERROR_HINTS, canonicalizeSourceOverrides, err, AssetError, MATERIAL_TEXTURE_SLOTS, deriveTextureLayout } from '@forgeax/engine-types';
+import { ok, err, validateSourceOverrideMap, ImportError, IMPORT_ERROR_HINTS, canonicalizeSourceOverrides, AssetError, IES_PROFILE_HEIGHT, IES_PROFILE_WIDTH, IES_PROFILE_BYTE_LENGTH, MATERIAL_TEXTURE_SLOTS, deriveTextureLayout } from '@forgeax/engine-types';
 export { IMPORT_ERROR_HINTS, ImportError } from '@forgeax/engine-types';
-import { resolve, isAbsolute, relative, dirname } from 'path';
-import { upgradeLegacyAuthoredPack, loadAssetConfig, resolveAssetSource, finalizePackageTransportSource, catalogSourcePathFor, projectCookedPackageEntry, buildCatalogProjection, createRuntimePackPublication, metaPathForGuid } from '@forgeax/engine-pack/build';
-import { createHash } from 'crypto';
-import { stat, mkdir, writeFile, rename, rm } from 'fs/promises';
-import { createAcceptedPublication, ddcOutputDigest, DdcGenerationSession, DdcLifecycle } from '@forgeax/engine-ddc';
-import { AssetGuid } from '@forgeax/engine-pack/guid';
+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, 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, 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 { projectScriptablePackSceneComponents, projectScriptablePackMeta } from '@forgeax/engine-pack/source';
-import { inventoryScriptablePackSource } from '@forgeax/engine-pack/source-node';
+import { isEngineMaterial } 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 { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { MESH_BIN_HEADER_V4_BYTES, writeMeshBinHeader } from '@forgeax/engine-pack/mesh-bin-contract';
-import { isScriptablePackAssetKind } from '@forgeax/engine-pack';
+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) {
@@ -42,8 +45,8 @@ async function sha256Hex(bytes2) {
   if (subtle === void 0) throw new Error("Web Crypto API is required for importer digests");
   const owned = new Uint8Array(bytes2.byteLength);
   owned.set(bytes2);
-  const digest = await subtle.digest("SHA-256", owned.buffer);
-  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const digest3 = await subtle.digest("SHA-256", owned.buffer);
+  return Array.from(new Uint8Array(digest3), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 async function artifactDigest(bytes2) {
   return `sha256:${await sha256Hex(bytes2)}`;
@@ -106,25 +109,192 @@ function finalizeImportProducts(product, inputFingerprint) {
     const products = [];
     for (const asset of product.assets) {
       const artifacts = await artifactDescriptors(asset.artifacts);
-      const digest = await productDigest(asset, artifacts);
+      const digest3 = await productDigest(asset, artifacts);
       products.push({
         guid: asset.guid,
         payload: asset.payload,
         refs: asset.refs.map((ref2) => ref2.guid),
         artifacts,
-        digest,
+        digest: digest3,
         receipt: {
           guid: asset.guid,
           origin: "sourceMeta",
           status: "succeeded",
           inputFingerprint,
-          outputDigest: digest
+          outputDigest: digest3
         }
       });
     }
     return products;
   })();
 }
+function deriveDefaultLodScreenCoverages(levelCount) {
+  if (!Number.isInteger(levelCount) || levelCount < 1 || levelCount > 8) {
+    throw new RangeError("levelCount must be an integer in [1, 8]");
+  }
+  return Array.from(
+    { length: levelCount - 1 },
+    (_, index) => Math.round(0.5 * 0.4 ** index * 1e6) / 1e6
+  );
+}
+function validateMeshLodContract(input) {
+  if (input.lods.length > 7) {
+    return err({
+      code: "mesh-lod-contract-invalid",
+      reason: "at most seven lower-detail levels are supported"
+    });
+  }
+  if (input.lodHysteresis !== void 0 && (!Number.isFinite(input.lodHysteresis) || input.lodHysteresis < 0 || input.lodHysteresis >= 1)) {
+    return err({
+      code: "mesh-lod-contract-invalid",
+      reason: "lodHysteresis must be finite and in [0, 1)"
+    });
+  }
+  if (input.generation !== void 0 && (!Number.isSafeInteger(input.generation) || input.generation < 0)) {
+    return err({
+      code: "mesh-lod-contract-invalid",
+      reason: "generation must be a non-negative safe integer"
+    });
+  }
+  const guids = /* @__PURE__ */ new Set();
+  let previous = 1;
+  for (const level of input.lods) {
+    if (level.meshGuid.trim() === "" || guids.has(level.meshGuid)) {
+      return err({
+        code: "mesh-lod-contract-invalid",
+        reason: "LOD mesh GUIDs must be unique and non-empty"
+      });
+    }
+    if (!Number.isFinite(level.screenCoverage) || level.screenCoverage <= 0 || level.screenCoverage > 1) {
+      return err({
+        code: "mesh-lod-contract-invalid",
+        reason: "screenCoverage must be finite and in (0, 1]"
+      });
+    }
+    if (level.screenCoverage >= previous) {
+      return err({
+        code: "mesh-lod-contract-invalid",
+        reason: "screenCoverage must strictly decrease by level"
+      });
+    }
+    guids.add(level.meshGuid);
+    previous = level.screenCoverage;
+  }
+  if (input.refs !== void 0) {
+    const refs = new Set(input.refs);
+    for (const level of input.lods) {
+      if (!refs.has(level.meshGuid)) {
+        return err({
+          code: "mesh-lod-contract-invalid",
+          reason: "every lower-detail mesh GUID must be enclosed by root refs"
+        });
+      }
+    }
+  }
+  if (input.rootMeshGuid !== void 0 && input.refs !== void 0 && !input.refs.includes(input.rootMeshGuid)) {
+    return err({
+      code: "mesh-lod-contract-invalid",
+      reason: "root mesh GUID must be included in refs"
+    });
+  }
+  if (input.rootBounds !== void 0) {
+    if (!validBounds(input.rootBounds)) {
+      return err({
+        code: "mesh-lod-contract-invalid",
+        reason: "root bounds must be finite and ordered"
+      });
+    }
+    for (const bounds of input.lodBounds ?? []) {
+      if (!validBounds(bounds) || !encloses(input.rootBounds, bounds)) {
+        return err({
+          code: "mesh-lod-contract-invalid",
+          reason: "root bounds must enclose every lower-detail bounds"
+        });
+      }
+    }
+  }
+  if (input.lodBounds !== void 0 && input.lodBounds.length !== input.lods.length) {
+    return err({
+      code: "mesh-lod-contract-invalid",
+      reason: "lod bounds must cover every lower level"
+    });
+  }
+  if (input.rootMaterialSlots !== void 0 || input.lodMaterialSlots !== void 0) {
+    const rootSlots = input.rootMaterialSlots ?? [];
+    const lowerSlots = input.lodMaterialSlots ?? [];
+    if (lowerSlots.length !== input.lods.length || lowerSlots.some((slots) => !sameSlots(rootSlots, slots))) {
+      return err({
+        code: "mesh-lod-contract-invalid",
+        reason: "lower-detail material slots must preserve root sourceKey order"
+      });
+    }
+  }
+  if (input.relations !== void 0 && hasCycle(input.relations)) {
+    return err({ code: "mesh-lod-contract-invalid", reason: "LOD relations must be acyclic" });
+  }
+  return ok({ lods: input.lods });
+}
+function validBounds(bounds) {
+  const [minX, minY, minZ] = bounds.min;
+  const [maxX, maxY, maxZ] = bounds.max;
+  return [minX, minY, minZ, maxX, maxY, maxZ].every(Number.isFinite) && minX <= maxX && minY <= maxY && minZ <= maxZ;
+}
+function encloses(root, child) {
+  return child.min[0] >= root.min[0] && child.min[1] >= root.min[1] && child.min[2] >= root.min[2] && child.max[0] <= root.max[0] && child.max[1] <= root.max[1] && child.max[2] <= root.max[2];
+}
+function sameSlots(root, child) {
+  return root.length === child.length && root.every((slot, index) => slot.sourceKey === child[index]?.sourceKey);
+}
+function hasCycle(relations) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const relation of relations)
+    edges.set(relation.from, [...edges.get(relation.from) ?? [], relation.to]);
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (visiting.has(node)) return true;
+    if (visited.has(node)) return false;
+    visiting.add(node);
+    for (const next of edges.get(node) ?? []) if (visit(next)) return true;
+    visiting.delete(node);
+    visited.add(node);
+    return false;
+  };
+  return [...edges.keys()].some(visit);
+}
+function reconcileMeshLodMeta(previous, next) {
+  const overlap = Math.min(previous.length, next.length);
+  for (let index = 0; index < overlap; index++) {
+    const oldEntry = previous[index];
+    const nextEntry = next[index];
+    if (oldEntry?.sourceKey !== nextEntry?.sourceKey) {
+      return err({
+        code: "mesh-lod-topology-change",
+        reason: "existing LOD source keys must remain prefix-stable",
+        previousIndices: [index],
+        nextIndices: [index]
+      });
+    }
+    if (oldEntry?.meshGuid !== nextEntry?.meshGuid) {
+      return err({
+        code: "mesh-lod-authority-conflict",
+        reason: `sourceKey ${nextEntry?.sourceKey ?? "<missing>"} changed mesh GUID`
+      });
+    }
+  }
+  const defaults = deriveDefaultLodScreenCoverages(next.length + 1);
+  const lods = next.map((entry, index) => ({
+    ...entry,
+    screenCoverage: previous[index]?.screenCoverage ?? entry.screenCoverage ?? defaults[index] ?? 0
+  }));
+  const valid = validateMeshLodContract({
+    lods: lods.map(({ meshGuid, screenCoverage }) => ({ meshGuid, screenCoverage }))
+  });
+  if (!valid.ok) return valid;
+  return ok({ lods });
+}
+
+// src/import-runner.ts
 var SHADER_RESERVED_IMPORTER_KEY = "shader";
 function isModuleLoadFailure(e) {
   if (!(e instanceof Error)) return false;
@@ -135,6 +305,9 @@ function isModuleLoadFailure(e) {
   const msg = e.message;
   return msg.includes("Cannot find module") || msg.includes("native addon") || msg.includes(".node");
 }
+function declarationsSourceKey(declarations, guid) {
+  return declarations.find((declaration) => declaration.guid === guid)?.sourceKey;
+}
 function normaliseForPack(value) {
   if (value === null || value === void 0) return value;
   if (value instanceof Float32Array || value instanceof Float64Array || value instanceof Uint8Array || value instanceof Uint16Array || value instanceof Uint32Array || value instanceof Int8Array || value instanceof Int16Array || value instanceof Int32Array) {
@@ -444,6 +617,37 @@ async function runImport(meta, registry, fs) {
     );
   }
   const produced = product.assets;
+  for (const asset of produced) {
+    if (asset.kind !== "mesh" || asset.payload === null || typeof asset.payload !== "object")
+      continue;
+    const payload = asset.payload;
+    if (payload.lods === void 0) continue;
+    const lods = payload.lods.map((level) => ({
+      meshGuid: typeof level.meshGuid === "string" ? level.meshGuid : typeof level.mesh === "string" ? level.mesh : JSON.stringify(level.mesh),
+      screenCoverage: level.screenCoverage
+    }));
+    const validated = validateMeshLodContract({
+      lods,
+      ...payload.lodHysteresis === void 0 ? {} : { lodHysteresis: payload.lodHysteresis }
+    });
+    if (!validated.ok) {
+      return errResult(
+        new ImportError({
+          code: validated.error.code,
+          expected: "MeshAsset LOD facts to satisfy the shared contract",
+          hint: IMPORT_ERROR_HINTS[validated.error.code],
+          detail: {
+            meshLodSourceKey: declarationsSourceKey(meta.subAssets, asset.guid),
+            reason: validated.error.reason,
+            ...validated.error.code === "mesh-lod-topology-change" ? {
+              previousIndices: validated.error.previousIndices,
+              nextIndices: validated.error.nextIndices
+            } : {}
+          }
+        })
+      );
+    }
+  }
   const declared = new Set(meta.subAssets.map((s) => s.guid));
   const producedGuids = new Set(produced.map((a) => a.guid));
   const unexpectedGuids = [...producedGuids].filter((g) => !declared.has(g));
@@ -575,104 +779,644 @@ function projectImportProductForBuild(product) {
     }))
   };
 }
-function failure(sourceKey, expected, actual) {
-  return {
-    code: "mesh-bin-payload-invalid",
-    subject: "mesh-bin",
-    sourceKey,
-    expected,
-    actual,
-    recovery: "re-cook the source with its Meta sidecar through the build-time importer"
-  };
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function asAttributeMap(value) {
-  return value ?? {};
+function isAsset(value) {
+  return record(value) && typeof value.kind === "string" && isScriptablePackAssetKind(value.kind);
 }
-function jsonValue(value) {
-  if (value instanceof Float32Array || value instanceof Uint16Array) return Array.from(value);
-  if (Array.isArray(value)) return value.map(jsonValue);
+function clone(value) {
+  return structuredClone(value);
+}
+function stable(value) {
+  if (value instanceof Uint8Array) return JSON.stringify(Array.from(value));
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
   if (value !== null && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [key, jsonValue(nested)])
-    );
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stable(object[key])}`).join(",")}}`;
   }
-  return value;
+  return JSON.stringify(value) ?? "null";
 }
-function refsMeta(payload, refs) {
-  const materialSlots = (payload.materialSlots ?? [{ slotName: "Default" }]).map(
-    (slot, slotIndex) => {
-      const defaultMaterial = slot.defaultMaterial;
-      let defaultMaterialRef;
-      if (defaultMaterial !== void 0) {
-        const guid = AssetGuid.format(defaultMaterial);
-        defaultMaterialRef = refs.findIndex((candidate) => candidate.toLowerCase() === guid);
-        if (defaultMaterialRef < 0) {
-          throw new Error(
-            `material slot ${slotIndex} default material ${guid} is absent from refs`
-          );
-        }
+async function digest(value) {
+  const crypto = globalThis.crypto?.subtle;
+  if (crypto === void 0) throw new Error("Web Crypto API is required for Pack fingerprints");
+  const bytes2 = await crypto.digest("SHA-256", new TextEncoder().encode(stable(value)));
+  return `sha256:${Array.from(new Uint8Array(bytes2), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function observedReader(source) {
+  const reads = /* @__PURE__ */ new Map();
+  const reader = {
+    async readByGuid(guid) {
+      const key = AssetGuid.format(guid).toLowerCase();
+      const cached = reads.get(key);
+      if (cached !== void 0) return ok(clone(cached.asset));
+      if (source === void 0) {
+        return err(
+          new AssetError({
+            code: "asset-not-found",
+            expected: `a published Asset snapshot for content dependency ${key}`,
+            hint: "publish the dependency or remove the content read from the Pack build",
+            detail: { sourcePath: key }
+          })
+        );
       }
-      return {
-        slotName: slot.slotName,
-        ...slot.sourceKey === void 0 ? {} : { sourceKey: slot.sourceKey },
-        ...defaultMaterialRef === void 0 ? {} : { defaultMaterialRef }
-      };
+      const result = await source.readByGuid(guid);
+      if (!result.ok) return result;
+      const asset = clone(result.value.asset);
+      reads.set(key, {
+        guid: key,
+        asset,
+        generation: result.value.generation,
+        digest: result.value.digest
+      });
+      return ok(clone(asset));
     }
-  );
+  };
+  return { reader, reads };
+}
+function buildContext(packageId, values, reader) {
+  if (values === void 0) return { packageId, readByGuid: reader.readByGuid };
+  return { packageId, values, readByGuid: reader.readByGuid };
+}
+function sourceKeyFailure(sourcePath, sourceKey) {
   return {
-    submeshes: payload.submeshes === void 0 || payload.submeshes.length === 0 ? [{ indexOffset: 0, indexCount: payload.indices?.length ?? 0, materialSlot: 0 }] : payload.submeshes,
-    materialSlots,
-    ...payload.aabb === void 0 ? {} : { aabb: jsonValue(payload.aabb) },
-    ...payload.morphTargets === void 0 ? {} : { morphTargets: jsonValue(payload.morphTargets) },
-    ...payload.morphWeights === void 0 ? {} : { morphWeights: jsonValue(payload.morphWeights) }
+    code: "pack-source-key-invalid",
+    expected: "a sourceKey matching the Pack source-key grammar",
+    hint: "return stable lower-case semantic keys instead of paths or output indexes",
+    detail: { sourcePath, sourceKey }
   };
 }
-function packMeshBinV4(payload, sourceKey, refs = []) {
-  try {
-    const vertices = payload.vertices;
-    const indices = payload.indices;
-    if (!(vertices instanceof Float32Array)) {
-      return err(
-        failure(sourceKey, "Float32Array interleaved vertices", "vertices is not Float32Array")
+function outputValueError(sourcePath, sourceKey, expected, actual) {
+  return {
+    code: "pack-parameter-invalid",
+    expected,
+    hint: "repair the build output and rebuild the Pack from a fresh generation",
+    detail: { sourcePath, sourceKey, actual: typeof actual === "string" ? actual : typeof actual }
+  };
+}
+function referenceError(code, sourcePath, guids) {
+  return {
+    code,
+    expected: code === "pack-output-reference-missing" ? "every output reference to resolve to a local or published AssetGuid" : "removed output GUIDs to have no incoming references",
+    hint: code === "pack-output-reference-missing" ? "build or publish the referenced Pack before verifying this output" : "migrate incoming references before publishing the topology change",
+    detail: { sourcePath, guids: [...guids].sort() }
+  };
+}
+function productError(sourcePath, sourceKey, producer, product) {
+  if (!record(product)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return an asset product object`,
+      product
+    );
+  }
+  if (!Array.isArray(product.refs)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return a refs array`,
+      product.refs
+    );
+  }
+  if (!record(product.artifacts)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return an artifacts object`,
+      product.artifacts
+    );
+  }
+  const payload = product.payload;
+  if (!record(payload) || payload.kind !== producer.kind) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return a matching payload kind`,
+      payload
+    );
+  }
+  for (const ref2 of product.refs) {
+    if (!record(ref2) || typeof ref2.guid !== "string" || !AssetGuid.parse(ref2.guid).ok) {
+      return outputValueError(
+        sourcePath,
+        sourceKey,
+        "producer refs to contain valid AssetGuid values",
+        ref2
       );
     }
-    if (indices !== void 0 && !(indices instanceof Uint16Array || indices instanceof Uint32Array)) {
+  }
+  for (const [key, artifact] of Object.entries(product.artifacts)) {
+    if (key.length === 0 || key.startsWith("/") || key.includes("..") || key.includes("\\") || !record(artifact) || typeof artifact.mediaType !== "string" || !(artifact.bytes instanceof Uint8Array)) {
+      return outputValueError(
+        sourcePath,
+        sourceKey,
+        "asset-local artifacts with safe keys and bytes",
+        key
+      );
+    }
+  }
+  return void 0;
+}
+function errorCode(value) {
+  return record(value) && typeof value.code === "string" ? value.code : void 0;
+}
+function normalizedGuidSet(value) {
+  return value === void 0 ? void 0 : new Set([...value].map((guid) => guid.toLowerCase()));
+}
+async function buildScriptablePack(options) {
+  const subjectPackageId = options.subjectPackageId ?? options.definition.packageId;
+  const availableGuids = normalizedGuidSet(options.availableGuids);
+  const observed = observedReader(options.assetSource);
+  let effectiveValues;
+  if ("parameters" in options.definition) {
+    const resolved = resolvePackParameterValues(
+      options.definition,
+      options.values ?? {},
+      options.inheritedValues
+    );
+    if (!resolved.ok) return resolved;
+    effectiveValues = resolved.value;
+  } else if (options.values !== void 0 && Object.keys(options.values).length > 0) {
+    return err(
+      outputValueError(
+        options.sourcePath,
+        "$.values",
+        "zero-parameter Packs to omit values and instance capabilities",
+        options.values
+      )
+    );
+  } else if (options.subjectPackageId !== void 0 && PackageId.format(options.subjectPackageId).toLowerCase() !== PackageId.format(options.definition.packageId).toLowerCase()) {
+    return err({
+      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,
+        rootPackageId: PackageId.format(options.definition.packageId),
+        subjectPackageId: PackageId.format(options.subjectPackageId)
+      }
+    });
+  }
+  let built;
+  try {
+    const context = buildContext(subjectPackageId, effectiveValues, observed.reader);
+    built = options.definition.build(context);
+    built = await built;
+  } catch (cause) {
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "Pack build to return a structured Result without throwing",
+        hint: "repair the authoring function and return err(...) for expected failures",
+        detail: {
+          reason: `${options.sourcePath}: ${cause instanceof Error ? cause.message : String(cause)}`
+        }
+      })
+    );
+  }
+  if (!record(built) || typeof built.ok !== "boolean") {
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "Pack build to return a Result object",
+        hint: "return ok(sourceKeyToAsset) or err(structuredError) from the authoring function",
+        detail: { reason: `${options.sourcePath}: malformed build result` }
+      })
+    );
+  }
+  if (!built.ok) {
+    if (errorCode(built.error) !== void 0) return err(built.error);
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "a structured Pack build error",
+        hint: "return an error carrying code, expected, hint and detail",
+        detail: { reason: `${options.sourcePath}: ${String(built.error)}` }
+      })
+    );
+  }
+  if (!record(built.value)) {
+    return err(
+      outputValueError(
+        options.sourcePath,
+        "$",
+        "build to return a sourceKey-to-Asset object",
+        built.value
+      )
+    );
+  }
+  const imported = [];
+  const stagedOutputs = [];
+  const localGuids = /* @__PURE__ */ new Set();
+  for (const sourceKey of Object.keys(built.value).sort()) {
+    if (!isValidPackSourceKey(sourceKey))
+      return err(sourceKeyFailure(options.sourcePath, sourceKey));
+    const asset = built.value[sourceKey];
+    if (!isAsset(asset)) {
       return err(
-        failure(sourceKey, "Uint16Array or Uint32Array indices", "indices has an unsupported type")
+        outputValueError(
+          options.sourcePath,
+          sourceKey,
+          "a concrete Asset with a supported kind",
+          asset
+        )
       );
     }
-    const attributes = asAttributeMap(payload.attributes);
-    const projection = deriveVertexLayoutProjection(attributes);
-    if (projection.attributes.length === 0 || projection.arrayStride === 0) {
+    const guid = AssetGuid.format(AssetGuid.derive(subjectPackageId, sourceKey));
+    const normalizedGuid = guid.toLowerCase();
+    if (localGuids.has(normalizedGuid) || availableGuids?.has(normalizedGuid)) {
+      return err({
+        code: "pack-guid-collision",
+        expected: "derived output GUIDs to be unique in the global source index",
+        hint: "change the colliding packageId or repair the source index before publishing",
+        detail: { sourcePath: options.sourcePath, guid }
+      });
+    }
+    localGuids.add(normalizedGuid);
+    const producer = options.outputs.get(asset.kind);
+    if (producer === void 0) {
       return err(
-        failure(
+        outputValueError(
+          options.sourcePath,
           sourceKey,
-          "a non-empty canonical geometry projection",
-          "projection has no attributes"
+          `a registered output producer for ${asset.kind}`,
+          asset.kind
         )
       );
     }
-    const vertexCount = payload.vertexCount ?? vertices.byteLength / projection.arrayStride;
-    if (!Number.isSafeInteger(vertexCount) || vertexCount < 0) {
+    let produced;
+    try {
+      produced = await producer.produce({ guid, sourceKey, asset });
+    } catch (cause) {
       return err(
-        failure(sourceKey, "a non-negative safe vertex cardinality", `vertexCount=${vertexCount}`)
+        new ImportError({
+          code: "import-internal-error",
+          expected: `producer ${producer.kind} to return a structured Result without throwing`,
+          hint: "repair the output producer and return err(...) for expected failures",
+          detail: {
+            reason: `${options.sourcePath}:${sourceKey}: ${cause instanceof Error ? cause.message : String(cause)}`
+          }
+        })
       );
     }
-    if (vertices.byteLength !== vertexCount * projection.arrayStride) {
+    if (!record(produced) || typeof produced.ok !== "boolean") {
       return err(
-        failure(
+        outputValueError(
+          options.sourcePath,
           sourceKey,
-          `vertices.byteLength=${vertexCount * projection.arrayStride}`,
-          `vertices.byteLength=${vertices.byteLength}; stride=${projection.arrayStride}`
+          `producer ${producer.kind} to return a Result`,
+          produced
         )
       );
     }
-    for (const attribute of projection.attributes) {
-      const value = attributes[attribute.key];
-      const components = attribute.byteLength / (attribute.format === "uint16x4" ? 2 : 4);
-      if (value === void 0 || !(value instanceof Float32Array) && !(value instanceof Uint16Array) || value.length !== vertexCount * components) {
-        return err(
-          failure(
+    if (!produced.ok) {
+      if (errorCode(produced.error) !== void 0) return err(produced.error);
+      return err(
+        new ImportError({
+          code: "import-internal-error",
+          expected: `producer ${producer.kind} to return a structured error`,
+          hint: "return an error carrying code, expected, hint and detail",
+          detail: { reason: `${options.sourcePath}:${sourceKey}: ${String(produced.error)}` }
+        })
+      );
+    }
+    const invalidProduct2 = productError(options.sourcePath, sourceKey, producer, produced.value);
+    if (invalidProduct2 !== void 0) return err(invalidProduct2);
+    const product2 = produced.value;
+    imported.push({
+      guid,
+      kind: asset.kind,
+      payload: product2.payload,
+      refs: product2.refs,
+      artifacts: product2.artifacts
+    });
+    stagedOutputs.push({
+      guid: AssetGuid.derive(subjectPackageId, sourceKey),
+      sourceKey,
+      asset: clone(asset),
+      digest: await digest(asset)
+    });
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const asset of imported) {
+    for (const ref2 of asset.refs) {
+      const guid = ref2.guid.toLowerCase();
+      if (!localGuids.has(guid)) referenced.add(guid);
+    }
+  }
+  if (options.deferReferenceValidation !== true) {
+    const missing = [...referenced].filter(
+      (guid) => availableGuids !== void 0 && !availableGuids.has(guid)
+    );
+    if (missing.length > 0)
+      return err(referenceError("pack-output-reference-missing", options.sourcePath, missing));
+  }
+  const externalEvidence = [...observed.reads.values()].sort((left, right) => left.guid.localeCompare(right.guid)).map(
+    (read) => ({
+      guid: read.guid,
+      usage: referenced.has(read.guid) ? "both" : "content",
+      generation: read.generation,
+      digest: read.digest
+    })
+  );
+  const inputFingerprint = await digest({
+    packageId: PackageId.format(subjectPackageId),
+    sourcePath: options.sourcePath,
+    sourceClosure: options.sourceClosure ?? [],
+    values: effectiveValues,
+    externalEvidence: externalEvidence.map(({ guid, usage, digest: evidenceDigest }) => ({
+      guid,
+      usage,
+      digest: evidenceDigest
+    })),
+    authoringContractVersion: options.authoringContractVersion ?? "scriptable-pack/1",
+    producerVersions: options.outputs.versions()
+  });
+  const refs = imported.flatMap((asset) => asset.refs);
+  const artifacts = Object.fromEntries(
+    imported.flatMap(
+      (asset) => Object.entries(asset.artifacts).map(([key, artifact]) => [`${asset.guid}/${key}`, artifact])
+    )
+  );
+  const product = createImportProduct({
+    assets: imported,
+    sourceDependencies: (options.sourceClosure ?? []).map((entry) => entry.path),
+    refs,
+    artifacts,
+    receipts: imported.map((asset) => ({
+      guid: asset.guid,
+      origin: "authoredPack",
+      status: "succeeded",
+      inputFingerprint
+    })),
+    diagnostics: [],
+    sourceRevision: inputFingerprint,
+    sourceKey: options.sourcePath
+  });
+  if (!product.ok) return err(product.error);
+  return ok({
+    product: product.value,
+    stagedOutputs,
+    externalEvidence,
+    inputFingerprint,
+    ...options.publication === void 0 ? {} : { publication: options.publication }
+  });
+}
+function stagedSource(staged, fallback) {
+  return {
+    async readByGuid(guid) {
+      const key = AssetGuid.format(guid).toLowerCase();
+      const local = staged.get(key);
+      if (local !== void 0) {
+        return ok({
+          asset: clone(local.asset),
+          generation: 1,
+          digest: local.digest ?? "sha256:staged"
+        });
+      }
+      if (fallback === void 0) {
+        return err({
+          code: "asset-not-found",
+          expected: "a staged or published content dependency",
+          hint: "wait for the dependency subject to materialize",
+          detail: { guid: key }
+        });
+      }
+      return fallback.readByGuid(guid);
+    }
+  };
+}
+async function buildScriptablePackWorklist(options) {
+  const orderedSubjects = [...options.subjects].sort(
+    (left, right) => left.sourcePath.localeCompare(right.sourcePath)
+  );
+  const pending = new Map(
+    orderedSubjects.map((subject, index) => [`${index}:${subject.sourcePath}`, subject])
+  );
+  const staged = /* @__PURE__ */ new Map();
+  const results = /* @__PURE__ */ new Map();
+  const availableGuids = /* @__PURE__ */ new Set([
+    ...normalizedGuidSet(options.availableGuids) ?? [],
+    ...BUILTIN_MESH_ASSETS.map((asset) => asset.guid.toLowerCase())
+  ]);
+  const maxPasses = options.maxPasses ?? Math.max(1, options.subjects.length + 1);
+  let iterations = 0;
+  for (; iterations < maxPasses && pending.size > 0; iterations += 1) {
+    let progress = false;
+    const waiting = /* @__PURE__ */ new Set();
+    for (const [key, subject] of pending) {
+      const result = await buildScriptablePack({
+        definition: subject.definition,
+        sourcePath: subject.sourcePath,
+        ...subject.subjectPackageId === void 0 ? {} : { subjectPackageId: subject.subjectPackageId },
+        ...subject.values === void 0 ? {} : { values: subject.values },
+        ...subject.inheritedValues === void 0 ? {} : { inheritedValues: subject.inheritedValues },
+        ...subject.sourceClosure === void 0 ? {} : { sourceClosure: subject.sourceClosure },
+        outputs: options.outputs,
+        assetSource: stagedSource(staged, options.assetSource),
+        availableGuids: /* @__PURE__ */ new Set([...availableGuids, ...staged.keys()]),
+        deferReferenceValidation: true
+      });
+      if (result.ok) {
+        results.set(key, result.value);
+        for (const output of result.value.stagedOutputs)
+          staged.set(AssetGuid.format(output.guid).toLowerCase(), output);
+        pending.delete(key);
+        progress = true;
+        continue;
+      }
+      if (errorCode(result.error) === "asset-not-found") {
+        const detail = record(result.error) && record(result.error.detail) ? result.error.detail : void 0;
+        const guid = detail !== void 0 && typeof detail.guid === "string" ? detail.guid : void 0;
+        if (guid !== void 0) waiting.add(guid.toLowerCase());
+        continue;
+      }
+      return result;
+    }
+    if (pending.size === 0) break;
+    if (!progress) {
+      return err({
+        code: "pack-content-dependency-stalled",
+        expected: "the content dependency worklist to make progress",
+        hint: "inspect waitingGuids and repair the missing output or content-read cycle, then rebuild",
+        detail: {
+          waitingGuids: [...waiting].sort(),
+          pendingSubjects: [...pending.values()].map((subject) => subject.sourcePath).sort(),
+          iterations: iterations + 1
+        }
+      });
+    }
+  }
+  if (pending.size > 0) {
+    return err({
+      code: "pack-content-dependency-stalled",
+      expected: "the content dependency worklist to finish within its bounded retry budget",
+      hint: "inspect pendingSubjects and waitingGuids, then repair the dependency graph",
+      detail: {
+        pendingSubjects: [...pending.values()].map((subject) => subject.sourcePath).sort(),
+        waitingGuids: [],
+        iterations
+      }
+    });
+  }
+  const knownGuids = /* @__PURE__ */ new Set([...availableGuids, ...staged.keys()]);
+  const missingReferences = /* @__PURE__ */ new Set();
+  for (const product of results.values()) {
+    const contentReads = new Set(product.externalEvidence.map((read) => read.guid.toLowerCase()));
+    for (const asset of product.product.assets) {
+      for (const reference of asset.refs) {
+        const guid = reference.guid.toLowerCase();
+        if (!knownGuids.has(guid) && !contentReads.has(guid)) missingReferences.add(guid);
+      }
+    }
+  }
+  if (missingReferences.size > 0) {
+    return err(
+      referenceError("pack-output-reference-missing", "worklist", [...missingReferences].sort())
+    );
+  }
+  const removed = [...options.incomingRefs?.keys() ?? []].filter(
+    (guid) => !staged.has(guid.toLowerCase())
+  );
+  const referencedRemoved = removed.filter(
+    (guid) => (options.incomingRefs?.get(guid) ?? []).length > 0
+  );
+  if (referencedRemoved.length > 0)
+    return err(referenceError("pack-output-reference-conflict", "worklist", referencedRemoved));
+  return ok({
+    products: [...results.values()].map((result) => result.product),
+    buildProducts: [...results.values()],
+    stagedOutputs: [...staged.values()],
+    iterations: pending.size === 0 && options.subjects.length > 0 ? iterations + 1 : iterations
+  });
+}
+function failure(sourceKey, expected, actual) {
+  return {
+    code: "mesh-bin-payload-invalid",
+    subject: "mesh-bin",
+    sourceKey,
+    expected,
+    actual,
+    recovery: "re-cook the source with its Meta sidecar through the build-time importer"
+  };
+}
+function asAttributeMap(value) {
+  return value ?? {};
+}
+function jsonValue(value) {
+  if (value instanceof Float32Array || value instanceof Uint16Array) return Array.from(value);
+  if (Array.isArray(value)) return value.map(jsonValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [key, jsonValue(nested)])
+    );
+  }
+  return value;
+}
+function refsMeta(payload, refs) {
+  const materialSlots = (payload.materialSlots ?? [{ slotName: "Default" }]).map(
+    (slot, slotIndex) => {
+      const defaultMaterial = slot.defaultMaterial;
+      let defaultMaterialRef;
+      if (defaultMaterial !== void 0) {
+        const guid = AssetGuid$1.format(defaultMaterial);
+        defaultMaterialRef = refs.findIndex((candidate) => candidate.toLowerCase() === guid);
+        if (defaultMaterialRef < 0) {
+          throw new Error(
+            `material slot ${slotIndex} default material ${guid} is absent from refs`
+          );
+        }
+      }
+      return {
+        slotName: slot.slotName,
+        ...slot.sourceKey === void 0 ? {} : { sourceKey: slot.sourceKey },
+        ...defaultMaterialRef === void 0 ? {} : { defaultMaterialRef }
+      };
+    }
+  );
+  if (payload.lods !== void 0 && payload.lods.length > 7) {
+    throw new Error("MeshAsset LOD chain supports at most seven lower-detail levels");
+  }
+  let previousCoverage = 1;
+  const seenLodGuids = /* @__PURE__ */ new Set();
+  const lods = payload.lods?.map((lod, lodIndex) => {
+    const guid = AssetGuid$1.format(lod.mesh).toLowerCase();
+    const meshRef = refs.findIndex((candidate) => candidate.toLowerCase() === guid);
+    if (meshRef < 0) {
+      throw new Error(`LOD ${lodIndex} mesh ${guid} is absent from refs`);
+    }
+    if (seenLodGuids.has(guid)) {
+      throw new Error(`LOD ${lodIndex} mesh ${guid} is duplicated`);
+    }
+    if (!Number.isFinite(lod.screenCoverage) || lod.screenCoverage <= 0 || lod.screenCoverage > 1 || lod.screenCoverage >= previousCoverage) {
+      throw new Error(
+        `LOD ${lodIndex} screenCoverage must be finite, in (0, 1], and strictly decreasing`
+      );
+    }
+    seenLodGuids.add(guid);
+    previousCoverage = lod.screenCoverage;
+    return { meshRef, screenCoverage: lod.screenCoverage };
+  });
+  if (payload.lodHysteresis !== void 0 && (!Number.isFinite(payload.lodHysteresis) || payload.lodHysteresis < 0 || payload.lodHysteresis >= 1)) {
+    throw new Error("lodHysteresis must be finite and in [0, 1)");
+  }
+  return {
+    submeshes: payload.submeshes === void 0 || payload.submeshes.length === 0 ? [{ indexOffset: 0, indexCount: payload.indices?.length ?? 0, materialSlot: 0 }] : payload.submeshes,
+    materialSlots,
+    ...payload.aabb === void 0 ? {} : { aabb: jsonValue(payload.aabb) },
+    ...payload.morphTargets === void 0 ? {} : { morphTargets: jsonValue(payload.morphTargets) },
+    ...payload.morphWeights === void 0 ? {} : { morphWeights: jsonValue(payload.morphWeights) },
+    ...lods === void 0 ? {} : { lods },
+    ...payload.lodHysteresis === void 0 ? {} : { lodHysteresis: payload.lodHysteresis }
+  };
+}
+function packMeshBinV4(payload, sourceKey, refs = []) {
+  try {
+    const vertices = payload.vertices;
+    const indices = payload.indices;
+    if (!(vertices instanceof Float32Array)) {
+      return err(
+        failure(sourceKey, "Float32Array interleaved vertices", "vertices is not Float32Array")
+      );
+    }
+    if (indices !== void 0 && !(indices instanceof Uint16Array || indices instanceof Uint32Array)) {
+      return err(
+        failure(sourceKey, "Uint16Array or Uint32Array indices", "indices has an unsupported type")
+      );
+    }
+    const attributes = asAttributeMap(payload.attributes);
+    const projection = deriveVertexLayoutProjection(attributes);
+    if (projection.attributes.length === 0 || projection.arrayStride === 0) {
+      return err(
+        failure(
+          sourceKey,
+          "a non-empty canonical geometry projection",
+          "projection has no attributes"
+        )
+      );
+    }
+    const vertexCount = payload.vertexCount ?? vertices.byteLength / projection.arrayStride;
+    if (!Number.isSafeInteger(vertexCount) || vertexCount < 0) {
+      return err(
+        failure(sourceKey, "a non-negative safe vertex cardinality", `vertexCount=${vertexCount}`)
+      );
+    }
+    if (vertices.byteLength !== vertexCount * projection.arrayStride) {
+      return err(
+        failure(
+          sourceKey,
+          `vertices.byteLength=${vertexCount * projection.arrayStride}`,
+          `vertices.byteLength=${vertices.byteLength}; stride=${projection.arrayStride}`
+        )
+      );
+    }
+    for (const attribute of projection.attributes) {
+      const value = attributes[attribute.key];
+      const components = attribute.byteLength / (attribute.format === "uint16x4" ? 2 : 4);
+      if (value === void 0 || !(value instanceof Float32Array) && !(value instanceof Uint16Array) || value.length !== vertexCount * components) {
+        return err(
+          failure(
             sourceKey,
             `${attribute.key} cardinality=${vertexCount * components}`,
             `${attribute.key} cardinality=${value?.byteLength ?? "missing"}`
@@ -733,388 +1477,42 @@ function packMeshBinV4(payload, sourceKey, refs = []) {
     offset += interleaved.byteLength;
     if (indices !== void 0 && indexBytes > 0) {
       out.set(new Uint8Array(indices.buffer, indices.byteOffset, indices.byteLength), offset);
-      offset += indexBytes;
-    }
-    out.set(meta, offset);
-    return ok(out);
-  } catch (error) {
-    return err(
-      failure(
-        sourceKey,
-        "valid canonical mesh payload",
-        error instanceof Error ? error.message : String(error)
-      )
-    );
-  }
-}
-function commonPathPrefix(paths) {
-  const first = paths[0];
-  if (first === void 0) return "";
-  const firstNormalized = first.replaceAll("\\", "/");
-  const firstDirectory = firstNormalized.slice(0, firstNormalized.lastIndexOf("/"));
-  const parts = firstDirectory.split("/");
-  let length = parts.length;
-  for (const path of paths.slice(1)) {
-    const normalized = path.replaceAll("\\", "/");
-    const candidate = normalized.slice(0, normalized.lastIndexOf("/")).split("/");
-    length = Math.min(length, candidate.length);
-    for (let index = 0; index < length; index += 1) {
-      if (parts[index] !== candidate[index]) {
-        length = index;
-        break;
-      }
-    }
-  }
-  return parts.slice(0, length).join("/");
-}
-function stableSourceClosure(closure) {
-  const root = commonPathPrefix(closure.map((entry) => entry.path));
-  return closure.map((entry) => ({
-    path: entry.path.replaceAll("\\", "/").slice(root.length).replace(/^\/+/, ""),
-    digest: entry.digest
-  })).sort((left, right) => left.path.localeCompare(right.path));
-}
-var AssetOutputProducerRegistry = class {
-  producers = /* @__PURE__ */ new Map();
-  register(producer) {
-    if (producer.kind.trim().length === 0 || producer.version.trim().length === 0) {
-      throw new TypeError("ScriptablePack output producer kind and version must be non-empty");
-    }
-    if (typeof producer.produce !== "function") {
-      throw new TypeError(`ScriptablePack output producer ${producer.kind} must expose produce`);
-    }
-    this.producers.set(producer.kind, producer);
-  }
-  get(kind) {
-    return this.producers.get(kind);
-  }
-  versions() {
-    return Object.fromEntries(
-      [...this.producers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([kind, producer]) => [kind, producer.version])
-    );
-  }
-};
-function privateClone(value) {
-  return structuredClone(value);
-}
-function record(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isAsset(value) {
-  return record(value) && typeof value.kind === "string" && isScriptablePackAssetKind(value.kind);
-}
-function isStructuredDomainError(value) {
-  return value !== null && typeof value === "object" && typeof value.code === "string" && typeof value.expected === "string" && typeof value.hint === "string";
-}
-function remapBuildFailureSource(value, sourcePath) {
-  if (value === null || typeof value !== "object") return void 0;
-  const error = value;
-  if (error.code !== "pack-source-load-failed") return void 0;
-  if (error.detail === null || typeof error.detail !== "object") return void 0;
-  const detail = error.detail;
-  if (detail.phase !== "build") return void 0;
-  return {
-    ...value,
-    detail: { ...detail, sourcePath }
-  };
-}
-function observedAssetReader(source) {
-  const reads = /* @__PURE__ */ new Map();
-  const reader = {
-    async readByGuid(guid) {
-      const key = AssetGuid.format(guid);
-      const cached = reads.get(key);
-      if (cached !== void 0) return ok(privateClone(cached.asset));
-      if (source === void 0) {
-        return err(
-          new AssetError({
-            code: "asset-not-found",
-            expected: `a host Asset snapshot source for ScriptablePack content read ${key}`,
-            hint: "configure the standard ScriptablePack asset source or remove the content read"
-          })
-        );
-      }
-      const result = await source.readByGuid(guid);
-      if (!result.ok) return result;
-      const fixed = privateClone(result.value.asset);
-      reads.set(key, {
-        guid: key,
-        asset: fixed,
-        generation: result.value.generation,
-        digest: result.value.digest
-      });
-      return ok(privateClone(fixed));
-    }
-  };
-  return { reader, reads };
-}
-function stable(value) {
-  if (value instanceof Uint8Array) return JSON.stringify(Array.from(value));
-  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    const record2 = value;
-    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable(record2[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
-}
-async function fingerprint(value) {
-  const subtle = globalThis.crypto?.subtle;
-  if (subtle === void 0)
-    throw new Error("Web Crypto API is required for ScriptablePack fingerprints");
-  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(stable(value)));
-  const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join(
-    ""
-  );
-  return `sha256:${hex}`;
-}
-function outputError(definition, output) {
-  const declaredKeys = Object.keys(definition.assets);
-  const outputKeys = Object.keys(output);
-  const outputKeySet = new Set(outputKeys);
-  const declaredKeySet = new Set(declaredKeys);
-  const missingKeys = declaredKeys.filter((key) => !outputKeySet.has(key));
-  const unexpectedSourceKeys = outputKeys.filter((key) => !declaredKeySet.has(key));
-  const kindMismatches = declaredKeys.flatMap((sourceKey) => {
-    const descriptor = definition.assets[sourceKey];
-    const value = output[sourceKey];
-    if (descriptor === void 0 || value === void 0) return [];
-    const actualKind = value !== null && typeof value === "object" && "kind" in value ? String(value.kind) : typeof value;
-    return actualKind === descriptor.kind ? [] : [{ sourceKey, expected: descriptor.kind, actual: actualKind }];
-  });
-  if (missingKeys.length === 0 && unexpectedSourceKeys.length === 0 && kindMismatches.length === 0) {
-    return void 0;
-  }
-  return {
-    code: "pack-source-output-invalid",
-    expected: "build output keys and kinds to exactly match definition.assets",
-    hint: "inspect sourceKey and GUID topology, then rebuild or cold-cook the ScriptablePack",
-    detail: {
-      missingGuids: missingKeys.map(
-        (key) => AssetGuid.format(definition.assets[key]?.guid)
-      ),
-      unexpectedSourceKeys,
-      kindMismatches
-    }
-  };
-}
-function externalClosureError(declared, referenced, read) {
-  const used = /* @__PURE__ */ new Set([...referenced, ...read]);
-  const undeclaredReferencedGuids = [...referenced].filter((guid) => !declared.has(guid));
-  const undeclaredReadGuids = [...read].filter((guid) => !declared.has(guid));
-  const unusedDeclaredGuids = [...declared].filter((guid) => !used.has(guid));
-  if (undeclaredReferencedGuids.length === 0 && undeclaredReadGuids.length === 0 && unusedDeclaredGuids.length === 0) {
-    return void 0;
-  }
-  return {
-    code: "pack-source-external-closure-mismatch",
-    expected: "externalAssets GUIDs to equal output external refs union AssetReader reads",
-    hint: "inspect refs and AssetReader reads, repair GUID declarations, then rebuild or cold-cook",
-    detail: {
-      undeclaredReferencedGuids: undeclaredReferencedGuids.sort(),
-      undeclaredReadGuids: undeclaredReadGuids.sort(),
-      unusedDeclaredGuids: unusedDeclaredGuids.sort()
-    }
-  };
-}
-function productContractError(sourceKey, kind, product) {
-  const mismatches = [];
-  if (product.payload.kind !== kind) {
-    mismatches.push({ sourceKey, expected: kind, actual: product.payload.kind });
-  }
-  for (const reference of product.refs) {
-    if (!AssetGuid.parse(reference.guid).ok) {
-      mismatches.push({
-        sourceKey,
-        expected: "every producer ref to contain a valid Asset GUID",
-        actual: reference.guid
-      });
-      break;
-    }
-  }
-  for (const [artifactKey, artifact] of Object.entries(product.artifacts)) {
-    if (artifactKey.length === 0 || artifactKey.startsWith("/") || artifactKey.includes("..") || artifactKey.includes("\\") || artifact.mediaType.trim().length === 0 || !(artifact.bytes instanceof Uint8Array)) {
-      mismatches.push({
-        sourceKey,
-        expected: "asset-local artifacts with safe keys, mediaType, and Uint8Array bytes",
-        actual: artifactKey
-      });
-      break;
-    }
-  }
-  if (mismatches.length === 0) return void 0;
-  return {
-    code: "pack-source-output-invalid",
-    expected: "producer output refs and asset-local artifacts to satisfy the Pack v2 contract",
-    hint: "inspect sourceKey and artifact provenance, repair refs or bytes, then rebuild or cold-cook",
-    detail: { missingGuids: [], unexpectedSourceKeys: [], kindMismatches: mismatches }
-  };
-}
-async function buildScriptablePack(options) {
-  const observed = observedAssetReader(options.assetSource);
-  let built;
-  try {
-    const build = options.definition.build;
-    built = await build(observed.reader);
-  } catch (error) {
-    return err(
-      new ImportError({
-        code: "import-internal-error",
-        expected: "ScriptablePack build to return a structured Result without throwing",
-        hint: "fix the build implementation and return a structured failure for expected authoring errors",
-        detail: { reason: error instanceof Error ? error.message : String(error) }
-      })
-    );
-  }
-  if (!built.ok) {
-    const remappedBuildFailure = remapBuildFailureSource(built.error, options.sourcePath);
-    if (remappedBuildFailure !== void 0) return err(remappedBuildFailure);
-    if (built.error instanceof ImportError || built.error instanceof AssetError || isStructuredDomainError(built.error)) {
-      return err(built.error);
+      offset += indexBytes;
     }
+    out.set(meta, offset);
+    return ok(out);
+  } catch (error) {
     return err(
-      new ImportError({
-        code: "import-internal-error",
-        expected: "ScriptablePack build failure to use a structured domain error",
-        hint: "return an error with code, expected, hint, and optional detail fields",
-        detail: { reason: String(built.error) }
-      })
-    );
-  }
-  if (!record(built.value)) {
-    return err(
-      new ImportError({
-        code: "import-internal-error",
-        expected: "ScriptablePack build output to be an object keyed by declared sourceKey",
-        hint: "return one concrete Asset payload for each declared sourceKey",
-        detail: { reason: "build output is not an object" }
-      })
+      failure(
+        sourceKey,
+        "valid canonical mesh payload",
+        error instanceof Error ? error.message : String(error)
+      )
     );
   }
-  const output = built.value;
-  const invalidOutput = outputError(options.definition, output);
-  if (invalidOutput !== void 0) return err(invalidOutput);
-  const assets = [];
-  for (const sourceKey of Object.keys(options.definition.assets).sort()) {
-    const descriptor = options.definition.assets[sourceKey];
-    const asset = output[sourceKey];
-    if (descriptor === void 0) continue;
-    if (!isAsset(asset)) {
-      return err(
-        new ImportError({
-          code: "import-internal-error",
-          expected: `a concrete Asset payload for sourceKey ${sourceKey}`,
-          hint: "return a durable Asset with a kind from SCRIPTABLE_PACK_ASSET_KINDS",
-          detail: { reason: "build output payload is missing or has an unknown kind" }
-        })
-      );
+}
+
+// src/scriptable-pack.ts
+var AssetOutputProducerRegistry = class {
+  producers = /* @__PURE__ */ new Map();
+  register(producer) {
+    if (producer.kind.trim().length === 0 || producer.version.trim().length === 0) {
+      throw new TypeError("Pack output producer kind and version must be non-empty");
     }
-    const producer = options.outputs.get(descriptor.kind);
-    if (producer === void 0) {
-      return err({
-        code: "pack-source-output-invalid",
-        expected: `a domain output producer registered for kind ${descriptor.kind}`,
-        hint: "attach the owning producer capability, inspect registration, then rebuild or cold-cook",
-        detail: {
-          missingGuids: [AssetGuid.format(descriptor.guid)],
-          unexpectedSourceKeys: [],
-          kindMismatches: []
-        }
-      });
+    if (typeof producer.produce !== "function") {
+      throw new TypeError(`Pack output producer ${producer.kind} must expose produce`);
     }
-    const product2 = await producer.produce({
-      guid: AssetGuid.format(descriptor.guid),
-      sourceKey,
-      asset
-    });
-    if (!product2.ok) return err(product2.error);
-    const productError = productContractError(sourceKey, descriptor.kind, product2.value);
-    if (productError !== void 0) return err(productError);
-    assets.push({
-      guid: AssetGuid.format(descriptor.guid),
-      kind: descriptor.kind,
-      ...descriptor.name === void 0 ? {} : { name: descriptor.name },
-      payload: product2.value.payload,
-      refs: product2.value.refs,
-      artifacts: product2.value.artifacts
-    });
+    this.producers.set(producer.kind, producer);
   }
-  const local = new Set(assets.map((asset) => asset.guid.toLowerCase()));
-  const referenced = new Set(
-    assets.flatMap((asset) => asset.refs.map((reference) => reference.guid.toLowerCase())).filter((guid) => !local.has(guid))
-  );
-  const read = new Set([...observed.reads.keys()].map((guid) => guid.toLowerCase()));
-  const declared = new Set(
-    Object.values(options.definition.externalAssets).map(
-      (guid) => AssetGuid.format(guid).toLowerCase()
-    )
-  );
-  const closureError2 = externalClosureError(declared, referenced, read);
-  if (closureError2 !== void 0) return err(closureError2);
-  const externalEvidence = [...declared].sort().map((guid) => {
-    const observedRead = observed.reads.get(guid);
-    const isReference = referenced.has(guid);
-    return {
-      guid,
-      usage: observedRead === void 0 ? "reference" : isReference ? "both" : "content",
-      ...observedRead === void 0 ? {} : { generation: observedRead.generation, digest: observedRead.digest }
-    };
-  });
-  const fingerprintEvidence = externalEvidence.map(({ guid, usage, digest }) => ({
-    guid,
-    usage,
-    ...digest === void 0 ? {} : { digest }
-  }));
-  const inputFingerprint = await fingerprint({
-    meta: projectScriptablePackMeta(options.definition, options.sourcePath),
-    sceneComponents: projectScriptablePackSceneComponents(options.definition.sceneComponents),
-    sourceClosure: stableSourceClosure(options.sourceClosure),
-    externalEvidence: fingerprintEvidence,
-    authoringContractVersion: options.authoringContractVersion,
-    producerVersions: options.outputs.versions()
-  });
-  const refs = assets.flatMap((asset) => asset.refs);
-  const artifacts = Object.fromEntries(
-    assets.flatMap(
-      (asset) => Object.entries(asset.artifacts).map(([key, artifact]) => [`${asset.guid}/${key}`, artifact])
-    )
-  );
-  const product = createImportProduct({
-    assets,
-    sourceDependencies: options.sourceClosure.map((entry) => entry.path),
-    refs,
-    artifacts,
-    receipts: assets.map((asset) => ({
-      guid: asset.guid,
-      origin: "sourceMeta",
-      status: "succeeded",
-      inputFingerprint
-    })),
-    diagnostics: [],
-    sourceRevision: inputFingerprint,
-    sourceKey: options.sourcePath
-  });
-  if (!product.ok) return err(product.error);
-  return ok({
-    product: product.value,
-    stagedOutputs: await Promise.all(
-      Object.keys(options.definition.assets).sort().map(async (sourceKey) => {
-        const descriptor = options.definition.assets[sourceKey];
-        const asset = output[sourceKey];
-        if (descriptor === void 0 || !isAsset(asset)) {
-          throw new Error(`validated ScriptablePack output ${sourceKey} is not an Asset`);
-        }
-        return {
-          guid: descriptor.guid,
-          sourceKey,
-          asset: privateClone(asset),
-          digest: await fingerprint(asset)
-        };
-      })
-    ),
-    externalEvidence,
-    inputFingerprint
-  });
-}
+  get(kind) {
+    return this.producers.get(kind);
+  }
+  versions() {
+    return Object.fromEntries(
+      [...this.producers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([kind, producer]) => [kind, producer.version])
+    );
+  }
+};
 
 // src/scriptable-pack-output-producers.ts
 function producerError(input, reason) {
@@ -1127,11 +1525,11 @@ function producerError(input, reason) {
 }
 function formatGuid(value) {
   if (typeof value === "string") {
-    const parsed = AssetGuid.parse(value);
+    const parsed = AssetGuid$1.parse(value);
     if (!parsed.ok) throw parsed.error;
-    return AssetGuid.format(parsed.value);
+    return AssetGuid$1.format(parsed.value);
   }
-  return AssetGuid.format(value);
+  return AssetGuid$1.format(value);
 }
 function canonical(value) {
   if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
@@ -1143,11 +1541,11 @@ function canonical(value) {
 function particleProgramArtifact(effect) {
   const artifactProgram = { format: effect.program.format, emitters: effect.program.emitters };
   const bytes2 = new TextEncoder().encode(canonical(artifactProgram));
-  const fingerprint2 = `sha256:${bytesToHex(sha256(bytes2))}`;
+  const fingerprint = `sha256:${bytesToHex(sha256(bytes2))}`;
   return {
-    program: { ...effect.program, fingerprint: fingerprint2 },
+    program: { ...effect.program, fingerprint },
     bytes: bytes2,
-    fingerprint: fingerprint2
+    fingerprint
   };
 }
 function materialProduct(input) {
@@ -1214,6 +1612,13 @@ function meshProduct(input) {
       sourceField: { fieldName: "materialSlots", arrayIndex: slotIndex }
     });
   }
+  const seenRefs = new Set(refs.map((reference) => reference.guid.toLowerCase()));
+  for (const [lodIndex, lod] of (mesh.lods ?? []).entries()) {
+    const guid = formatGuid(lod.mesh);
+    if (seenRefs.has(guid.toLowerCase())) continue;
+    seenRefs.add(guid.toLowerCase());
+    refs.push({ guid, sourceField: { fieldName: "lods", arrayIndex: lodIndex } });
+  }
   return {
     payload: mesh,
     refs,
@@ -1254,6 +1659,25 @@ function sceneProduct(input, components) {
     artifacts: {}
   };
 }
+function containsAssetGuid(value) {
+  if (typeof value === "string") return AssetGuid$1.parse(value).ok;
+  if (Array.isArray(value)) return value.some(containsAssetGuid);
+  if (value !== null && typeof value === "object") {
+    return Object.values(value).some(containsAssetGuid);
+  }
+  return false;
+}
+function preExternalizedSceneProduct(input) {
+  if (input.asset.kind !== "scene") throw new TypeError("expected SceneAsset");
+  if (containsAssetGuid(input.asset)) {
+    throw new TypeError("direct scene payload must use explicit refs with runtime indices");
+  }
+  return {
+    payload: { ...input.asset, kind: "scene" },
+    refs: [],
+    artifacts: {}
+  };
+}
 function createSafeProducer(kind, version, product) {
   return {
     kind,
@@ -1362,7 +1786,7 @@ function ordinaryPodProduct(input) {
     case "tileset": {
       const tileset = asset;
       const refs = tileset.atlases.map((atlas, index) => {
-        const parsed = AssetGuid.parse(atlas);
+        const parsed = AssetGuid$1.parse(atlas);
         if (!parsed.ok) throw parsed.error;
         return ref(parsed.value, "atlases", index);
       });
@@ -1395,7 +1819,7 @@ function ordinaryPodProduct(input) {
     }
     case "skin": {
       const skin = asset;
-      const skeletonGuid = AssetGuid.parse(skin.skeletonGuid);
+      const skeletonGuid = AssetGuid$1.parse(skin.skeletonGuid);
       if (!skeletonGuid.ok) throw skeletonGuid.error;
       return {
         payload: skin,
@@ -1414,7 +1838,7 @@ function ordinaryPodProduct(input) {
       const refs = [];
       const nodes = graph.nodes.map((node, index) => {
         if (node.type !== "clip") return node;
-        const parsed = AssetGuid.parse(node.clip);
+        const parsed = AssetGuid$1.parse(node.clip);
         if (!parsed.ok) throw parsed.error;
         const referenceIndex = refs.push(ref(parsed.value, "nodes", index)) - 1;
         return { ...node, clip: referenceIndex };
@@ -1455,219 +1879,74 @@ function ordinaryPodProduct(input) {
             mediaType: "application/json",
             assetCodec: { name: "forgeax-vfx-program", version: effect.program.format },
             bytes: cooked.bytes
-          }
-        }
-      };
-    }
-    case "material":
-    case "mesh":
-    case "scene":
-      throw new TypeError(`ordinary producer received already-owned ${asset.kind} asset`);
-  }
-}
-var materialAssetOutputProducer = createSafeProducer(
-  "material",
-  "material-pack/1",
-  materialProduct
-);
-var meshAssetOutputProducer = createSafeProducer("mesh", "mesh-binary/4", meshProduct);
-var textureAssetOutputProducer = createSafeProducer(
-  "texture",
-  "texture-pack/1",
-  textureProduct
-);
-function createSceneAssetOutputProducer(sceneComponents = []) {
-  const schemas = new Map(
-    sceneComponents.map((component) => [component.name, component.fields])
-  );
-  return createSafeProducer("scene", "scene-pack/3", (input) => sceneProduct(input, schemas));
-}
-function createStandardAssetOutputProducerRegistry(sceneComponents = []) {
-  const registry = new AssetOutputProducerRegistry();
-  registry.register(materialAssetOutputProducer);
-  registry.register(meshAssetOutputProducer);
-  registry.register(textureAssetOutputProducer);
-  registry.register(createSceneAssetOutputProducer(sceneComponents));
-  for (const kind of [
-    "equirect",
-    "sampler",
-    "font",
-    "render-pipeline",
-    "tileset",
-    "video",
-    "skeleton",
-    "skin",
-    "animation-clip",
-    "animation-graph",
-    "audio",
-    "particle-effect"
-  ]) {
-    registry.register(createSafeProducer(kind, "ordinary-pod/1", ordinaryPodProduct));
-  }
-  return registry;
-}
-function stable2(value) {
-  if (ArrayBuffer.isView(value)) {
-    return `${value.constructor.name}:${JSON.stringify(Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)))}`;
-  }
-  if (Array.isArray(value)) return `[${value.map(stable2).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    const record2 = value;
-    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable2(record2[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
-}
-async function assetDigest(asset) {
-  const bytes2 = new TextEncoder().encode(stable2(asset));
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes2);
-  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
-}
-function cycleError(stack, owner, guid) {
-  const cycleStart = stack.indexOf(owner);
-  const cycle = [...stack.slice(cycleStart), owner];
-  return {
-    code: "pack-source-build-cycle",
-    expected: "an acyclic graph of ScriptablePack content dependencies",
-    actual: cycle.join(" -> "),
-    hint: "break one content read edge or convert it to a reference-only dependency",
-    retryable: false,
-    recoveryActions: ["inspect-content-dependency-graph", "edit-source"],
-    detail: { sourcePath: owner, sourceKey: guid, incomingRefs: cycle }
-  };
-}
-function missingOutputError(owner, guid) {
-  return {
-    code: "pack-source-output-invalid",
-    expected: `owner ${owner} to stage every declared output including ${guid}`,
-    hint: "return one output for every GUID declared by the staged owner",
-    detail: { missingGuids: [guid], unexpectedSourceKeys: [], kindMismatches: [] }
-  };
-}
-function createScriptablePackStagedAssetSnapshotSource(options) {
-  const owners = options.declaredExternalOutputs === void 0 || options.declaredExternalOutputs.length === 0 ? options.owners : [
-    {
-      id: "<declared-pack-external>",
-      guids: options.declaredExternalOutputs.map((output) => output.guid),
-      async build() {
-        return ok(options.declaredExternalOutputs ?? []);
-      }
-    },
-    ...options.owners
-  ];
-  const ownerByGuid = /* @__PURE__ */ new Map();
-  for (const owner of owners) {
-    if (owner.id.trim().length === 0) throw new TypeError("staged owner id must be non-empty");
-    for (const guid of owner.guids) {
-      const key = AssetGuid.format(guid).toLowerCase();
-      const existing = ownerByGuid.get(key);
-      if (existing !== void 0) {
-        throw new TypeError(`staged GUID ${key} is owned by both ${existing.id} and ${owner.id}`);
-      }
-      ownerByGuid.set(key, owner);
-    }
-  }
-  const snapshots = /* @__PURE__ */ new Map();
-  const builds = /* @__PURE__ */ new Map();
-  const sourceFor = (stack) => ({
-    async readByGuid(guid) {
-      const key = AssetGuid.format(guid).toLowerCase();
-      const cached = snapshots.get(key);
-      if (cached !== void 0) return ok(structuredClone(cached));
-      const owner = ownerByGuid.get(key);
-      if (owner === void 0) {
-        return err(
-          new AssetError({
-            code: "asset-not-imported",
-            expected: "a staged local owner for the requested GUID",
-            hint: "declare the local ScriptablePack output before rebuilding the generation"
-          })
-        );
-      }
-      if (stack.includes(owner.id)) return err(cycleError(stack, owner.id, key));
-      let building = builds.get(owner.id);
-      if (building === void 0) {
-        building = (async () => {
-          const built2 = await owner.build(sourceFor([...stack, owner.id]));
-          if (!built2.ok) {
-            builds.delete(owner.id);
-            return built2;
-          }
-          const next = /* @__PURE__ */ new Map();
-          for (const output of built2.value) {
-            const outputGuid = AssetGuid.format(output.guid).toLowerCase();
-            if (ownerByGuid.get(outputGuid) !== owner) {
-              builds.delete(owner.id);
-              return err(missingOutputError(owner.id, outputGuid));
-            }
-            next.set(outputGuid, {
-              asset: structuredClone(output.asset),
-              generation: options.generation,
-              digest: output.digest ?? await assetDigest(output.asset)
-            });
-          }
-          for (const declared of owner.guids) {
-            const declaredGuid = AssetGuid.format(declared).toLowerCase();
-            if (!next.has(declaredGuid)) {
-              builds.delete(owner.id);
-              return err(missingOutputError(owner.id, declaredGuid));
-            }
-          }
-          for (const [outputGuid, snapshot] of next) snapshots.set(outputGuid, snapshot);
-          return ok(void 0);
-        })();
-        builds.set(owner.id, building);
-      }
-      const built = await building;
-      if (!built.ok) return built;
-      const staged = snapshots.get(key);
-      return staged === void 0 ? err(missingOutputError(owner.id, key)) : ok(structuredClone(staged));
+          }
+        }
+      };
     }
-  });
-  return sourceFor([]);
-}
-var META_ARTIFACT_KEY = "scriptable-pack.meta.json";
-function withPrebuiltMeta(product, anchorGuid, meta) {
-  const bytes2 = new TextEncoder().encode(`${JSON.stringify(meta)}
-`);
-  return {
-    ...product,
-    assets: product.assets.map(
-      (asset) => asset.guid.toLowerCase() === anchorGuid ? {
-        ...asset,
+    case "ies-profile": {
+      const profile = asset;
+      return {
+        payload: profile,
+        refs: [],
         artifacts: {
-          ...asset.artifacts,
-          [META_ARTIFACT_KEY]: { mediaType: "application/json", bytes: bytes2 }
+          body: {
+            mediaType: "application/octet-stream",
+            assetCodec: { name: "forgeax-ies-profile", version: "1" },
+            bytes: bytes(profile.data)
+          }
         }
-      } : asset
-    )
-  };
-}
-async function produceScriptableSourcePackage(options) {
-  const built = await buildScriptablePack(options);
-  if (!built.ok) return err(built.error);
-  const declaredGuids = Object.values(options.definition.assets).map((descriptor) => AssetGuid.format(descriptor.guid).toLowerCase()).sort();
-  const anchorGuid = declaredGuids[0];
-  if (anchorGuid === void 0) {
-    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: [] }
-    });
+      };
+    }
+    case "material":
+    case "mesh":
+    case "scene":
+      throw new TypeError(`ordinary producer received already-owned ${asset.kind} asset`);
   }
-  const product = withPrebuiltMeta(
-    built.value.product,
-    anchorGuid,
-    projectScriptablePackMeta(options.definition, options.sourcePath)
+}
+var materialAssetOutputProducer = createSafeProducer(
+  "material",
+  "material-pack/1",
+  materialProduct
+);
+var meshAssetOutputProducer = createSafeProducer("mesh", "mesh-binary/4", meshProduct);
+var textureAssetOutputProducer = createSafeProducer(
+  "texture",
+  "texture-pack/1",
+  textureProduct
+);
+function createSceneAssetOutputProducer(sceneComponents = []) {
+  const schemas = new Map(
+    sceneComponents.map((component) => [component.name, component.fields])
   );
-  return ok({
-    anchorGuid,
-    declaredGuids,
-    product,
-    stagedOutputs: built.value.stagedOutputs,
-    inputFingerprint: built.value.inputFingerprint,
-    externalEvidence: built.value.externalEvidence
-  });
+  return createSafeProducer("scene", "scene-pack/3", (input) => sceneProduct(input, schemas));
+}
+function createPreExternalizedSceneAssetOutputProducer() {
+  return createSafeProducer("scene", "scene-pack/3", preExternalizedSceneProduct);
+}
+function createStandardAssetOutputProducerRegistry(sceneComponents = []) {
+  const registry = new AssetOutputProducerRegistry();
+  registry.register(materialAssetOutputProducer);
+  registry.register(meshAssetOutputProducer);
+  registry.register(textureAssetOutputProducer);
+  registry.register(createSceneAssetOutputProducer(sceneComponents));
+  for (const kind of [
+    "equirect",
+    "sampler",
+    "font",
+    "render-pipeline",
+    "tileset",
+    "video",
+    "skeleton",
+    "skin",
+    "animation-clip",
+    "animation-graph",
+    "audio",
+    "particle-effect",
+    "ies-profile"
+  ]) {
+    registry.register(createSafeProducer(kind, "ordinary-pod/1", ordinaryPodProduct));
+  }
+  return registry;
 }
 function parseProducerReadiness(value) {
   if (value === void 0 || value === "before-consume" || value === "on-demand") {
@@ -1767,25 +2046,517 @@ function canonicalScriptableSourcePath(sourcePath) {
   const markerIndex = normalized.indexOf(marker);
   return markerIndex < 0 ? normalized : normalized.slice(markerIndex + 1);
 }
-function scriptablePackInputs(sourcePaths, declarations, cwd, generationFor, policyFor, sourceIdentityFor) {
-  return sourcePaths.flatMap((sourcePath) => {
-    const declaration = declarations.get(resolve(cwd, sourcePath));
-    if (declaration?.format !== "pack.ts") return [];
-    const projected = sourceIdentityFor?.(sourcePath);
-    const catalogSourcePath = projected === void 0 || 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)
+async function declaredPackExternalOutputs(declarations, cookers = [], requiredGuids = [], externalImport) {
+  if (requiredGuids.length === 0) return [];
+  const required = new Set(requiredGuids.map((guid) => AssetGuid$1.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$1.parse(asset.guid);
+      if (!parsed.ok) throw parsed.error;
+      available.add(AssetGuid$1.format(parsed.value).toLowerCase());
+    }
+  }
+  const outputs = [];
+  for (const declaration of declarations.values()) {
+    if (declaration.format === "meta.json") {
+      if (externalImport === void 0) continue;
+      if (!declaration.value.subAssets.some((asset) => required.has(asset.guid.toLowerCase()))) {
+        continue;
+      }
+      const resolved = resolveAssetSource(declaration.sourcePath, declaration.value.source);
+      const meta = {
+        importer: declaration.value.importer,
+        source: resolved,
+        sourceRevision: declaration.sourceRevision,
+        ...declaration.value.packageId === void 0 ? {} : { packageId: declaration.value.packageId },
+        ...declaration.value.provenance === void 0 ? {} : { provenance: declaration.value.provenance },
+        ...declaration.value.revision === void 0 ? {} : { revision: declaration.value.revision },
+        ...declaration.value.diagnostics === void 0 ? {} : { diagnostics: declaration.value.diagnostics },
+        importSettings: declaration.value.importSettings,
+        ...declaration.value.sourceOverrides === void 0 ? {} : { sourceOverrides: declaration.value.sourceOverrides },
+        subAssets: declaration.value.subAssets.map(({ guid, sourceIndex, sourceKey, kind }) => ({
+          guid,
+          sourceIndex,
+          ...sourceKey === void 0 ? {} : { sourceKey },
+          kind
+        })),
+        buildPack: false
+      };
+      const sourcePackage = await produceSourcePackage({
+        meta,
+        registry: externalImport.importerRegistry,
+        fs: externalImport.fsForImport
+      });
+      if (!sourcePackage.ok) {
+        throw new AssetError({
+          code: "asset-not-imported",
+          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) {
+        if (!required.has(asset.guid.toLowerCase())) continue;
+        const parsed = AssetGuid$1.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,
+          sourceKey: declared?.sourceKey ?? asset.guid,
+          asset: { ...asset.payload, kind: asset.kind }
+        });
+      }
+      continue;
+    }
+    if (declaration.format !== "pack.json") continue;
+    if (declaration.value.schemaVersion === "3.0.0") {
+      const parsed = parsePackSourceJson(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$1.parse(asset.guid);
+        if (!parsedGuid.ok) throw parsedGuid.error;
+        const cooked2 = cookedByGuid.get(asset.guid.toLowerCase());
+        if (cooked2 === void 0) {
+          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: cooked2.kind, ...cooked2.payload }
+        });
+      }
+      continue;
+    }
+    const cooked = await readCookedAuthoredPack(declaration.value, cookers, declaration.sourcePath);
+    for (const asset of cooked?.logicalPackage.assets ?? declaration.value.assets) {
+      if (!required.has(asset.guid.toLowerCase())) continue;
+      const parsedGuid = AssetGuid$1.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 }
+      });
+    }
+  }
+  return outputs;
+}
+async function readCookedAuthoredPack(authoredPack, cookers = [], sourcePath) {
+  if (authoredPack.schemaVersion !== "2.0.0") return void 0;
+  const registry = new NativeCookerRegistry();
+  for (const cooker of cookers) registry.register(cooker);
+  const assets = [];
+  const refsByGuid = /* @__PURE__ */ new Map();
+  let hasCookedAsset = false;
+  for (const asset of authoredPack.assets) {
+    if (asset.execution !== "cooked") {
+      assets.push({
+        guid: asset.guid,
+        kind: asset.kind,
+        ...asset.name === void 0 ? {} : { name: asset.name },
+        payload: asset.payload,
+        refs: asset.refs,
+        artifacts: {}
+      });
+      continue;
+    }
+    if (isEngineOwnedMaterial(asset)) {
+      assets.push({
+        guid: asset.guid,
+        kind: asset.kind,
+        ...asset.name === void 0 ? {} : { 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 === void 0 ? {} : { sourceKey: asset.sourceKey },
+      ...sourcePath === void 0 ? {} : { 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 === void 0 ? {} : { name: asset.name },
+      payload: draft.payload,
+      refs: [...draft.refs],
+      artifacts: draft.artifacts
+    });
+  }
+  return hasCookedAsset ? {
+    logicalPackage: { assets },
+    refsByGuid
+  } : void 0;
+}
+function directReference(guid) {
+  return { guid, sourceField: { fieldName: "refs" } };
+}
+function mergeDirectReferences(produced, declared) {
+  const merged = [...produced];
+  const seen = new Set(produced.map((reference) => reference.guid.toLowerCase()));
+  for (const guid of declared) {
+    const parsed = AssetGuid$1.parse(guid);
+    if (!parsed.ok) throw parsed.error;
+    const normalized = AssetGuid$1.format(parsed.value);
+    if (seen.has(normalized.toLowerCase())) continue;
+    seen.add(normalized.toLowerCase());
+    merged.push(directReference(normalized));
+  }
+  return merged;
+}
+function directReferenceFailure(sourcePath, guids) {
+  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, nativeFingerprints) {
+  if (nativeFingerprints.size === 0) return sourceRevision;
+  return `sha256:${packageTransportRevision({
+    sourceRevision,
+    nativeCookers: [...nativeFingerprints.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )
+  })}`;
+}
+function importedAssetArtifacts(assets) {
+  return Object.fromEntries(
+    assets.flatMap(
+      (asset) => Object.entries(asset.artifacts).map(([key, artifact]) => [`${asset.guid}/${key}`, artifact])
+    )
+  );
+}
+function rawDirectProduct(input) {
+  const inputFingerprint = `sha256:${packageTransportRevision({
+    packageId: input.projected.packageId,
+    sourceRevision: input.sourceRevision,
+    assets: input.projected.assets
+  })}`;
+  const assets = input.projected.assets.map((asset) => ({
+    guid: asset.guid,
+    kind: asset.kind,
+    ...asset.name === void 0 ? {} : { 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",
+        status: "succeeded",
+        inputFingerprint
+      })),
+      diagnostics: [],
+      sourceRevision: inputFingerprint,
+      sourceKey: input.sourcePath
+    },
+    stagedOutputs: input.projected.assets.map((asset) => ({
+      guid: directGuid(asset.guid),
+      sourceKey: asset.sourceKey,
+      asset: {
+        ...directRuntimePayload(asset),
+        kind: asset.kind
+      },
+      digest: `sha256:${packageTransportRevision({ kind: asset.kind, payload: asset.payload })}`
+    })),
+    externalEvidence: [],
+    inputFingerprint
+  };
+}
+function directGuid(value) {
+  const parsed = AssetGuid$1.parse(value);
+  if (!parsed.ok) throw parsed.error;
+  return parsed.value;
+}
+function nativeRefs(refs) {
+  return refs.map((guid) => {
+    const parsed = AssetGuid$1.parse(guid);
+    if (!parsed.ok) throw parsed.error;
+    return { guid: AssetGuid$1.format(parsed.value) };
+  });
+}
+function nativeCookSource(asset) {
+  if (asset.kind !== "material" || asset.payload === null || typeof asset.payload !== "object" || Array.isArray(asset.payload)) {
+    return asset.payload;
+  }
+  return { ...asset.payload, kind: asset.kind };
+}
+function isEngineOwnedMaterial(asset) {
+  if (asset.kind !== "material" || asset.payload === null || typeof asset.payload !== "object" || Array.isArray(asset.payload)) {
+    return false;
+  }
+  return isEngineMaterial(asset.payload);
+}
+function directRuntimePayload(asset) {
+  if (asset.kind !== "ui" || asset.payload === null || typeof asset.payload !== "object" || Array.isArray(asset.payload)) {
+    return asset.payload;
+  }
+  return { ...asset.payload, guid: asset.guid };
+}
+function directAssetForProducer(asset) {
+  const payload = {
+    ...directRuntimePayload(asset),
+    kind: asset.kind
+  };
+  if (asset.kind !== "mesh") return payload;
+  return normalizeMeshPayload(payload, asset.refs) ?? payload;
+}
+async function prepareDirectPackTransport(input) {
+  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 !== void 0 && Object.keys(asset.artifacts).length > 0
+  );
+  if (directArtifacts !== void 0) {
+    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$1.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 = /* @__PURE__ */ new Map();
+  const nativeFingerprints = /* @__PURE__ */ new Map();
+  for (const asset of input.projected.assets) {
+    if (!isScriptablePackAssetKind(asset.kind)) continue;
+    if (cookerRegistry.get(asset.kind) === void 0) 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 known2 = /* @__PURE__ */ new Set([...availableGuids, ...localGuids]);
+    const missing2 = /* @__PURE__ */ new Set();
+    for (const asset of raw.product.assets) {
+      for (const reference of asset.refs) {
+        if (!known2.has(reference.guid.toLowerCase())) missing2.add(reference.guid.toLowerCase());
       }
-    ];
+    }
+    if (missing2.size > 0) return err(directReferenceFailure(input.sourcePath, [...missing2]));
+    const finalized2 = await finalizePackageTransportSource(
+      projectImportProductForBuild(raw.product),
+      input.policy
+    );
+    const facts2 = projectScriptablePackPublication(raw);
+    if (!facts2.ok) return facts2;
+    const displaySourcePath2 = input.displaySourcePath ?? input.sourcePath;
+    const revision2 = await scriptablePackResourceRevision(displaySourcePath2, raw.inputFingerprint, [
+      { path: input.sourcePath, digest: input.sourceRevision }
+    ]);
+    return ok({
+      projected: input.projected,
+      product: raw,
+      finalized: finalized2,
+      facts: facts2.value,
+      revision: revision2
+    });
+  }
+  const definition = {
+    schemaVersion: "2.0.0",
+    packageId: packageId.value,
+    build: () => ok(
+      Object.fromEntries(
+        input.projected.assets.map((asset) => [
+          asset.sourceKey,
+          {
+            ...nativeDrafts.get(asset.guid.toLowerCase())?.payload ?? directAssetForProducer(asset),
+            kind: asset.kind
+          }
+        ])
+      )
+    )
+  };
+  const outputs = createStandardAssetOutputProducerRegistry();
+  outputs.register(createPreExternalizedSceneAssetOutputProducer());
+  const built = await buildScriptablePack({
+    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,
+      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 = /* @__PURE__ */ new Set();
+  const known = /* @__PURE__ */ 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 = {
+    ...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 = projectScriptablePackPublication(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
   });
 }
+async function prepareLegacyPackTransport(authoredPack, cookers, policyFor, sourcePath) {
+  const firstGuid = authoredPack.assets[0]?.guid?.toLowerCase();
+  if (authoredPack.schemaVersion !== "2.0.0" || firstGuid === void 0) {
+    return { pack: authoredPack, ...firstGuid === void 0 ? {} : { firstGuid } };
+  }
+  const cooked = await readCookedAuthoredPack(authoredPack, cookers, sourcePath);
+  if (cooked === void 0) return { pack: authoredPack, firstGuid };
+  return {
+    pack: authoredPack,
+    firstGuid,
+    cooked,
+    finalized: await finalizePackageTransportSource(cooked.logicalPackage, policyFor(firstGuid))
+  };
+}
 async function materializePreparedScriptablePack(prepared, paths, sink) {
   const { product, finalized } = prepared;
   await sink.writePackage(paths.packagePath, JSON.stringify(finalized.pack));
@@ -1797,188 +2568,39 @@ async function materializePreparedScriptablePack(prepared, paths, sink) {
     );
   }
   const receipts = /* @__PURE__ */ new Map();
-  for (const guid of product.declaredGuids) {
-    const path = paths.receiptPath(guid);
+  for (const asset of product.product.assets) {
+    const path = paths.receiptPath(asset.guid);
     await sink.writeReceipt(
       path,
       JSON.stringify({
-        guid,
+        guid: asset.guid,
         origin: "sourceMeta",
         status: "succeeded",
         inputFingerprint: product.inputFingerprint,
         outputDigest: finalized.digest
       })
     );
-    receipts.set(guid, path);
+    receipts.set(asset.guid.toLowerCase(), path);
   }
   return receipts;
 }
-async function readCookedAuthoredPack(authoredPack, cookers = [], sourcePath) {
-  const parsed = upgradeLegacyAuthoredPack(authoredPack);
-  if (parsed.schemaVersion !== "2.0.0" || parsed.assets === void 0) return void 0;
-  const registry = new NativeCookerRegistry();
-  for (const cooker of cookers) registry.register(cooker);
-  const assets = [];
-  const refsByGuid = /* @__PURE__ */ new Map();
-  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 === void 0 ? {} : { name: asset.name },
-        ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
-        ...asset.sourceIndex === void 0 ? {} : { sourceIndex: asset.sourceIndex },
-        ...asset.relations === void 0 ? {} : { 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 === void 0 ? {} : { sourceKey: asset.sourceKey },
-      ...sourcePath === void 0 ? {} : { 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 === void 0 ? {} : { name: asset.name },
-      ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
-      ...asset.sourceIndex === void 0 ? {} : { sourceIndex: asset.sourceIndex },
-      ...asset.relations === void 0 ? {} : { relations: asset.relations },
-      payload: draft.payload,
-      refs,
-      artifacts: draft.artifacts
-    });
-  }
-  return hasCookedAsset ? {
-    logicalPackage: { schemaVersion: "2.0.0", kind: "internal-text-package", assets },
-    refsByGuid
-  } : void 0;
-}
-async function declaredPackExternalOutputs(declarations, cookers = [], requiredGuids = [], externalImport) {
-  if (requiredGuids.length === 0) return [];
-  const required = new Set(requiredGuids.map((guid) => AssetGuid.format(guid).toLowerCase()));
-  const outputs = [];
-  for (const declaration of declarations.values()) {
-    if (declaration.format === "meta.json") {
-      if (externalImport === void 0) continue;
-      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 meta = {
-        importer: declaration.value.importer,
-        source: resolved.value,
-        sourceRevision: declaration.sourceRevision,
-        ...declaration.value.packageId === void 0 ? {} : { packageId: declaration.value.packageId },
-        ...declaration.value.provenance === void 0 ? {} : { provenance: declaration.value.provenance },
-        ...declaration.value.revision === void 0 ? {} : { revision: declaration.value.revision },
-        ...declaration.value.diagnostics === void 0 ? {} : { diagnostics: declaration.value.diagnostics },
-        importSettings: declaration.value.importSettings,
-        ...declaration.value.sourceOverrides === void 0 ? {} : { sourceOverrides: declaration.value.sourceOverrides },
-        subAssets: declaration.value.subAssets.map(({ guid, sourceIndex, sourceKey, kind }) => ({
-          guid,
-          sourceIndex,
-          ...sourceKey === void 0 ? {} : { sourceKey },
-          kind
-        })),
-        buildPack: false
-      };
-      const sourcePackage = await produceSourcePackage({
-        meta,
-        registry: externalImport.importerRegistry,
-        fs: externalImport.fsForImport
-      });
-      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`
-        });
-      }
-      for (const asset of sourcePackage.value.product.assets) {
-        const key = asset.guid.toLowerCase();
-        if (!required.has(key)) continue;
-        const parsed = AssetGuid.parse(asset.guid);
-        if (!parsed.ok) throw parsed.error;
-        outputs.push({
-          guid: parsed.value,
-          asset: { kind: asset.kind, ...asset.payload }
-        });
-      }
-      continue;
-    }
-    if (declaration.format !== "pack.json") continue;
-    const declaredAssets = declaration.value.assets.filter(
-      (asset) => required.has(asset.guid.toLowerCase())
-    );
-    if (declaredAssets.length === 0) 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 } });
-    }
-  }
-  return outputs;
-}
-async function prepareAuthoredPackTransport(authoredPack, cookers, policyFor, sourcePath) {
-  const pack = upgradeLegacyAuthoredPack(authoredPack);
-  const firstGuid = pack.assets?.[0]?.guid?.toLowerCase();
-  if (pack.schemaVersion !== "2.0.0" || firstGuid === void 0) {
-    return { pack, ...firstGuid === void 0 ? {} : { firstGuid } };
-  }
-  const cooked = await readCookedAuthoredPack(pack, cookers, sourcePath);
-  if (cooked === void 0) return { pack, firstGuid };
-  return {
-    pack,
-    firstGuid,
-    cooked,
-    finalized: await finalizePackageTransportSource(cooked.logicalPackage, policyFor(firstGuid))
-  };
-}
 function projectScriptablePackPublication(product) {
   const assets = new Map(product.product.assets.map((asset) => [asset.guid.toLowerCase(), asset]));
   const outputs = [];
   for (const staged of product.stagedOutputs) {
-    const guid = AssetGuid.format(staged.guid).toLowerCase();
+    const guid = AssetGuid$1.format(staged.guid).toLowerCase();
     const asset = assets.get(guid);
-    if (asset === void 0 || staged.digest === void 0) {
+    if (asset === void 0 || staged.digest === void 0 || staged.sourceKey === void 0) {
       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: `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 }
       });
     }
     outputs.push({
       guid,
-      sourceKey: staged.sourceKey ?? guid,
+      sourceKey: staged.sourceKey,
       kind: asset.kind,
       digest: staged.digest,
       refs: asset.refs.map((reference) => reference.guid)
@@ -1994,130 +2616,115 @@ function projectScriptablePackPublication(product) {
     )
   });
 }
-async function scriptablePackResourceRevision(displaySourcePath, digest, sourceClosure) {
-  const observedAt = Math.trunc(
-    Math.max(
-      ...await Promise.all(sourceClosure.map(async (entry) => (await stat(entry.path)).mtimeMs))
-    )
+function snapshotSourceForStagedOutputs(outputs) {
+  if (outputs.length === 0) return void 0;
+  const byGuid = new Map(
+    outputs.map((output) => [AssetGuid$1.format(output.guid).toLowerCase(), output])
   );
-  return { digest, observedAt, rootId: displaySourcePath };
-}
-async function produceScriptablePackProducts(sources, declaredExternalOutputs = []) {
-  const entries = /* @__PURE__ */ new Map();
-  for (const source of sources) {
-    if (entries.has(source.displaySourcePath)) continue;
-    entries.set(source.displaySourcePath, {
-      source,
-      definition: source.definition,
-      closure: source.sourceClosure
-    });
-  }
-  const products = /* @__PURE__ */ new Map();
-  const owners = [...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);
+  return {
+    async readByGuid(guid) {
+      const key = AssetGuid$1.format(guid).toLowerCase();
+      const output = byGuid.get(key);
+      if (output === void 0) {
+        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"
+          })
+        );
       }
-    })
-  );
-  const generationDigest = createHash("sha256").update(
-    JSON.stringify(
-      [...entries.values()].flatMap((entry) => entry.closure).sort((a, b) => a.path.localeCompare(b.path))
-    )
-  ).digest();
-  const stagedSource = createScriptablePackStagedAssetSnapshotSource({
-    generation: generationDigest.readUInt32BE(0),
-    owners,
-    declaredExternalOutputs
-  });
-  const prepared = /* @__PURE__ */ new Map();
-  for (const source of sources) {
-    const entry = entries.get(source.displaySourcePath);
-    if (entry === void 0) {
-      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 }
+      return ok({
+        asset: structuredClone(output.asset),
+        generation: 1,
+        digest: output.digest ?? "sha256:staged"
       });
     }
-    const first = Object.values(entry.definition.assets)[0];
-    if (first === void 0) {
-      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: [] }
-      });
+  };
+}
+function composeScriptablePackAssetSource(staged, published) {
+  if (staged === void 0) return published;
+  if (published === void 0) 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 staged = await stagedSource.readByGuid(first.guid);
-    if (!staged.ok) return err(staged.error);
-    const produced = products.get(source.displaySourcePath);
-    if (produced === void 0) {
+  };
+}
+async function produceScriptablePackProducts(options) {
+  if (options.sources.length === 0) return ok(/* @__PURE__ */ new Map());
+  const external = options.declaredExternalOutputs ?? [];
+  const assetSource = composeScriptablePackAssetSource(
+    snapshotSourceForStagedOutputs(external),
+    options.assetSource
+  );
+  const availableGuids = /* @__PURE__ */ new Set([
+    ...options.availableGuids ?? [],
+    ...external.map((output) => AssetGuid$1.format(output.guid).toLowerCase())
+  ]);
+  const workItems = options.sources.map((source) => ({
+    definition: source.definition,
+    sourcePath: source.sourcePath,
+    ...source.subjectPackageId === void 0 ? {} : { subjectPackageId: source.subjectPackageId },
+    ...source.values === void 0 ? {} : { values: source.values },
+    ...source.inheritedValues === void 0 ? {} : { inheritedValues: source.inheritedValues },
+    sourceClosure: source.sourceClosure
+  }));
+  const worklist = await buildScriptablePackWorklist({
+    subjects: workItems,
+    outputs: createStandardAssetOutputProducerRegistry(
+      options.sources.flatMap(
+        (source) => projectScriptablePackSceneComponents(source.definition.sceneComponents)
+      )
+    ),
+    ...assetSource === void 0 ? {} : { assetSource },
+    availableGuids,
+    ...options.incomingRefs === void 0 ? {} : { incomingRefs: options.incomingRefs },
+    ...options.maxPasses === void 0 ? {} : { maxPasses: options.maxPasses }
+  });
+  if (!worklist.ok) return worklist;
+  const productsBySource = new Map(
+    worklist.value.buildProducts.filter((product) => product.product.sourceKey !== void 0).map((product) => [product.product.sourceKey, product])
+  );
+  const prepared = /* @__PURE__ */ new Map();
+  for (const source of options.sources) {
+    const product = productsBySource.get(source.sourcePath);
+    if (product === void 0) {
       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 = projectScriptablePackPublication(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,
@@ -2126,6 +2733,22 @@ async function produceScriptablePackProducts(sources, declaredExternalOutputs =
   }
   return ok(prepared);
 }
+async function scriptablePackResourceRevision(displaySourcePath, digest3, sourceClosure) {
+  const mtimes = await Promise.all(
+    sourceClosure.map(async (entry) => {
+      try {
+        return (await stat(entry.path)).mtimeMs;
+      } catch (error) {
+        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: digest3, observedAt, rootId: displaySourcePath };
+}
 function normalizeCatalogPath(path) {
   return path.replaceAll("\\", "/").replace(/^\.\//, "");
 }
@@ -2148,120 +2771,273 @@ function scriptableArtifactPath(guid, key) {
   return `${guid.toLowerCase()}/${key.includes(".") ? key : `${key}.bin`}`;
 }
 function runtimePublicationFor(context, input) {
-  return createRuntimePackPublication({
+  const publicationInput = {
     pack: input.pack,
     scopeId: context.runtimeBinding?.scopeId ?? "asset-runtime",
     sourcePath: input.sourcePath,
     sourceRevision: input.sourceRevision,
     packageUrl: input.packageUrl,
     ...input.digest === void 0 ? {} : { digest: input.digest },
+    ...input.inputFingerprint === void 0 ? {} : { inputFingerprint: input.inputFingerprint },
+    ...input.outputs === void 0 ? {} : { outputs: input.outputs },
+    ...input.externalEvidence === void 0 ? {} : { externalEvidence: input.externalEvidence },
     generation: context.runtimeBinding?.generation ?? context.generation
+  };
+  if (input.sourceKeys === void 0) return createRuntimePackPublication(publicationInput);
+  const derived = createRuntimePackPublication(publicationInput);
+  const outputs = derived.publication.outputs.map((output) => ({
+    ...output,
+    sourceKey: input.sourceKeys?.get(output.guid.toLowerCase()) ?? output.sourceKey
+  }));
+  return createRuntimePackPublication({ ...publicationInput, outputs });
+}
+function sourceKeysFor(declarations) {
+  return new Map(
+    declarations.flatMap(
+      (declaration) => declaration.sourceKey === void 0 ? [] : [[declaration.guid.toLowerCase(), declaration.sourceKey]]
+    )
+  );
+}
+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 : "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 }
   });
 }
-async function buildAuthoredPackages(context) {
-  const scriptableSources = [...context.inventory.sourceDeclarations.entries()].filter(([, declaration]) => declaration.format === "pack.ts").map(([sourcePath]) => sourcePath);
-  if (scriptableSources.length === 0) return /* @__PURE__ */ new Map();
-  const inputs = scriptablePackInputs(
-    scriptableSources,
-    context.inventory.sourceDeclarations,
-    context.cwd,
-    () => context.generation,
-    () => (product) => ({
-      base: context.basePrefix === "" ? "/" : context.basePrefix,
-      packagePath: `assets/${product.anchorGuid}.pack.json`,
-      artifactPath: scriptableArtifactPath
-    }),
-    context.fsForImport.sourceIdentityFor
+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 buildPackSources(context) {
+  const subjects = /* @__PURE__ */ new Map();
+  for (const [sourcePath, declaration] of context.inventory.sourceDeclarations) {
+    if (declaration.format === "pack.ts") {
+      const key = PackageId.format(declaration.definition.packageId).toLowerCase();
+      subjects.set(key, {
+        kind: "source",
+        packageId: declaration.definition.packageId,
+        sourcePath,
+        definition: declaration.definition,
+        sourceClosure: declaration.sourceClosure
+      });
+      continue;
+    }
+    if (declaration.format !== "pack.json" || declaration.value.schemaVersion !== "3.0.0") {
+      continue;
+    }
+    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(), {
+        kind: "direct",
+        packageId: parsed.value.packageId,
+        sourcePath
+      });
+    } else {
+      subjects.set(PackageId.format(parsed.value.packageId).toLowerCase(), {
+        kind: "instance",
+        packageId: parsed.value.packageId,
+        parent: parsed.value.parent,
+        values: parsed.value.values,
+        sourcePath
+      });
+    }
+  }
+  const sourceSubject = (packageId) => {
+    const subject = subjects.get(PackageId.format(packageId).toLowerCase());
+    return subject?.kind === "source" ? subject : void 0;
+  };
+  const readSubject = async (packageId) => {
+    const subject = subjects.get(PackageId.format(packageId).toLowerCase());
+    if (subject === void 0) return void 0;
+    if (subject.kind === "source") {
+      return {
+        format: "source",
+        packageId: subject.packageId,
+        parameters: "parameters" in subject.definition ? subject.definition.parameters : []
+      };
+    }
+    if (subject.kind === "instance") {
+      return {
+        format: "instance",
+        packageId: subject.packageId,
+        parent: subject.parent,
+        values: subject.values
+      };
+    }
+    return {
+      format: "direct",
+      packageId: subject.packageId
+    };
+  };
+  const orderedSubjects = [...subjects.values()].sort(
+    (left, right) => left.sourcePath.localeCompare(right.sourcePath)
   );
-  const preparedResult = await produceScriptablePackProducts(
-    inputs,
-    await declaredPackExternalOutputs(
-      context.inventory.sourceDeclarations,
-      context.cookers,
-      inputs.flatMap((input) => Object.values(input.definition.externalAssets)),
-      {
-        importerRegistry: context.importerRegistry,
-        fsForImport: context.fsForImport,
-        assetPaths: loadAssetConfig(context.cwd).paths
+  const inputs = [];
+  for (const subject of orderedSubjects) {
+    if (subject.kind === "source") {
+      const packageId = PackageId.format(subject.packageId);
+      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 ScriptablePack source packageId to remain fixed during production",
+          hint: "retry after source writes settle and rebuild the current generation",
+          detail: {
+            sourcePath: subject.sourcePath,
+            scannedPackageId: packageId,
+            loadedPackageId: PackageId.format(loaded.value.packageId)
+          }
+        });
       }
-    )
-  );
-  if (!preparedResult.ok) throw context.fail(preparedResult.error);
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of context.inventory.entries) {
-    if (!entry.sourcePath.endsWith(".pack.ts") || result.has(entry.sourcePath)) continue;
-    const prepared = preparedResult.value.get(canonicalScriptableSourcePath(entry.sourcePath));
-    if (prepared === void 0) {
-      throw context.fail({
-        code: "catalog-declaration-missing",
-        expected: "the ScriptablePack inventory to retain every authored Pack source",
-        hint: "rerun the source inventory and rebuild from the accepted declaration set",
-        detail: { stage: "scan", sourcePath: entry.sourcePath }
+      inputs.push({
+        sourcePath: subject.sourcePath,
+        displaySourcePath: packCatalogSourcePath(context, subject.sourcePath),
+        definition: loaded.value,
+        sourceClosure: subject.sourceClosure,
+        publicationGeneration: context.generation,
+        policy: {
+          base: context.basePrefix === "" ? "/" : context.basePrefix,
+          packagePath: `assets/${packageId}.pack.json`,
+          artifactPath: scriptableArtifactPath
+        }
       });
     }
-    const { product, finalized, facts, revision, publication } = prepared;
-    const packagePath = `assets/${product.anchorGuid}.pack.json`;
-    const runtimePublication = createRuntimePackPublication({
-      pack: { assets: finalized.pack.assets },
-      scopeId: context.runtimeBinding?.scopeId ?? "asset-runtime",
-      sourcePath: publication.sourcePath,
-      sourceRevision: publication.sourceRevision,
-      packageUrl: finalized.packageUrl,
-      inputFingerprint: publication.receipt.inputFingerprint,
-      digest: finalized.digest,
-      generation: context.runtimeBinding?.generation ?? publication.generation,
-      outputs: facts.outputs,
-      externalEvidence: publication.externalEvidence
-    });
-    const receiptPaths = await materializePreparedScriptablePack(
-      prepared,
+  }
+  for (const subject of orderedSubjects) {
+    if (subject.kind !== "instance") continue;
+    const resolved = await resolvePackParameterInheritance(
       {
-        packagePath,
-        artifactPath: (path) => `assets/${path}`,
-        receiptPath: (guid) => `assets/${guid}.receipt.json`
+        format: "instance",
+        packageId: subject.packageId,
+        parent: subject.parent,
+        values: subject.values
       },
-      {
-        writePackage: (path) => {
-          context.sink.emitFile({
-            type: "asset",
-            fileName: path,
-            originalFileName: `${context.cwd}/${entry.sourcePath}`,
-            source: JSON.stringify(runtimePublication.pack)
-          });
-        },
-        writeArtifact: (path, bytes2) => {
-          context.sink.emitFile({ type: "asset", fileName: path, source: bytes2 });
-        },
-        writeReceipt: (path, source) => {
-          context.sink.emitFile({ type: "asset", fileName: path, source });
+      readSubject
+    );
+    if (!resolved.ok) dynamicFailure(context, resolved.error);
+    const root = sourceSubject(resolved.value.rootPackageId);
+    if (root === void 0) {
+      dynamicFailure(context, {
+        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 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 ScriptablePack parent packageId to remain fixed during production",
+        hint: "retry after source writes settle and rebuild the current generation",
+        detail: {
+          sourcePath: root.sourcePath,
+          scannedPackageId: PackageId.format(root.packageId),
+          loadedPackageId: PackageId.format(loaded.value.packageId)
         }
+      });
+    }
+    const packageId = PackageId.format(subject.packageId);
+    inputs.push({
+      sourcePath: subject.sourcePath,
+      displaySourcePath: packCatalogSourcePath(context, subject.sourcePath),
+      definition: loaded.value,
+      sourceClosure: root.sourceClosure,
+      subjectPackageId: subject.packageId,
+      values: resolved.value.values,
+      publicationGeneration: context.generation,
+      policy: {
+        base: context.basePrefix === "" ? "/" : context.basePrefix,
+        packagePath: `assets/${packageId}.pack.json`,
+        artifactPath: scriptableArtifactPath
       }
-    );
-    result.set(entry.sourcePath, {
-      packageUrl: finalized.packageUrl,
-      receiptUrls: new Map(
-        [...receiptPaths].map(([guid, path]) => [guid, context.sink.fileUrl(path)])
-      ),
-      revision,
-      publication: runtimePublication.publication,
-      refs: facts.refs
     });
   }
-  return result;
+  if (inputs.length === 0) return [];
+  const requiredGuids = context.inventory.entries.flatMap((entry) => {
+    const parsed = AssetGuid$1.parse(entry.guid);
+    if (!parsed.ok) dynamicFailure(context, parsed.error);
+    return [parsed.value];
+  });
+  const externalOutputs = await declaredPackExternalOutputs(
+    context.inventory.sourceDeclarations,
+    context.cookers,
+    requiredGuids,
+    {
+      importerRegistry: context.importerRegistry,
+      fsForImport: context.fsForImport
+    }
+  );
+  const availableGuids = new Set(requiredGuids.map((guid) => AssetGuid$1.format(guid).toLowerCase()));
+  const built = await produceScriptablePackProducts({
+    sources: inputs,
+    declaredExternalOutputs: externalOutputs,
+    availableGuids
+  });
+  if (!built.ok) dynamicFailure(context, built.error);
+  const bundles = [];
+  for (const input of inputs) {
+    const prepared = built.value.get(input.displaySourcePath);
+    if (prepared === void 0) {
+      dynamicFailure(context, {
+        code: "pack-build-failed",
+        expected: "the worklist to return one prepared result per source subject",
+        hint: "rerun Pack source generation from a clean inventory",
+        detail: { sourcePath: input.sourcePath }
+      });
+    }
+    const packageId = PackageId.format(input.subjectPackageId ?? input.definition.packageId);
+    const stagedByGuid = new Map(
+      prepared.product.stagedOutputs.map((output) => [
+        AssetGuid$1.format(output.guid).toLowerCase(),
+        output
+      ])
+    );
+    const entries = projectPackageCatalog(
+      prepared.product.product.assets.map((asset, sourceIndex) => {
+        const staged = stagedByGuid.get(asset.guid.toLowerCase());
+        return {
+          guid: asset.guid,
+          kind: asset.kind,
+          sourcePath: input.displaySourcePath,
+          sourceIndex,
+          ...staged?.sourceKey === void 0 ? {} : { sourceKey: staged.sourceKey },
+          refs: asset.refs.map((reference) => reference.guid),
+          execution: "cooked",
+          packageId,
+          provenance: { provider: "pack-ts", version: "2.0.0" }
+        };
+      }),
+      `${context.basePrefix === "/" ? "" : context.basePrefix}/${input.displaySourcePath}`
+    );
+    bundles.push({ input, prepared, entries });
+  }
+  return bundles;
 }
-function updateImportedEntries(entries, guids, packageUrl, projection = {}, refsByGuid, publication, sourcePath) {
+function updateImportedEntries(entries, guids, packageUrl, projection = {}, refsByGuid, publication, sourcePath, receiptUrls, revision) {
   const selected = new Set(guids.map((guid) => guid.toLowerCase()));
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
     if (entry === void 0 || !selected.has(entry.guid.toLowerCase())) continue;
     const refs = refsByGuid?.get(entry.guid.toLowerCase());
+    const cookReceiptUrl = receiptUrls?.get(entry.guid.toLowerCase());
     entries[index] = {
       ...entry,
       packageUrl,
       ...projection,
       ...sourcePath === void 0 ? {} : { sourcePath },
       ...publication === void 0 ? {} : { publication },
-      ...refs === void 0 ? {} : { refs }
+      ...refs === void 0 ? {} : { refs },
+      ...cookReceiptUrl === void 0 ? {} : { cookReceiptUrl },
+      ...revision === void 0 ? {} : { revision }
     };
   }
 }
@@ -2275,11 +3051,30 @@ async function emitPackDocument(work, options) {
   }
   const referenceId = work.context.sink.emitFile({
     type: "asset",
+    fileName: options.packageName.startsWith("assets/") ? options.packageName : `assets/${options.packageName}`,
     name: options.packageName,
     originalFileName: options.originalFileName,
     source: JSON.stringify(options.pack)
   });
   const packageUrl = work.context.sink.fileUrl(work.context.sink.getFileName(referenceId));
+  const receiptUrls = /* @__PURE__ */ new Map();
+  for (const receipt of options.receipts ?? []) {
+    const guid = receipt.guid.toLowerCase();
+    const receiptReferenceId = work.context.sink.emitFile({
+      type: "asset",
+      fileName: `assets/${guid}.receipt.json`,
+      name: `${guid}.receipt.json`,
+      originalFileName: options.originalFileName,
+      source: JSON.stringify({
+        ...receipt,
+        ...receipt.outputDigest === void 0 && options.receiptOutputDigest === void 0 ? {} : { outputDigest: receipt.outputDigest ?? options.receiptOutputDigest }
+      })
+    });
+    receiptUrls.set(
+      guid,
+      work.context.sink.fileUrl(work.context.sink.getFileName(receiptReferenceId))
+    );
+  }
   updateImportedEntries(
     work.importedEntries,
     options.guids,
@@ -2287,11 +3082,13 @@ async function emitPackDocument(work, options) {
     options.projection,
     options.refsByGuid,
     options.publication,
-    options.sourcePath
+    options.sourcePath,
+    receiptUrls,
+    options.revision
   );
   return packageUrl;
 }
-async function emitAuthoredPack(work, guidSeen, entry) {
+async function emitAuthoredPack(work, guidSeen, entry, availableGuids) {
   const sourceDeclaration = sourceDeclarationForCatalogPath(
     entry.sourcePath,
     work.context.inventory.sourceDeclarations,
@@ -2308,39 +3105,143 @@ async function emitAuthoredPack(work, guidSeen, entry) {
       detail: { stage: "scan", sourcePath: packPath }
     });
   }
-  const prepared = await prepareAuthoredPackTransport(
-    declaration.value,
+  if (declaration.value.schemaVersion === "3.0.0") {
+    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 ScriptablePack parent and do not have direct Catalog rows",
+        detail: { stage: "scan", sourcePath: packPath }
+      });
+    }
+    const projected = projectDirectPackJson(parsed.value);
+    if (!projected.ok) dynamicFailure(work.context, projected.error);
+    const prepared2 = await prepareDirectPackTransport({
+      projected: projected.value,
+      sourcePath: packPath,
+      sourceRevision: declaration.sourceRevision,
+      availableGuids,
+      cookers: work.context.cookers,
+      policy: {
+        base: work.context.basePrefix === "" ? "/" : work.context.basePrefix,
+        packagePath: `assets/${projected.value.packageId}.pack.json`,
+        artifactPath: (assetGuid, key) => `${assetGuid}/${key}.bin`,
+        sink: () => {
+        }
+      }
+    });
+    if (!prepared2.ok) dynamicFailure(work.context, prepared2.error);
+    const { product, finalized, facts, revision } = prepared2.value;
+    const publication = runtimePublicationFor(work.context, {
+      pack: finalized.pack,
+      sourcePath: entry.sourcePath,
+      sourceRevision: product.inputFingerprint,
+      packageUrl: finalized.packageUrl,
+      digest: finalized.digest,
+      inputFingerprint: product.inputFingerprint,
+      outputs: facts.outputs,
+      externalEvidence: product.externalEvidence
+    });
+    await emitPackDocument(work, {
+      pack: publication.pack,
+      artifacts: finalized.artifacts,
+      packageName: `${prepared2.value.projected.packageId}.pack.json`,
+      originalFileName: packPath,
+      guids: product.product.assets.map((asset) => asset.guid),
+      projection: work.context.authoredCookedCurrentProjection,
+      refsByGuid: facts.refs,
+      receipts: product.product.receipts,
+      receiptOutputDigest: finalized.digest,
+      publication: publication.publication,
+      sourcePath: entry.sourcePath,
+      revision
+    });
+    for (const asset of product.product.assets) guidSeen.add(asset.guid.toLowerCase());
+    return;
+  }
+  const legacy = declaration.value;
+  const prepared = await prepareLegacyPackTransport(
+    legacy,
     work.context.cookers,
     (guid) => ({
       base: work.context.basePrefix === "" ? "/" : work.context.basePrefix,
       packagePath: `assets/${guid}.pack.json`,
-      artifactPath: (artifactGuid, key) => `${artifactGuid}/${key}.bin`
+      artifactPath: (assetGuid, key) => `${assetGuid}/${key}.bin`
     }),
     packPath
   );
   const outputGuid = prepared.firstGuid ?? entry.guid;
-  const authoredPack = prepared.finalized?.pack ?? prepared.pack;
-  const runtimePublication = authoredPack.assets === void 0 || authoredPack.assets.length === 0 ? void 0 : runtimePublicationFor(work.context, {
-    pack: { assets: authoredPack.assets },
+  const authoredPack = prepared.finalized?.pack ?? {
+    schemaVersion: "2.0.0",
+    kind: "internal-text-package",
+    assets: legacy.assets.map((asset) => ({
+      guid: asset.guid,
+      kind: asset.kind,
+      ...asset.name === void 0 ? {} : { name: asset.name },
+      payload: asset.payload,
+      refs: asset.refs,
+      artifacts: asset.artifacts ?? {}
+    }))
+  };
+  const runtimePublication = runtimePublicationFor(work.context, {
+    pack: authoredPack,
     sourcePath: entry.sourcePath,
     sourceRevision: declaration.sourceRevision,
     packageUrl: prepared.finalized?.packageUrl ?? `${work.context.basePrefix === "/" ? "" : work.context.basePrefix}/assets/${outputGuid}.pack.json`,
     ...prepared.finalized?.digest === void 0 ? {} : { digest: prepared.finalized.digest }
   });
   await emitPackDocument(work, {
-    pack: runtimePublication?.pack ?? authoredPack,
+    pack: runtimePublication.pack,
     artifacts: prepared.finalized?.artifacts ?? [],
     packageName: `${outputGuid}.pack.json`,
     originalFileName: packPath,
-    guids: prepared.pack.assets?.map((asset) => asset.guid) ?? [outputGuid],
+    guids: authoredPack.assets.map((asset) => asset.guid),
     projection: prepared.finalized === void 0 ? work.context.directCurrentProjection : work.context.authoredCookedCurrentProjection,
-    ...prepared.cooked === void 0 ? {} : { refsByGuid: prepared.cooked.refsByGuid },
-    ...runtimePublication === void 0 ? {} : { publication: runtimePublication.publication }
+    refsByGuid: new Map(authoredPack.assets.map((asset) => [asset.guid.toLowerCase(), asset.refs])),
+    ...prepared.finalized?.receipts === void 0 ? {} : {
+      receipts: prepared.finalized.receipts,
+      receiptOutputDigest: prepared.finalized.digest
+    },
+    publication: runtimePublication.publication,
+    sourcePath: entry.sourcePath
   });
-  for (const guid of prepared.pack.assets?.map((asset) => asset.guid) ?? [outputGuid]) {
+  for (const guid of authoredPack.assets.map((asset) => asset.guid)) {
     guidSeen.add(guid.toLowerCase());
   }
 }
+async function emitScriptablePack(work, guidSeen, bundle) {
+  const { input, prepared } = bundle;
+  const packageId = PackageId.format(input.subjectPackageId ?? input.definition.packageId);
+  const runtimePublication = createRuntimePackPublication({
+    pack: { assets: prepared.finalized.pack.assets },
+    scopeId: work.context.runtimeBinding?.scopeId ?? "asset-runtime",
+    sourcePath: input.displaySourcePath,
+    sourceRevision: prepared.product.inputFingerprint,
+    packageUrl: prepared.finalized.packageUrl,
+    inputFingerprint: prepared.product.inputFingerprint,
+    digest: prepared.finalized.digest,
+    generation: work.context.runtimeBinding?.generation ?? prepared.publication.generation,
+    outputs: prepared.facts.outputs,
+    externalEvidence: prepared.product.externalEvidence
+  });
+  await emitPackDocument(work, {
+    pack: runtimePublication.pack,
+    artifacts: prepared.finalized.artifacts,
+    packageName: `${packageId}.pack.json`,
+    originalFileName: input.sourcePath,
+    guids: prepared.product.product.assets.map((asset) => asset.guid),
+    projection: work.context.authoredCookedCurrentProjection,
+    refsByGuid: prepared.facts.refs,
+    receipts: prepared.product.product.receipts,
+    receiptOutputDigest: prepared.finalized.digest,
+    publication: runtimePublication.publication,
+    sourcePath: input.displaySourcePath,
+    revision: prepared.revision
+  });
+  for (const asset of prepared.product.product.assets) guidSeen.add(asset.guid.toLowerCase());
+}
 async function emitFinalizedOwner(work, metaPath, sourcePath, subAssets, sourcePackage, ownerFinalizer) {
   const ownerGuid = subAssets[0]?.guid;
   if (ownerGuid === void 0) return;
@@ -2409,11 +3310,12 @@ async function emitFinalizedOwner(work, metaPath, sourcePath, subAssets, sourceP
     sourcePath
   });
 }
-async function emitBuildEntry(work, guidSeen, entry) {
+async function emitBuildEntry(work, guidSeen, entry, availableGuids) {
   const guid = entry.guid.toLowerCase();
   const metaPath = metaPathForGuid(work.context.inventory.declarations, guid);
   if (metaPath === void 0) {
-    if (entry.sourcePath.endsWith(".pack.json")) await emitAuthoredPack(work, guidSeen, entry);
+    if (entry.sourcePath.endsWith(".pack.json"))
+      await emitAuthoredPack(work, guidSeen, entry, availableGuids);
     else guidSeen.add(guid);
     return;
   }
@@ -2466,7 +3368,8 @@ async function emitBuildEntry(work, guidSeen, entry) {
     sourcePath: canonicalSourcePath,
     sourceRevision: finalized.sourceRevision,
     packageUrl: finalized.packageUrl,
-    digest: finalized.digest
+    digest: finalized.digest,
+    sourceKeys: sourceKeysFor(subAssets)
   });
   await emitPackDocument(work, {
     pack: runtimePublication.pack,
@@ -2483,24 +3386,21 @@ async function emitBuildEntry(work, guidSeen, entry) {
   });
 }
 async function produceBuildAssets(context) {
-  const entries = [...context.inventory.entries];
-  const authored = await buildAuthoredPackages(context);
-  const importedEntries = entries.map((entry) => {
-    const scriptable = authored.get(entry.sourcePath);
-    if (scriptable === void 0) return entry;
-    const cookReceiptUrl = scriptable.receiptUrls.get(entry.guid.toLowerCase());
-    return projectCookedPackageEntry(entry, {
-      packageUrl: scriptable.packageUrl,
-      revision: scriptable.revision,
-      refs: scriptable.refs.get(entry.guid.toLowerCase()) ?? [],
-      ...cookReceiptUrl === void 0 ? {} : { cookReceiptUrl },
-      publication: scriptable.publication
-    });
-  });
+  const dynamicBundles = await buildPackSources(context);
+  const entries = [
+    ...context.inventory.entries,
+    ...dynamicBundles.flatMap((bundle) => bundle.entries)
+  ];
+  const availableGuids = new Set(entries.map((entry) => entry.guid.toLowerCase()));
+  const importedEntries = [...entries];
   const guidSeen = /* @__PURE__ */ new Set();
   const work = { importedEntries, context };
+  for (const bundle of dynamicBundles) {
+    await emitScriptablePack(work, guidSeen, bundle);
+  }
   for (const entry of importedEntries) {
-    if (!guidSeen.has(entry.guid.toLowerCase())) await emitBuildEntry(work, guidSeen, entry);
+    if (!guidSeen.has(entry.guid.toLowerCase()))
+      await emitBuildEntry(work, guidSeen, entry, availableGuids);
   }
   return importedEntries;
 }
@@ -2531,89 +3431,674 @@ function catalogImporterPolicy(importer, hostImporterKeys) {
       hint: "let the provider producer materialize the declared output"
     };
   }
-  if (hostImporterKeys.has(importer)) {
-    return {
-      disposition: "publish",
-      hostProvided: true,
-      expected: "a registered host Catalog provider declaration",
-      hint: "let the registered provider materialize the declared output"
-    };
+  if (hostImporterKeys.has(importer)) {
+    return {
+      disposition: "publish",
+      hostProvided: true,
+      expected: "a registered host Catalog provider declaration",
+      hint: "let the registered provider materialize the declared output"
+    };
+  }
+  return {
+    disposition: "missing",
+    hostProvided: false,
+    expected: "the sidecar importer must be present in the registered provider set",
+    hint: "wire the provider through the host importer registry before building the Catalog"
+  };
+}
+async function buildCatalogResult(roots, base = "/", registeredImporterKeys = /* @__PURE__ */ new Set(), scanOptions = {}, catalogVisibility = () => true, sourceIdentityFor) {
+  const options = {
+    base,
+    scanOptions,
+    importerPolicy: (importer) => catalogImporterPolicy(importer, registeredImporterKeys),
+    visibility: catalogVisibility,
+    ...sourceIdentityFor === void 0 ? {} : { sourceIdentityFor }
+  };
+  return buildCatalogProjection(roots, options);
+}
+function numericTokens(source, startLine) {
+  return source.split(/\r?\n/).slice(startLine).join(" ").replaceAll(",", " ").split(/\s+/).filter((token) => token.length > 0).map(Number);
+}
+function allFinite(values) {
+  return values.every(Number.isFinite);
+}
+function parseLm63TypeC(source) {
+  const lines = source.split(/\r?\n/);
+  const tiltLine = lines.findIndex((line) => /^\s*TILT\s*=/i.test(line));
+  if (tiltLine < 0) return err({ code: "invalid-ies", reason: "missing TILT declaration" });
+  const tiltSource = lines[tiltLine];
+  if (tiltSource === void 0)
+    return err({ code: "invalid-ies", reason: "missing TILT declaration" });
+  const tilt = tiltSource.slice(tiltSource.indexOf("=") + 1).trim().toUpperCase();
+  if (tilt !== "NONE") return err({ code: "unsupported-tilt", reason: `TILT=${tilt}` });
+  const values = numericTokens(source, tiltLine + 1);
+  if (values.length < 12 || !allFinite(values.slice(0, 12))) {
+    return err({ code: "invalid-ies", reason: "numeric header is incomplete or non-finite" });
+  }
+  const verticalCount = values[3];
+  const horizontalCount = values[4];
+  const photometricType = values[5];
+  if (verticalCount === void 0 || horizontalCount === void 0 || photometricType === void 0) {
+    return err({ code: "invalid-ies", reason: "numeric header is incomplete or non-finite" });
+  }
+  if (photometricType !== 1) {
+    return err({
+      code: "unsupported-photometric-type",
+      reason: `photometric type ${photometricType} is not Type C`
+    });
+  }
+  if (!Number.isInteger(verticalCount) || !Number.isInteger(horizontalCount) || verticalCount < 2 || horizontalCount < 1) {
+    return err({ code: "invalid-ies", reason: "angle counts are invalid" });
+  }
+  const angleOffset = 12;
+  const verticalEnd = angleOffset + verticalCount;
+  const horizontalEnd = verticalEnd + horizontalCount;
+  const candelaEnd = horizontalEnd + verticalCount * horizontalCount;
+  if (values.length < candelaEnd) {
+    return err({ code: "invalid-ies", reason: "angle or candela table is incomplete" });
+  }
+  const verticalAnglesDeg = values.slice(angleOffset, verticalEnd);
+  const horizontalAnglesDeg = values.slice(verticalEnd, horizontalEnd);
+  const candelaMultiplier = values[2];
+  if (candelaMultiplier === void 0) {
+    return err({ code: "invalid-ies", reason: "numeric header is incomplete or non-finite" });
+  }
+  const candela = values.slice(horizontalEnd, candelaEnd).map((value) => value * candelaMultiplier);
+  if (!allFinite(verticalAnglesDeg) || !allFinite(horizontalAnglesDeg) || !allFinite(candela) || verticalAnglesDeg[0] !== 0 || verticalAnglesDeg[verticalAnglesDeg.length - 1] !== 180 || horizontalAnglesDeg[0] !== 0) {
+    return err({ code: "invalid-ies", reason: "Type C angles or candela values are invalid" });
+  }
+  return ok({ tilt: "NONE", verticalAnglesDeg, horizontalAnglesDeg, candela });
+}
+function horizontalTable(source) {
+  const angles = [...source.horizontalAnglesDeg];
+  const values = [...source.candela];
+  const verticalCount = source.verticalAnglesDeg.length;
+  const lastAngle = angles.at(-1);
+  if (lastAngle === void 0) return { angles, values };
+  if (lastAngle < 360) {
+    for (let index = angles.length - 2; index > 0; index--) {
+      const angle = angles[index];
+      if (angle === void 0) continue;
+      angles.push(360 - angle);
+      const row = source.horizontalAnglesDeg.length - 1 - index;
+      values.push(
+        ...source.candela.slice(row * verticalCount, row * verticalCount + verticalCount)
+      );
+    }
+  }
+  return { angles, values };
+}
+function interpolate(values, angles, angle, verticalIndex, verticalCount) {
+  const wrapped = (angle % 360 + 360) % 360;
+  const last = angles.length - 1;
+  const finalAngle = angles[last];
+  const firstAngle = angles[0];
+  if (finalAngle === void 0 || firstAngle === void 0) return Number.NaN;
+  for (let index = 0; index < last; index++) {
+    const left = angles[index];
+    const right = angles[index + 1];
+    if (left === void 0 || right === void 0) continue;
+    if (wrapped < left || wrapped > right) continue;
+    const span2 = right - left;
+    const factor2 = span2 === 0 ? 0 : (wrapped - left) / span2;
+    const a = values[index * verticalCount + verticalIndex] ?? 0;
+    const b = values[(index + 1) * verticalCount + verticalIndex] ?? 0;
+    return a + (b - a) * factor2;
+  }
+  const first = values[verticalIndex] ?? 0;
+  const finalRow = (angles.length - 1) * verticalCount + verticalIndex;
+  const final = values[finalRow] ?? 0;
+  const span = 360 - finalAngle + firstAngle;
+  const factor = span === 0 ? 0 : (wrapped - finalAngle + 360) / span;
+  return final + (first - final) * factor;
+}
+function toFloat16(value) {
+  if (value === 0) return 0;
+  const sign = value < 0 ? 32768 : 0;
+  const absolute = Math.abs(value);
+  if (!Number.isFinite(absolute)) return sign | 31744;
+  const exponent = Math.floor(Math.log2(absolute));
+  if (exponent < -14) return sign | Math.round(absolute / 2 ** -24);
+  if (exponent > 15) return sign | 31744;
+  const mantissa = Math.round((absolute / 2 ** exponent - 1) * 1024);
+  return sign | exponent + 15 << 10 | Math.min(mantissa, 1023);
+}
+function readFloat16LE(bytes2, offset) {
+  const bits = (bytes2[offset] ?? 0) | (bytes2[offset + 1] ?? 0) << 8;
+  const sign = (bits & 32768) === 0 ? 1 : -1;
+  const exponent = bits >>> 10 & 31;
+  const fraction = bits & 1023;
+  if (exponent === 0) return sign * 2 ** -14 * (fraction / 2 ** 10);
+  if (exponent === 31) return fraction === 0 ? sign * Infinity : Number.NaN;
+  return sign * 2 ** (exponent - 15) * (1 + fraction / 2 ** 10);
+}
+function resampleTypeC(source) {
+  const table = horizontalTable(source);
+  const verticalCount = source.verticalAnglesDeg.length;
+  const output = new Uint8Array(IES_PROFILE_WIDTH * IES_PROFILE_HEIGHT * 2);
+  let peak = 0;
+  const samples = [];
+  for (let y = 0; y < IES_PROFILE_HEIGHT; y++) {
+    const vertical = y / (IES_PROFILE_HEIGHT - 1) * 180;
+    let lower = 0;
+    while (lower + 1 < verticalCount && (source.verticalAnglesDeg[lower + 1] ?? 0) < vertical)
+      lower++;
+    const upper = Math.min(lower + 1, verticalCount - 1);
+    const left = source.verticalAnglesDeg[lower] ?? 0;
+    const right = source.verticalAnglesDeg[upper] ?? 0;
+    const factor = right === left ? 0 : (vertical - left) / (right - left);
+    for (let x = 0; x < IES_PROFILE_WIDTH; x++) {
+      const horizontal = x / IES_PROFILE_WIDTH * 360;
+      const low = interpolate(table.values, table.angles, horizontal, lower, verticalCount);
+      const high = interpolate(table.values, table.angles, horizontal, upper, verticalCount);
+      const value = low + (high - low) * factor;
+      samples.push(Math.max(0, value));
+      peak = Math.max(peak, value);
+    }
+  }
+  const divisor = peak > 0 ? peak : 1;
+  for (let index = 0; index < samples.length; index++) {
+    const bits = toFloat16((samples[index] ?? 0) / divisor);
+    output[index * 2] = bits & 255;
+    output[index * 2 + 1] = bits >>> 8;
+  }
+  return output;
+}
+
+// src/ies/ies-importer.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeFloat16(bytes2, offset) {
+  const bits = (bytes2[offset] ?? 0) | (bytes2[offset + 1] ?? 0) << 8;
+  const sign = (bits & 32768) === 0 ? 1 : -1;
+  const exponent = bits >>> 10 & 31;
+  const fraction = bits & 1023;
+  if (exponent === 0) return sign * 2 ** -14 * (fraction / 2 ** 10);
+  if (exponent === 31) return fraction === 0 ? sign * Infinity : Number.NaN;
+  return sign * 2 ** (exponent - 15) * (1 + fraction / 2 ** 10);
+}
+function validateIesProfilePayload(value) {
+  if (!isRecord(value) || value.kind !== "ies-profile") {
+    return err(new Error("IES payload kind must be ies-profile"));
+  }
+  const data = value.data;
+  if (!(data instanceof Uint8Array) || data.byteLength !== IES_PROFILE_BYTE_LENGTH) {
+    return err(
+      new Error(
+        `IES payload must contain ${IES_PROFILE_WIDTH}x${IES_PROFILE_HEIGHT} little-endian f16 samples`
+      )
+    );
+  }
+  for (let offset = 0; offset < data.byteLength; offset += 2) {
+    if (!Number.isFinite(decodeFloat16(data, offset))) {
+      return err(new Error("IES payload contains a non-finite f16 sample"));
+    }
+  }
+  return ok(value);
+}
+function sourceValidationError(ctx, reason) {
+  return new ImportError({
+    code: "source-validation-failed",
+    expected: "LM-63 Type C source with TILT=NONE",
+    hint: IMPORT_ERROR_HINTS["source-validation-failed"],
+    detail: {
+      diagnostics: [
+        {
+          code: "ies-source-invalid",
+          severity: "error",
+          sourcePath: ctx.source,
+          sourceRange: { start: 0, end: 0, line: 1, column: 1 },
+          rule: "LM-63 Type C TILT=NONE",
+          expected: "LM-63 Type C source with TILT=NONE",
+          actual: reason,
+          hint: "repair the IES source and rerun the build-time importer"
+        }
+      ]
+    }
+  });
+}
+async function importIes(ctx) {
+  const source = await ctx.readSource();
+  if (!source.ok) {
+    return {
+      ok: false,
+      error: new ImportError({
+        code: "source-read-failed",
+        expected: `readable IES source at ${ctx.source}`,
+        hint: IMPORT_ERROR_HINTS["source-read-failed"],
+        detail: { source: ctx.source, reason: String(source.error) }
+      })
+    };
+  }
+  const parsed = parseLm63TypeC(new TextDecoder().decode(source.value));
+  if (!parsed.ok) return { ok: false, error: sourceValidationError(ctx, parsed.error.reason) };
+  const declaration = ctx.subAssets.find((asset) => asset.kind === "ies-profile");
+  if (declaration === void 0) {
+    return {
+      ok: false,
+      error: sourceValidationError(ctx, "missing ies-profile sub-asset declaration")
+    };
+  }
+  const data = resampleTypeC(parsed.value);
+  const payload = { kind: "ies-profile", data };
+  return {
+    ok: true,
+    value: {
+      assets: [
+        {
+          guid: declaration.guid,
+          kind: "ies-profile",
+          payload,
+          refs: [],
+          artifacts: {
+            body: {
+              mediaType: "application/octet-stream",
+              assetCodec: { name: "forgeax-ies-profile", version: "1" },
+              bytes: data
+            }
+          }
+        }
+      ],
+      sourceDependencies: [ctx.source]
+    }
+  };
+}
+var iesImporter = {
+  key: "ies",
+  import: importIes
+};
+
+// src/importer-registry.ts
+var ImporterRegistry = class {
+  importers = /* @__PURE__ */ new Map();
+  /**
+   * Register an importer for its `importer.key`. Fail-fast on a malformed
+   * importer (charter P3); idempotent on a repeated key (last write wins).
+   *
+   * @param importer the `{ key, import }` object to register.
+   * @throws TypeError when `importer.key` is empty or `importer.import` is not
+   *   a function - a wire-time misconfiguration the host must fix.
+   */
+  register(importer) {
+    if (typeof importer.key !== "string" || importer.key.length === 0) {
+      throw new TypeError(
+        `ImporterRegistry.register: importer.key must be a non-empty string (got ${JSON.stringify(importer.key)})`
+      );
+    }
+    if (typeof importer.import !== "function") {
+      throw new TypeError(
+        `ImporterRegistry.register: importer.import must be a function for key "${importer.key}"`
+      );
+    }
+    this.importers.set(importer.key, importer);
+  }
+  /**
+   * Look up the importer registered for `key`. Returns `undefined` when no
+   * importer is wired - the import runner maps that to a structured
+   * `ImportError(code='importer-not-registered')` with the registered keys in
+   * `.detail.registeredImporters` (charter P3).
+   */
+  get(key) {
+    return this.importers.get(key);
+  }
+  /**
+   * The importer keys currently wired, in insertion order. Fed into the
+   * `importer-not-registered` error `.detail.registeredImporters` so AI users
+   * see exactly what is injectable.
+   */
+  registeredImporters() {
+    return [...this.importers.keys()];
+  }
+  /** Project the first registered producer capability into the runner context. */
+  contextCapabilities() {
+    for (const importer of this.importers.values()) {
+      const decoder = importer.capabilities?.decodeImage;
+      if (decoder !== void 0) return { decodeImage: decoder };
+    }
+    return {};
+  }
+  /** Ask the registered producer whether a declaration has a Catalog product. */
+  shouldPublishCatalog(input) {
+    return this.get(input.importer)?.capabilities?.catalog?.publish?.({
+      importSettings: input.importSettings,
+      subAssets: input.subAssets
+    }) ?? true;
+  }
+};
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stable2(value) {
+  if (value instanceof ArrayBuffer) {
+    return `ArrayBuffer:${JSON.stringify(Array.from(new Uint8Array(value)))}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    return `${value.constructor.name}:${JSON.stringify(
+      Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength))
+    )}`;
+  }
+  if (Array.isArray(value)) return `[${value.map(stable2).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable2(record2[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function digest2(value) {
+  return `sha256:${createHash("sha256").update(stable2(value)).digest("hex")}`;
+}
+function generationFromDigest(value) {
+  const parsed = Number.parseInt(value.slice("sha256:".length, "sha256:".length + 8), 16);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : 1;
+}
+function reasonOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function collectPackFiles(assetRoots) {
+  const files = /* @__PURE__ */ new Set();
+  async function visit(directory) {
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      return err({
+        code: "scriptable-pack-file-root-unreadable",
+        expected: "every configured ScriptablePack asset root to be readable",
+        hint: "restore the asset root or configure a readable directory, then retry the ScriptablePack build",
+        detail: { root: directory, reason: reasonOf(error) }
+      });
+    }
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+      const child = resolve(directory, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await visit(child);
+        if (!nested.ok) return nested;
+      } else if (entry.isFile() && entry.name.endsWith(".pack.json")) {
+        files.add(child);
+      }
+    }
+    return ok(void 0);
+  }
+  for (const rawRoot of [...new Set(assetRoots.map((root) => resolve(root)))].sort(
+    (a, b) => a.localeCompare(b)
+  )) {
+    let info;
+    try {
+      info = await stat(rawRoot);
+    } catch (error) {
+      return err({
+        code: "scriptable-pack-file-root-unreadable",
+        expected: "every configured ScriptablePack asset root to exist and be readable",
+        hint: "restore the asset root or configure a readable directory, then retry the ScriptablePack build",
+        detail: { root: rawRoot, reason: reasonOf(error) }
+      });
+    }
+    if (info.isFile()) {
+      if (rawRoot.endsWith(".pack.json")) files.add(rawRoot);
+      continue;
+    }
+    if (!info.isDirectory()) {
+      return err({
+        code: "scriptable-pack-file-root-unreadable",
+        expected: "every configured ScriptablePack asset root to be a file or directory",
+        hint: "configure an asset root containing ordinary .pack.json files, then retry the ScriptablePack build",
+        detail: { root: rawRoot, reason: "root is neither a file nor a directory" }
+      });
+    }
+    const visited = await visit(rawRoot);
+    if (!visited.ok) return visited;
+  }
+  return ok([...files].sort((left, right) => left.localeCompare(right)));
+}
+function invalidPack(path, errors) {
+  return {
+    code: "scriptable-pack-file-invalid",
+    expected: "a schema-valid ordinary .pack.json package",
+    hint: "repair the Pack JSON against the package schema, then retry the ScriptablePack build",
+    detail: { path, ajvErrors: errors }
+  };
+}
+function assetFromRow(path, row) {
+  if (!isScriptablePackAssetKind$1(row.kind)) {
+    return err({
+      code: "scriptable-pack-file-asset-invalid",
+      expected: "an ordinary ScriptablePack Asset kind from SCRIPTABLE_PACK_ASSET_KINDS",
+      hint: "use an ordinary engine Asset kind or keep the custom payload outside this Asset snapshot source",
+      detail: { path, guid: row.guid, reason: `unsupported kind ${JSON.stringify(row.kind)}` }
+    });
+  }
+  if (!isRecord2(row.payload)) {
+    return err({
+      code: "scriptable-pack-file-asset-invalid",
+      expected: "the Pack row payload to be a JSON object",
+      hint: "write a complete ordinary Asset payload in the .pack.json row, then retry the ScriptablePack build",
+      detail: { path, guid: row.guid, reason: "payload is not an object" }
+    });
+  }
+  const payloadKind = row.payload.kind;
+  if (payloadKind !== void 0 && payloadKind !== row.kind) {
+    return err({
+      code: "scriptable-pack-file-asset-invalid",
+      expected: "the row kind and payload.kind to agree",
+      hint: "repair the duplicated kind discriminant in the .pack.json row, then retry the ScriptablePack build",
+      detail: {
+        path,
+        guid: row.guid,
+        reason: `row kind ${JSON.stringify(row.kind)} does not match payload.kind ${JSON.stringify(payloadKind)}`
+      }
+    });
+  }
+  const asset = { ...row.payload, kind: row.kind };
+  return ok({ asset, digest: digest2(asset) });
+}
+async function indexPackFiles(assetRoots) {
+  const files = await collectPackFiles(assetRoots);
+  if (!files.ok) return files;
+  const byGuid = /* @__PURE__ */ new Map();
+  const pathsByGuid = /* @__PURE__ */ new Map();
+  const documents = [];
+  for (const path of files.value) {
+    let body;
+    try {
+      body = await readFile(path, "utf8");
+    } catch (error) {
+      return err({
+        code: "scriptable-pack-file-unreadable",
+        expected: "a readable .pack.json file",
+        hint: "restore the .pack.json file, then retry the ScriptablePack build",
+        detail: { path, reason: reasonOf(error) }
+      });
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch (error) {
+      return err({
+        code: "scriptable-pack-file-json-invalid",
+        expected: "a parseable JSON .pack.json file",
+        hint: "repair or restore the .pack.json file, then retry the ScriptablePack build",
+        detail: { path, reason: reasonOf(error) }
+      });
+    }
+    if (!validatePack(parsed)) {
+      return err(
+        invalidPack(
+          path,
+          (validatePack.errors ?? []).map((error) => ({
+            instancePath: error.instancePath,
+            message: error.message ?? "unknown schema validation error"
+          }))
+        )
+      );
+    }
+    const document = parsed;
+    documents.push(document);
+    for (const row of document.assets) {
+      const existingPath = pathsByGuid.get(row.guid.toLowerCase());
+      if (existingPath !== void 0) {
+        return err({
+          code: "scriptable-pack-file-guid-collision",
+          expected: "each ordinary Pack asset GUID to be declared by exactly one .pack.json file",
+          hint: "remove the duplicate GUID declaration or keep one authoritative .pack.json package, then retry",
+          detail: { guid: row.guid.toLowerCase(), paths: [existingPath, path] }
+        });
+      }
+      const asset = assetFromRow(path, row);
+      if (!asset.ok) return asset;
+      const key = row.guid.toLowerCase();
+      pathsByGuid.set(key, path);
+      byGuid.set(key, asset.value);
+    }
+  }
+  const sourceDigest = digest2(
+    [...documents].sort((left, right) => stable2(left).localeCompare(stable2(right)))
+  );
+  return ok({
+    generation: generationFromDigest(sourceDigest),
+    assets: byGuid
+  });
+}
+function createScriptablePackFileAssetSnapshotSource(options) {
+  const index = indexPackFiles(options.assetRoots);
+  return {
+    async readByGuid(guid) {
+      const key = AssetGuid$1.format(guid).toLowerCase();
+      const indexed = await index;
+      if (!indexed.ok) return indexed;
+      const asset = indexed.value.assets.get(key);
+      if (asset === void 0) {
+        return err({
+          code: "asset-not-found",
+          expected: `an ordinary .pack.json asset with GUID ${key} under the configured asset roots`,
+          hint: "add the dependency to an asset root or declare it as a ScriptablePack external reference, then retry",
+          detail: { guid: key }
+        });
+      }
+      return ok({
+        asset: structuredClone(asset.asset),
+        generation: indexed.value.generation,
+        digest: asset.digest
+      });
+    }
+  };
+}
+function stable3(value) {
+  if (ArrayBuffer.isView(value)) {
+    return `${value.constructor.name}:${JSON.stringify(Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)))}`;
+  }
+  if (Array.isArray(value)) return `[${value.map(stable3).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable3(record2[key])}`).join(",")}}`;
   }
+  return JSON.stringify(value) ?? "null";
+}
+async function assetDigest(asset) {
+  const bytes2 = new TextEncoder().encode(stable3(asset));
+  const digest3 = await globalThis.crypto.subtle.digest("SHA-256", bytes2);
+  return `sha256:${Array.from(new Uint8Array(digest3), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function cycleError(stack, owner, guid) {
+  const cycleStart = stack.indexOf(owner);
+  const cycle = [...stack.slice(cycleStart), owner];
   return {
-    disposition: "missing",
-    hostProvided: false,
-    expected: "the sidecar importer must be present in the registered provider set",
-    hint: "wire the provider through the host importer registry before building the Catalog"
+    code: "pack-content-dependency-stalled",
+    expected: "the content dependency worklist to make progress",
+    hint: "inspect the waiting GUID and pending subjects, then break the content-read cycle",
+    detail: { waitingGuids: [guid], pendingSubjects: cycle, iterations: 1 }
   };
 }
-async function buildCatalogResult(roots, base = "/", registeredImporterKeys = /* @__PURE__ */ new Set(), scanOptions = {}, catalogVisibility = () => true, sourceIdentityFor) {
-  const options = {
-    base,
-    scanOptions,
-    importerPolicy: (importer) => catalogImporterPolicy(importer, registeredImporterKeys),
-    visibility: catalogVisibility,
-    ...sourceIdentityFor === void 0 ? {} : { sourceIdentityFor }
+function missingOutputError(owner, guid) {
+  return {
+    code: "pack-source-output-invalid",
+    expected: `owner ${owner} to stage every declared output including ${guid}`,
+    hint: "return one output for every GUID declared by the staged owner",
+    detail: { missingGuids: [guid], unexpectedSourceKeys: [], kindMismatches: [] }
   };
-  return buildCatalogProjection(roots, options);
 }
-
-// src/importer-registry.ts
-var ImporterRegistry = class {
-  importers = /* @__PURE__ */ new Map();
-  /**
-   * Register an importer for its `importer.key`. Fail-fast on a malformed
-   * importer (charter P3); idempotent on a repeated key (last write wins).
-   *
-   * @param importer the `{ key, import }` object to register.
-   * @throws TypeError when `importer.key` is empty or `importer.import` is not
-   *   a function - a wire-time misconfiguration the host must fix.
-   */
-  register(importer) {
-    if (typeof importer.key !== "string" || importer.key.length === 0) {
-      throw new TypeError(
-        `ImporterRegistry.register: importer.key must be a non-empty string (got ${JSON.stringify(importer.key)})`
-      );
-    }
-    if (typeof importer.import !== "function") {
-      throw new TypeError(
-        `ImporterRegistry.register: importer.import must be a function for key "${importer.key}"`
-      );
+function createScriptablePackStagedAssetSnapshotSource(options) {
+  const owners = options.declaredExternalOutputs === void 0 || options.declaredExternalOutputs.length === 0 ? options.owners : [
+    {
+      id: "<declared-pack-external>",
+      guids: options.declaredExternalOutputs.map((output) => output.guid),
+      async build() {
+        return ok(options.declaredExternalOutputs ?? []);
+      }
+    },
+    ...options.owners
+  ];
+  const ownerByGuid = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    if (owner.id.trim().length === 0) throw new TypeError("staged owner id must be non-empty");
+    for (const guid of owner.guids) {
+      const key = AssetGuid$1.format(guid).toLowerCase();
+      const existing = ownerByGuid.get(key);
+      if (existing !== void 0) {
+        throw new TypeError(`staged GUID ${key} is owned by both ${existing.id} and ${owner.id}`);
+      }
+      ownerByGuid.set(key, owner);
     }
-    this.importers.set(importer.key, importer);
-  }
-  /**
-   * Look up the importer registered for `key`. Returns `undefined` when no
-   * importer is wired - the import runner maps that to a structured
-   * `ImportError(code='importer-not-registered')` with the registered keys in
-   * `.detail.registeredImporters` (charter P3).
-   */
-  get(key) {
-    return this.importers.get(key);
-  }
-  /**
-   * The importer keys currently wired, in insertion order. Fed into the
-   * `importer-not-registered` error `.detail.registeredImporters` so AI users
-   * see exactly what is injectable.
-   */
-  registeredImporters() {
-    return [...this.importers.keys()];
   }
-  /** Project the first registered producer capability into the runner context. */
-  contextCapabilities() {
-    for (const importer of this.importers.values()) {
-      const decoder = importer.capabilities?.decodeImage;
-      if (decoder !== void 0) return { decodeImage: decoder };
+  const snapshots = /* @__PURE__ */ new Map();
+  const builds = /* @__PURE__ */ new Map();
+  const sourceFor = (stack) => ({
+    async readByGuid(guid) {
+      const key = AssetGuid$1.format(guid).toLowerCase();
+      const cached = snapshots.get(key);
+      if (cached !== void 0) return ok(structuredClone(cached));
+      const owner = ownerByGuid.get(key);
+      if (owner === void 0) {
+        return err(
+          new AssetError({
+            code: "asset-not-imported",
+            expected: "a staged local owner for the requested GUID",
+            hint: "declare the local ScriptablePack output before rebuilding the generation"
+          })
+        );
+      }
+      if (stack.includes(owner.id)) return err(cycleError(stack, owner.id, key));
+      let building = builds.get(owner.id);
+      if (building === void 0) {
+        building = (async () => {
+          const built2 = await owner.build(sourceFor([...stack, owner.id]));
+          if (!built2.ok) {
+            builds.delete(owner.id);
+            return built2;
+          }
+          const next = /* @__PURE__ */ new Map();
+          for (const output of built2.value) {
+            const outputGuid = AssetGuid$1.format(output.guid).toLowerCase();
+            if (ownerByGuid.get(outputGuid) !== owner) {
+              builds.delete(owner.id);
+              return err(missingOutputError(owner.id, outputGuid));
+            }
+            next.set(outputGuid, {
+              asset: structuredClone(output.asset),
+              generation: options.generation,
+              digest: output.digest ?? await assetDigest(output.asset)
+            });
+          }
+          for (const declared of owner.guids) {
+            const declaredGuid = AssetGuid$1.format(declared).toLowerCase();
+            if (!next.has(declaredGuid)) {
+              builds.delete(owner.id);
+              return err(missingOutputError(owner.id, declaredGuid));
+            }
+          }
+          for (const [outputGuid, snapshot] of next) snapshots.set(outputGuid, snapshot);
+          return ok(void 0);
+        })();
+        builds.set(owner.id, building);
+      }
+      const built = await building;
+      if (!built.ok) return built;
+      const staged = snapshots.get(key);
+      return staged === void 0 ? err(missingOutputError(owner.id, key)) : ok(structuredClone(staged));
     }
-    return {};
-  }
-  /** Ask the registered producer whether a declaration has a Catalog product. */
-  shouldPublishCatalog(input) {
-    return this.get(input.importer)?.capabilities?.catalog?.publish?.({
-      importSettings: input.importSettings,
-      subAssets: input.subAssets
-    }) ?? true;
-  }
-};
+  });
+  return sourceFor([]);
+}
 
 // src/source-package-errors.ts
 var SOURCE_PACKAGE_ERROR_POLICY = {
@@ -2674,6 +4159,9 @@ function importFailureCode(error) {
     case "source-read-failed":
     case "import-internal-error":
     case "mesh-material-slot-topology-change":
+    case "mesh-lod-contract-invalid":
+    case "mesh-lod-topology-change":
+    case "mesh-lod-authority-conflict":
     case "unknown-source-key":
     case "duplicate-source-key":
     case "invalid-source-overrides":
@@ -2687,6 +4175,9 @@ var IMPORT_ERROR_CODES = /* @__PURE__ */ new Set([
   "import-produced-no-assets",
   "guid-mismatch",
   "mesh-material-slot-topology-change",
+  "mesh-lod-contract-invalid",
+  "mesh-lod-topology-change",
+  "mesh-lod-authority-conflict",
   "import-internal-error",
   "source-validation-failed",
   "unknown-source-key",
@@ -2804,7 +4295,7 @@ async function commitSourcePackageDdc(candidate) {
 async function persistTransport(transport) {
   if (transport === void 0) return true;
   const directory = dirname(transport.path);
-  const temporary = `${transport.path}.tmp`;
+  const temporary = `${transport.path}.${randomUUID()}.tmp`;
   try {
     await mkdir(directory, { recursive: true });
     if (((await stat(directory)).mode & 146) === 0) {
@@ -2828,9 +4319,179 @@ 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 digest = head.currentKey ?? input.desiredKey;
-  const revision = { digest, observedAt, rootId: input.root };
+  const digest3 = head.currentKey ?? input.desiredKey;
+  const revision = { digest: digest3, observedAt, rootId: input.root };
   const published = new Set(input.publishedGuids.map((guid) => guid.toLowerCase()));
   const catalog = input.nextCatalog.map((row) => {
     if (!published.has(row.guid.toLowerCase())) return row;
@@ -2855,6 +4516,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: {
@@ -2862,7 +4532,7 @@ async function stageImportPublication(input) {
       guid: input.guid,
       payload: input.pack,
       refs: [],
-      artifacts: {},
+      artifacts,
       receipt: {
         guid: input.guid,
         key: input.desiredKey,
@@ -2872,17 +4542,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 {
@@ -2924,6 +4588,35 @@ async function commitImportPublication(candidate) {
       )
     };
   }
+  const transportPersisted = await persistTransport(candidate.input.transport);
+  if (!transportPersisted) {
+    await restoreImportPublication(candidate);
+    return {
+      ok: false,
+      error: {
+        code: "source-package-publication-invalid",
+        expected: "the sidecar and DDC publication to commit atomically",
+        hint: "repair the sidecar destination, then rebuild or cold-cook the source package",
+        detail: "sidecar transport persistence failed; restored the previous DDC/LKG generation",
+        diagnostic: sourcePackageError(
+          "source-package-publication-invalid",
+          {
+            sourceMeta: "<import-publication>",
+            anchorGuid: candidate.input.guid,
+            affectedGuids: candidate.input.publishedGuids,
+            producer: "source-package/import-publication",
+            importer: "import-publication"
+          },
+          { stage: "route-integrity", reason: "sidecar transport persistence failed" }
+        )
+      },
+      head: await inspectHead(
+        candidate.input.root,
+        candidate.input.guid,
+        candidate.input.desiredKey
+      )
+    };
+  }
   const projected = projectImportPublication(candidate.input, publication.value, Date.now());
   return {
     ok: true,
@@ -2931,7 +4624,7 @@ async function commitImportPublication(candidate) {
     head: publication.value,
     catalog: projected.catalog,
     revision: projected.revision,
-    transportPersisted: await persistTransport(candidate.input.transport)
+    transportPersisted
   };
 }
 async function discardImportPublication(candidate) {
@@ -2941,6 +4634,6 @@ async function restoreImportPublication(candidate) {
   await candidate.ddc.session.restoreEntry(candidate.ddc);
 }
 
-export { AssetOutputProducerRegistry, DEFAULT_CATALOG_IMPORTER_KEYS, ImporterRegistry, SHADER_RESERVED_IMPORTER_KEY, buildCatalogResult, buildScriptablePack, canonicalScriptableSourcePath, catalogImporterPolicy, commitImportPublication, containsSourcePackageError, createImportProduct, createSceneAssetOutputProducer, createScriptablePackStagedAssetSnapshotSource, createStandardAssetOutputProducerRegistry, declaredPackExternalOutputs, discardImportPublication, finalizeImportProducts, finalizeSourcePackage, materialAssetOutputProducer, materializePreparedScriptablePack, meshAssetOutputProducer, normaliseForPack, normalizeSourcePackageError, packMeshBinV4, parseProducerReadiness, prepareAuthoredPackTransport, produceBuildAssets, produceScriptablePackProducts, produceScriptableSourcePackage, produceSourcePackage, projectImportProductForBuild, projectScriptablePackPublication, publishImportPublication, readCookedAuthoredPack, restoreImportPublication, runImport, scriptablePackInputs, sourceDeclarationForCatalogPath, sourcePackageAssetsByGuid, sourcePackageError, stageImportPublication, textureAssetOutputProducer };
+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