@forgeax/engine-import 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -1,52 +1,41 @@
 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 { resolve, dirname } from 'path';
+import { upgradeLegacyAuthoredPack, 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 { projectScriptablePackMeta } from '@forgeax/engine-pack/source';
-import { componentSchema } from '@forgeax/engine-ecs/internal';
+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 invalid(field) {
+function invalidProduct(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",
+    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 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));
+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;
@@ -75,7 +64,7 @@ function concatBytes(chunks) {
 }
 async function productDigest(asset, artifacts) {
   const chunks = [
-    JSON.stringify(digestPayload(asset)),
+    JSON.stringify(projectImportedAssetPayload(asset)),
     JSON.stringify(asset.refs.map((ref2) => ref2.guid)),
     JSON.stringify(artifacts)
   ];
@@ -102,15 +91,15 @@ async function artifactDescriptors(artifacts) {
   }
   return Object.fromEntries(entries);
 }
-function digestPayload(asset) {
-  if (Object.keys(asset.artifacts).length === 0) return asset.payload;
+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 payload = asset.payload;
     const { data: _runtimeBytes, ...metadata } = payload;
     return metadata;
   }
-  return asset.payload;
+  return payload;
 }
 function finalizeImportProducts(product, inputFingerprint) {
   return (async () => {
@@ -498,10 +487,35 @@ async function runImport(meta, registry, fs) {
       })
     );
   }
+  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: productWithDependencies, cookProducts }
+      value: { product: terminalProduct.value, cookProducts }
     };
   }
   const assets = produced.map((a) => {
@@ -536,57 +550,28 @@ async function runImport(meta, registry, fs) {
   return {
     ok: true,
     value: {
-      product: {
-        ...productWithDependencies
-      },
+      product: terminalProduct.value,
       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()];
-  }
-};
+// 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",
@@ -842,7 +827,7 @@ function observedAssetReader(source) {
           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"
+            hint: "configure the standard ScriptablePack asset source or remove the content read"
           })
         );
       }
@@ -1036,8 +1021,7 @@ async function buildScriptablePack(options) {
     const product2 = await producer.produce({
       guid: AssetGuid.format(descriptor.guid),
       sourceKey,
-      asset,
-      ...options.components === void 0 ? {} : { components: options.components }
+      asset
     });
     if (!product2.ok) return err(product2.error);
     const productError = productContractError(sourceKey, descriptor.kind, product2.value);
@@ -1061,8 +1045,8 @@ async function buildScriptablePack(options) {
       (guid) => AssetGuid.format(guid).toLowerCase()
     )
   );
-  const closureError = externalClosureError(declared, referenced, read);
-  if (closureError !== void 0) return err(closureError);
+  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);
@@ -1077,19 +1061,38 @@ async function buildScriptablePack(options) {
     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),
+    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: product.value,
     stagedOutputs: await Promise.all(
       Object.keys(options.definition.assets).sort().map(async (sourceKey) => {
         const descriptor = options.definition.assets[sourceKey];
@@ -1109,6 +1112,8 @@ async function buildScriptablePack(options) {
     inputFingerprint
   });
 }
+
+// src/scriptable-pack-output-producers.ts
 function producerError(input, reason) {
   return new ImportError({
     code: "import-internal-error",
@@ -1192,17 +1197,6 @@ function materialProduct(input) {
     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;
@@ -1237,22 +1231,16 @@ function meshProduct(input) {
     }
   };
 }
-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) {
+function sceneProduct(input, components) {
   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);
+    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 {
@@ -1261,6 +1249,19 @@ function sceneProduct(input) {
     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",
@@ -1442,36 +1443,23 @@ function ordinaryPodProduct(input) {
       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 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));
 }
-var sceneAssetOutputProducer = {
-  kind: "scene",
-  version: "scene-pack/2",
-  produce(input) {
-    try {
-      return ok(sceneProduct(input));
-    } catch (error) {
-      return err(producerError(input, error));
-    }
-  }
-};
-function createStandardAssetOutputProducerRegistry() {
+function createStandardAssetOutputProducerRegistry(sceneComponents = []) {
   const registry = new AssetOutputProducerRegistry();
   registry.register(materialAssetOutputProducer);
   registry.register(meshAssetOutputProducer);
-  registry.register(sceneAssetOutputProducer);
+  registry.register(createSceneAssetOutputProducer(sceneComponents));
   for (const kind of [
     "texture",
     "equirect",
@@ -1487,7 +1475,7 @@ function createStandardAssetOutputProducerRegistry() {
     "audio",
     "particle-effect"
   ]) {
-    registry.register(createOrdinaryAssetOutputProducer(kind));
+    registry.register(createSafeProducer(kind, "ordinary-pod/1", ordinaryPodProduct));
   }
   return registry;
 }
@@ -1529,8 +1517,18 @@ function missingOutputError(owner, guid) {
   };
 }
 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 options.owners) {
+  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();
@@ -1550,12 +1548,11 @@ function createScriptablePackStagedAssetSnapshotSource(options) {
       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"
+            expected: "a staged local owner for the requested GUID",
+            hint: "declare the local ScriptablePack output before rebuilding the generation"
           })
         );
       }
@@ -1601,7 +1598,1170 @@ function createScriptablePackStagedAssetSnapshotSource(options) {
   });
   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
+  });
+}
+
+// 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 = []) {
+  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 !== "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);
+}
+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/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))
+    )
+  );
+  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);
+}
+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") {
+      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, ImporterRegistry, SHADER_RESERVED_IMPORTER_KEY, buildScriptablePack, createMaterialImportProduct, createScriptablePackStagedAssetSnapshotSource, createStandardAssetOutputProducerRegistry, finalizeImportProducts, materialAssetOutputProducer, materialImportProductReady, meshAssetOutputProducer, normaliseForPack, packMeshBinV4, runImport, sceneAssetOutputProducer };
+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