@forgeax/engine-import 0.1.28 → 0.1.30

package/dist/index.mjs

@@ -3,7 +3,7 @@ export { IMPORT_ERROR_HINTS, ImportError } from '@forgeax/engine-types';
 import { resolve, dirname, isAbsolute, relative } from 'path';
 import { resolveAssetSource, finalizePackageTransportSource, packageTransportRevision, catalogSourcePathFor, buildCatalogProjection, projectPackageCatalog, createRuntimePackPublication, metaPathForGuid } from '@forgeax/engine-pack/build';
 import { AssetGuid as AssetGuid$1, PackageId as PackageId$1 } from '@forgeax/engine-pack/guid';
-import { resolvePackParameterValues, PackageId, isValidPackSourceKey, AssetGuid, parsePackSourceJson, projectDirectPackJson, isScriptablePackAssetKind, projectScriptablePackSceneComponents, resolvePackParameterInheritance } from '@forgeax/engine-pack/source';
+import { resolvePackParameterValues, PackageId, isValidPackSourceKey, isScriptablePackAssetKind, AssetGuid, parsePackSourceJson, projectDirectPackJson, 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';
@@ -11,12 +11,12 @@ import { deriveVertexLayoutProjection, normalizeMeshPayload } from '@forgeax/eng
 import { BUILTIN_MESH_ASSETS } from '@forgeax/engine-pack/builtin';
 import { NativeCookerRegistry } from '@forgeax/engine-pack/native-cooker';
 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 { externalizeSceneAsset } from '@forgeax/engine-scene';
 import { MESH_BIN_HEADER_V4_BYTES, writeMeshBinHeader } from '@forgeax/engine-pack/mesh-bin-contract';
-import { createHash, randomUUID } from 'crypto';
 import { validatePack, isScriptablePackAssetKind as isScriptablePackAssetKind$1 } from '@forgeax/engine-pack';
+import { createHash, randomUUID } from 'crypto';
 import { canonicalDdcJson } from '@forgeax/engine-ddc/key';
 
 // src/index.ts
@@ -45,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 digest3 = await subtle.digest("SHA-256", owned.buffer);
-  return Array.from(new Uint8Array(digest3), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const digest = await subtle.digest("SHA-256", owned.buffer);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 async function artifactDigest(bytes2) {
   return `sha256:${await sha256Hex(bytes2)}`;
@@ -109,19 +109,19 @@ function finalizeImportProducts(product, inputFingerprint) {
     const products = [];
     for (const asset of product.assets) {
       const artifacts = await artifactDescriptors(asset.artifacts);
-      const digest3 = await productDigest(asset, artifacts);
+      const digest = await productDigest(asset, artifacts);
       products.push({
         guid: asset.guid,
         payload: asset.payload,
         refs: asset.refs.map((ref2) => ref2.guid),
         artifacts,
-        digest: digest3,
+        digest,
         receipt: {
           guid: asset.guid,
           origin: "sourceMeta",
           status: "succeeded",
           inputFingerprint,
-          outputDigest: digest3
+          outputDigest: digest
         }
       });
     }
@@ -779,1217 +779,1364 @@ function projectImportProductForBuild(product) {
     }))
   };
 }
-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 needsMaterialCook(asset) {
-  return asset.kind === "material" && Array.isArray(asset.passes) && !isEngineMaterial(asset);
-}
-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") {
-    const object = value;
-    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stable(object[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
-}
-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 }
-          })
-        );
+function scriptablePackFingerprint(value) {
+  const hash = sha256.create();
+  const encoder = new TextEncoder();
+  const text = (part) => {
+    hash.update(encoder.encode(part));
+  };
+  const binary = (type, bytes2) => {
+    text(`\0${type}:${bytes2.byteLength}:`);
+    hash.update(bytes2);
+    text("\0");
+  };
+  const visit = (item) => {
+    if (ArrayBuffer.isView(item)) {
+      binary(item.constructor.name, new Uint8Array(item.buffer, item.byteOffset, item.byteLength));
+    } else if (item instanceof ArrayBuffer) {
+      binary("ArrayBuffer", new Uint8Array(item));
+    } else if (Array.isArray(item)) {
+      text("[");
+      for (let i = 0; i < item.length; i++) {
+        if (i) text(",");
+        visit(item[i]);
       }
-      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));
+      text("]");
+    } else if (item !== null && typeof item === "object") {
+      const object = item;
+      text("{");
+      let first = true;
+      for (const key of Object.keys(object).sort()) {
+        if (!first) text(",");
+        first = false;
+        text(`${JSON.stringify(key)}:`);
+        visit(object[key]);
+      }
+      text("}");
+    } else {
+      text(JSON.stringify(item) ?? "null");
     }
   };
-  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 {
-    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 }
-  };
+  text("scriptable-pack-fingerprint/2:");
+  visit(value);
+  return `sha256:${bytesToHex(hash.digest())}`;
 }
-function outputValueError(sourcePath, sourceKey, expected, actual) {
+function failure(sourceKey, expected, actual) {
   return {
-    code: "pack-parameter-invalid",
+    code: "mesh-bin-payload-invalid",
+    subject: "mesh-bin",
+    sourceKey,
     expected,
-    hint: "repair the build output and rebuild the Pack from a fresh generation",
-    detail: { sourcePath, sourceKey, actual: typeof actual === "string" ? actual : typeof actual }
+    actual,
+    recovery: "re-cook the source with its Meta sidecar through the build-time importer"
   };
 }
-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 asAttributeMap(value) {
+  return value ?? {};
 }
-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
+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)])
     );
   }
-  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
-      );
+  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");
   }
-  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
+  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 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()));
+  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 }
+  };
 }
-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;
+function packMeshBinV4(payload, sourceKey, refs = []) {
   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();
-  const materialCookerRegistry = new NativeCookerRegistry();
-  for (const cooker of options.cookers ?? []) materialCookerRegistry.register(cooker);
-  const nativeFingerprints = /* @__PURE__ */ new Map();
-  for (const sourceKey of Object.keys(built.value).sort()) {
-    if (!isValidPackSourceKey(sourceKey))
-      return err(sourceKeyFailure(options.sourcePath, sourceKey));
-    const asset = built.value[sourceKey];
-    if (!isAsset(asset)) {
+    const vertices = payload.vertices;
+    const indices = payload.indices;
+    if (!(vertices instanceof Float32Array)) {
       return err(
-        outputValueError(
-          options.sourcePath,
-          sourceKey,
-          "a concrete Asset with a supported kind",
-          asset
-        )
+        failure(sourceKey, "Float32Array interleaved vertices", "vertices is not Float32Array")
       );
     }
-    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 }
-      });
+    if (indices !== void 0 && !(indices instanceof Uint16Array || indices instanceof Uint32Array)) {
+      return err(
+        failure(sourceKey, "Uint16Array or Uint32Array indices", "indices has an unsupported type")
+      );
     }
