@forgeax/engine-import 0.0.0-dev.8d955ade1c79

package/dist/index.mjs

@@ -0,0 +1,2849 @@
+import { ok, validateSourceOverrideMap, ImportError, IMPORT_ERROR_HINTS, canonicalizeSourceOverrides, err, AssetError, MATERIAL_TEXTURE_SLOTS } from '@forgeax/engine-types';
+export { IMPORT_ERROR_HINTS, ImportError } from '@forgeax/engine-types';
+import { resolve, dirname } from 'path';
+import { upgradeLegacyAuthoredPack, loadAssetConfig, resolveAssetSource, finalizePackageTransportSource, projectCookedPackageEntry, buildCatalogProjection, createRuntimePackPublication, metaPathForGuid } from '@forgeax/engine-pack/build';
+import { createHash } from 'crypto';
+import { stat, mkdir, writeFile, rename, rm } from 'fs/promises';
+import { createAcceptedPublication, ddcOutputDigest, DdcGenerationSession, DdcLifecycle } from '@forgeax/engine-ddc';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { NativeCookerRegistry } from '@forgeax/engine-pack/native-cooker';
+import { projectScriptablePackSceneComponents, projectScriptablePackMeta } from '@forgeax/engine-pack/source';
+import { inventoryScriptablePackSource } from '@forgeax/engine-pack/source-node';
+import { externalizeSceneAsset } from '@forgeax/engine-scene';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { MESH_BIN_HEADER_V4_BYTES, writeMeshBinHeader } from '@forgeax/engine-pack/mesh-bin-contract';
+import { isScriptablePackAssetKind } from '@forgeax/engine-pack';
+
+// src/index.ts
+function invalidProduct(field) {
+  return err({
+    code: "import-product-invalid",
+    expected: "a complete terminal import product with source identity",
+    hint: "preserve refs, artifacts, receipts, diagnostics, and source revision at the product boundary",
+    detail: { field }
+  });
+}
+function createImportProduct(input) {
+  if (!Array.isArray(input.assets)) return invalidProduct("assets");
+  if (!Array.isArray(input.sourceDependencies)) return invalidProduct("sourceDependencies");
+  if (input.sourceRevision.trim().length === 0) return invalidProduct("sourceRevision");
+  if (!Array.isArray(input.refs)) return invalidProduct("refs");
+  if (input.artifacts === null || typeof input.artifacts !== "object") {
+    return invalidProduct("artifacts");
+  }
+  if (!Array.isArray(input.receipts)) return invalidProduct("receipts");
+  if (!Array.isArray(input.diagnostics)) return invalidProduct("diagnostics");
+  return ok({ ...input });
+}
+async function sha256Hex(bytes2) {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle === void 0) throw new Error("Web Crypto API is required for importer digests");
+  const owned = new Uint8Array(bytes2.byteLength);
+  owned.set(bytes2);
+  const digest = await subtle.digest("SHA-256", owned.buffer);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function artifactDigest(bytes2) {
+  return `sha256:${await sha256Hex(bytes2)}`;
+}
+function concatBytes(chunks) {
+  const encoder = new TextEncoder();
+  const encoded = chunks.map(
+    (chunk) => typeof chunk === "string" ? encoder.encode(chunk) : chunk
+  );
+  const totalLength = encoded.reduce((total, chunk) => total + chunk.byteLength, 0);
+  const bytes2 = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of encoded) {
+    bytes2.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes2;
+}
+async function productDigest(asset, artifacts) {
+  const chunks = [
+    JSON.stringify(projectImportedAssetPayload(asset)),
+    JSON.stringify(asset.refs.map((ref2) => ref2.guid)),
+    JSON.stringify(artifacts)
+  ];
+  for (const [key, artifact] of Object.entries(asset.artifacts).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    chunks.push(key, artifact.bytes);
+  }
+  return `sha256:${await sha256Hex(concatBytes(chunks))}`;
+}
+async function artifactDescriptors(artifacts) {
+  const entries = [];
+  for (const [path, artifact] of Object.entries(artifacts)) {
+    entries.push([
+      path,
+      {
+        path,
+        mediaType: artifact.mediaType,
+        byteLength: artifact.bytes.byteLength,
+        integrity: { algorithm: "sha256", digest: await artifactDigest(artifact.bytes) },
+        ...artifact.assetCodec === void 0 ? {} : { assetCodec: artifact.assetCodec }
+      }
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+function projectImportedAssetPayload(asset) {
+  const payload = asset.payload;
+  if (Object.keys(asset.artifacts).length === 0) return payload;
+  if (asset.kind === "mesh") return { kind: "mesh" };
+  if (asset.kind === "texture" || asset.kind === "equirect") {
+    const { data: _runtimeBytes, ...metadata } = payload;
+    return metadata;
+  }
+  return payload;
+}
+function finalizeImportProducts(product, inputFingerprint) {
+  return (async () => {
+    const products = [];
+    for (const asset of product.assets) {
+      const artifacts = await artifactDescriptors(asset.artifacts);
+      const digest = await productDigest(asset, artifacts);
+      products.push({
+        guid: asset.guid,
+        payload: asset.payload,
+        refs: asset.refs.map((ref2) => ref2.guid),
+        artifacts,
+        digest,
+        receipt: {
+          guid: asset.guid,
+          origin: "sourceMeta",
+          status: "succeeded",
+          inputFingerprint,
+          outputDigest: digest
+        }
+      });
+    }
+    return products;
+  })();
+}
+var SHADER_RESERVED_IMPORTER_KEY = "shader";
+function isModuleLoadFailure(e) {
+  if (!(e instanceof Error)) return false;
+  const code = e.code;
+  if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_DLOPEN_FAILED") {
+    return true;
+  }
+  const msg = e.message;
+  return msg.includes("Cannot find module") || msg.includes("native addon") || msg.includes(".node");
+}
+function normaliseForPack(value) {
+  if (value === null || value === void 0) return value;
+  if (value instanceof Float32Array || value instanceof Float64Array || value instanceof Uint8Array || value instanceof Uint16Array || value instanceof Uint32Array || value instanceof Int8Array || value instanceof Int16Array || value instanceof Int32Array) {
+    return Array.from(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(normaliseForPack);
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = normaliseForPack(v);
+    }
+    return out;
+  }
+  return value;
+}
+function declarationFields(declaration) {
+  if (declaration === void 0) return {};
+  return {
+    sourceIndex: declaration.sourceIndex,
+    ...declaration.sourceKey !== void 0 ? { sourceKey: declaration.sourceKey } : {},
+    ...declaration.relations !== void 0 ? { relations: declaration.relations } : {}
+  };
+}
+function joinSiblingPath(sourcePath, uri) {
+  const slash = Math.max(sourcePath.lastIndexOf("/"), sourcePath.lastIndexOf("\\"));
+  const dir = slash >= 0 ? sourcePath.slice(0, slash + 1) : "";
+  return `${dir}${uri}`;
+}
+function normalizeDependencyPath(path) {
+  const slash = path.replaceAll("\\", "/");
+  const parts = [];
+  for (const part of slash.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      parts.pop();
+    } else {
+      parts.push(part);
+    }
+  }
+  return parts.join("/");
+}
+function errResult(error) {
+  return { ok: false, error };
+}
+function sourceKeyActual(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (value === void 0) return "missing";
+  return typeof value;
+}
+function sourceReadFailureReason(error) {
+  if (typeof error !== "object" || error === null) {
+    return typeof error === "string" ? error : "unknown";
+  }
+  const metadata = error;
+  const token = typeof metadata.code === "string" ? metadata.code : typeof metadata.name === "string" ? metadata.name : void 0;
+  switch (token) {
+    case "ENOENT":
+    case "NotFoundError":
+      return "not-found";
+    case "EACCES":
+    case "EPERM":
+    case "PermissionDeniedError":
+    case "NotAllowedError":
+    case "SecurityError":
+      return "permission-denied";
+    case "EAGAIN":
+    case "EBUSY":
+    case "EINTR":
+    case "ECONNABORTED":
+    case "ECONNREFUSED":
+    case "ECONNRESET":
+    case "EHOSTUNREACH":
+    case "ENETDOWN":
+    case "ENETUNREACH":
+    case "ETIMEDOUT":
+    case "EPIPE":
+    case "ABORT_ERR":
+    case "AbortError":
+    case "TimeoutError":
+      return "transient";
+    default:
+      if (typeof metadata.detail === "object" && metadata.detail !== null) {
+        const reason = metadata.detail.reason;
+        if (typeof reason === "string" && reason.length > 0) return reason;
+      }
+      if (typeof metadata.message === "string" && metadata.message.length > 0) {
+        return metadata.message;
+      }
+      return "unknown";
+  }
+}
+function validateOutputSourceKeys(meta) {
+  if (meta.subAssets.length <= 1) return void 0;
+  const diagnostics = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, declaration] of meta.subAssets.entries()) {
+    const sourcePath = `${meta.source}#subAssets[${index}]`;
+    const sourceRange = { start: 0, end: 0, line: 1, column: 1 };
+    const sourceKey = declaration.sourceKey;
+    if (typeof sourceKey !== "string" || sourceKey.trim().length === 0) {
+      diagnostics.push({
+        code: "source-key-required",
+        severity: "error",
+        sourcePath,
+        sourceRange,
+        rule: "import-output-source-key",
+        expected: "a non-empty producer-owned sourceKey",
+        actual: sourceKeyActual(sourceKey),
+        hint: "publish a stable semantic sourceKey; sourceIndex is only a locator"
+      });
+      continue;
+    }
+    const prior = seen.get(sourceKey);
+    if (prior !== void 0) {
+      diagnostics.push({
+        code: "duplicate-source-key",
+        severity: "error",
+        sourcePath,
+        sourceRange,
+        rule: "import-output-source-key-unique",
+        expected: "sourceKey to be unique within one imported package",
+        actual: `${JSON.stringify(sourceKey)} duplicates subAssets[${prior}]`,
+        hint: "rename the duplicate semantic output before writing Meta"
+      });
+      continue;
+    }
+    seen.set(sourceKey, index);
+  }
+  if (diagnostics.length === 0) return void 0;
+  return new ImportError({
+    code: "source-validation-failed",
+    expected: "every writable imported output to declare a unique non-empty sourceKey",
+    hint: IMPORT_ERROR_HINTS["source-validation-failed"],
+    detail: { diagnostics }
+  });
+}
+async function runImport(meta, registry, fs) {
+  if (meta.importer === SHADER_RESERVED_IMPORTER_KEY) {
+    return { ok: true, value: { skipped: "shader" } };
+  }
+  const sourceKeyError = validateOutputSourceKeys(meta);
+  if (sourceKeyError !== void 0) return errResult(sourceKeyError);
+  const declaredSourceKeys = meta.subAssets.flatMap(
+    (subAsset) => subAsset.sourceKey === void 0 ? [] : [subAsset.sourceKey]
+  );
+  const sourceOverridesResult = validateSourceOverrideMap(meta.sourceOverrides, declaredSourceKeys);
+  if (!sourceOverridesResult.ok) {
+    const error = new ImportError({
+      code: sourceOverridesResult.error.code,
+      expected: sourceOverridesResult.error.expected,
+      hint: IMPORT_ERROR_HINTS[sourceOverridesResult.error.code],
+      detail: {
+        sourceKey: sourceOverridesResult.error.actual,
+        declaredSourceKeys,
+        reason: sourceOverridesResult.error.hint
+      }
+    });
+    if (sourceOverridesResult.error.actual !== void 0) {
+      Object.assign(error, { actual: sourceOverridesResult.error.actual });
+    }
+    return errResult(error);
+  }
+  const importer = registry.get(meta.importer);
+  if (importer === void 0) {
+    return errResult(
+      new ImportError({
+        code: "importer-not-registered",
+        expected: `an importer registered for meta.importer "${meta.importer}"`,
+        hint: IMPORT_ERROR_HINTS["importer-not-registered"],
+        detail: {
+          importer: meta.importer,
+          registeredImporters: registry.registeredImporters()
+        }
+      })
+    );
+  }
+  const dependencies = /* @__PURE__ */ new Set();
+  const readSource = async (sourcePath) => {
+    dependencies.add(normalizeDependencyPath(sourcePath));
+    try {
+      return await fs.readSource(sourcePath);
+    } catch (error) {
+      return { ok: false, error };
+    }
+  };
+  const readSibling = async (uri) => {
+    let inner;
+    try {
+      if (fs.readSibling) {
+        dependencies.add(normalizeDependencyPath(joinSiblingPath(meta.source, uri)));
+        inner = await fs.readSibling(meta.source, uri);
+      } else {
+        inner = await readSource(joinSiblingPath(meta.source, uri));
+      }
+    } catch (error) {
+      inner = { ok: false, error };
+    }
+    if (inner.ok) {
+      return { ok: true, value: inner.value };
+    }
+    return {
+      ok: false,
+      error: new ImportError({
+        code: "source-read-failed",
+        expected: `readable sibling file "${uri}" co-located with meta.source "${meta.source}"`,
+        hint: IMPORT_ERROR_HINTS["source-read-failed"],
+        detail: {
+          source: uri,
+          reason: sourceReadFailureReason(inner.error)
+        }
+      })
+    };
+  };
+  const decodeImage = fs.decodeImage ?? (async () => {
+    throw new Error(
+      "ImportRunnerFs.decodeImage was not provided; gltfImporter texture extraction requires the host (vite-plugin-pack / cli-gltf / test) to bind decodeImage when constructing the ImportRunnerFs"
+    );
+  });
+  const canonicalSourceOverrides = canonicalizeSourceOverrides(sourceOverridesResult.value);
+  const ctx = {
+    source: meta.source,
+    readSource: () => readSource(meta.source),
+    readSibling,
+    decodeImage,
+    subAssets: meta.subAssets.map(({ guid, sourceIndex, sourceKey, kind }) => ({
+      guid,
+      sourceIndex,
+      ...sourceKey === void 0 ? {} : { sourceKey },
+      kind
+    })),
+    importSettings: meta.importSettings ?? {},
+    ...canonicalSourceOverrides === void 0 ? {} : { sourceOverrides: canonicalSourceOverrides }
+  };
+  const sourceProbe = await readSource(meta.source);
+  if (!sourceProbe.ok) {
+    return errResult(
+      new ImportError({
+        code: "source-read-failed",
+        expected: `readable source file at meta.source "${meta.source}"`,
+        hint: IMPORT_ERROR_HINTS["source-read-failed"],
+        detail: {
+          source: meta.source,
+          reason: sourceReadFailureReason(sourceProbe.error)
+        }
+      })
+    );
+  }
+  let product;
+  try {
+    const imported = await importer.import(ctx);
+    if (imported === void 0 || imported === null || typeof imported !== "object" || !("ok" in imported)) {
+      throw new Error(
+        "importer returned a legacy or malformed result; expected ImportResult<ImportProduct>"
+      );
+    } else {
+      if (!imported.ok) {
+        if (imported.error === void 0)
+          throw new Error("importer returned an invalid failure result");
+        if (imported.error instanceof ImportError) return errResult(imported.error);
+        return errResult(
+          new ImportError({
+            code: "import-internal-error",
+            expected: `importer "${meta.importer}" to return a structured ImportError`,
+            hint: IMPORT_ERROR_HINTS["import-internal-error"],
+            detail: { reason: String(imported.error) }
+          })
+        );
+      }
+      if (imported.value === void 0)
+        throw new Error("importer returned an invalid success result");
+      const value = imported.value;
+      if (value === void 0 || !Array.isArray(value.assets) || !Array.isArray(value.sourceDependencies) || "artifacts" in value) {
+        throw new Error("importer returned an invalid ImportProduct");
+      }
+      for (const asset of value.assets) {
+        if (asset === null || typeof asset !== "object" || !("artifacts" in asset) || asset.artifacts === null || typeof asset.artifacts !== "object" || Array.isArray(asset.artifacts)) {
+          throw new Error("importer returned an asset without local artifacts");
+        }
+      }
+      product = value;
+    }
+  } catch (e) {
+    if (e instanceof ImportError) return errResult(e);
+    const message = e instanceof Error ? e.message : String(e);
+    if (isModuleLoadFailure(e)) {
+      return errResult(
+        new ImportError({
+          code: "import-internal-error",
+          expected: `importer module "${meta.importer}" to load (module + native addon present)`,
+          hint: IMPORT_ERROR_HINTS["import-internal-error"],
+          detail: { loadError: message }
+        })
+      );
+    }
+    return errResult(
+      new ImportError({
+        code: "import-internal-error",
+        expected: `importer "${meta.importer}" to convert the source without throwing`,
+        hint: IMPORT_ERROR_HINTS["import-internal-error"],
+        detail: { reason: message }
+      })
+    );
+  }
+  const produced = product.assets;
+  const declared = new Set(meta.subAssets.map((s) => s.guid));
+  const producedGuids = new Set(produced.map((a) => a.guid));
+  const unexpectedGuids = [...producedGuids].filter((g) => !declared.has(g));
+  if (unexpectedGuids.length > 0) {
+    return errResult(
+      new ImportError({
+        code: "guid-mismatch",
+        expected: "every produced GUID to be declared in meta.subAssets[]",
+        hint: IMPORT_ERROR_HINTS["guid-mismatch"],
+        detail: { unexpectedGuids }
+      })
+    );
+  }
+  const missingGuids = [...declared].filter((g) => !producedGuids.has(g));
+  if (produced.length === 0 || missingGuids.length > 0) {
+    return errResult(
+      new ImportError({
+        code: "import-produced-no-assets",
+        expected: produced.length === 0 ? "the importer to produce at least one ImportedAsset" : "the produced GUID set to be a superset of meta.subAssets[]",
+        hint: IMPORT_ERROR_HINTS["import-produced-no-assets"],
+        detail: { missingGuids }
+      })
+    );
+  }
+  const declarations = new Map(
+    meta.subAssets.map((declaration) => [declaration.guid, declaration])
+  );
+  const productWithDependencies = {
+    ...product,
+    sourceDependencies: [...dependencies]
+  };
+  const inputFingerprint = `source:${[...dependencies].sort().join("|")}`;
+  let cookProducts;
+  try {
+    cookProducts = await finalizeImportProducts(productWithDependencies, inputFingerprint);
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    return errResult(
+      new ImportError({
+        code: "import-internal-error",
+        expected: `importer "${meta.importer}" finalization to produce complete CookProduct digests`,
+        hint: IMPORT_ERROR_HINTS["import-internal-error"],
+        detail: { reason: `finalization/digest: ${reason}` }
+      })
+    );
+  }
+  const terminalProduct = createImportProduct({
+    ...productWithDependencies,
+    refs: productWithDependencies.assets.flatMap((asset) => asset.refs),
+    artifacts: Object.fromEntries(
+      productWithDependencies.assets.flatMap(
+        (asset) => Object.entries(asset.artifacts).map(([key, artifact]) => [
+          `${asset.guid}/${key}`,
+          artifact
+        ])
+      )
+    ),
+    receipts: cookProducts.map((product2) => product2.receipt),
+    diagnostics: meta.diagnostics ?? [],
+    sourceRevision: inputFingerprint
+  });
+  if (!terminalProduct.ok) {
+    return errResult(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "the import product to retain complete terminal producer facts",
+        hint: "preserve source identity and producer evidence when returning the import product",
+        detail: { reason: terminalProduct.error.detail.field }
+      })
+    );
+  }
+  if (meta.buildPack === false) {
+    return {
+      ok: true,
+      value: { product: terminalProduct.value, cookProducts }
+    };
+  }
+  const assets = produced.map((a) => {
+    const outputFields = declarationFields(declarations.get(a.guid));
+    return {
+      guid: a.guid,
+      kind: a.kind,
+      ...outputFields,
+      ...a.name !== void 0 ? { name: a.name } : {},
+      // bug-20260610: mesh / scene / animation-clip payloads carry Float32Array
+      // / Uint16Array / Uint32Array fields. JSON.stringify on a typed array
+      // serialises to `{ "0": v0, "1": v1, ... }` (a plain object), which the
+      // runtime mesh / animation loaders reject (`vertexData instanceof
+      // Float32Array` and `Array.isArray(vertexData)` both fail). Convert
+      // every typed-array field to a plain Array here so the pack is JSON-
+      // roundtrip safe end-to-end.  This matches the convention every
+      // existing pack-fixture test uses (`vertices: Array.from(...)`).
+      payload: normaliseForPack(a.payload),
+      refs: a.refs.map((r) => r.guid),
+      artifacts: a.artifacts
+    };
+  });
+  const pack = {
+    schemaVersion: "2.0.0",
+    kind: "internal-text-package",
+    ...meta.packageId !== void 0 ? { packageId: meta.packageId } : {},
+    ...meta.provenance !== void 0 ? { provenance: meta.provenance } : {},
+    ...meta.revision !== void 0 ? { revision: meta.revision } : {},
+    ...meta.diagnostics !== void 0 ? { diagnostics: meta.diagnostics } : {},
+    assets
+  };
+  return {
+    ok: true,
+    value: {
+      product: terminalProduct.value,
+      cookProducts,
+      pack
+    }
+  };
+}
+
+// src/pack-projection.ts
+function projectImportProductForBuild(product) {
+  return {
+    schemaVersion: "2.0.0",
+    kind: "internal-text-package",
+    assets: product.assets.map((asset) => ({
+      guid: asset.guid,
+      kind: asset.kind,
+      ...asset.name === void 0 ? {} : { name: asset.name },
+      payload: normaliseForPack(projectImportedAssetPayload(asset)),
+      refs: asset.refs.map((reference) => reference.guid),
+      artifacts: asset.artifacts
+    }))
+  };
+}
+function failure(sourceKey, expected, actual) {
+  return {
+    code: "mesh-bin-payload-invalid",
+    subject: "mesh-bin",
+    sourceKey,
+    expected,
+    actual,
+    recovery: "re-cook the source with its Meta sidecar through the build-time importer"
+  };
+}
+function asAttributeMap(value) {
+  return value ?? {};
+}
+function jsonValue(value) {
+  if (value instanceof Float32Array || value instanceof Uint16Array) return Array.from(value);
+  if (Array.isArray(value)) return value.map(jsonValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [key, jsonValue(nested)])
+    );
+  }
+  return value;
+}
+function refsMeta(payload, refs) {
+  const materialSlots = (payload.materialSlots ?? [{ slotName: "Default" }]).map(
+    (slot, slotIndex) => {
+      const defaultMaterial = slot.defaultMaterial;
+      let defaultMaterialRef;
+      if (defaultMaterial !== void 0) {
+        const guid = AssetGuid.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 }
+      };
+    }
+  );
+  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) }
+  };
+}
+function packMeshBinV4(payload, sourceKey, refs = []) {
+  try {
+    const vertices = payload.vertices;
+    const indices = payload.indices;
+    if (!(vertices instanceof Float32Array)) {
+      return err(
+        failure(sourceKey, "Float32Array interleaved vertices", "vertices is not Float32Array")
+      );
+    }
+    if (indices !== void 0 && !(indices instanceof Uint16Array || indices instanceof Uint32Array)) {
+      return err(
+        failure(sourceKey, "Uint16Array or Uint32Array indices", "indices has an unsupported type")
+      );
+    }
+    const attributes = asAttributeMap(payload.attributes);
+    const projection = deriveVertexLayoutProjection(attributes);
+    if (projection.attributes.length === 0 || projection.arrayStride === 0) {
+      return err(
+        failure(
+          sourceKey,
+          "a non-empty canonical geometry projection",
+          "projection has no attributes"
+        )
+      );
+    }
+    const vertexCount = payload.vertexCount ?? vertices.byteLength / projection.arrayStride;
+    if (!Number.isSafeInteger(vertexCount) || vertexCount < 0) {
+      return err(
+        failure(sourceKey, "a non-negative safe vertex cardinality", `vertexCount=${vertexCount}`)
+      );
+    }
+    if (vertices.byteLength !== vertexCount * projection.arrayStride) {
+      return err(
+        failure(
+          sourceKey,
+          `vertices.byteLength=${vertexCount * projection.arrayStride}`,
+          `vertices.byteLength=${vertices.byteLength}; stride=${projection.arrayStride}`
+        )
+      );
+    }
+    for (const attribute of projection.attributes) {
+      const value = attributes[attribute.key];
+      const components = attribute.byteLength / (attribute.format === "uint16x4" ? 2 : 4);
+      if (value === void 0 || !(value instanceof Float32Array) && !(value instanceof Uint16Array) || value.length !== vertexCount * components) {
+        return err(
+          failure(
+            sourceKey,
+            `${attribute.key} cardinality=${vertexCount * components}`,
+            `${attribute.key} cardinality=${value?.byteLength ?? "missing"}`
+          )
+        );
+      }
+    }
+    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
+            );
+          }
+        }
+      }
+    }
+    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)
+      )
+    );
+  }
+}
+function commonPathPrefix(paths) {
+  const first = paths[0];
+  if (first === void 0) return "";
+  const firstNormalized = first.replaceAll("\\", "/");
+  const firstDirectory = firstNormalized.slice(0, firstNormalized.lastIndexOf("/"));
+  const parts = firstDirectory.split("/");
+  let length = parts.length;
+  for (const path of paths.slice(1)) {
+    const normalized = path.replaceAll("\\", "/");
+    const candidate = normalized.slice(0, normalized.lastIndexOf("/")).split("/");
+    length = Math.min(length, candidate.length);
+    for (let index = 0; index < length; index += 1) {
+      if (parts[index] !== candidate[index]) {
+        length = index;
+        break;
+      }
+    }
+  }
+  return parts.slice(0, length).join("/");
+}
+function stableSourceClosure(closure) {
+  const root = commonPathPrefix(closure.map((entry) => entry.path));
+  return closure.map((entry) => ({
+    path: entry.path.replaceAll("\\", "/").slice(root.length).replace(/^\/+/, ""),
+    digest: entry.digest
+  })).sort((left, right) => left.path.localeCompare(right.path));
+}
+var AssetOutputProducerRegistry = class {
+  producers = /* @__PURE__ */ new Map();
+  register(producer) {
+    if (producer.kind.trim().length === 0 || producer.version.trim().length === 0) {
+      throw new TypeError("ScriptablePack output producer kind and version must be non-empty");
+    }
+    if (typeof producer.produce !== "function") {
+      throw new TypeError(`ScriptablePack output producer ${producer.kind} must expose produce`);
+    }
+    this.producers.set(producer.kind, producer);
+  }
+  get(kind) {
+    return this.producers.get(kind);
+  }
+  versions() {
+    return Object.fromEntries(
+      [...this.producers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([kind, producer]) => [kind, producer.version])
+    );
+  }
+};
+function privateClone(value) {
+  return structuredClone(value);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isAsset(value) {
+  return record(value) && typeof value.kind === "string" && isScriptablePackAssetKind(value.kind);
+}
+function isStructuredDomainError(value) {
+  return value !== null && typeof value === "object" && typeof value.code === "string" && typeof value.expected === "string" && typeof value.hint === "string";
+}
+function remapBuildFailureSource(value, sourcePath) {
+  if (value === null || typeof value !== "object") return void 0;
+  const error = value;
+  if (error.code !== "pack-source-load-failed") return void 0;
+  if (error.detail === null || typeof error.detail !== "object") return void 0;
+  const detail = error.detail;
+  if (detail.phase !== "build") return void 0;
+  return {
+    ...value,
+    detail: { ...detail, sourcePath }
+  };
+}
+function observedAssetReader(source) {
+  const reads = /* @__PURE__ */ new Map();
+  const reader = {
+    async readByGuid(guid) {
+      const key = AssetGuid.format(guid);
+      const cached = reads.get(key);
+      if (cached !== void 0) return ok(privateClone(cached.asset));
+      if (source === void 0) {
+        return err(
+          new AssetError({
+            code: "asset-not-found",
+            expected: `a host Asset snapshot source for ScriptablePack content read ${key}`,
+            hint: "configure the standard ScriptablePack asset source or remove the content read"
+          })
+        );
+      }
+      const result = await source.readByGuid(guid);
+      if (!result.ok) return result;
+      const fixed = privateClone(result.value.asset);
+      reads.set(key, {
+        guid: key,
+        asset: fixed,
+        generation: result.value.generation,
+        digest: result.value.digest
+      });
+      return ok(privateClone(fixed));
+    }
+  };
+  return { reader, reads };
+}
+function stable(value) {
+  if (value instanceof Uint8Array) return JSON.stringify(Array.from(value));
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable(record2[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+async function fingerprint(value) {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle === void 0)
+    throw new Error("Web Crypto API is required for ScriptablePack fingerprints");
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(stable(value)));
+  const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  return `sha256:${hex}`;
+}
+function outputError(definition, output) {
+  const declaredKeys = Object.keys(definition.assets);
+  const outputKeys = Object.keys(output);
+  const outputKeySet = new Set(outputKeys);
+  const declaredKeySet = new Set(declaredKeys);
+  const missingKeys = declaredKeys.filter((key) => !outputKeySet.has(key));
+  const unexpectedSourceKeys = outputKeys.filter((key) => !declaredKeySet.has(key));
+  const kindMismatches = declaredKeys.flatMap((sourceKey) => {
+    const descriptor = definition.assets[sourceKey];
+    const value = output[sourceKey];
+    if (descriptor === void 0 || value === void 0) return [];
+    const actualKind = value !== null && typeof value === "object" && "kind" in value ? String(value.kind) : typeof value;
+    return actualKind === descriptor.kind ? [] : [{ sourceKey, expected: descriptor.kind, actual: actualKind }];
+  });
+  if (missingKeys.length === 0 && unexpectedSourceKeys.length === 0 && kindMismatches.length === 0) {
+    return void 0;
+  }
+  return {
+    code: "pack-source-output-invalid",
+    expected: "build output keys and kinds to exactly match definition.assets",
+    hint: "inspect sourceKey and GUID topology, then rebuild or cold-cook the ScriptablePack",
+    detail: {
+      missingGuids: missingKeys.map(
+        (key) => AssetGuid.format(definition.assets[key]?.guid)
+      ),
+      unexpectedSourceKeys,
+      kindMismatches
+    }
+  };
+}
+function externalClosureError(declared, referenced, read) {
+  const used = /* @__PURE__ */ new Set([...referenced, ...read]);
+  const undeclaredReferencedGuids = [...referenced].filter((guid) => !declared.has(guid));
+  const undeclaredReadGuids = [...read].filter((guid) => !declared.has(guid));
+  const unusedDeclaredGuids = [...declared].filter((guid) => !used.has(guid));
+  if (undeclaredReferencedGuids.length === 0 && undeclaredReadGuids.length === 0 && unusedDeclaredGuids.length === 0) {
+    return void 0;
+  }
+  return {
+    code: "pack-source-external-closure-mismatch",
+    expected: "externalAssets GUIDs to equal output external refs union AssetReader reads",
+    hint: "inspect refs and AssetReader reads, repair GUID declarations, then rebuild or cold-cook",
+    detail: {
+      undeclaredReferencedGuids: undeclaredReferencedGuids.sort(),
+      undeclaredReadGuids: undeclaredReadGuids.sort(),
+      unusedDeclaredGuids: unusedDeclaredGuids.sort()
+    }
+  };
+}
+function productContractError(sourceKey, kind, product) {
+  const mismatches = [];
+  if (product.payload.kind !== kind) {
+    mismatches.push({ sourceKey, expected: kind, actual: product.payload.kind });
+  }
+  for (const reference of product.refs) {
+    if (!AssetGuid.parse(reference.guid).ok) {
+      mismatches.push({
+        sourceKey,
+        expected: "every producer ref to contain a valid Asset GUID",
+        actual: reference.guid
+      });
+      break;
+    }
+  }
+  for (const [artifactKey, artifact] of Object.entries(product.artifacts)) {
+    if (artifactKey.length === 0 || artifactKey.startsWith("/") || artifactKey.includes("..") || artifactKey.includes("\\") || artifact.mediaType.trim().length === 0 || !(artifact.bytes instanceof Uint8Array)) {
+      mismatches.push({
+        sourceKey,
+        expected: "asset-local artifacts with safe keys, mediaType, and Uint8Array bytes",
+        actual: artifactKey
+      });
+      break;
+    }
+  }
+  if (mismatches.length === 0) return void 0;
+  return {
+    code: "pack-source-output-invalid",
+    expected: "producer output refs and asset-local artifacts to satisfy the Pack v2 contract",
+    hint: "inspect sourceKey and artifact provenance, repair refs or bytes, then rebuild or cold-cook",
+    detail: { missingGuids: [], unexpectedSourceKeys: [], kindMismatches: mismatches }
+  };
+}
+async function buildScriptablePack(options) {
+  const observed = observedAssetReader(options.assetSource);
+  let built;
+  try {
+    const build = options.definition.build;
+    built = await build(observed.reader);
+  } catch (error) {
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "ScriptablePack build to return a structured Result without throwing",
+        hint: "fix the build implementation and return a structured failure for expected authoring errors",
+        detail: { reason: error instanceof Error ? error.message : String(error) }
+      })
+    );
+  }
+  if (!built.ok) {
+    const remappedBuildFailure = remapBuildFailureSource(built.error, options.sourcePath);
+    if (remappedBuildFailure !== void 0) return err(remappedBuildFailure);
+    if (built.error instanceof ImportError || built.error instanceof AssetError || isStructuredDomainError(built.error)) {
+      return err(built.error);
+    }
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "ScriptablePack build failure to use a structured domain error",
+        hint: "return an error with code, expected, hint, and optional detail fields",
+        detail: { reason: String(built.error) }
+      })
+    );
+  }
+  if (!record(built.value)) {
+    return err(
+      new ImportError({
+        code: "import-internal-error",
+        expected: "ScriptablePack build output to be an object keyed by declared sourceKey",
+        hint: "return one concrete Asset payload for each declared sourceKey",
+        detail: { reason: "build output is not an object" }
+      })
+    );
+  }
+  const output = built.value;
+  const invalidOutput = outputError(options.definition, output);
+  if (invalidOutput !== void 0) return err(invalidOutput);
+  const assets = [];
+  for (const sourceKey of Object.keys(options.definition.assets).sort()) {
+    const descriptor = options.definition.assets[sourceKey];
+    const asset = output[sourceKey];
+    if (descriptor === void 0) continue;
+    if (!isAsset(asset)) {
+      return err(
+        new ImportError({
+          code: "import-internal-error",
+          expected: `a concrete Asset payload for sourceKey ${sourceKey}`,
+          hint: "return a durable Asset with a kind from SCRIPTABLE_PACK_ASSET_KINDS",
+          detail: { reason: "build output payload is missing or has an unknown kind" }
+        })
+      );
+    }
+    const producer = options.outputs.get(descriptor.kind);
+    if (producer === void 0) {
+      return err({
+        code: "pack-source-output-invalid",
+        expected: `a domain output producer registered for kind ${descriptor.kind}`,
+        hint: "attach the owning producer capability, inspect registration, then rebuild or cold-cook",
+        detail: {
+          missingGuids: [AssetGuid.format(descriptor.guid)],
+          unexpectedSourceKeys: [],
+          kindMismatches: []
+        }
+      });
+    }
+    const product2 = await producer.produce({
+      guid: AssetGuid.format(descriptor.guid),
+      sourceKey,
+      asset
+    });
+    if (!product2.ok) return err(product2.error);
+    const productError = productContractError(sourceKey, descriptor.kind, product2.value);
+    if (productError !== void 0) return err(productError);
+    assets.push({
+      guid: AssetGuid.format(descriptor.guid),
+      kind: descriptor.kind,
+      ...descriptor.name === void 0 ? {} : { name: descriptor.name },
+      payload: product2.value.payload,
+      refs: product2.value.refs,
+      artifacts: product2.value.artifacts
+    });
+  }
+  const local = new Set(assets.map((asset) => asset.guid.toLowerCase()));
+  const referenced = new Set(
+    assets.flatMap((asset) => asset.refs.map((reference) => reference.guid.toLowerCase())).filter((guid) => !local.has(guid))
+  );
+  const read = new Set([...observed.reads.keys()].map((guid) => guid.toLowerCase()));
+  const declared = new Set(
+    Object.values(options.definition.externalAssets).map(
+      (guid) => AssetGuid.format(guid).toLowerCase()
+    )
+  );
+  const closureError2 = externalClosureError(declared, referenced, read);
+  if (closureError2 !== void 0) return err(closureError2);
+  const externalEvidence = [...declared].sort().map((guid) => {
+    const observedRead = observed.reads.get(guid);
+    const isReference = referenced.has(guid);
+    return {
+      guid,
+      usage: observedRead === void 0 ? "reference" : isReference ? "both" : "content",
+      ...observedRead === void 0 ? {} : { generation: observedRead.generation, digest: observedRead.digest }
+    };
+  });
+  const fingerprintEvidence = externalEvidence.map(({ guid, usage, digest }) => ({
+    guid,
+    usage,
+    ...digest === void 0 ? {} : { digest }
+  }));
+  const inputFingerprint = await fingerprint({
+    meta: projectScriptablePackMeta(options.definition, options.sourcePath),
+    sceneComponents: projectScriptablePackSceneComponents(options.definition.sceneComponents),
+    sourceClosure: stableSourceClosure(options.sourceClosure),
+    externalEvidence: fingerprintEvidence,
+    authoringContractVersion: options.authoringContractVersion,
+    producerVersions: options.outputs.versions()
+  });
+  const refs = assets.flatMap((asset) => asset.refs);
+  const artifacts = Object.fromEntries(
+    assets.flatMap(
+      (asset) => Object.entries(asset.artifacts).map(([key, artifact]) => [`${asset.guid}/${key}`, artifact])
+    )
+  );
+  const product = createImportProduct({
+    assets,
+    sourceDependencies: options.sourceClosure.map((entry) => entry.path),
+    refs,
+    artifacts,
+    receipts: assets.map((asset) => ({
+      guid: asset.guid,
+      origin: "sourceMeta",
+      status: "succeeded",
+      inputFingerprint
+    })),
+    diagnostics: [],
+    sourceRevision: inputFingerprint,
+    sourceKey: options.sourcePath
+  });
+  if (!product.ok) return err(product.error);
+  return ok({
+    product: product.value,
+    stagedOutputs: await Promise.all(
+      Object.keys(options.definition.assets).sort().map(async (sourceKey) => {
+        const descriptor = options.definition.assets[sourceKey];
+        const asset = output[sourceKey];
+        if (descriptor === void 0 || !isAsset(asset)) {
+          throw new Error(`validated ScriptablePack output ${sourceKey} is not an Asset`);
+        }
+        return {
+          guid: descriptor.guid,
+          sourceKey,
+          asset: privateClone(asset),
+          digest: await fingerprint(asset)
+        };
+      })
+    ),
+    externalEvidence,
+    inputFingerprint
+  });
+}
+
+// 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.parse(value);
+    if (!parsed.ok) throw parsed.error;
+    return AssetGuid.format(parsed.value);
+  }
+  return AssetGuid.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 fingerprint2 = `sha256:${bytesToHex(sha256(bytes2))}`;
+  return {
+    program: { ...effect.program, fingerprint: fingerprint2 },
+    bytes: bytes2,
+    fingerprint: fingerprint2
+  };
+}
+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").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] = 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;
+    }
+  }
+  const { parent: _parent, values: _values, ...materialShape } = material;
+  return {
+    payload: {
+      ...materialShape,
+      ...parent === void 0 ? {} : { parent },
+      ...material.values === void 0 ? {} : { values }
+    },
+    refs,
+    artifacts: {}
+  };
+}
+function meshProduct(input) {
+  if (input.asset.kind !== "mesh") throw new TypeError("expected MeshAsset");
+  const mesh = input.asset;
+  const refs = [];
+  for (let slotIndex = 0; slotIndex < mesh.materialSlots.length; slotIndex++) {
+    const defaultMaterial = mesh.materialSlots[slotIndex]?.defaultMaterial;
+    if (defaultMaterial === void 0) continue;
+    refs.push({
+      guid: formatGuid(defaultMaterial),
+      sourceField: { fieldName: "materialSlots", arrayIndex: slotIndex }
+    });
+  }
+  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;
+        })()
+      }
+    }
+  };
+}
+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 createSafeProducer(kind, version, product) {
+  return {
+    kind,
+    version,
+    produce(input) {
+      try {
+        return ok(product(input));
+      } catch (error) {
+        return err(producerError(input, error));
+      }
+    }
+  };
+}
+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 ordinaryPodProduct(input) {
+  const asset = input.asset;
+  switch (asset.kind) {
+    case "texture": {
+      const texture = asset;
+      return {
+        payload: texture,
+        refs: [],
+        artifacts: {
+          body: {
+            mediaType: "image/raw",
+            assetCodec: { name: "raw-image", version: "1" },
+            bytes: bytes(texture.data)
+          }
+        }
+      };
+    }
+    case "equirect": {
+      const equirect = asset;
+      return {
+        payload: equirect,
+        refs: [],
+        artifacts: {
+          body: {
+            mediaType: "image/raw",
+            assetCodec: { name: "raw-image", version: "1" },
+            bytes: bytes(equirect.data)
+          }
+        }
+      };
+    }
+    case "sampler": {
+      const sampler = asset;
+      return { payload: sampler, refs: [], artifacts: { body: jsonArtifact(sampler) } };
+    }
+    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) }
+      };
+    }
+    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.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: {} };
+    }
+    case "skeleton": {
+      const skeleton = asset;
+      return {
+        payload: skeleton,
+        refs: [],
+        artifacts: { body: jsonArtifact(skeleton) }
+      };
+    }
+    case "skin": {
+      const skin = asset;
+      const skeletonGuid = AssetGuid.parse(skin.skeletonGuid);
+      if (!skeletonGuid.ok) throw skeletonGuid.error;
+      return {
+        payload: skin,
+        refs: [ref(skeletonGuid.value, "skeletonGuid")],
+        artifacts: { body: jsonArtifact(skin) }
+      };
+    }
+    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.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) }
+      };
+    }
+    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()
+          }
+        }
+      };
+    }
+    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
+          }
+        }
+      };
+    }
+    case "material":
+    case "mesh":
+    case "scene":
+      throw new TypeError(`ordinary producer received already-owned ${asset.kind} asset`);
+  }
+}
+var materialAssetOutputProducer = createSafeProducer(
+  "material",
+  "material-pack/1",
+  materialProduct
+);
+var meshAssetOutputProducer = createSafeProducer("mesh", "mesh-binary/4", meshProduct);
+function createSceneAssetOutputProducer(sceneComponents = []) {
+  const schemas = new Map(
+    sceneComponents.map((component) => [component.name, component.fields])
+  );
+  return createSafeProducer("scene", "scene-pack/3", (input) => sceneProduct(input, schemas));
+}
+function createStandardAssetOutputProducerRegistry(sceneComponents = []) {
+  const registry = new AssetOutputProducerRegistry();
+  registry.register(materialAssetOutputProducer);
+  registry.register(meshAssetOutputProducer);
+  registry.register(createSceneAssetOutputProducer(sceneComponents));
+  for (const kind of [
+    "texture",
+    "equirect",
+    "sampler",
+    "font",
+    "render-pipeline",
+    "tileset",
+    "video",
+    "skeleton",
+    "skin",
+    "animation-clip",
+    "animation-graph",
+    "audio",
+    "particle-effect"
+  ]) {
+    registry.register(createSafeProducer(kind, "ordinary-pod/1", ordinaryPodProduct));
+  }
+  return registry;
+}
+function stable2(value) {
+  if (ArrayBuffer.isView(value)) {
+    return `${value.constructor.name}:${JSON.stringify(Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)))}`;
+  }
+  if (Array.isArray(value)) return `[${value.map(stable2).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stable2(record2[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+async function assetDigest(asset) {
+  const bytes2 = new TextEncoder().encode(stable2(asset));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes2);
+  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function cycleError(stack, owner, guid) {
+  const cycleStart = stack.indexOf(owner);
+  const cycle = [...stack.slice(cycleStart), owner];
+  return {
+    code: "pack-source-build-cycle",
+    expected: "an acyclic graph of ScriptablePack content dependencies",
+    actual: cycle.join(" -> "),
+    hint: "break one content read edge or convert it to a reference-only dependency",
+    retryable: false,
+    recoveryActions: ["inspect-content-dependency-graph", "edit-source"],
+    detail: { sourcePath: owner, sourceKey: guid, incomingRefs: cycle }
+  };
+}
+function missingOutputError(owner, guid) {
+  return {
+    code: "pack-source-output-invalid",
+    expected: `owner ${owner} to stage every declared output including ${guid}`,
+    hint: "return one output for every GUID declared by the staged owner",
+    detail: { missingGuids: [guid], unexpectedSourceKeys: [], kindMismatches: [] }
+  };
+}
+function createScriptablePackStagedAssetSnapshotSource(options) {
+  const owners = options.declaredExternalOutputs === void 0 || options.declaredExternalOutputs.length === 0 ? options.owners : [
+    {
+      id: "<declared-pack-external>",
+      guids: options.declaredExternalOutputs.map((output) => output.guid),
+      async build() {
+        return ok(options.declaredExternalOutputs ?? []);
+      }
+    },
+    ...options.owners
+  ];
+  const ownerByGuid = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    if (owner.id.trim().length === 0) throw new TypeError("staged owner id must be non-empty");
+    for (const guid of owner.guids) {
+      const key = AssetGuid.format(guid).toLowerCase();
+      const existing = ownerByGuid.get(key);
+      if (existing !== void 0) {
+        throw new TypeError(`staged GUID ${key} is owned by both ${existing.id} and ${owner.id}`);
+      }
+      ownerByGuid.set(key, owner);
+    }
+  }
+  const snapshots = /* @__PURE__ */ new Map();
+  const builds = /* @__PURE__ */ new Map();
+  const sourceFor = (stack) => ({
+    async readByGuid(guid) {
+      const key = AssetGuid.format(guid).toLowerCase();
+      const cached = snapshots.get(key);
+      if (cached !== void 0) return ok(structuredClone(cached));
+      const owner = ownerByGuid.get(key);
+      if (owner === void 0) {
+        return err(
+          new AssetError({
+            code: "asset-not-imported",
+            expected: "a staged local owner for the requested GUID",
+            hint: "declare the local ScriptablePack output before rebuilding the generation"
+          })
+        );
+      }
+      if (stack.includes(owner.id)) return err(cycleError(stack, owner.id, key));
+      let building = builds.get(owner.id);
+      if (building === void 0) {
+        building = (async () => {
+          const built2 = await owner.build(sourceFor([...stack, owner.id]));
+          if (!built2.ok) {
+            builds.delete(owner.id);
+            return built2;
+          }
+          const next = /* @__PURE__ */ new Map();
+          for (const output of built2.value) {
+            const outputGuid = AssetGuid.format(output.guid).toLowerCase();
+            if (ownerByGuid.get(outputGuid) !== owner) {
+              builds.delete(owner.id);
+              return err(missingOutputError(owner.id, outputGuid));
+            }
+            next.set(outputGuid, {
+              asset: structuredClone(output.asset),
+              generation: options.generation,
+              digest: output.digest ?? await assetDigest(output.asset)
+            });
+          }
+          for (const declared of owner.guids) {
+            const declaredGuid = AssetGuid.format(declared).toLowerCase();
+            if (!next.has(declaredGuid)) {
+              builds.delete(owner.id);
+              return err(missingOutputError(owner.id, declaredGuid));
+            }
+          }
+          for (const [outputGuid, snapshot] of next) snapshots.set(outputGuid, snapshot);
+          return ok(void 0);
+        })();
+        builds.set(owner.id, building);
+      }
+      const built = await building;
+      if (!built.ok) return built;
+      const staged = snapshots.get(key);
+      return staged === void 0 ? err(missingOutputError(owner.id, key)) : ok(structuredClone(staged));
+    }
+  });
+  return sourceFor([]);
+}
+var META_ARTIFACT_KEY = "scriptable-pack.meta.json";
+function withPrebuiltMeta(product, anchorGuid, meta) {
+  const bytes2 = new TextEncoder().encode(`${JSON.stringify(meta)}
+`);
+  return {
+    ...product,
+    assets: product.assets.map(
+      (asset) => asset.guid.toLowerCase() === anchorGuid ? {
+        ...asset,
+        artifacts: {
+          ...asset.artifacts,
+          [META_ARTIFACT_KEY]: { mediaType: "application/json", bytes: bytes2 }
+        }
+      } : asset
+    )
+  };
+}
+async function produceScriptableSourcePackage(options) {
+  const built = await buildScriptablePack(options);
+  if (!built.ok) return err(built.error);
+  const declaredGuids = Object.values(options.definition.assets).map((descriptor) => AssetGuid.format(descriptor.guid).toLowerCase()).sort();
+  const anchorGuid = declaredGuids[0];
+  if (anchorGuid === void 0) {
+    return err({
+      code: "pack-source-output-invalid",
+      expected: "at least one declared ScriptablePack output",
+      hint: "add an output descriptor before building the package",
+      detail: { missingGuids: [], unexpectedSourceKeys: [], kindMismatches: [] }
+    });
+  }
+  const product = withPrebuiltMeta(
+    built.value.product,
+    anchorGuid,
+    projectScriptablePackMeta(options.definition, options.sourcePath)
+  );
+  return ok({
+    anchorGuid,
+    declaredGuids,
+    product,
+    stagedOutputs: built.value.stagedOutputs,
+    inputFingerprint: built.value.inputFingerprint,
+    externalEvidence: built.value.externalEvidence
+  });
+}
+function parseProducerReadiness(value) {
+  if (value === void 0 || value === "before-consume" || value === "on-demand") {
+    return { ok: true, value: value ?? "before-consume" };
+  }
+  return {
+    ok: false,
+    error: {
+      code: "producer-readiness-invalid",
+      expected: "'before-consume' or 'on-demand'",
+      hint: "set producerReadiness to before-consume or on-demand",
+      detail: { value }
+    }
+  };
+}
+function finalizeSourcePackage(product, finalizer, artifactUrl) {
+  if (finalizer === void 0) return ok(product);
+  const result = finalizer(product, { artifactUrl });
+  if (!result.ok) return err(result.error);
+  return ok({
+    ...product,
+    assets: product.assets.map(
+      (asset, index) => index === 0 ? { ...asset, payload: result.value.asset } : asset
+    )
+  });
+}
+function closureError(declaredGuids, producedGuids) {
+  const declared = new Set(declaredGuids.map((guid) => guid.toLowerCase()));
+  const produced = new Set(producedGuids.map((guid) => guid.toLowerCase()));
+  const counts = /* @__PURE__ */ new Map();
+  for (const guid of producedGuids) {
+    const key = guid.toLowerCase();
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const duplicateGuids = [...counts.entries()].filter(([, count]) => count > 1).map(([guid]) => guid);
+  return {
+    code: "source-package-guid-closure-mismatch",
+    expected: "the importer to return exactly one asset for every declared Meta GUID",
+    hint: "repair the Meta declaration or importer output, then rebuild the whole source package",
+    detail: {
+      stage: "closure",
+      declaredGuids,
+      producedGuids,
+      missingGuids: declaredGuids.filter((guid) => !produced.has(guid.toLowerCase())),
+      unexpectedGuids: producedGuids.filter((guid) => !declared.has(guid.toLowerCase())),
+      duplicateGuids
+    }
+  };
+}
+function producedGuidsFromImportFailure(declaredGuids, detail) {
+  if ("missingGuids" in detail) {
+    return declaredGuids.filter((guid) => !detail.missingGuids.includes(guid));
+  }
+  if ("unexpectedGuids" in detail) return [...declaredGuids, ...detail.unexpectedGuids];
+  return [];
+}
+async function produceSourcePackage(input) {
+  const declaredGuids = input.meta.subAssets.map((asset) => asset.guid);
+  const result = await runImport(input.meta, input.registry, input.fs);
+  if (!result.ok) {
+    const producedGuids2 = producedGuidsFromImportFailure(declaredGuids, result.error.detail);
+    return {
+      ok: false,
+      error: closureError(declaredGuids, producedGuids2)
+    };
+  }
+  if ("skipped" in result.value) {
+    return { ok: false, error: closureError(declaredGuids, []) };
+  }
+  const producedGuids = result.value.product.assets.map((asset) => asset.guid);
+  const declaredSet = new Set(declaredGuids.map((guid) => guid.toLowerCase()));
+  const producedSet = new Set(producedGuids.map((guid) => guid.toLowerCase()));
+  const hasDuplicate = new Set(producedGuids.map((guid) => guid.toLowerCase())).size !== producedGuids.length;
+  const complete = !hasDuplicate && declaredGuids.length === producedGuids.length && declaredGuids.every((guid) => producedSet.has(guid.toLowerCase())) && producedGuids.every((guid) => declaredSet.has(guid.toLowerCase()));
+  if (!complete) return { ok: false, error: closureError(declaredGuids, producedGuids) };
+  const product = result.value.product;
+  const anchorGuid = [...declaredGuids].sort((left, right) => left.localeCompare(right))[0];
+  if (anchorGuid === void 0)
+    return { ok: false, error: closureError(declaredGuids, producedGuids) };
+  return {
+    ok: true,
+    value: {
+      anchorGuid,
+      declaredGuids,
+      product
+    }
+  };
+}
+function sourcePackageAssetsByGuid(source) {
+  return new Map(source.product.assets.map((asset) => [asset.guid.toLowerCase(), asset]));
+}
+
+// src/scriptable-pack-host.ts
+function canonicalScriptableSourcePath(sourcePath) {
+  const normalized = sourcePath.replaceAll("\\", "/");
+  const marker = "/assets/";
+  const markerIndex = normalized.indexOf(marker);
+  return markerIndex < 0 ? normalized : normalized.slice(markerIndex + 1);
+}
+function scriptablePackInputs(sourcePaths, declarations, cwd, generationFor, policyFor) {
+  return sourcePaths.flatMap((sourcePath) => {
+    const declaration = declarations.get(resolve(cwd, sourcePath));
+    if (declaration?.format !== "pack.ts") return [];
+    const displaySourcePath = canonicalScriptableSourcePath(sourcePath);
+    return [
+      {
+        sourcePath: resolve(cwd, sourcePath),
+        displaySourcePath,
+        definition: declaration.definition,
+        sourceClosure: declaration.sourceClosure,
+        publicationGeneration: generationFor(displaySourcePath),
+        policy: policyFor(displaySourcePath)
+      }
+    ];
+  });
+}
+async function materializePreparedScriptablePack(prepared, paths, sink) {
+  const { product, finalized } = prepared;
+  await sink.writePackage(paths.packagePath, JSON.stringify(finalized.pack));
+  for (const artifact of finalized.artifacts) {
+    await sink.writeArtifact(
+      paths.artifactPath(artifact.path),
+      artifact.bytes,
+      artifact.path.endsWith(".json") ? "application/json" : artifact.mediaType
+    );
+  }
+  const receipts = /* @__PURE__ */ new Map();
+  for (const guid of product.declaredGuids) {
+    const path = paths.receiptPath(guid);
+    await sink.writeReceipt(
+      path,
+      JSON.stringify({
+        guid,
+        origin: "sourceMeta",
+        status: "succeeded",
+        inputFingerprint: product.inputFingerprint,
+        outputDigest: finalized.digest
+      })
+    );
+    receipts.set(guid, path);
+  }
+  return receipts;
+}
+async function readCookedAuthoredPack(authoredPack, cookers = [], sourcePath) {
+  const parsed = upgradeLegacyAuthoredPack(authoredPack);
+  if (parsed.schemaVersion !== "2.0.0" || parsed.assets === void 0) return void 0;
+  const registry = new NativeCookerRegistry();
+  for (const cooker of cookers) registry.register(cooker);
+  const assets = [];
+  const refsByGuid = /* @__PURE__ */ new Map();
+  let hasCookedAsset = false;
+  for (const asset of parsed.assets) {
+    const shouldCook = asset.execution === "cooked";
+    if (!shouldCook) {
+      assets.push({
+        guid: asset.guid,
+        kind: asset.kind,
+        ...asset.name === void 0 ? {} : { name: asset.name },
+        ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
+        ...asset.sourceIndex === void 0 ? {} : { sourceIndex: asset.sourceIndex },
+        ...asset.relations === void 0 ? {} : { relations: asset.relations },
+        payload: asset.payload,
+        refs: asset.refs ?? [],
+        artifacts: {}
+      });
+      continue;
+    }
+    hasCookedAsset = true;
+    const result = await registry.runDraft(asset.kind, {
+      guid: asset.guid,
+      source: asset.payload,
+      ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
+      ...sourcePath === void 0 ? {} : { sourcePath },
+      refs: asset.refs ?? []
+    });
+    if (!result.ok) throw result.error;
+    const draft = result.value;
+    const refs = [...draft.refs];
+    refsByGuid.set(asset.guid.toLowerCase(), refs);
+    assets.push({
+      guid: draft.guid,
+      kind: asset.kind,
+      ...asset.name === void 0 ? {} : { name: asset.name },
+      ...asset.sourceKey === void 0 ? {} : { sourceKey: asset.sourceKey },
+      ...asset.sourceIndex === void 0 ? {} : { sourceIndex: asset.sourceIndex },
+      ...asset.relations === void 0 ? {} : { relations: asset.relations },
+      payload: draft.payload,
+      refs,
+      artifacts: draft.artifacts
+    });
+  }
+  return hasCookedAsset ? {
+    logicalPackage: { schemaVersion: "2.0.0", kind: "internal-text-package", assets },
+    refsByGuid
+  } : void 0;
+}
+async function declaredPackExternalOutputs(declarations, cookers = [], requiredGuids = [], externalImport) {
+  if (requiredGuids.length === 0) return [];
+  const required = new Set(requiredGuids.map((guid) => AssetGuid.format(guid).toLowerCase()));
+  const outputs = [];
+  for (const declaration of declarations.values()) {
+    if (declaration.format === "meta.json") {
+      if (externalImport === void 0) continue;
+      if (!declaration.value.subAssets.some((asset) => required.has(asset.guid.toLowerCase()))) {
+        continue;
+      }
+      const assetPaths = externalImport.assetPaths ?? loadAssetConfig(process.cwd()).paths;
+      const resolved = resolveAssetSource(
+        declaration.sourcePath,
+        declaration.value.source,
+        assetPaths
+      );
+      if (!resolved.ok) {
+        throw new AssetError({
+          code: "asset-not-imported",
+          expected: `a resolvable source for Meta dependency ${declaration.sourcePath}`,
+          hint: "repair the Meta source path before rebuilding the ScriptablePack"
+        });
+      }
+      const meta = {
+        importer: declaration.value.importer,
+        source: resolved.value,
+        sourceRevision: declaration.sourceRevision,
+        ...declaration.value.packageId === void 0 ? {} : { packageId: declaration.value.packageId },
+        ...declaration.value.provenance === void 0 ? {} : { provenance: declaration.value.provenance },
+        ...declaration.value.revision === void 0 ? {} : { revision: declaration.value.revision },
+        ...declaration.value.diagnostics === void 0 ? {} : { diagnostics: declaration.value.diagnostics },
+        importSettings: declaration.value.importSettings,
+        ...declaration.value.sourceOverrides === void 0 ? {} : { sourceOverrides: declaration.value.sourceOverrides },
+        subAssets: declaration.value.subAssets.map(({ guid, sourceIndex, sourceKey, kind }) => ({
+          guid,
+          sourceIndex,
+          ...sourceKey === void 0 ? {} : { sourceKey },
+          kind
+        })),
+        buildPack: false
+      };
+      const sourcePackage = await produceSourcePackage({
+        meta,
+        registry: externalImport.importerRegistry,
+        fs: externalImport.fsForImport
+      });
+      if (!sourcePackage.ok) {
+        throw new AssetError({
+          code: "asset-not-imported",
+          expected: `the ${declaration.value.importer} importer to produce Meta dependency outputs`,
+          hint: `repair ${declaration.sourcePath} before rebuilding the ScriptablePack`
+        });
+      }
+      for (const asset of sourcePackage.value.product.assets) {
+        const key = asset.guid.toLowerCase();
+        if (!required.has(key)) continue;
+        const parsed = AssetGuid.parse(asset.guid);
+        if (!parsed.ok) throw parsed.error;
+        outputs.push({
+          guid: parsed.value,
+          asset: { kind: asset.kind, ...asset.payload }
+        });
+      }
+      continue;
+    }
+    if (declaration.format !== "pack.json") continue;
+    const declaredAssets = declaration.value.assets.filter(
+      (asset) => required.has(asset.guid.toLowerCase())
+    );
+    if (declaredAssets.length === 0) continue;
+    const cooked = await readCookedAuthoredPack(declaration.value, cookers, declaration.sourcePath);
+    for (const asset of cooked?.logicalPackage.assets.filter(
+      (item) => required.has(item.guid.toLowerCase())
+    ) ?? declaredAssets) {
+      const parsed = AssetGuid.parse(asset.guid);
+      if (!parsed.ok) throw parsed.error;
+      outputs.push({ guid: parsed.value, asset: { kind: asset.kind, ...asset.payload } });
+    }
+  }
+  return outputs;
+}
+async function prepareAuthoredPackTransport(authoredPack, cookers, policyFor, sourcePath) {
+  const pack = upgradeLegacyAuthoredPack(authoredPack);
+  const firstGuid = pack.assets?.[0]?.guid?.toLowerCase();
+  if (pack.schemaVersion !== "2.0.0" || firstGuid === void 0) {
+    return { pack, ...firstGuid === void 0 ? {} : { firstGuid } };
+  }
+  const cooked = await readCookedAuthoredPack(pack, cookers, sourcePath);
+  if (cooked === void 0) return { pack, firstGuid };
+  return {
+    pack,
+    firstGuid,
+    cooked,
+    finalized: await finalizePackageTransportSource(cooked.logicalPackage, policyFor(firstGuid))
+  };
+}
+function projectScriptablePackPublication(product) {
+  const assets = new Map(product.product.assets.map((asset) => [asset.guid.toLowerCase(), asset]));
+  const outputs = [];
+  for (const staged of product.stagedOutputs) {
+    const guid = AssetGuid.format(staged.guid).toLowerCase();
+    const asset = assets.get(guid);
+    if (asset === void 0 || staged.digest === void 0) {
+      return err({
+        code: "pack-source-output-invalid",
+        expected: `ScriptablePack publication output ${guid} to include a product and digest`,
+        hint: "repair the ScriptablePack producer output and rebuild",
+        detail: { stage: "publication", guid }
+      });
+    }
+    outputs.push({
+      guid,
+      sourceKey: staged.sourceKey ?? guid,
+      kind: asset.kind,
+      digest: staged.digest,
+      refs: asset.refs.map((reference) => reference.guid)
+    });
+  }
+  return ok({
+    outputs,
+    refs: new Map(
+      product.product.assets.map((asset) => [
+        asset.guid.toLowerCase(),
+        asset.refs.map((reference) => reference.guid)
+      ])
+    )
+  });
+}
+async function scriptablePackResourceRevision(displaySourcePath, digest, sourceClosure) {
+  const observedAt = Math.trunc(
+    Math.max(
+      ...await Promise.all(sourceClosure.map(async (entry) => (await stat(entry.path)).mtimeMs))
+    )
+  );
+  return { digest, observedAt, rootId: displaySourcePath };
+}
+async function produceScriptablePackProducts(sources, declaredExternalOutputs = []) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (entries.has(source.displaySourcePath)) continue;
+    entries.set(source.displaySourcePath, {
+      source,
+      definition: source.definition,
+      closure: source.sourceClosure
+    });
+  }
+  const products = /* @__PURE__ */ new Map();
+  const owners = [...entries.entries()].map(
+    ([displaySourcePath, entry]) => ({
+      id: displaySourcePath,
+      guids: Object.values(entry.definition.assets).map((asset) => asset.guid),
+      async build(source) {
+        const produced = await produceScriptableSourcePackage({
+          definition: entry.definition,
+          sourcePath: displaySourcePath,
+          assetSource: source,
+          outputs: createStandardAssetOutputProducerRegistry(
+            projectScriptablePackSceneComponents(entry.definition.sceneComponents)
+          ),
+          sourceClosure: entry.closure,
+          authoringContractVersion: "scriptable-pack-production/1"
+        });
+        if (!produced.ok) return produced;
+        const observedClosure = await inventoryScriptablePackSource(entry.source.sourcePath);
+        if (JSON.stringify(observedClosure) !== JSON.stringify(entry.closure)) {
+          return err({
+            code: "pack-source-load-failed",
+            expected: "the complete ScriptablePack module closure to remain fixed during one build",
+            hint: "retry the build after source and helper writes have settled",
+            detail: {
+              sourcePath: displaySourcePath,
+              reason: "source-changed",
+              phase: "build",
+              diagnostic: "module closure changed while the staged generation was building"
+            }
+          });
+        }
+        products.set(displaySourcePath, produced.value);
+        return ok(produced.value.stagedOutputs);
+      }
+    })
+  );
+  const generationDigest = createHash("sha256").update(
+    JSON.stringify(
+      [...entries.values()].flatMap((entry) => entry.closure).sort((a, b) => a.path.localeCompare(b.path))
+    )
+  ).digest();
+  const stagedSource = createScriptablePackStagedAssetSnapshotSource({
+    generation: generationDigest.readUInt32BE(0),
+    owners,
+    declaredExternalOutputs
+  });
+  const prepared = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const entry = entries.get(source.displaySourcePath);
+    if (entry === void 0) {
+      return err({
+        code: "pack-source-path-invalid",
+        expected: "a ScriptablePack source registered in the current inventory",
+        actual: source.displaySourcePath,
+        hint: "rebuild the source inventory before producing this path",
+        retryable: true,
+        recoveryActions: ["rebuild-source-inventory"],
+        detail: { sourcePath: source.displaySourcePath }
+      });
+    }
+    const first = Object.values(entry.definition.assets)[0];
+    if (first === void 0) {
+      return err({
+        code: "pack-source-output-invalid",
+        expected: "at least one declared ScriptablePack output",
+        hint: "add an output descriptor before building the package",
+        detail: { missingGuids: [], unexpectedSourceKeys: [], kindMismatches: [] }
+      });
+    }
+    const staged = await stagedSource.readByGuid(first.guid);
+    if (!staged.ok) return err(staged.error);
+    const produced = products.get(source.displaySourcePath);
+    if (produced === void 0) {
+      return err({
+        code: "pack-source-output-invalid",
+        expected: "the staged owner build to retain its source-package product",
+        hint: "retry the ScriptablePack production attempt",
+        detail: {
+          missingGuids: [AssetGuid.format(first.guid)],
+          unexpectedSourceKeys: [],
+          kindMismatches: []
+        }
+      });
+    }
+    const transportPolicy = typeof source.policy === "function" ? source.policy(produced) : source.policy;
+    const logicalPackage = projectImportProductForBuild(produced.product);
+    const finalized = await finalizePackageTransportSource(logicalPackage, transportPolicy);
+    const facts = projectScriptablePackPublication(produced);
+    if (!facts.ok) return err(facts.error);
+    const revision = await scriptablePackResourceRevision(
+      source.displaySourcePath,
+      produced.inputFingerprint,
+      source.sourceClosure
+    );
+    const publication = createAcceptedPublication({
+      sourcePath: source.displaySourcePath,
+      sourceRevision: produced.inputFingerprint,
+      generation: source.publicationGeneration,
+      digest: finalized.digest,
+      packageUrl: finalized.packageUrl,
+      inputFingerprint: produced.inputFingerprint,
+      outputs: facts.value.outputs,
+      externalEvidence: produced.externalEvidence
+    });
+    prepared.set(source.displaySourcePath, {
+      product: produced,
+      finalized,
+      facts: facts.value,
+      revision,
+      publication
+    });
+  }
+  return ok(prepared);
+}
+
+// src/build-production.ts
+function scriptableArtifactPath(guid, key) {
+  return `${guid.toLowerCase()}/${key.includes(".") ? key : `${key}.bin`}`;
+}
+function runtimePublicationFor(context, input) {
+  return createRuntimePackPublication({
+    pack: input.pack,
+    scopeId: context.runtimeBinding?.scopeId ?? "asset-runtime",
+    sourcePath: input.sourcePath,
+    sourceRevision: input.sourceRevision,
+    packageUrl: input.packageUrl,
+    ...input.digest === void 0 ? {} : { digest: input.digest },
+    generation: context.runtimeBinding?.generation ?? context.generation
+  });
+}
+async function buildAuthoredPackages(context) {
+  const scriptableSources = [
+    ...new Set(
+      context.inventory.entries.filter((entry) => entry.sourcePath.endsWith(".pack.ts")).map((entry) => entry.sourcePath)
+    )
+  ];
+  if (scriptableSources.length === 0) return /* @__PURE__ */ new Map();
+  const inputs = scriptablePackInputs(
+    scriptableSources,
+    context.inventory.sourceDeclarations,
+    context.cwd,
+    () => context.generation,
+    () => (product) => ({
+      base: context.basePrefix === "" ? "/" : context.basePrefix,
+      packagePath: `assets/${product.anchorGuid}.pack.json`,
+      artifactPath: scriptableArtifactPath
+    })
+  );
+  const preparedResult = await produceScriptablePackProducts(
+    inputs,
+    await declaredPackExternalOutputs(
+      context.inventory.sourceDeclarations,
+      context.cookers,
+      inputs.flatMap((input) => Object.values(input.definition.externalAssets)),
+      {
+        importerRegistry: context.importerRegistry,
+        fsForImport: context.fsForImport,
+        assetPaths: loadAssetConfig(context.cwd).paths
+      }
+    )
+  );
+  if (!preparedResult.ok) throw context.fail(preparedResult.error);
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of context.inventory.entries) {
+    if (!entry.sourcePath.endsWith(".pack.ts") || result.has(entry.sourcePath)) continue;
+    const prepared = preparedResult.value.get(canonicalScriptableSourcePath(entry.sourcePath));
+    if (prepared === void 0) {
+      throw context.fail({
+        code: "catalog-declaration-missing",
+        expected: "the ScriptablePack inventory to retain every authored Pack source",
+        hint: "rerun the source inventory and rebuild from the accepted declaration set",
+        detail: { stage: "scan", sourcePath: entry.sourcePath }
+      });
+    }
+    const { product, finalized, facts, revision, publication } = prepared;
+    const packagePath = `assets/${product.anchorGuid}.pack.json`;
+    const runtimePublication = createRuntimePackPublication({
+      pack: { assets: finalized.pack.assets },
+      scopeId: context.runtimeBinding?.scopeId ?? "asset-runtime",
+      sourcePath: publication.sourcePath,
+      sourceRevision: publication.sourceRevision,
+      packageUrl: finalized.packageUrl,
+      inputFingerprint: publication.receipt.inputFingerprint,
+      digest: finalized.digest,
+      generation: context.runtimeBinding?.generation ?? publication.generation,
+      outputs: facts.outputs,
+      externalEvidence: publication.externalEvidence
+    });
+    const receiptPaths = await materializePreparedScriptablePack(
+      prepared,
+      {
+        packagePath,
+        artifactPath: (path) => `assets/${path}`,
+        receiptPath: (guid) => `assets/${guid}.receipt.json`
+      },
+      {
+        writePackage: (path) => {
+          context.sink.emitFile({
+            type: "asset",
+            fileName: path,
+            originalFileName: `${context.cwd}/${entry.sourcePath}`,
+            source: JSON.stringify(runtimePublication.pack)
+          });
+        },
+        writeArtifact: (path, bytes2) => {
+          context.sink.emitFile({ type: "asset", fileName: path, source: bytes2 });
+        },
+        writeReceipt: (path, source) => {
+          context.sink.emitFile({ type: "asset", fileName: path, source });
+        }
+      }
+    );
+    result.set(entry.sourcePath, {
+      packageUrl: finalized.packageUrl,
+      receiptUrls: new Map(
+        [...receiptPaths].map(([guid, path]) => [guid, context.sink.fileUrl(path)])
+      ),
+      revision,
+      publication: runtimePublication.publication,
+      refs: facts.refs
+    });
+  }
+  return result;
+}
+function updateImportedEntries(entries, guids, packageUrl, projection = {}, refsByGuid, publication) {
+  const selected = new Set(guids.map((guid) => guid.toLowerCase()));
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (entry === void 0 || !selected.has(entry.guid.toLowerCase())) continue;
+    const refs = refsByGuid?.get(entry.guid.toLowerCase());
+    entries[index] = {
+      ...entry,
+      packageUrl,
+      ...projection,
+      ...publication === void 0 ? {} : { publication },
+      ...refs === void 0 ? {} : { refs }
+    };
+  }
+}
+async function emitPackDocument(work, options) {
+  for (const artifact of options.artifacts) {
+    work.context.sink.emitFile({
+      type: "asset",
+      fileName: `assets/${artifact.path}`,
+      source: artifact.bytes
+    });
+  }
+  const referenceId = work.context.sink.emitFile({
+    type: "asset",
+    name: options.packageName,
+    originalFileName: options.originalFileName,
+    source: JSON.stringify(options.pack)
+  });
+  const packageUrl = work.context.sink.fileUrl(work.context.sink.getFileName(referenceId));
+  updateImportedEntries(
+    work.importedEntries,
+    options.guids,
+    packageUrl,
+    options.projection,
+    options.refsByGuid,
+    options.publication
+  );
+  return packageUrl;
+}
+async function emitAuthoredPack(work, guidSeen, entry) {
+  const packPath = resolve(work.context.cwd, entry.sourcePath);
+  const declaration = work.context.inventory.sourceDeclarations.get(packPath);
+  if (declaration?.format !== "pack.json") {
+    throw work.context.fail({
+      code: "catalog-declaration-missing",
+      expected: "the inventory to retain the authored Pack declaration",
+      hint: "rerun Pack inventory before emitting the authored Pack",
+      detail: { stage: "scan", sourcePath: packPath }
+    });
+  }
+  const prepared = await prepareAuthoredPackTransport(
+    declaration.value,
+    work.context.cookers,
+    (guid) => ({
+      base: work.context.basePrefix === "" ? "/" : work.context.basePrefix,
+      packagePath: `assets/${guid}.pack.json`,
+      artifactPath: (artifactGuid, key) => `${artifactGuid}/${key}.bin`
+    }),
+    packPath
+  );
+  const outputGuid = prepared.firstGuid ?? entry.guid;
+  const authoredPack = prepared.finalized?.pack ?? prepared.pack;
+  const runtimePublication = authoredPack.assets === void 0 || authoredPack.assets.length === 0 ? void 0 : runtimePublicationFor(work.context, {
+    pack: { assets: authoredPack.assets },
+    sourcePath: packPath,
+    sourceRevision: prepared.finalized?.sourceRevision ?? entry.sourcePath,
+    packageUrl: prepared.finalized?.packageUrl ?? `${work.context.basePrefix === "/" ? "" : work.context.basePrefix}/assets/${outputGuid}.pack.json`,
+    ...prepared.finalized?.digest === void 0 ? {} : { digest: prepared.finalized.digest }
+  });
+  await emitPackDocument(work, {
+    pack: runtimePublication?.pack ?? authoredPack,
+    artifacts: prepared.finalized?.artifacts ?? [],
+    packageName: `${outputGuid}.pack.json`,
+    originalFileName: packPath,
+    guids: prepared.pack.assets?.map((asset) => asset.guid) ?? [outputGuid],
+    projection: prepared.finalized === void 0 ? work.context.directCurrentProjection : work.context.authoredCookedCurrentProjection,
+    ...prepared.cooked === void 0 ? {} : { refsByGuid: prepared.cooked.refsByGuid },
+    ...runtimePublication === void 0 ? {} : { publication: runtimePublication.publication }
+  });
+  for (const guid of prepared.pack.assets?.map((asset) => asset.guid) ?? [outputGuid]) {
+    guidSeen.add(guid.toLowerCase());
+  }
+}
+async function emitFinalizedOwner(work, metaPath, subAssets, sourcePackage, ownerFinalizer) {
+  const ownerGuid = subAssets[0]?.guid;
+  if (ownerGuid === void 0) return;
+  const artifactPaths = /* @__PURE__ */ new Map();
+  const sourceAsset = sourcePackage.product.assets[0];
+  for (const [path, artifact] of Object.entries(sourceAsset?.artifacts ?? {})) {
+    const ref2 = work.context.sink.emitFile({
+      type: "asset",
+      name: path,
+      originalFileName: path,
+      source: artifact.bytes
+    });
+    artifactPaths.set(path, work.context.sink.getFileName(ref2));
+  }
+  const ownerProduct = finalizeSourcePackage(
+    sourcePackage.product,
+    ownerFinalizer,
+    (artifact) => work.context.sink.fileUrl(artifactPaths.get(artifact.path) ?? artifact.path)
+  );
+  if (!ownerProduct.ok) throw work.context.fail(ownerProduct.error);
+  const ownerPackage = await finalizePackageTransportSource(
+    projectImportProductForBuild(ownerProduct.value),
+    {
+      base: work.context.basePrefix,
+      packagePath: `assets/${ownerGuid}.pack.json`,
+      artifactPath: (_guid, key) => {
+        const emittedPath = artifactPaths.get(key);
+        if (emittedPath === void 0) {
+          throw work.context.fail({
+            code: "producer-artifact-missing",
+            expected: `producer artifact ${key} to be emitted before Pack finalization`,
+            hint: "repair the importer finalizer artifact closure and rebuild",
+            detail: { stage: "finalize", metaPath, artifact: key }
+          });
+        }
+        return emittedPath.replace(/^assets\//, "");
+      },
+      sink: () => {
+      }
+    }
+  );
+  const runtimePublication = runtimePublicationFor(work.context, {
+    pack: { assets: ownerPackage.pack.assets },
+    sourcePath: metaPath,
+    sourceRevision: ownerPackage.sourceRevision,
+    packageUrl: ownerPackage.packageUrl,
+    digest: ownerPackage.digest
+  });
+  await emitPackDocument(work, {
+    pack: runtimePublication.pack,
+    artifacts: ownerPackage.artifacts,
+    packageName: `${ownerGuid}.pack.json`,
+    originalFileName: metaPath,
+    guids: subAssets.map((sub) => sub.guid),
+    projection: work.context.cookedCurrentProjection,
+    refsByGuid: new Map(
+      ownerProduct.value.assets.map((asset) => [
+        asset.guid.toLowerCase(),
+        asset.refs.map((ref2) => ref2.guid)
+      ])
+    ),
+    publication: runtimePublication.publication
+  });
+}
+async function emitBuildEntry(work, guidSeen, entry) {
+  const guid = entry.guid.toLowerCase();
+  const metaPath = metaPathForGuid(work.context.inventory.declarations, guid);
+  if (metaPath === void 0) {
+    if (entry.sourcePath.endsWith(".pack.json")) await emitAuthoredPack(work, guidSeen, entry);
+    else guidSeen.add(guid);
+    return;
+  }
+  const declaration = work.context.inventory.declarations.get(metaPath);
+  if (declaration === void 0) {
+    throw work.context.fail({
+      code: "catalog-declaration-missing",
+      expected: "every indexed Meta path to have one validated producer declaration",
+      hint: "rerun the inventory and repair the Catalog declaration index",
+      detail: { metaPath }
+    });
+  }
+  const runMeta = { ...declaration, buildPack: false };
+  const subAssets = runMeta.subAssets;
+  for (const sub of subAssets) guidSeen.add(sub.guid.toLowerCase());
+  const sourcePackage = await produceSourcePackage({
+    meta: runMeta,
+    registry: work.context.importerRegistry,
+    fs: work.context.fsForImport
+  });
+  if (!sourcePackage.ok) throw work.context.fail(sourcePackage.error);
+  const ownerFinalizer = work.context.importerRegistry.get(runMeta.importer)?.finalize;
+  if (ownerFinalizer !== void 0) {
+    await emitFinalizedOwner(work, metaPath, subAssets, sourcePackage.value, ownerFinalizer);
+    return;
+  }
+  const finalized = await finalizePackageTransportSource(
+    projectImportProductForBuild(sourcePackage.value.product),
+    {
+      base: work.context.basePrefix,
+      packagePath: `assets/${subAssets[0]?.guid ?? "pack"}.pack.json`,
+      artifactPath: (assetGuid, key) => `${assetGuid}-${key}.bin`,
+      sink: () => {
+      }
+    }
+  );
+  const productByGuid = sourcePackageAssetsByGuid(sourcePackage.value);
+  const runtimePublication = runtimePublicationFor(work.context, {
+    pack: { assets: finalized.pack.assets },
+    sourcePath: metaPath,
+    sourceRevision: finalized.sourceRevision,
+    packageUrl: finalized.packageUrl,
+    digest: finalized.digest
+  });
+  await emitPackDocument(work, {
+    pack: runtimePublication.pack,
+    artifacts: finalized.artifacts,
+    packageName: `${subAssets[0]?.guid ?? "pack"}.pack.json`,
+    originalFileName: metaPath,
+    guids: subAssets.map((sub) => sub.guid),
+    projection: work.context.cookedCurrentProjection,
+    refsByGuid: new Map(
+      [...productByGuid].map(([guid2, asset]) => [guid2, asset.refs.map((ref2) => ref2.guid)])
+    ),
+    publication: runtimePublication.publication
+  });
+}
+async function produceBuildAssets(context) {
+  const entries = [...context.inventory.entries];
+  const authored = await buildAuthoredPackages(context);
+  const importedEntries = entries.map((entry) => {
+    const scriptable = authored.get(entry.sourcePath);
+    if (scriptable === void 0) return entry;
+    const cookReceiptUrl = scriptable.receiptUrls.get(entry.guid.toLowerCase());
+    return projectCookedPackageEntry(entry, {
+      packageUrl: scriptable.packageUrl,
+      revision: scriptable.revision,
+      refs: scriptable.refs.get(entry.guid.toLowerCase()) ?? [],
+      ...cookReceiptUrl === void 0 ? {} : { cookReceiptUrl },
+      publication: scriptable.publication
+    });
+  });
+  const guidSeen = /* @__PURE__ */ new Set();
+  const work = { importedEntries, context };
+  for (const entry of importedEntries) {
+    if (!guidSeen.has(entry.guid.toLowerCase())) await emitBuildEntry(work, guidSeen, entry);
+  }
+  return importedEntries;
+}
+
+// src/catalog-importer-policy.ts
+var DEFAULT_CATALOG_IMPORTER_KEYS = [
+  "image",
+  "gltf",
+  "fbx",
+  "audio",
+  "font",
+  "ui"
+];
+function catalogImporterPolicy(importer, hostImporterKeys) {
+  if (importer === SHADER_RESERVED_IMPORTER_KEY) {
+    return {
+      disposition: "exclude",
+      hostProvided: false,
+      expected: "the provider must publish cooked runtime output before Catalog projection",
+      hint: "remove the source declaration from Pack roots or publish its cooked runtime module"
+    };
+  }
+  if (DEFAULT_CATALOG_IMPORTER_KEYS.includes(importer)) {
+    return {
+      disposition: "publish",
+      hostProvided: false,
+      expected: "a standard Catalog provider declaration",
+      hint: "let the provider producer materialize the declared output"
+    };
+  }
+  if (hostImporterKeys.has(importer)) {
+    return {
+      disposition: "publish",
+      hostProvided: true,
+      expected: "a registered host Catalog provider declaration",
+      hint: "let the registered provider materialize the declared output"
+    };
+  }
+  return {
+    disposition: "missing",
+    hostProvided: false,
+    expected: "the sidecar importer must be present in the registered provider set",
+    hint: "wire the provider through the host importer registry before building the Catalog"
+  };
+}
+async function buildCatalogResult(roots, base = "/", registeredImporterKeys = /* @__PURE__ */ new Set(), scanOptions = {}, catalogVisibility = () => true) {
+  const options = {
+    base,
+    scanOptions,
+    importerPolicy: (importer) => catalogImporterPolicy(importer, registeredImporterKeys),
+    visibility: catalogVisibility
+  };
+  return buildCatalogProjection(roots, options);
+}
+
+// src/importer-registry.ts
+var ImporterRegistry = class {
+  importers = /* @__PURE__ */ new Map();
+  /**
+   * Register an importer for its `importer.key`. Fail-fast on a malformed
+   * importer (charter P3); idempotent on a repeated key (last write wins).
+   *
+   * @param importer the `{ key, import }` object to register.
+   * @throws TypeError when `importer.key` is empty or `importer.import` is not
+   *   a function - a wire-time misconfiguration the host must fix.
+   */
+  register(importer) {
+    if (typeof importer.key !== "string" || importer.key.length === 0) {
+      throw new TypeError(
+        `ImporterRegistry.register: importer.key must be a non-empty string (got ${JSON.stringify(importer.key)})`
+      );
+    }
+    if (typeof importer.import !== "function") {
+      throw new TypeError(
+        `ImporterRegistry.register: importer.import must be a function for key "${importer.key}"`
+      );
+    }
+    this.importers.set(importer.key, importer);
+  }
+  /**
+   * Look up the importer registered for `key`. Returns `undefined` when no
+   * importer is wired - the import runner maps that to a structured
+   * `ImportError(code='importer-not-registered')` with the registered keys in
+   * `.detail.registeredImporters` (charter P3).
+   */
+  get(key) {
+    return this.importers.get(key);
+  }
+  /**
+   * The importer keys currently wired, in insertion order. Fed into the
+   * `importer-not-registered` error `.detail.registeredImporters` so AI users
+   * see exactly what is injectable.
+   */
+  registeredImporters() {
+    return [...this.importers.keys()];
+  }
+  /** Project the first registered producer capability into the runner context. */
+  contextCapabilities() {
+    for (const importer of this.importers.values()) {
+      const decoder = importer.capabilities?.decodeImage;
+      if (decoder !== void 0) return { decodeImage: decoder };
+    }
+    return {};
+  }
+  /** Ask the registered producer whether a declaration has a Catalog product. */
+  shouldPublishCatalog(input) {
+    return this.get(input.importer)?.capabilities?.catalog?.publish?.({
+      importSettings: input.importSettings,
+      subAssets: input.subAssets
+    }) ?? true;
+  }
+};
+
+// src/source-package-errors.ts
+var SOURCE_PACKAGE_ERROR_POLICY = {
+  "source-package-meta-invalid": {
+    expected: "a valid source Meta declaration with complete GUID topology",
+    hint: "repair the Meta declaration, then rebuild or cold-cook the source package"
+  },
+  "source-package-importer-missing": {
+    expected: "a registered importer for the source Meta importer key",
+    hint: "register the named importer, then rebuild or cold-cook the source package"
+  },
+  "source-package-conversion-failed": {
+    expected: "the configured importer to convert the source successfully",
+    hint: "repair the source or importer, then rebuild or cold-cook the source package"
+  },
+  "source-package-ddc-failed": {
+    expected: "a readable persistent DDC entry with matching integrity evidence",
+    hint: "discard the invalid derived entry, then rebuild or cold-cook the source package"
+  },
+  "source-package-publication-invalid": {
+    expected: "a complete Pack body, refs, artifacts, and route integrity",
+    hint: "repair the missing product bytes, then rebuild or cold-cook the source package"
+  },
+  "source-package-guid-closure-mismatch": {
+    expected: "exactly one produced asset for every declared GUID",
+    hint: "repair the Meta topology or importer output, then rebuild the whole source package"
+  }
+};
+function sourcePackageError(code, context, detail) {
+  const policy = SOURCE_PACKAGE_ERROR_POLICY[code];
+  return {
+    code,
+    expected: policy?.expected,
+    hint: policy?.hint,
+    detail: { ...context, ...detail }
+  };
+}
+function unknownReason(error) {
+  if (error !== null && typeof error === "object") {
+    const value = error;
+    if (typeof value.code === "string") {
+      const detail = value.detail;
+      const reason = detail !== null && typeof detail === "object" && "reason" in detail ? detail.reason : void 0;
+      const diagnostic = detail !== null && typeof detail === "object" && "diagnostic" in detail ? detail.diagnostic : void 0;
+      return `${value.code}: ${typeof diagnostic === "string" ? diagnostic : typeof reason === "string" ? reason : String(value.expected ?? "producer failure")}`;
+    }
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function importFailureCode(error) {
+  switch (error.code) {
+    case "importer-not-registered":
+      return "source-package-importer-missing";
+    case "import-produced-no-assets":
+    case "guid-mismatch":
+    case "source-validation-failed":
+      return "source-package-guid-closure-mismatch";
+    case "source-read-failed":
+    case "import-internal-error":
+    case "mesh-material-slot-topology-change":
+    case "unknown-source-key":
+    case "duplicate-source-key":
+    case "invalid-source-overrides":
+    case "invalid-source-override-payload":
+      return "source-package-conversion-failed";
+  }
+}
+function normalizeSourcePackageError(error, context) {
+  if (isSourcePackageError(error)) return error;
+  if (isScriptablePackFailure(error)) {
+    return sourcePackageError("source-package-conversion-failed", context, {
+      stage: "conversion",
+      reason: unknownReason(error)
+    });
+  }
+  if (isImportError(error)) {
+    const code = importFailureCode(error);
+    const detail = {
+      stage: code === "source-package-importer-missing" ? "importer" : "conversion",
+      reason: unknownReason(error),
+      ...code === "source-package-importer-missing" && "registeredImporters" in error.detail ? { registeredImporters: error.detail.registeredImporters } : {}
+    };
+    return sourcePackageError(code, context, detail);
+  }
+  return sourcePackageError(contextErrorStage(error), context, {
+    stage: "conversion",
+    reason: unknownReason(error)
+  });
+}
+function isSourcePackageError(error) {
+  return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" && error.code in SOURCE_PACKAGE_ERROR_POLICY && "expected" in error && typeof error.expected === "string" && "hint" in error && typeof error.hint === "string" && "detail" in error && error.detail !== null && typeof error.detail === "object";
+}
+function contextErrorStage(error) {
+  return error instanceof SyntaxError ? "source-package-meta-invalid" : "source-package-conversion-failed";
+}
+function isImportError(error) {
+  return error !== null && typeof error === "object" && "code" in error && "expected" in error && "hint" in error && "detail" in error;
+}
+function isScriptablePackFailure(error) {
+  return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" && error.code.startsWith("pack-source-") && "expected" in error && typeof error.expected === "string" && "hint" in error && typeof error.hint === "string" && "detail" in error;
+}
+function inspectHead(root, guid, desiredKey) {
+  return new DdcLifecycle(root).inspect(guid, desiredKey);
+}
+var PUBLICATION_SETTLE_TIMEOUT_MS = 5e3;
+var PUBLICATION_SETTLE_POLL_MS = 10;
+async function inspectAfterSupersededCommit(candidate) {
+  let head = await inspectHead(candidate.root, candidate.lease.guid, candidate.lease.desiredKey);
+  if (head.state === "current" && head.currentKey === candidate.lease.desiredKey) return head;
+  const deadline = Date.now() + PUBLICATION_SETTLE_TIMEOUT_MS;
+  while (Date.now() < deadline && head.activeLease !== void 0 && head.activeLease.attempt !== candidate.lease.attempt && head.activeLease.desiredKey === candidate.lease.desiredKey) {
+    await new Promise((resolve3) => setTimeout(resolve3, PUBLICATION_SETTLE_POLL_MS));
+    head = await inspectHead(candidate.root, candidate.lease.guid, candidate.lease.desiredKey);
+    if (head.state === "current" && head.currentKey === candidate.lease.desiredKey) return head;
+  }
+  return head;
+}
+async function stageSourcePackageDdc(input) {
+  const session = new DdcGenerationSession(input.root, { generation: 1 });
+  try {
+    const candidate = await session.stageEntry(input.entry);
+    return ok({ ...candidate, root: input.root, session, context: input.context });
+  } catch (error) {
+    return err(
+      sourcePackageError("source-package-ddc-failed", input.context, {
+        stage: "ddc",
+        reason: error instanceof Error ? error.message : String(error)
+      })
+    );
+  }
+}
+async function commitSourcePackageDdc(candidate) {
+  try {
+    const commit = await candidate.session.commitEntry(candidate, candidate.lease.desiredKey);
+    if (commit.result !== "current") {
+      const head = await inspectAfterSupersededCommit(candidate);
+      if (head.state === "current" && head.currentKey === candidate.lease.desiredKey) {
+        return ok(head);
+      }
+      return err(
+        sourcePackageError("source-package-ddc-failed", candidate.context, {
+          stage: "ddc",
+          reason: `DDC lifecycle commit returned ${commit.result}`
+        })
+      );
+    }
+    return ok(await inspectHead(candidate.root, candidate.lease.guid, candidate.lease.desiredKey));
+  } catch (error) {
+    return err(
+      sourcePackageError("source-package-ddc-failed", candidate.context, {
+        stage: "ddc",
+        reason: error instanceof Error ? error.message : String(error)
+      })
+    );
+  }
+}
+async function persistTransport(transport) {
+  if (transport === void 0) return true;
+  const directory = dirname(transport.path);
+  const temporary = `${transport.path}.tmp`;
+  try {
+    await mkdir(directory, { recursive: true });
+    if (((await stat(directory)).mode & 146) === 0) {
+      throw new Error("transport directory is read-only");
+    }
+    await writeFile(temporary, transport.body);
+    await rename(temporary, transport.path);
+    return true;
+  } catch {
+    await rm(temporary, { force: true }).catch(() => {
+    });
+    return false;
+  }
+}
+function importPublicationFailure(error) {
+  return {
+    code: error.code,
+    expected: error.expected,
+    hint: error.hint,
+    detail: error.detail.reason ?? error.detail.stage,
+    diagnostic: error
+  };
+}
+function projectImportPublication(input, head, observedAt) {
+  const digest = head.currentKey ?? input.desiredKey;
+  const revision = { digest, observedAt, rootId: input.root };
+  const published = new Set(input.publishedGuids.map((guid) => guid.toLowerCase()));
+  const catalog = input.nextCatalog.map((row) => {
+    if (!published.has(row.guid.toLowerCase())) return row;
+    const previousLkg = head.lastKnownGoodKey === void 0 ? void 0 : input.previousCatalog.find(
+      (candidate) => candidate.guid.toLowerCase() === row.guid.toLowerCase() && candidate.revision?.digest === head.lastKnownGoodKey
+    );
+    const projection = row.projection === void 0 ? void 0 : (() => {
+      const { lastKnownGood: _staleLastKnownGood, ...withoutLastKnownGood } = row.projection;
+      return previousLkg?.packageUrl === void 0 ? withoutLastKnownGood : { ...withoutLastKnownGood, lastKnownGood: { packageUrl: previousLkg.packageUrl } };
+    })();
+    return {
+      ...row,
+      revision,
+      ...projection === void 0 ? {} : { projection }
+    };
+  });
+  return { catalog, revision };
+}
+async function publishImportPublication(input) {
+  const staged = await stageImportPublication(input);
+  if (!staged.ok) return staged;
+  return commitImportPublication(staged.candidate);
+}
+async function stageImportPublication(input) {
+  const staged = await stageSourcePackageDdc({
+    root: input.root,
+    entry: {
+      key: input.desiredKey,
+      guid: input.guid,
+      payload: input.pack,
+      refs: [],
+      artifacts: {},
+      receipt: {
+        guid: input.guid,
+        key: input.desiredKey,
+        producer: "engine-import/source-package-publication",
+        inputFingerprint: input.desiredKey,
+        outputDigest: ddcOutputDigest({
+          guid: input.guid,
+          payload: input.pack,
+          refs: [],
+          artifacts: {}
+        })
+      }
+    },
+    context: {
+      sourceMeta: "<import-publication>",
+      anchorGuid: input.guid,
+      affectedGuids: input.publishedGuids,
+      producer: "source-package/import-publication",
+      importer: "import-publication"
+    }
+  });
+  if (!staged.ok) {
+    return {
+      ok: false,
+      error: importPublicationFailure(staged.error),
+      head: await inspectHead(input.root, input.guid, input.desiredKey)
+    };
+  }
+  const lastKnownGoodKey = staged.value.previousHead.currentKey !== void 0 && staged.value.previousHead.currentKey !== input.desiredKey ? staged.value.previousHead.currentKey : staged.value.previousHead.lastKnownGoodKey;
+  const projectedHead = {
+    ...staged.value.previousHead,
+    state: "cooking",
+    currentKey: input.desiredKey,
+    ...lastKnownGoodKey === void 0 ? {} : { lastKnownGoodKey }
+  };
+  const projected = projectImportPublication(input, projectedHead, Date.now());
+  return {
+    ok: true,
+    candidate: {
+      input,
+      ddc: staged.value,
+      key: input.desiredKey,
+      head: projectedHead,
+      catalog: projected.catalog,
+      revision: projected.revision
+    }
+  };
+}
+async function commitImportPublication(candidate) {
+  const publication = await commitSourcePackageDdc(candidate.ddc);
+  if (!publication.ok) {
+    return {
+      ok: false,
+      error: importPublicationFailure(publication.error),
+      head: await inspectHead(
+        candidate.input.root,
+        candidate.input.guid,
+        candidate.input.desiredKey
+      )
+    };
+  }
+  const projected = projectImportPublication(candidate.input, publication.value, Date.now());
+  return {
+    ok: true,
+    key: candidate.input.desiredKey,
+    head: publication.value,
+    catalog: projected.catalog,
+    revision: projected.revision,
+    transportPersisted: await persistTransport(candidate.input.transport)
+  };
+}
+async function discardImportPublication(candidate) {
+  await candidate.ddc.session.discardEntry(candidate.ddc);
+}
+async function restoreImportPublication(candidate) {
+  await candidate.ddc.session.restoreEntry(candidate.ddc);
+}
+
+export { AssetOutputProducerRegistry, DEFAULT_CATALOG_IMPORTER_KEYS, ImporterRegistry, SHADER_RESERVED_IMPORTER_KEY, buildCatalogResult, buildScriptablePack, canonicalScriptableSourcePath, catalogImporterPolicy, commitImportPublication, createImportProduct, createSceneAssetOutputProducer, createScriptablePackStagedAssetSnapshotSource, createStandardAssetOutputProducerRegistry, declaredPackExternalOutputs, discardImportPublication, finalizeImportProducts, finalizeSourcePackage, materialAssetOutputProducer, materializePreparedScriptablePack, meshAssetOutputProducer, normaliseForPack, normalizeSourcePackageError, packMeshBinV4, parseProducerReadiness, prepareAuthoredPackTransport, produceBuildAssets, produceScriptablePackProducts, produceScriptableSourcePackage, produceSourcePackage, projectImportProductForBuild, projectScriptablePackPublication, publishImportPublication, readCookedAuthoredPack, restoreImportPublication, runImport, scriptablePackInputs, sourcePackageAssetsByGuid, sourcePackageError, stageImportPublication };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map