@forgeax/engine-import 0.1.2

package/dist/index.mjs

@@ -0,0 +1,1607 @@
+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 { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { MESH_BIN_HEADER_V4_BYTES, writeMeshBinHeader, isScriptablePackAssetKind } from '@forgeax/engine-pack';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { projectScriptablePackMeta } from '@forgeax/engine-pack/source';
+import { componentSchema } from '@forgeax/engine-ecs/internal';
+import { externalizeSceneAsset } from '@forgeax/engine-scene';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+
+// src/index.ts
+function invalid(field) {
+  return err({
+    code: "material-import-product-invalid",
+    expected: "an authored MaterialAsset with complete dependency references",
+    hint: "declare every material dependency before the product enters the cook pipeline",
+    detail: { field }
+  });
+}
+function distinct(values) {
+  return [...new Set(values)];
+}
+function createMaterialImportProduct(input) {
+  if (!input.guid || !input.sourcePath) return invalid("guid/sourcePath");
+  if (input.material.kind !== "material") return invalid("material.kind");
+  if (!input.sourceEvidence.inputFingerprint || !input.sourceEvidence.importerVersion) {
+    return invalid("sourceEvidence");
+  }
+  const refs = distinct([
+    ...input.refs.parent,
+    ...input.refs.textures,
+    ...input.refs.samplers,
+    ...input.refs.modules
+  ]);
+  return ok({
+    sourcePath: input.sourcePath,
+    sourceEvidence: input.sourceEvidence,
+    asset: {
+      guid: input.guid,
+      kind: "material",
+      payload: input.material,
+      refs: refs.map((guid) => ({ guid })),
+      artifacts: {}
+    }
+  });
+}
+function materialImportProductReady(product, availableRefs) {
+  return product.asset.refs.every((reference) => availableRefs.has(reference.guid));
+}
+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(digestPayload(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 digestPayload(asset) {
+  if (Object.keys(asset.artifacts).length === 0) return asset.payload;
+  if (asset.kind === "mesh") return { kind: "mesh" };
+  if (asset.kind === "texture" || asset.kind === "equirect") {
+    const payload = asset.payload;
+    const { data: _runtimeBytes, ...metadata } = payload;
+    return metadata;
+  }
+  return asset.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}` }
+      })
+    );
+  }
+  if (meta.buildPack === false) {
+    return {
+      ok: true,
+      value: { product: productWithDependencies, 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: {
+        ...productWithDependencies
+      },
+      cookProducts,
+      pack
+    }
+  };
+}
+
+// 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()];
+  }
+};
+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 pluginPack({ scriptablePack: { assetSource, ... } }) 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,
+      ...options.components === void 0 ? {} : { components: options.components }
+    });
+    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 closureError = externalClosureError(declared, referenced, read);
+  if (closureError !== void 0) return err(closureError);
+  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 product = {
+    assets,
+    sourceDependencies: options.sourceClosure.map((entry) => entry.path)
+  };
+  const inputFingerprint = await fingerprint({
+    meta: projectScriptablePackMeta(options.definition, options.sourcePath),
+    sourceClosure: stableSourceClosure(options.sourceClosure),
+    externalEvidence: fingerprintEvidence,
+    authoringContractVersion: options.authoringContractVersion,
+    producerVersions: options.outputs.versions()
+  });
+  return ok({
+    product,
+    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
+  });
+}
+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: {}
+  };
+}
+var materialAssetOutputProducer = {
+  kind: "material",
+  version: "material-pack/1",
+  produce(input) {
+    try {
+      return ok(materialProduct(input));
+    } catch (error) {
+      return err(producerError(input, error));
+    }
+  }
+};
+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;
+        })()
+      }
+    }
+  };
+}
+var meshAssetOutputProducer = {
+  kind: "mesh",
+  version: "mesh-binary/4",
+  produce(input) {
+    try {
+      return ok(meshProduct(input));
+    } catch (error) {
+      return err(producerError(input, error));
+    }
+  }
+};
+function sceneProduct(input) {
+  if (input.asset.kind !== "scene") throw new TypeError("expected SceneAsset");
+  const externalized = externalizeSceneAsset(input.asset, (componentName) => {
+    const component = input.components?.get(componentName);
+    return component === void 0 ? void 0 : componentSchema(component);
+  });
+  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 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 ordinaryAssetOutputProducer = {
+  kind: "texture",
+  version: "ordinary-pod/1",
+  produce(input) {
+    try {
+      return ok(ordinaryPodProduct(input));
+    } catch (error) {
+      return err(producerError(input, error));
+    }
+  }
+};
+function createOrdinaryAssetOutputProducer(kind) {
+  return { ...ordinaryAssetOutputProducer, kind };
+}
+var sceneAssetOutputProducer = {
+  kind: "scene",
+  version: "scene-pack/2",
+  produce(input) {
+    try {
+      return ok(sceneProduct(input));
+    } catch (error) {
+      return err(producerError(input, error));
+    }
+  }
+};
+function createStandardAssetOutputProducerRegistry() {
+  const registry = new AssetOutputProducerRegistry();
+  registry.register(materialAssetOutputProducer);
+  registry.register(meshAssetOutputProducer);
+  registry.register(sceneAssetOutputProducer);
+  for (const kind of [
+    "texture",
+    "equirect",
+    "sampler",
+    "font",
+    "render-pipeline",
+    "tileset",
+    "video",
+    "skeleton",
+    "skin",
+    "animation-clip",
+    "animation-graph",
+    "audio",
+    "particle-effect"
+  ]) {
+    registry.register(createOrdinaryAssetOutputProducer(kind));
+  }
+  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 ownerByGuid = /* @__PURE__ */ new Map();
+  for (const owner of options.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) {
+        if (options.fallback !== void 0) return options.fallback.readByGuid(guid);
+        return err(
+          new AssetError({
+            code: "asset-not-imported",
+            expected: "a staged local owner or explicit prebuilt fallback for the requested GUID",
+            hint: "declare the local ScriptablePack output or configure a prebuilt asset authority"
+          })
+        );
+      }
+      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([]);
+}
+
+export { AssetOutputProducerRegistry, ImporterRegistry, SHADER_RESERVED_IMPORTER_KEY, buildScriptablePack, createMaterialImportProduct, createScriptablePackStagedAssetSnapshotSource, createStandardAssetOutputProducerRegistry, finalizeImportProducts, materialAssetOutputProducer, materialImportProductReady, meshAssetOutputProducer, normaliseForPack, packMeshBinV4, runImport, sceneAssetOutputProducer };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map