-    localGuids.add(normalizedGuid);
-    const producer = options.outputs.get(asset.kind);
-    if (producer === void 0) {
+    const attributes = asAttributeMap(payload.attributes);
+    const projection = deriveVertexLayoutProjection(attributes);
+    if (projection.attributes.length === 0 || projection.arrayStride === 0) {
       return err(
-        outputValueError(
-          options.sourcePath,
+        failure(
           sourceKey,
-          `a registered output producer for ${asset.kind}`,
-          asset.kind
+          "a non-empty canonical geometry projection",
+          "projection has no attributes"
         )
       );
     }
-    let produced;
-    try {
-      produced = await producer.produce({ guid, sourceKey, asset });
-    } catch (cause) {
+    const vertexCount = payload.vertexCount ?? vertices.byteLength / projection.arrayStride;
+    if (!Number.isSafeInteger(vertexCount) || vertexCount < 0) {
       return err(
-        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)}`
-          }
-        })
+        failure(sourceKey, "a non-negative safe vertex cardinality", `vertexCount=${vertexCount}`)
       );
     }
-    if (!record(produced) || typeof produced.ok !== "boolean") {
+    if (vertices.byteLength !== vertexCount * projection.arrayStride) {
       return err(
-        outputValueError(
-          options.sourcePath,
+        failure(
           sourceKey,
-          `producer ${producer.kind} to return a Result`,
-          produced
+          `vertices.byteLength=${vertexCount * projection.arrayStride}`,
+          `vertices.byteLength=${vertices.byteLength}; stride=${projection.arrayStride}`
         )
       );
     }
-    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;
-    let payload = product2.payload;
-    let artifacts2 = product2.artifacts;
-    if (needsMaterialCook(asset) && materialCookerRegistry.get("material") !== void 0) {
-      const cooked = await materialCookerRegistry.runDraft("material", {
-        guid,
-        source: asset,
-        sourceKey,
-        sourcePath: options.sourcePath,
-        refs: product2.refs.map((reference) => reference.guid)
-      });
-      if (!cooked.ok) return err(cooked.error);
-      if (cooked.value.guid.toLowerCase() !== normalizedGuid) {
-        return err({
-          code: "pack-source-output-invalid",
-          expected: "the authored material cooker to preserve the derived AssetGuid",
-          hint: "repair the native material cooker output GUID and rebuild the Pack",
-          detail: {
-            sourcePath: options.sourcePath,
+    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,
-            expectedGuid: guid,
-            actualGuid: cooked.value.guid
+            `${attribute.key} cardinality=${vertexCount * components}`,
+            `${attribute.key} cardinality=${value?.byteLength ?? "missing"}`
+          )
+        );
+      }
+    }
+    const interleaved = new Uint8Array(vertexCount * projection.arrayStride);
+    const interleavedView = new DataView(interleaved.buffer);
+    for (const attribute of projection.attributes) {
+      const value = attributes[attribute.key];
+      if (value === void 0) continue;
+      const components = attribute.byteLength / (attribute.format === "uint16x4" ? 2 : 4);
+      for (let vertex = 0; vertex < vertexCount; vertex++) {
+        for (let component = 0; component < components; component++) {
+          const sourceIndex = vertex * components + component;
+          const targetOffset = vertex * projection.arrayStride + attribute.offset + component * (attribute.format === "uint16x4" ? 2 : 4);
+          if (attribute.format === "uint16x4") {
+            interleavedView.setUint16(targetOffset, value[sourceIndex] ?? 0, true);
+          } else {
+            interleavedView.setFloat32(
+              targetOffset,
+              value[sourceIndex] ?? 0,
+              true
+            );
           }
-        });
+        }
       }
-      payload = cooked.value.payload;
-      artifacts2 = cooked.value.artifacts;
-      nativeFingerprints.set(sourceKey, cooked.value.inputFingerprint);
     }
-    imported.push({
-      guid,
-      kind: asset.kind,
-      payload,
-      refs: product2.refs,
-      artifacts: artifacts2
-    });
-    stagedOutputs.push({
-      guid: AssetGuid.derive(subjectPackageId, sourceKey),
-      sourceKey,
-      asset: clone(asset),
-      digest: await digest(asset)
-    });
+    const indexCount = indices?.length ?? 0;
+    const indexWidth = indices === void 0 || indexCount === 0 ? 0 : indices.BYTES_PER_ELEMENT;
+    const indexBytes = indexCount * indexWidth;
+    if (!Number.isSafeInteger(indexBytes) || indexBytes > 4294967295) {
+      return err(failure(sourceKey, "safe index payload byte length", `indexBytes=${indexBytes}`));
+    }
+    const meta = new TextEncoder().encode(JSON.stringify(refsMeta(payload, refs)));
+    const header = {
+      version: 4,
+      projectionVersion: projection.schemaVersion,
+      mask: projection.mask,
+      digest: projection.digest,
+      stride: projection.arrayStride,
+      vertexCount,
+      vertexBytes: interleaved.byteLength,
+      indexCount,
+      indexWidth,
+      indexBytes,
+      jsonBytes: meta.byteLength
+    };
+    const total = MESH_BIN_HEADER_V4_BYTES + interleaved.byteLength + indexBytes + meta.byteLength;
+    if (!Number.isSafeInteger(total) || total > 4294967295) {
+      return err(failure(sourceKey, "safe mesh binary byte length", `total=${total}`));
+    }
+    const out = new Uint8Array(total);
+    writeMeshBinHeader(header, out);
+    let offset = MESH_BIN_HEADER_V4_BYTES;
+    out.set(interleaved, offset);
+    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)
+      )
+    );
   }
-  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);
+}
+
+// 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");
+    }
+    if (typeof producer.produce !== "function") {
+      throw new TypeError(`Pack output producer ${producer.kind} must expose produce`);
     }
+    this.producers.set(producer.kind, producer);
   }
-  if (options.deferReferenceValidation !== true) {
-    const missing = [...referenced].filter(
-      (guid) => availableGuids !== void 0 && !availableGuids.has(guid)
+  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])
     );
-    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 authoredInputFingerprint = 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 inputFingerprint = nativeFingerprints.size === 0 ? authoredInputFingerprint : await digest({
-    sourceRevision: authoredInputFingerprint,
-    nativeCookers: [...nativeFingerprints.entries()].sort(
-      ([left], [right]) => left.localeCompare(right)
-    )
-  });
-  const refs = imported.flatMap((asset) => asset.refs);
-  const artifacts = Object.fromEntries(
-    imported.flatMap(
-      (asset) => 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 }
+};
+
+// src/scriptable-pack-output-producers.ts
+function producerError(input, reason) {
+  return new ImportError({
+    code: "import-internal-error",
+    expected: `ScriptablePack ${input.asset.kind} output ${input.sourceKey} to satisfy its domain producer contract`,
+    hint: "fix the generated Asset payload and rebuild the ScriptablePack",
+    detail: { reason: reason instanceof Error ? reason.message : String(reason) }
   });
 }
-function stagedSource(staged, fallback) {
+function formatGuid(value) {
+  if (typeof value === "string") {
+    const parsed = AssetGuid$1.parse(value);
+    if (!parsed.ok) throw parsed.error;
+    return AssetGuid$1.format(parsed.value);
+  }
+  return AssetGuid$1.format(value);
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `${JSON.stringify(key)}:${canonical(child)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function particleProgramArtifact(effect) {
+  const artifactProgram = { format: effect.program.format, emitters: effect.program.emitters };
+  const bytes2 = new TextEncoder().encode(canonical(artifactProgram));
+  const fingerprint = `sha256:${bytesToHex(sha256(bytes2))}`;
   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);
-    }
+    program: { ...effect.program, fingerprint },
+    bytes: bytes2,
+    fingerprint
   };
 }
-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,
-        ...options.cookers === void 0 ? {} : { cookers: options.cookers },
-        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;
+function materialProduct(input) {
+  if (input.asset.kind !== "material") throw new TypeError("expected MaterialAsset");
+  const material = input.asset;
+  const refs = [];
+  const addRef = (guid, sourceField) => {
+    refs.push({ guid: formatGuid(guid), sourceField });
+    return refs.length - 1;
+  };
+  const addMaterialRef = (value, sourceField) => {
+    if (typeof value === "number") {
+      throw new TypeError("material texture references must be GUIDs, not runtime handles");
     }
-    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
+    return addRef(value, sourceField);
+  };
+  const textureFields = material.parameters === void 0 ? new Set(MATERIAL_TEXTURE_SLOTS) : new Set(
+    material.parameters.filter(
+      (parameter) => parameter.type === "texture" || parameter.type === "texture_cube"
+    ).map((parameter) => parameter.name)
+  );
+  const parent = material.parent === void 0 ? void 0 : addRef(material.parent, { fieldName: "parent" });
+  const values = {};
+  for (const fieldName of Object.keys(material.values ?? {}).sort()) {
+    const value = material.values?.[fieldName];
+    if (typeof value === "string" && textureFields.has(fieldName)) {
+      values[fieldName] = {
+        texture: addMaterialRef(value, { componentName: "<material>", fieldName })
+      };
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value) && "texture" in value) {
+      const texture = value;
+      values[fieldName] = {
+        ...texture,
+        texture: addMaterialRef(texture.texture, { componentName: "<material>", fieldName }),
+        ...texture.sampler === void 0 ? {} : {
+          sampler: addMaterialRef(texture.sampler, {
+            componentName: "<material>",
+            fieldName: `${fieldName}.sampler`
+          })
         }
-      });
+      };
+    } else {
+      values[fieldName] = value;
     }
   }
