@forgeax/engine-import 0.1.28 → 0.1.29

package/dist/index.mjs

@@ -779,1217 +779,1286 @@ 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 }
-          })
-        );
-      }
-      const result = await source.readByGuid(guid);
-      if (!result.ok) return result;
-      const asset = clone(result.value.asset);
-      reads.set(key, {
-        guid: key,
-        asset,
-        generation: result.value.generation,
-        digest: result.value.digest
-      });
-      return ok(clone(asset));
-    }
-  };
-  return { reader, reads };
-}
-function buildContext(packageId, values, reader) {
-  if (values === void 0) return { packageId, readByGuid: reader.readByGuid };
-  return { packageId, values, readByGuid: reader.readByGuid };
-}
-function sourceKeyFailure(sourcePath, sourceKey) {
-  return {
-    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 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`
+          })
         }
-      });
-    }
-  }
-  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);
-      }
+      };
+    } else {
+      values[fieldName] = value;
     }
   }
-  if (missingReferences.size > 0) {
-    return err(
-      referenceError("pack-output-reference-missing", "worklist", [...missingReferences].sort())
-    );
-  }
-  const removed = [...options.incomingRefs?.keys() ?? []].filter(
-    (guid) => !staged.has(guid.toLowerCase())
-  );
-  const referencedRemoved = removed.filter(
-    (guid) => (options.incomingRefs?.get(guid) ?? []).length > 0
-  );
-  if (referencedRemoved.length > 0)
-    return err(referenceError("pack-output-reference-conflict", "worklist", referencedRemoved));
-  return ok({
-    products: [...results.values()].map((result) => result.product),
-    buildProducts: [...results.values()],
-    stagedOutputs: [...staged.values()],
-    iterations: pending.size === 0 && options.subjects.length > 0 ? iterations + 1 : iterations
-  });
-}
-function failure(sourceKey, expected, actual) {
+  const { parent: _parent, values: _values, ...materialShape } = material;
   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: {
+      ...materialShape,
+      ...parent === void 0 ? {} : { parent },
+      ...material.values === void 0 ? {} : { values }
+    },
+    refs,
+    artifacts: {}
   };
 }
-function asAttributeMap(value) {
-  return value ?? {};
-}
-function jsonValue(value) {
-  if (value instanceof Float32Array || value instanceof Uint16Array) return Array.from(value);
-  if (Array.isArray(value)) return value.map(jsonValue);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [key, jsonValue(nested)])
-    );
+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 }
+    });
   }
-  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`
+  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;
+        })()
       }
-      return {
-        slotName: slot.slotName,
-        ...slot.sourceKey === void 0 ? {} : { sourceKey: slot.sourceKey },
-        ...defaultMaterialRef === void 0 ? {} : { defaultMaterialRef }
-      };
-    }
-  );
-  if (payload.lods !== void 0 && payload.lods.length > 7) {
-    throw new Error("MeshAsset LOD chain supports at most seven lower-detail levels");
-  }
-  let previousCoverage = 1;
-  const seenLodGuids = /* @__PURE__ */ new Set();
-  const lods = payload.lods?.map((lod, lodIndex) => {
-    const guid = AssetGuid$1.format(lod.mesh).toLowerCase();
-    const meshRef = refs.findIndex((candidate) => candidate.toLowerCase() === guid);
-    if (meshRef < 0) {
-      throw new Error(`LOD ${lodIndex} mesh ${guid} is absent from refs`);
-    }
-    if (seenLodGuids.has(guid)) {
-      throw new Error(`LOD ${lodIndex} mesh ${guid} is duplicated`);
     }
-    if (!Number.isFinite(lod.screenCoverage) || lod.screenCoverage <= 0 || lod.screenCoverage > 1 || lod.screenCoverage >= previousCoverage) {
-      throw new Error(
-        `LOD ${lodIndex} screenCoverage must be finite, in (0, 1], and strictly decreasing`
+  };
+}
+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`
       );
     }
-    seenLodGuids.add(guid);
-    previousCoverage = lod.screenCoverage;
-    return { meshRef, screenCoverage: lod.screenCoverage };
+    return schema;
   });
-  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 (!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 {
-    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: { ...input.asset, kind: "scene" },
+    refs: [],
+    artifacts: {}
   };
 }
-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 createSafeProducer(kind, version, product) {
+  return {
+    kind,
+    version,
+    produce(input) {
+      try {
+        return ok(product(input));
+      } catch (error) {
+        return err(producerError(input, error));
+      }
     }
-    if (indices !== void 0 && !(indices instanceof Uint16Array || indices instanceof Uint32Array)) {
-      return err(
-        failure(sourceKey, "Uint16Array or Uint32Array indices", "indices has an unsupported type")
-      );
+  };
+}
+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 (!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 {
+    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)
+      }
     }
-    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"
-        )
-      );
+  };
+}
+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)
+          }
+        }
+      };
     }
-    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 "sampler": {
+      const sampler = asset;
+      return { payload: sampler, refs: [], artifacts: { body: jsonArtifact(sampler) } };
     }
-    if (vertices.byteLength !== vertexCount * projection.arrayStride) {
-      return err(
-        failure(
-          sourceKey,
-          `vertices.byteLength=${vertexCount * projection.arrayStride}`,
-          `vertices.byteLength=${vertices.byteLength}; stride=${projection.arrayStride}`
-        )
-      );
+    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) }
+      };
     }
-    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 "render-pipeline": {
+      const pipeline = asset;
+      return {
+        payload: pipeline,
+        refs: [],
+        artifacts: { body: jsonArtifact(pipeline) }
+      };
+    }
+    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) }
+      };
+    }
+    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);
-  }
-  versions() {
-    return Object.fromEntries(
-      [...this.producers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([kind, producer]) => [kind, producer.version])
-    );
+    case "material":
+    case "mesh":
+    case "scene":
+      throw new TypeError(`ordinary producer received already-owned ${asset.kind} asset`);
   }
-};
-
-// 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 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);
+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 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 createPreExternalizedSceneAssetOutputProducer() {
+  return createSafeProducer("scene", "scene-pack/3", preExternalizedSceneProduct);
 }
-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 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`
-          })
-        }
-      };
-    } else {
-      values[fieldName] = value;
-    }
+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
+      )
+    );
   }