-  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 { parent: _parent, values: _values, ...materialShape } = material;
+  return {
+    payload: {
+      ...materialShape,
+      ...parent === void 0 ? {} : { parent },
+      ...material.values === void 0 ? {} : { values }
+    },
+    refs,
+    artifacts: {}
+  };
+}
+function meshProduct(input) {
+  if (input.asset.kind !== "mesh") throw new TypeError("expected MeshAsset");
+  const mesh = input.asset;
+  const refs = [];
+  for (let slotIndex = 0; slotIndex < mesh.materialSlots.length; slotIndex++) {
+    const defaultMaterial = mesh.materialSlots[slotIndex]?.defaultMaterial;
+    if (defaultMaterial === void 0) continue;
+    refs.push({
+      guid: formatGuid(defaultMaterial),
+      sourceField: { fieldName: "materialSlots", arrayIndex: slotIndex }
     });
   }
-  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 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 } });
   }
-  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"
+    payload: mesh,
+    refs,
+    artifacts: {
+      body: {
+        mediaType: "application/x-forgeax-mesh",
+        assetCodec: { name: "mesh-binary", version: "4" },
+        bytes: (() => {
+          const packed = packMeshBinV4(
+            mesh,
+            input.sourceKey,
+            refs.map((reference) => reference.guid)
+          );
+          if (!packed.ok) {
+            throw packed.error;
+          }
+          return packed.value;
+        })()
+      }
+    }
   };
 }
-function asAttributeMap(value) {
-  return value ?? {};
+function sceneProduct(input, components) {
+  if (input.asset.kind !== "scene") throw new TypeError("expected SceneAsset");
+  const externalized = externalizeSceneAsset(input.asset, (componentName) => {
+    const schema = components.get(componentName);
+    if (schema === void 0) {
+      throw new TypeError(
+        `ScriptablePack scene component ${componentName} is missing from sceneComponents`
+      );
+    }
+    return schema;
+  });
+  if (!externalized.ok) throw new TypeError(`scene field ${externalized.error.field} is invalid`);
+  return {
+    payload: { kind: "scene", ...externalized.value.payload },
+    refs: externalized.value.refs,
+    artifacts: {}
+  };
 }
-function jsonValue(value) {
-  if (value instanceof Float32Array || value instanceof Uint16Array) return Array.from(value);
-  if (Array.isArray(value)) return value.map(jsonValue);
+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.fromEntries(
-      Object.entries(value).map(([key, nested]) => [key, jsonValue(nested)])
-    );
+    return Object.values(value).some(containsAssetGuid);
   }
-  return value;
+  return false;
 }
-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");
+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");
   }
-  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`
-      );
+  return {
+    payload: { ...input.asset, kind: "scene" },
+    refs: [],
+    artifacts: {}
+  };
+}
+function createSafeProducer(kind, version, product) {
+  return {
+    kind,
+    version,
+    produce(input) {
+      try {
+        return ok(product(input));
+      } catch (error) {
+        return err(producerError(input, error));
+      }
     }
-    seenLodGuids.add(guid);
-    previousCoverage = lod.screenCoverage;
-    return { meshRef, screenCoverage: lod.screenCoverage };
+  };
+}
+function jsonArtifact(value) {
+  return {
+    mediaType: "application/json",
+    assetCodec: { name: "forgeax-json", version: "1" },
+    bytes: new TextEncoder().encode(JSON.stringify(value))
+  };
+}
+function ref(guid, fieldName, arrayIndex) {
+  return {
+    guid: formatGuid(guid),
+    sourceField: { fieldName, ...arrayIndex === void 0 ? {} : { arrayIndex } }
+  };
+}
+function bytes(value) {
+  return Uint8Array.from(value);
+}
+function textureProduct(input) {
+  if (input.asset.kind !== "texture") throw new TypeError("expected TextureAsset");
+  const texture = input.asset;
+  const layout = deriveTextureLayout({
+    shape: texture.shape,
+    format: texture.format,
+    mips: texture.mips,
+    actualByteLength: texture.data.byteLength,
+    order: "mip-major,image-major,row-major"
   });
-  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)");
+  if (!layout.ok) {
+    const expectedBytes = layout.error.code === "texture-packing-invalid" ? layout.error.detail.expectedBytes : texture.data.byteLength;
+    const actualBytes = layout.error.code === "texture-packing-invalid" ? layout.error.detail.actualBytes : texture.data.byteLength;
+    throw new TypeError(
+      `texture data is not canonical: expected ${expectedBytes} bytes, got ${actualBytes}`
+    );
   }
   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 }
+    payload: texture,
+    refs: [],
+    artifacts: {
+      body: {
+        mediaType: texture.format === "r8unorm" ? "application/x-forgeax-r8" : `application/x-forgeax-${texture.format}`,
+        assetCodec: { name: texture.format, version: "1" },
+        bytes: bytes(texture.data)
+      }
+    }
   };
 }
-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 ordinaryPodProduct(input) {
+  const asset = input.asset;
+  switch (asset.kind) {
+    case "texture":
+      return textureProduct(input);
+    case "equirect": {
+      const equirect = asset;
+      return {
+        payload: equirect,
+        refs: [],
+        artifacts: {
+          body: {
+            mediaType: "image/raw",
+            assetCodec: { name: "raw-image", version: "1" },
+            bytes: bytes(equirect.data)
+          }
+        }
+      };
     }
-    if (indices !== void 0 && !(indices instanceof Uint16Array || indices instanceof Uint32Array)) {
-      return err(
-        failure(sourceKey, "Uint16Array or Uint32Array indices", "indices has an unsupported type")
-      );
+    case "sampler": {
+      const sampler = asset;
+      return { payload: sampler, refs: [], artifacts: { body: jsonArtifact(sampler) } };
     }
-    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"
-        )
-      );
+    case "font": {
+      const font = asset;
+      const atlas = ref(font.atlas, "atlas");
+      const sampler = ref(font.sampler, "sampler");
+      return {
+        payload: {
+          kind: font.kind,
+          glyphs: font.glyphs,
+          common: font.common,
+          atlasGuid: atlas.guid,
+          samplerGuid: sampler.guid
+        },
+        refs: [atlas, sampler],
+        artifacts: { body: jsonArtifact(font) }
+      };
     }
-    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}`)
-      );
+    case "render-pipeline": {
+      const pipeline = asset;
+      return {
+        payload: pipeline,
+        refs: [],
+        artifacts: { body: jsonArtifact(pipeline) }
+      };
     }