-  const { parent: _parent, values: _values, ...materialShape } = material;
-  return {
-    payload: {
-      ...materialShape,
-      ...parent === void 0 ? {} : { parent },
-      ...material.values === void 0 ? {} : { values }
-    },
-    refs,
-    artifacts: {}
-  };
+  return registry;
 }
-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;
-        })()
-      }
-    }
-  };
+
+// src/scriptable-pack-build.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(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 isAsset(value) {
+  return record(value) && typeof value.kind === "string" && isScriptablePackAssetKind(value.kind);
 }
-function containsAssetGuid(value) {
-  if (typeof value === "string") return AssetGuid$1.parse(value).ok;
-  if (Array.isArray(value)) return value.some(containsAssetGuid);
+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") {
-    return Object.values(value).some(containsAssetGuid);
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stable(object[key])}`).join(",")}}`;
   }
-  return false;
+  return JSON.stringify(value) ?? "null";
 }
-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: {}
-  };
+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 createSafeProducer(kind, version, product) {
-  return {
-    kind,
-    version,
-    produce(input) {
-      try {
-        return ok(product(input));
-      } catch (error) {
-        return err(producerError(input, error));
+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 }
+          })
+        );
       }
+      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 jsonArtifact(value) {
+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 {
-    mediaType: "application/json",
-    assetCodec: { name: "forgeax-json", version: "1" },
-    bytes: new TextEncoder().encode(JSON.stringify(value))
+    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 ref(guid, fieldName, arrayIndex) {
+function outputValueError(sourcePath, sourceKey, expected, actual) {
   return {
-    guid: formatGuid(guid),
-    sourceField: { fieldName, ...arrayIndex === void 0 ? {} : { arrayIndex } }
+    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 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 referenceError(code, sourcePath, guids) {
   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)
-      }
-    }
+    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 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)
-          }
+function productError(sourcePath, sourceKey, producer, product) {
+  if (!record(product)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return an asset product object`,
+      product
+    );
+  }
+  if (!Array.isArray(product.refs)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return a refs array`,
+      product.refs
+    );
+  }
+  if (!record(product.artifacts)) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return an artifacts object`,
+      product.artifacts
+    );
+  }
+  const payload = product.payload;
+  if (!record(payload) || payload.kind !== producer.kind) {
+    return outputValueError(
+      sourcePath,
+      sourceKey,
+      `producer ${producer.kind} to return a matching payload kind`,
+      payload
+    );
+  }
+  for (const ref2 of product.refs) {
+    if (!record(ref2) || typeof ref2.guid !== "string" || !AssetGuid.parse(ref2.guid).ok) {
+      return outputValueError(
+        sourcePath,
+        sourceKey,
+        "producer refs to contain valid AssetGuid values",
+        ref2
+      );
+    }
+  }
+  for (const [key, artifact] of Object.entries(product.artifacts)) {
+    if (key.length === 0 || key.startsWith("/") || key.includes("..") || key.includes("\\") || !record(artifact) || typeof artifact.mediaType !== "string" || !(artifact.bytes instanceof Uint8Array)) {
+      return outputValueError(
+        sourcePath,
+        sourceKey,
+        "asset-local artifacts with safe keys and bytes",
+        key
+      );
+    }
+  }
+  return void 0;
+}
+function errorCode(value) {
+  return record(value) && typeof value.code === "string" ? value.code : void 0;
+}
+function normalizedGuidSet(value) {
+  return value === void 0 ? void 0 : new Set([...value].map((guid) => guid.toLowerCase()));
+}
+async function buildScriptablePack(options) {
+  const subjectPackageId = options.subjectPackageId ?? options.definition.packageId;
+  const availableGuids = normalizedGuidSet(options.availableGuids);
+  const observed = observedReader(options.assetSource);
+  let effectiveValues;
+  if ("parameters" in options.definition) {
+    const resolved = resolvePackParameterValues(
+      options.definition,
+      options.values ?? {},
+      options.inheritedValues
+    );
+    if (!resolved.ok) return resolved;
+    effectiveValues = resolved.value;
+  } else if (options.values !== void 0 && Object.keys(options.values).length > 0) {
+    return err(
+      outputValueError(
+        options.sourcePath,
+        "$.values",
+        "zero-parameter Packs to omit values and instance capabilities",
+        options.values
+      )
+    );
+  } else if (options.subjectPackageId !== void 0 && PackageId.format(options.subjectPackageId).toLowerCase() !== PackageId.format(options.definition.packageId).toLowerCase()) {
+    return err({
+      code: "pack-parent-has-no-parameters",
+      expected: "a ScriptablePack source with parameters for an independent instance packageId",
+      hint: "use clone for a zero-parameter Pack instead of building it as an instance",
+      detail: {
+        sourcePath: options.sourcePath,
+        rootPackageId: PackageId.format(options.definition.packageId),
+        subjectPackageId: PackageId.format(options.subjectPackageId)
+      }
+    });
+  }
+  let built;
+  try {
+    const context = buildContext(subjectPackageId, effectiveValues, observed.reader);
+    built = options.definition.build(context);
+    built = await built;
+  } catch (cause) {
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "Pack build to return a structured Result without throwing",
+        hint: "repair the authoring function and return err(...) for expected failures",
+        detail: {
+          reason: `${options.sourcePath}: ${cause instanceof Error ? cause.message : String(cause)}`
         }
-      };
+      })
+    );
+  }
+  if (!record(built) || typeof built.ok !== "boolean") {
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "Pack build to return a Result object",
+        hint: "return ok(sourceKeyToAsset) or err(structuredError) from the authoring function",
+        detail: { reason: `${options.sourcePath}: malformed build result` }
+      })
+    );
+  }
+  if (!built.ok) {
+    if (errorCode(built.error) !== void 0) return err(built.error);
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "a structured Pack build error",
+        hint: "return an error carrying code, expected, hint and detail",
+        detail: { reason: `${options.sourcePath}: ${String(built.error)}` }
+      })
+    );
+  }
+  if (!record(built.value)) {
+    return err(
+      outputValueError(
+        options.sourcePath,
+        "$",
+        "build to return a sourceKey-to-Asset object",
+        built.value
+      )
+    );
+  }
+  const imported = [];
+  const stagedOutputs = [];
+  const localGuids = /* @__PURE__ */ new Set();
+  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)) {
+      return err(
+        outputValueError(
+          options.sourcePath,
+          sourceKey,
+          "a concrete Asset with a supported kind",
+          asset
+        )
+      );
     }
-    case "sampler": {
-      const sampler = asset;
-      return { payload: sampler, refs: [], artifacts: { body: jsonArtifact(sampler) } };
+    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 }
+      });
     }
-    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) }
-      };
+    localGuids.add(normalizedGuid);
+    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
+        )
+      );
     }
-    case "render-pipeline": {
-      const pipeline = asset;
-      return {
-        payload: pipeline,
-        refs: [],
-        artifacts: { body: jsonArtifact(pipeline) }
-      };
+    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)}`
+          }
+        })
+      );
     }
-    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 (!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) && 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)
       });
-      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 digest(asset)
+    });
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const asset of imported) {
+    for (const ref2 of asset.refs) {
+      const guid = ref2.guid.toLowerCase();
+      if (!localGuids.has(guid)) referenced.add(guid);
+    }
+  }
+  if (options.deferReferenceValidation !== true) {
+    const missing = [...referenced].filter(
+      (guid) => availableGuids !== void 0 && !availableGuids.has(guid)
+    );
+    if (missing.length > 0)
+      return err(referenceError("pack-output-reference-missing", options.sourcePath, missing));
+  }
+  const externalEvidence = [...observed.reads.values()].sort((left, right) => left.guid.localeCompare(right.guid)).map(
+    (read) => ({
+      guid: read.guid,
+      usage: referenced.has(read.guid) ? "both" : "content",
+      generation: read.generation,
+      digest: read.digest
+    })
+  );
+  const 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 }
+  });
+}
+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") {