-    if (vertices.byteLength !== vertexCount * projection.arrayStride) {
-      return err(
-        failure(
-          sourceKey,
-          `vertices.byteLength=${vertexCount * projection.arrayStride}`,
-          `vertices.byteLength=${vertices.byteLength}; stride=${projection.arrayStride}`
-        )
-      );
+    case "tileset": {
+      const tileset = asset;
+      const refs = tileset.atlases.map((atlas, index) => {
+        const parsed = AssetGuid$1.parse(atlas);
+        if (!parsed.ok) throw parsed.error;
+        return ref(parsed.value, "atlases", index);
+      });
+      return {
+        payload: { ...tileset, atlases: refs.map((_entry, index) => index) },
+        refs,
+        artifacts: { body: jsonArtifact(tileset) }
+      };
     }
-    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"}`
-          )
+    case "video": {
+      const video = asset;
+      try {
+        const url = new URL(video.url);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+          throw new Error("unsupported URL scheme");
+      } catch (error) {
+        throw new TypeError(
+          `video URL is invalid: ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      return { payload: video, refs: [], artifacts: {} };
     }
-    const interleaved = new Uint8Array(vertexCount * projection.arrayStride);
-    const interleavedView = new DataView(interleaved.buffer);
-    for (const attribute of projection.attributes) {
-      const value = attributes[attribute.key];
-      if (value === void 0) continue;
-      const components = attribute.byteLength / (attribute.format === "uint16x4" ? 2 : 4);
-      for (let vertex = 0; vertex < vertexCount; vertex++) {
-        for (let component = 0; component < components; component++) {
-          const sourceIndex = vertex * components + component;
-          const targetOffset = vertex * projection.arrayStride + attribute.offset + component * (attribute.format === "uint16x4" ? 2 : 4);
-          if (attribute.format === "uint16x4") {
-            interleavedView.setUint16(targetOffset, value[sourceIndex] ?? 0, true);
-          } else {
-            interleavedView.setFloat32(
-              targetOffset,
-              value[sourceIndex] ?? 0,
-              true
-            );
-          }
-        }
-      }
+    case "skeleton": {
+      const skeleton = asset;
+      return {
+        payload: skeleton,
+        refs: [],
+        artifacts: { body: jsonArtifact(skeleton) }
+      };
     }
-    const indexCount = indices?.length ?? 0;
-    const indexWidth = indices === void 0 || indexCount === 0 ? 0 : indices.BYTES_PER_ELEMENT;
-    const indexBytes = indexCount * indexWidth;
-    if (!Number.isSafeInteger(indexBytes) || indexBytes > 4294967295) {
-      return err(failure(sourceKey, "safe index payload byte length", `indexBytes=${indexBytes}`));
+    case "skin": {
+      const skin = asset;
+      const skeletonGuid = AssetGuid$1.parse(skin.skeletonGuid);
+      if (!skeletonGuid.ok) throw skeletonGuid.error;
+      return {
+        payload: skin,
+        refs: [ref(skeletonGuid.value, "skeletonGuid")],
+        artifacts: { body: jsonArtifact(skin) }
+      };
     }
-    const meta = new TextEncoder().encode(JSON.stringify(refsMeta(payload, refs)));
-    const header = {
-      version: 4,
-      projectionVersion: projection.schemaVersion,
-      mask: projection.mask,
-      digest: projection.digest,
-      stride: projection.arrayStride,
-      vertexCount,
-      vertexBytes: interleaved.byteLength,
-      indexCount,
-      indexWidth,
-      indexBytes,
-      jsonBytes: meta.byteLength
-    };
-    const total = MESH_BIN_HEADER_V4_BYTES + interleaved.byteLength + indexBytes + meta.byteLength;
-    if (!Number.isSafeInteger(total) || total > 4294967295) {
-      return err(failure(sourceKey, "safe mesh binary byte length", `total=${total}`));
+    case "animation-clip":
+      return {
+        payload: asset,
+        refs: [],
+        artifacts: { body: jsonArtifact(asset) }
+      };
+    case "animation-graph": {
+      const graph = asset;
+      const refs = [];
+      const nodes = graph.nodes.map((node, index) => {
+        if (node.type !== "clip") return node;
+        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 };
+      });
+      return {
+        payload: { kind: graph.kind, root: graph.root, nodes },
+        refs,
+        artifacts: { body: jsonArtifact(graph) }
+      };
     }
-    const out = new Uint8Array(total);
-    writeMeshBinHeader(header, out);
-    let offset = MESH_BIN_HEADER_V4_BYTES;
-    out.set(interleaved, offset);
-    offset += interleaved.byteLength;
-    if (indices !== void 0 && indexBytes > 0) {
-      out.set(new Uint8Array(indices.buffer, indices.byteOffset, indices.byteLength), offset);
-      offset += indexBytes;
+    case "audio": {
+      const audio = asset;
+      return {
+        payload: {
+          kind: audio.kind,
+          sourceKey: audio.sourceKey,
+          mediaType: audio.mediaType,
+          bytes: audio.bytes.slice()
+        },
+        refs: [],
+        artifacts: {
+          source: {
+            mediaType: audio.mediaType,
+            assetCodec: { name: "browser-audio", version: "1" },
+            bytes: audio.bytes.slice()
+          }
+        }
+      };
     }
-    out.set(meta, offset);
-    return ok(out);
-  } catch (error) {
-    return err(
-      failure(
-        sourceKey,
-        "valid canonical mesh payload",
-        error instanceof Error ? error.message : String(error)
-      )
-    );
-  }
-}
-
-// 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");
+    case "particle-effect": {
+      const effect = asset;
+      const cooked = particleProgramArtifact(effect);
+      const refs = /* @__PURE__ */ new Set();
+      for (const emitter of cooked.program.emitters) {
+        for (const renderer of emitter.renderers) {
+          if (!("material" in renderer) || typeof renderer.material !== "string") {
+            throw new Error(`Particle emitter '${emitter.id}' requires a renderer Material GUID`);
+          }
+          refs.add(formatGuid(renderer.material));
+          if ("kind" in renderer && renderer.kind === "mesh") {
+            if (!("mesh" in renderer) || typeof renderer.mesh !== "string") {
+              throw new Error(`Particle emitter '${emitter.id}' requires a renderer Mesh GUID`);
+            }
+            refs.add(formatGuid(renderer.mesh));
+          }
+        }
+      }
+      return {
+        payload: { ...effect, programFingerprint: cooked.fingerprint, program: cooked.program },
+        refs: [...refs].sort().map((guid) => ({ guid })),
+        artifacts: {
+          "particle-effect/program.json": {
+            mediaType: "application/json",
+            assetCodec: { name: "forgeax-vfx-program", version: effect.program.format },
+            bytes: cooked.bytes
+          }
+        }
+      };
     }
-    if (typeof producer.produce !== "function") {
-      throw new TypeError(`Pack output producer ${producer.kind} must expose produce`);
+    case "ies-profile": {
+      const profile = asset;
+      return {
+        payload: profile,
+        refs: [],
+        artifacts: {
+          body: {
+            mediaType: "application/octet-stream",
+            assetCodec: { name: "forgeax-ies-profile", version: "1" },
+            bytes: bytes(profile.data)
+          }
+        }
+      };
     }
-    this.producers.set(producer.kind, producer);
-  }
-  get(kind) {
-    return this.producers.get(kind);
+    case "material":
+    case "mesh":
+    case "scene":
+      throw new TypeError(`ordinary producer received already-owned ${asset.kind} asset`);
   }
-  versions() {
-    return Object.fromEntries(
-      [...this.producers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([kind, producer]) => [kind, producer.version])
+}
+var materialAssetOutputProducer = createSafeProducer(
+  "material",
+  "material-pack/2",
+  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 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,
+        kind === "particle-effect" ? "particle-effect/2" : "ordinary-pod/1",
+        ordinaryPodProduct
+      )
     );
   }
-};
+  return registry;
+}
 
-// src/scriptable-pack-output-producers.ts
-function producerError(input, reason) {
-  return new ImportError({
-    code: "import-internal-error",
-    expected: `ScriptablePack ${input.asset.kind} output ${input.sourceKey} to satisfy its domain producer contract`,
-    hint: "fix the generated Asset payload and rebuild the ScriptablePack",
-    detail: { reason: reason instanceof Error ? reason.message : String(reason) }
-  });
+// src/scriptable-pack-build.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function formatGuid(value) {
-  if (typeof value === "string") {
-    const parsed = AssetGuid$1.parse(value);
-    if (!parsed.ok) throw parsed.error;
-    return AssetGuid$1.format(parsed.value);
-  }
-  return AssetGuid$1.format(value);
+function isAsset(value) {
+  return record(value) && typeof value.kind === "string" && isScriptablePackAssetKind(value.kind);
 }
-function canonical(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `${JSON.stringify(key)}:${canonical(child)}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
+function needsMaterialCook(asset) {
+  return asset.kind === "material" && Array.isArray(asset.passes) && !isEngineMaterial(asset);
 }
-function particleProgramArtifact(effect) {
-  const artifactProgram = { format: effect.program.format, emitters: effect.program.emitters };
-  const bytes2 = new TextEncoder().encode(canonical(artifactProgram));
-  const fingerprint = `sha256:${bytesToHex(sha256(bytes2))}`;
-  return {
-    program: { ...effect.program, fingerprint },
-    bytes: bytes2,
-    fingerprint
-  };
+function clone(value) {
+  return structuredClone(value);
 }
-function materialProduct(input) {
-  if (input.asset.kind !== "material") throw new TypeError("expected MaterialAsset");
-  const material = input.asset;
-  const refs = [];
-  const addRef = (guid, sourceField) => {
-    refs.push({ guid: formatGuid(guid), sourceField });
-    return refs.length - 1;
-  };
-  const addMaterialRef = (value, sourceField) => {
-    if (typeof value === "number") {
-      throw new TypeError("material texture references must be GUIDs, not runtime handles");
-    }
-    return addRef(value, sourceField);
-  };
-  const textureFields = material.parameters === void 0 ? new Set(MATERIAL_TEXTURE_SLOTS) : new Set(
-    material.parameters.filter(
-      (parameter) => parameter.type === "texture" || parameter.type === "texture_cube"
-    ).map((parameter) => parameter.name)
-  );
-  const parent = material.parent === void 0 ? void 0 : addRef(material.parent, { fieldName: "parent" });
-  const values = {};
-  for (const fieldName of Object.keys(material.values ?? {}).sort()) {
-    const value = material.values?.[fieldName];
-    if (typeof value === "string" && textureFields.has(fieldName)) {
-      values[fieldName] = {
-        texture: addMaterialRef(value, { componentName: "<material>", fieldName })
-      };
-    } else if (value !== null && typeof value === "object" && !Array.isArray(value) && "texture" in value) {
-      const texture = value;
-      values[fieldName] = {
-        ...texture,
-        texture: addMaterialRef(texture.texture, { componentName: "<material>", fieldName }),
-        ...texture.sampler === void 0 ? {} : {
-          sampler: addMaterialRef(texture.sampler, {
-            componentName: "<material>",
-            fieldName: `${fieldName}.sampler`
+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 }
           })
-        }
-      };
-    } else {
-      values[fieldName] = value;
-    }
-  }
-  const { parent: _parent, values: _values, ...materialShape } = material;
-  return {
-    payload: {
-      ...materialShape,
-      ...parent === void 0 ? {} : { parent },
-      ...material.values === void 0 ? {} : { values }
-    },
-    refs,
-    artifacts: {}
-  };
-}
-function meshProduct(input) {
-  if (input.asset.kind !== "mesh") throw new TypeError("expected MeshAsset");
-  const mesh = input.asset;
-  const refs = [];
-  for (let slotIndex = 0; slotIndex < mesh.materialSlots.length; slotIndex++) {
-    const defaultMaterial = mesh.materialSlots[slotIndex]?.defaultMaterial;
-    if (defaultMaterial === void 0) continue;
-    refs.push({
-      guid: formatGuid(defaultMaterial),
-      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,
-    artifacts: {
-      body: {
-        mediaType: "application/x-forgeax-mesh",
-        assetCodec: { name: "mesh-binary", version: "4" },
-        bytes: (() => {
-          const packed = packMeshBinV4(
-            mesh,
-            input.sourceKey,
-            refs.map((reference) => reference.guid)
-          );
-          if (!packed.ok) {
-            throw packed.error;
-          }
-          return packed.value;
-        })()
+        );
       }
+      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 sceneProduct(input, components) {
-  if (input.asset.kind !== "scene") throw new TypeError("expected SceneAsset");
-  const externalized = externalizeSceneAsset(input.asset, (componentName) => {
-    const schema = components.get(componentName);
-    if (schema === void 0) {
-      throw new TypeError(
-        `ScriptablePack scene component ${componentName} is missing from sceneComponents`
-      );
-    }
-    return schema;
-  });
-  if (!externalized.ok) throw new TypeError(`scene field ${externalized.error.field} is invalid`);
-  return {
-    payload: { kind: "scene", ...externalized.value.payload },
-    refs: externalized.value.refs,
-    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 buildContext(packageId, values, reader) {
+  if (values === void 0) return { packageId, readByGuid: reader.readByGuid };
+  return { packageId, values, readByGuid: reader.readByGuid };
 }
-function createSafeProducer(kind, version, product) {
+function sourceKeyFailure(sourcePath, sourceKey) {
   return {
-    kind,
-    version,
-    produce(input) {
-      try {
-        return ok(product(input));
-      } catch (error) {
-        return err(producerError(input, error));
-      }
-    }
+    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 jsonArtifact(value) {
+function outputValueError(sourcePath, sourceKey, expected, actual) {
   return {
-    mediaType: "application/json",
-    assetCodec: { name: "forgeax-json", version: "1" },
-    bytes: new TextEncoder().encode(JSON.stringify(value))
+    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 ref(guid, fieldName, arrayIndex) {
+function referenceError(code, sourcePath, guids) {
   return {
-    guid: formatGuid(guid),
-    sourceField: { fieldName, ...arrayIndex === void 0 ? {} : { arrayIndex } }
+    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 bytes(value) {
-  return Uint8Array.from(value);
-}
-function textureProduct(input) {
-  if (input.asset.kind !== "texture") throw new TypeError("expected TextureAsset");
-  const texture = input.asset;
-  const layout = deriveTextureLayout({
-    shape: texture.shape,
-    format: texture.format,
-    mips: texture.mips,
-    actualByteLength: texture.data.byteLength,
-    order: "mip-major,image-major,row-major"
-  });
-  if (!layout.ok) {
-    const expectedBytes = layout.error.code === "texture-packing-invalid" ? layout.error.detail.expectedBytes : texture.data.byteLength;
-    const actualBytes = layout.error.code === "texture-packing-invalid" ? layout.error.detail.actualBytes : texture.data.byteLength;
-    throw new TypeError(
-      `texture data is not canonical: expected ${expectedBytes} bytes, got ${actualBytes}`
+function productError(sourcePath, sourceKey, producer, product) {
+  if (!record(product)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return an asset product object`,
+      product
     );
   }
-  return {
-    payload: texture,
-    refs: [],
-    artifacts: {
-      body: {
-        mediaType: texture.format === "r8unorm" ? "application/x-forgeax-r8" : `application/x-forgeax-${texture.format}`,
-        assetCodec: { name: texture.format, version: "1" },
-        bytes: bytes(texture.data)
-      }
-    }
-  };
-}
-function ordinaryPodProduct(input) {
-  const asset = input.asset;
-  switch (asset.kind) {
-    case "texture":
-      return textureProduct(input);
-    case "equirect": {
-      const equirect = asset;
-      return {
-        payload: equirect,
-        refs: [],
-        artifacts: {
-          body: {
-            mediaType: "image/raw",
-            assetCodec: { name: "raw-image", version: "1" },
-            bytes: bytes(equirect.data)
-          }
-        }
-      };
+  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
+      );
     }
-    case "sampler": {
-      const sampler = asset;
-      return { payload: sampler, refs: [], artifacts: { body: jsonArtifact(sampler) } };
+  }
+  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
+      );
     }
-    case "font": {
-      const font = asset;
-      const atlas = ref(font.atlas, "atlas");
-      const sampler = ref(font.sampler, "sampler");
-      return {
-        payload: {
-          kind: font.kind,
-          glyphs: font.glyphs,
-          common: font.common,
-          atlasGuid: atlas.guid,
-          samplerGuid: sampler.guid
-        },
-        refs: [atlas, sampler],
-        artifacts: { body: jsonArtifact(font) }
-      };
+  }
+  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();
+  const cookerRegistry = new NativeCookerRegistry();
+  for (const cooker of options.cookers ?? []) cookerRegistry.register(cooker);
+  const nativeFingerprints = /* @__PURE__ */ new Map();
+  for (const sourceKey of Object.keys(built.value).sort()) {
+    if (!isValidPackSourceKey(sourceKey))
+      return err(sourceKeyFailure(options.sourcePath, sourceKey));
+    const asset = built.value[sourceKey];
+    const customSource = record(asset) && asset.execution === "cooked";
+    if (customSource && (typeof asset.kind !== "string" || asset.kind.trim().length === 0 || isScriptablePackAssetKind(asset.kind) || !("source" in asset) || Object.keys(asset).some((key) => !["kind", "execution", "source"].includes(key)))) {
+      return err(
+        outputValueError(
+          options.sourcePath,
+          sourceKey,
+          "a custom kind with only execution: cooked and source; ordinary Assets use their standard producers",
+          asset
+        )
+      );
     }
-    case "render-pipeline": {
-      const pipeline = asset;
-      return {
-        payload: pipeline,
-        refs: [],
-        artifacts: { body: jsonArtifact(pipeline) }
+    if (!customSource && !isAsset(asset)) {
+      return err(
+        outputValueError(
+          options.sourcePath,
+          sourceKey,
+          "a concrete Asset with a supported kind",
+          asset
+        )
+      );
+    }
+    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);
+    if (customSource) {
+      const cooked = await cookerRegistry.runDraft(asset.kind, {
+        guid,
+        sourceKey,
+        sourcePath: options.sourcePath,
+        source: asset.source,
+        refs: []
+      });
+      if (!cooked.ok) return err(cooked.error);
+      if (cooked.value.guid.toLowerCase() !== normalizedGuid)
+        return err({
+          code: "pack-source-output-invalid",
+          expected: "the custom cooker to preserve the derived AssetGuid",
+          hint: "remove cooker-owned identity generation and retain the host GUID",
+          detail: {
+            sourcePath: options.sourcePath,
+            sourceKey,
+            expectedGuid: guid,
+            actualGuid: cooked.value.guid
+          }
+        });
+      const product3 = {
+        payload: cooked.value.payload,
+        refs: cooked.value.refs.map((guid2) => ({ guid: guid2 })),
+        artifacts: cooked.value.artifacts
       };
+      const invalid = productError(options.sourcePath, sourceKey, { kind: asset.kind }, product3);
+      if (invalid !== void 0) return err(invalid);
+      imported.push({ guid, kind: asset.kind, ...product3 });
+      nativeFingerprints.set(sourceKey, cooked.value.inputFingerprint);
+      stagedOutputs.push({
+        guid: AssetGuid.derive(subjectPackageId, sourceKey),
+        sourceKey,
+        asset: clone(asset),
+        digest: await scriptablePackFingerprint(asset)
+      });
+      continue;
     }
-    case "tileset": {
-      const tileset = asset;
-      const refs = tileset.atlases.map((atlas, index) => {
-        const parsed = AssetGuid$1.parse(atlas);
-        if (!parsed.ok) throw parsed.error;
-        return ref(parsed.value, "atlases", index);
+    if (!isAsset(asset))
+      return err(outputValueError(options.sourcePath, sourceKey, "an ordinary Asset", asset));
+    const producer = options.outputs.get(asset.kind);
+    if (producer === void 0) {
+      return err(
+        outputValueError(
+          options.sourcePath,
+          sourceKey,
+          `a registered output producer for ${asset.kind}`,
+          asset.kind
+        )
+      );
+    }
+    let produced;
+    try {
+      produced = await producer.produce({ guid, sourceKey, asset });
+    } catch (cause) {
+      return err(
+        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 (!record(produced) || typeof produced.ok !== "boolean") {
+      return err(
+        outputValueError(
+          options.sourcePath,
+          sourceKey,
+          `producer ${producer.kind} to return a Result`,
+          produced
+        )
+      );
+    }
+    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;
+    let payload = product2.payload;
+    let artifacts2 = product2.artifacts;
+    let refs2 = product2.refs;
+    if (needsMaterialCook(asset) && cookerRegistry.get("material") !== void 0) {
+      const cooked = await cookerRegistry.runDraft("material", {
+        guid,
+        source: asset,
+        sourceKey,
+        sourcePath: options.sourcePath,
+        refs: product2.refs.map((reference) => reference.guid)
       });
-      return {
-        payload: { ...tileset, atlases: refs.map((_entry, index) => index) },
-        refs,
-        artifacts: { body: jsonArtifact(tileset) }
+      if (!cooked.ok) return err(cooked.error);
+      if (cooked.value.guid.toLowerCase() !== normalizedGuid) {
+        return err({
+          code: "pack-source-output-invalid",
+          expected: "the authored material cooker to preserve the derived AssetGuid",
+          hint: "repair the native material cooker output GUID and rebuild the Pack",
+          detail: {
+            sourcePath: options.sourcePath,
+            sourceKey,
+            expectedGuid: guid,
+            actualGuid: cooked.value.guid
+          }
+        });
+      }
+      const cookedAsset = cooked.value.payload;
+      if (!isAsset(cookedAsset) || cookedAsset.kind !== "material") {
+        return err({
+          code: "pack-source-output-invalid",
+          expected: "the authored material cooker to return a material payload",
+          hint: "repair the native material cooker payload and rebuild the Pack",
+          detail: { sourcePath: options.sourcePath, sourceKey }
+        });
+      }
+      const projected = await materialAssetOutputProducer.produce({
+        guid,
+        sourceKey,
+        asset: cookedAsset
+      });
+      if (!projected.ok) return err(projected.error);
+      const projectedInvalid = productError(
+        options.sourcePath,
+        sourceKey,
+        materialAssetOutputProducer,
+        projected.value
+      );
+      if (projectedInvalid !== void 0) return err(projectedInvalid);
+      payload = projected.value.payload;
+      artifacts2 = {
+        ...product2.artifacts,
+        ...cooked.value.artifacts,
+        ...projected.value.artifacts
       };
+      const mergedRefs = [...projected.value.refs];
+      const seenRefs = new Set(mergedRefs.map((reference) => reference.guid.toLowerCase()));
+      for (const cookerRef of cooked.value.refs) {
+        const parsed = AssetGuid.parse(cookerRef);
+        if (!parsed.ok) {
+          return err({
+            code: "pack-source-output-invalid",
+            expected: "the authored material cooker refs to contain valid AssetGuid values",
+            hint: "repair the native material cooker refs and rebuild the Pack",
+            detail: { sourcePath: options.sourcePath, sourceKey, ref: cookerRef }
+          });
+        }
+        const formatted = AssetGuid.format(parsed.value);
+        const normalizedRef = formatted.toLowerCase();
+        if (seenRefs.has(normalizedRef)) continue;
+        seenRefs.add(normalizedRef);
+        mergedRefs.push({ guid: formatted });
+      }
+      refs2 = mergedRefs;
+      nativeFingerprints.set(sourceKey, cooked.value.inputFingerprint);
     }
-    case "video": {
-      const video = asset;
-      try {
-        const url = new URL(video.url);
-        if (url.protocol !== "http:" && url.protocol !== "https:")
-          throw new Error("unsupported URL scheme");
-      } catch (error) {
-        throw new TypeError(
-          `video URL is invalid: ${error instanceof Error ? error.message : String(error)}`
-        );
+    imported.push({
+      guid,
+      kind: asset.kind,
+      payload,
+      refs: refs2,
+      artifacts: artifacts2
+    });
+    stagedOutputs.push({
+      guid: AssetGuid.derive(subjectPackageId, sourceKey),
+      sourceKey,
+      asset: clone(asset),
+      digest: await scriptablePackFingerprint(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 authoredInputFingerprint = await scriptablePackFingerprint({
+    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 inputFingerprint = nativeFingerprints.size === 0 ? authoredInputFingerprint : await scriptablePackFingerprint({
+    sourceRevision: authoredInputFingerprint,
+    nativeCookers: [...nativeFingerprints.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )
+  });
+  const refs = imported.flatMap((asset) => asset.refs);
+  const artifacts = Object.fromEntries(
+    imported.flatMap(
+      (asset) => 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"
+        });
       }
-      return { payload: video, refs: [], artifacts: {} };
-    }
-    case "skeleton": {
-      const skeleton = asset;
-      return {
-        payload: skeleton,
-        refs: [],
-        artifacts: { body: jsonArtifact(skeleton) }
-      };
-    }
-    case "skin": {
-      const skin = asset;
-      const skeletonGuid = AssetGuid$1.parse(skin.skeletonGuid);
-      if (!skeletonGuid.ok) throw skeletonGuid.error;
-      return {
-        payload: skin,
-        refs: [ref(skeletonGuid.value, "skeletonGuid")],
-        artifacts: { body: jsonArtifact(skin) }
-      };
+      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);
     }
-    case "animation-clip":
-      return {
-        payload: asset,
-        refs: [],
-        artifacts: { body: jsonArtifact(asset) }
-      };
-    case "animation-graph": {
-      const graph = asset;
-      const refs = [];
-      const nodes = graph.nodes.map((node, index) => {
-        if (node.type !== "clip") return node;
-        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 };
+  };
+}
+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,
+        ...options.cookers === void 0 ? {} : { cookers: options.cookers },
+        assetSource: stagedSource(staged, options.assetSource),
+        availableGuids: /* @__PURE__ */ new Set([...availableGuids, ...staged.keys()]),
+        deferReferenceValidation: true
       });
-      return {
-        payload: { kind: graph.kind, root: graph.root, nodes },
-        refs,
-        artifacts: { body: jsonArtifact(graph) }
-      };
-    }
-    case "audio": {
-      const audio = asset;
-      return {
-        payload: {
-          kind: audio.kind,
-          sourceKey: audio.sourceKey,
-          mediaType: audio.mediaType,
-          bytes: audio.bytes.slice()
-        },
-        refs: [],
-        artifacts: {
-          source: {
-            mediaType: audio.mediaType,
-            assetCodec: { name: "browser-audio", version: "1" },
-            bytes: audio.bytes.slice()
-          }
-        }
-      };
+      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;
     }
-    case "particle-effect": {
-      const effect = asset;
-      const cooked = particleProgramArtifact(effect);
-      return {
-        payload: { ...effect, programFingerprint: cooked.fingerprint, program: cooked.program },
-        refs: [],
-        artifacts: {
-          "particle-effect/program.json": {
-            mediaType: "application/json",
-            assetCodec: { name: "forgeax-vfx-program", version: effect.program.format },
-            bytes: cooked.bytes
-          }
+    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
         }
-      };
+      });
     }
-    case "ies-profile": {
-      const profile = asset;
-      return {
-        payload: profile,
-        refs: [],
-        artifacts: {
-          body: {
-            mediaType: "application/octet-stream",
-            assetCodec: { name: "forgeax-ies-profile", version: "1" },
-            bytes: bytes(profile.data)
-          }
-        }
-      };
+  }
+  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);
+      }
     }
-    case "material":
-    case "mesh":
-    case "scene":
-      throw new TypeError(`ordinary producer received already-owned ${asset.kind} asset`);
   }
-}
-var materialAssetOutputProducer = createSafeProducer(
-  "material",
-  "material-pack/2",
-  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 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));
+  if (missingReferences.size > 0) {
+    return err(
+      referenceError("pack-output-reference-missing", "worklist", [...missingReferences].sort())
+    );
   }
-  return registry;
+  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 parseProducerReadiness(value) {
   if (value === void 0 || value === "before-consume" || value === "on-demand") {
@@ -2779,7 +2926,7 @@ async function produceScriptablePackProducts(options) {
   }
   return ok(prepared);
 }
-async function scriptablePackResourceRevision(displaySourcePath, digest3, sourceClosure) {
+async function scriptablePackResourceRevision(displaySourcePath, digest, sourceClosure) {
   const mtimes = await Promise.all(
     sourceClosure.map(async (entry) => {
       try {
@@ -2793,7 +2940,7 @@ async function scriptablePackResourceRevision(displaySourcePath, digest3, source
     })
   );
   const observedAt = mtimes.length === 0 ? 0 : Math.trunc(Math.max(...mtimes));
-  return { digest: digest3, observedAt, rootId: displaySourcePath };
+  return { digest, observedAt, rootId: displaySourcePath };
 }
 function normalizeCatalogPath(path) {
   return path.replaceAll("\\", "/").replace(/^\.\//, "");
@@ -2826,16 +2973,11 @@ function runtimePublicationFor(context, input) {
     ...input.digest === void 0 ? {} : { digest: input.digest },
     ...input.inputFingerprint === void 0 ? {} : { inputFingerprint: input.inputFingerprint },
     ...input.outputs === void 0 ? {} : { outputs: input.outputs },
+    ...input.sourceKeys === void 0 ? {} : { sourceKeys: input.sourceKeys },
     ...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 });
+  return createRuntimePackPublication(publicationInput);
 }
 function sourceKeysFor(declarations) {
   return new Map(
@@ -3234,6 +3376,7 @@ async function emitAuthoredPack(work, guidSeen, entry, availableGuids) {
   };
   const runtimePublication = runtimePublicationFor(work.context, {
     pack: authoredPack,
+    sourceKeys: sourceKeysFor(legacy.assets),
     sourcePath: entry.sourcePath,
     sourceRevision: declaration.sourceRevision,
     packageUrl: prepared.finalized?.packageUrl ?? `${work.context.basePrefix === "/" ? "" : work.context.basePrefix}/assets/${outputGuid}.pack.json`,
@@ -3816,25 +3959,6 @@ var ImporterRegistry = class {
 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;
@@ -3937,7 +4061,7 @@ function assetFromRow(path, row) {
     });
   }
   const asset = { ...row.payload, kind: row.kind };
-  return ok({ asset, digest: digest2(asset) });
+  return ok({ asset, digest: scriptablePackFingerprint(asset) });
 }
 async function indexPackFiles(assetRoots) {
   const files = await collectPackFiles(assetRoots);
@@ -3998,9 +4122,7 @@ async function indexPackFiles(assetRoots) {
       byGuid.set(key, asset.value);
     }
   }
-  const sourceDigest = digest2(
-    [...documents].sort((left, right) => stable2(left).localeCompare(stable2(right)))
-  );
+  const sourceDigest = scriptablePackFingerprint(documents.map(scriptablePackFingerprint).sort());
   return ok({
     generation: generationFromDigest(sourceDigest),
     assets: byGuid
@@ -4030,22 +4152,6 @@ function createScriptablePackFileAssetSnapshotSource(options) {
     }
   };
 }
-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];
@@ -4123,7 +4229,7 @@ function createScriptablePackStagedAssetSnapshotSource(options) {
             next.set(outputGuid, {
               asset: structuredClone(output.asset),
               generation: options.generation,
-              digest: output.digest ?? await assetDigest(output.asset)
+              digest: output.digest ?? await scriptablePackFingerprint(output.asset)
             });
           }
           for (const declared of owner.guids) {
@@ -4537,8 +4643,8 @@ function validatePublicationArtifactClosure(input) {
   return ok(publicationArtifacts(input.transport));
 }
 function projectImportPublication(input, head, observedAt) {
-  const digest3 = head.currentKey ?? input.desiredKey;
-  const revision = { digest: digest3, observedAt, rootId: input.root };
+  const digest = head.currentKey ?? input.desiredKey;
+  const revision = { digest, 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;