@plasius/asset-contracts 0.7.0 → 0.8.0

package/dist/index.js

@@ -5,8 +5,8 @@ import {
   SHADER_VALIDATION_EVIDENCE_VERSION,
   SUPPORTED_ADDITIVE_WEBGPU_MATRIX_POLICIES,
   SUPPORTED_STABLE_WEBGPU_MATRIX_POLICIES,
-  canonicalizeGpuContract as canonicalizeGpuContract3,
-  computeSha256 as computeSha2562,
+  canonicalizeGpuContract as canonicalizeGpuContract4,
+  computeSha256 as computeSha2563,
   parseGpuInterfaceManifest,
   parseJsonBytes,
   parseModelGpuCompatibilityDescriptor,
@@ -2797,7 +2797,7 @@ function requireEnum(value, allowed, fieldName) {
 }
 function requireReasonCodes(value, fieldName) {
   const entries = asDenseArray(value, fieldName, 0, 32);
-  const result = entries.map((entry, index) => requireReasonCode(entry, `${fieldName}[${index}]`));
+  const result = entries.map((entry2, index) => requireReasonCode(entry2, `${fieldName}[${index}]`));
   if (new Set(result).size !== result.length) throw new Error(`${fieldName} must not contain duplicates.`);
   return result;
 }
@@ -3119,7 +3119,7 @@ function createPvoxRuntimeRequestProfileV1(value) {
   const record2 = asRecord(value, fieldName);
   exactKeys(record2, ["profileId", "fidelityProfileId", "capabilityProfileId", "geometryMode", "requiredCapabilities", "limits"], fieldName);
   const requestedCapabilityEntries = asDenseArray(record2.requiredCapabilities, `${fieldName}.requiredCapabilities`, 1, PVOX_CAPABILITIES.length);
-  const requiredCapabilities = requestedCapabilityEntries.map((entry, index) => requireEnum(entry, PVOX_CAPABILITIES, `${fieldName}.requiredCapabilities[${index}]`));
+  const requiredCapabilities = requestedCapabilityEntries.map((entry2, index) => requireEnum(entry2, PVOX_CAPABILITIES, `${fieldName}.requiredCapabilities[${index}]`));
   if (new Set(requiredCapabilities).size !== requiredCapabilities.length) {
     throw new Error(`${fieldName}.requiredCapabilities must not contain duplicates.`);
   }
@@ -3282,7 +3282,7 @@ function createPvoxAssetManifestV1(input) {
   }
   if (expectedOffset !== artifact.byteLength) throw new Error("PvoxAssetManifestV1 pages must exactly cover the artifact bytes.");
   const lodEntries = asDenseArray(record2.lods, "PvoxAssetManifestV1.lods", 1, 4);
-  const lods = lodEntries.map((entry, index) => createLod(entry, index, pages.length));
+  const lods = lodEntries.map((entry2, index) => createLod(entry2, index, pages.length));
   for (const [index, current] of lods.entries()) {
     if (current.level !== index) throw new Error("PvoxAssetManifestV1 LOD levels must be contiguous from LOD0.");
     const previous = lods[index - 1];
@@ -3518,7 +3518,7 @@ function createPhysicalPropertyEvidence(input) {
   const reviewedBy = record2.reviewedBy === void 0 ? void 0 : requireToken(record2.reviewedBy, "PhysicalPropertyEvidence.reviewedBy");
   const reviewedAt = record2.reviewedAt === void 0 ? void 0 : requireTimestamp(record2.reviewedAt, "PhysicalPropertyEvidence.reviewedAt");
   const reviewToken = record2.reviewToken === void 0 ? void 0 : requireAttestation(record2.reviewToken, "PhysicalPropertyEvidence.reviewToken");
-  if (new Set([reviewedBy, reviewedAt, reviewToken].map((entry) => entry === void 0)).size !== 1) throw new Error("PhysicalPropertyEvidence signed review identity, timestamp, and token must be supplied together.");
+  if (new Set([reviewedBy, reviewedAt, reviewToken].map((entry2) => entry2 === void 0)).size !== 1) throw new Error("PhysicalPropertyEvidence signed review identity, timestamp, and token must be supplied together.");
   if (provenance === "inferred" && reviewedBy === void 0) throw new Error("Inferred PhysicalPropertyEvidence requires human review.");
   return deepFreeze2({
     property,
@@ -3541,9 +3541,9 @@ function createPvoxPhysicalRegionInventoryV1(input) {
   exactKeys(record2, ["inventoryVersion", "subjectContentHash", "inventoryHash", "inventoryHashAttestation", "validationEvidenceHash", "entries"], fieldName);
   if (record2.inventoryVersion !== PVOX_PHYSICAL_REGION_INVENTORY_VERSION) throw new Error(`${fieldName}.inventoryVersion is unsupported.`);
   const entriesInput = asDenseArray(record2.entries, `${fieldName}.entries`, 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions);
-  const entries = entriesInput.map((entry, index) => {
+  const entries = entriesInput.map((entry2, index) => {
     const entryName = `${fieldName}.entries[${index}]`;
-    const item = asRecord(entry, entryName);
+    const item = asRecord(entry2, entryName);
     exactKeys(item, ["regionIndex", "physicalPaletteIndex", "regionId", "materialId"], entryName);
     return {
       regionIndex: requireInteger(item.regionIndex, `${entryName}.regionIndex`, 0, PVOX_DEFAULT_LIMITS.maximumMaterialRegions - 1),
@@ -3552,7 +3552,7 @@ function createPvoxPhysicalRegionInventoryV1(input) {
       materialId: requireToken(item.materialId, `${entryName}.materialId`)
     };
   });
-  if (entries.some((entry, index) => entry.regionIndex !== index)) throw new Error(`${fieldName} regionIndex values must be contiguous and canonically ordered.`);
+  if (entries.some((entry2, index) => entry2.regionIndex !== index)) throw new Error(`${fieldName} regionIndex values must be contiguous and canonically ordered.`);
   const pairs = entries.map(({ regionId, materialId }) => `${regionId}\0${materialId}`);
   if (new Set(pairs).size !== pairs.length) throw new Error(`${fieldName} region/material pairs must be unique.`);
   const inventoryHash = requireSha256(record2.inventoryHash, `${fieldName}.inventoryHash`);
@@ -3689,9 +3689,9 @@ function createPvoxEditJournalCurrentState(input, baseManifest) {
   const record2 = asRecord(input, fieldName);
   exactKeys(record2, ["baseContentHash", "basePageSetHash", "placementId", "gridVersion", "revision", "rootHash", "latestJournalHash", "pageHashes"], fieldName);
   const pageEntries = asDenseArray(record2.pageHashes, `${fieldName}.pageHashes`, baseManifest.pages.length, baseManifest.pages.length);
-  const pageHashes = pageEntries.map((entry, index) => {
+  const pageHashes = pageEntries.map((entry2, index) => {
     const entryName = `${fieldName}.pageHashes[${index}]`;
-    const page = asRecord(entry, entryName);
+    const page = asRecord(entry2, entryName);
     exactKeys(page, ["pageIndex", "sha256"], entryName);
     const pageIndex = requireInteger(page.pageIndex, `${entryName}.pageIndex`, 0, baseManifest.pages.length - 1);
     if (pageIndex !== index) throw new Error(`${fieldName}.pageHashes must be complete and ordered by pageIndex.`);
@@ -3742,9 +3742,9 @@ function createPvoxEditJournal(input, baseManifestInput, currentStateInput) {
     }
   }
   const patchEntries = asDenseArray(record2.patches, "PvoxEditJournal.patches", 1, PVOX_MAX_EDIT_PATCHES);
-  const patches = patchEntries.map((entry, index) => {
+  const patches = patchEntries.map((entry2, index) => {
     const fieldName = `PvoxEditJournal.patches[${index}]`;
-    const patch = asRecord(entry, fieldName);
+    const patch = asRecord(entry2, fieldName);
     exactKeys(patch, ["fieldKind", "lodLevel", "partitionIndex", "hierarchyDepth", "mortonCode", "expectedPageIndex", "expectedPageHash", "operation", "expectedBrickHash", "resultingBrickHash", "resultingPageHash"], fieldName);
     const mortonCode = requireString(patch.mortonCode, `${fieldName}.mortonCode`, 16);
     if (!MORTON_CODE.test(mortonCode)) throw new Error(`${fieldName}.mortonCode must be a canonical Morton code.`);
@@ -3821,7 +3821,7 @@ function createPvoxEditJournalChain(input, baseManifestInput) {
   const journals = [];
   const operationIds = /* @__PURE__ */ new Set();
   const currentPageHashes = new Map(baseManifest.pages.map(({ pageIndex, sha256: sha2562 }) => [pageIndex, sha2562]));
-  for (const entry of entries) {
+  for (const entry2 of entries) {
     const previous = journals.at(-1);
     const currentState = previous === void 0 ? void 0 : {
       baseContentHash: previous.baseContentHash,
@@ -3833,7 +3833,7 @@ function createPvoxEditJournalChain(input, baseManifestInput) {
       latestJournalHash: previous.journalHash,
       pageHashes: baseManifest.pages.map(({ pageIndex }) => ({ pageIndex, sha256: currentPageHashes.get(pageIndex) }))
     };
-    const journal = createPvoxEditJournal(entry, baseManifest, currentState);
+    const journal = createPvoxEditJournal(entry2, baseManifest, currentState);
     if (previous === void 0 && (journal.expectedRevision !== 0 || journal.previousJournalHash !== PVOX_EDIT_JOURNAL_GENESIS_HASH)) {
       throw new Error("PvoxEditJournalChain must begin at the canonical genesis revision.");
     }
@@ -3891,10 +3891,10 @@ function createTransform2(value, fieldName) {
   exactKeys(record2, ["translationMetres", "rotationQuaternion", "scale"], fieldName);
   const translationMetres = requireVector(record2.translationMetres, `${fieldName}.translationMetres`);
   const rotationEntries = asDenseArray(record2.rotationQuaternion, `${fieldName}.rotationQuaternion`, 4, 4);
-  const rotationQuaternion = rotationEntries.map((entry, index) => requireNumber(entry, `${fieldName}.rotationQuaternion[${index}]`, -1, 1));
+  const rotationQuaternion = rotationEntries.map((entry2, index) => requireNumber(entry2, `${fieldName}.rotationQuaternion[${index}]`, -1, 1));
   if (Math.abs(Math.hypot(...rotationQuaternion) - 1) > 1e-4) throw new Error(`${fieldName}.rotationQuaternion must be normalized.`);
   const scale = requireVector(record2.scale, `${fieldName}.scale`);
-  if (scale.some((entry) => entry <= 0)) throw new Error(`${fieldName}.scale values must be positive.`);
+  if (scale.some((entry2) => entry2 <= 0)) throw new Error(`${fieldName}.scale values must be positive.`);
   return { translationMetres, rotationQuaternion, scale };
 }
 function createAssemblyChild2(value, index, resolutionId, candidateId) {
@@ -4062,10 +4062,10 @@ function createModelProcessingManifestV2(input) {
   }
   const capabilityEntries = asDenseArray(record2.capabilities, "ModelProcessingManifestV2.capabilities", PVOX_CAPABILITIES.length, PVOX_CAPABILITIES.length);
   const capabilities = capabilityEntries.map(createVoxelCapabilityAssessment);
-  const byCapability = new Map(capabilities.map((entry) => [entry.capability, entry]));
+  const byCapability = new Map(capabilities.map((entry2) => [entry2.capability, entry2]));
   if (byCapability.size !== PVOX_CAPABILITIES.length || PVOX_CAPABILITIES.some((name) => !byCapability.has(name))) throw new Error("ModelProcessingManifestV2 must include every PVOX capability exactly once.");
   const orderedCapabilities = PVOX_CAPABILITIES.map((name) => byCapability.get(name));
-  if (orderedCapabilities.some((entry) => entry.subjectContentHash !== binaryClosureHash)) throw new Error("ModelProcessingManifestV2 capability evidence must bind the binaryClosureHash.");
+  if (orderedCapabilities.some((entry2) => entry2.subjectContentHash !== binaryClosureHash)) throw new Error("ModelProcessingManifestV2 capability evidence must bind the binaryClosureHash.");
   const capabilityEvidenceSetHash = requireSha256(record2.capabilityEvidenceSetHash, "ModelProcessingManifestV2.capabilityEvidenceSetHash");
   const capabilityEvidenceSetAttestation = createHashAttestation(
     record2.capabilityEvidenceSetAttestation,
@@ -4074,7 +4074,7 @@ function createModelProcessingManifestV2(input) {
     "ModelProcessingManifestV2.capabilityEvidenceSetAttestation"
   );
   const requiredCapabilityEntries = asDenseArray(record2.requiredCapabilities, "ModelProcessingManifestV2.requiredCapabilities", 1, PVOX_CAPABILITIES.length);
-  const requiredCapabilities = requiredCapabilityEntries.map((entry, index) => requireEnum(entry, PVOX_CAPABILITIES, `ModelProcessingManifestV2.requiredCapabilities[${index}]`));
+  const requiredCapabilities = requiredCapabilityEntries.map((entry2, index) => requireEnum(entry2, PVOX_CAPABILITIES, `ModelProcessingManifestV2.requiredCapabilities[${index}]`));
   if (new Set(requiredCapabilities).size !== requiredCapabilities.length) throw new Error("ModelProcessingManifestV2.requiredCapabilities must be unique.");
   if (!requiredCapabilities.includes("rendering")) throw new Error("ModelProcessingManifestV2 rendering capability is always required.");
   if (technicalProfile.hasCollision !== (byCapability.get("collision")?.status === "supported")) throw new Error("ModelProcessingManifestV2 collision capability must match technicalProfile.hasCollision.");
@@ -4087,9 +4087,9 @@ function createModelProcessingManifestV2(input) {
   }
   const physicalEntries = asDenseArray(record2.physicalProperties, "ModelProcessingManifestV2.physicalProperties", 0, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries);
   const physicalProperties = physicalEntries.map(createPhysicalPropertyEvidence);
-  const byRegionProperty = new Map(physicalProperties.map((entry) => [`${entry.regionId}\0${entry.materialId}\0${entry.property}`, entry]));
+  const byRegionProperty = new Map(physicalProperties.map((entry2) => [`${entry2.regionId}\0${entry2.materialId}\0${entry2.property}`, entry2]));
   if (byRegionProperty.size !== physicalProperties.length) throw new Error("ModelProcessingManifestV2 physical properties must be unique per region, material, and property.");
-  if (physicalProperties.some((entry) => entry.subjectContentHash !== binaryClosureHash)) throw new Error("ModelProcessingManifestV2 physical evidence must bind the PVOX binary closure subject.");
+  if (physicalProperties.some((entry2) => entry2.subjectContentHash !== binaryClosureHash)) throw new Error("ModelProcessingManifestV2 physical evidence must bind the PVOX binary closure subject.");
   const authoritativePairs = physicalRegionInventory.entries.map(({ regionId, materialId }) => `${regionId}\0${materialId}`);
   const authoritativePairSet = new Set(authoritativePairs);
   if (physicalProperties.some(({ regionId, materialId }) => !authoritativePairSet.has(`${regionId}\0${materialId}`))) {
@@ -4171,7 +4171,7 @@ function createModelProcessingManifestV2(input) {
     throw new Error("ModelProcessingManifestV2 fidelity evidence must exactly match every governed PVOX LOD0 metric.");
   }
   const childEntries = asDenseArray(record2.children, "ModelProcessingManifestV2.children", 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren);
-  const children = childEntries.map((entry, index) => createAssemblyChild2(entry, index, resolutionId, candidateId));
+  const children = childEntries.map((entry2, index) => createAssemblyChild2(entry2, index, resolutionId, candidateId));
   const kind = requireEnum(record2.kind, ["leaf", "assembly"], "ModelProcessingManifestV2.kind");
   if (kind === "leaf" && children.length !== 0) throw new Error("A leaf ModelProcessingManifestV2 cannot contain children.");
   if (kind === "leaf" && technicalProfile.partitionCount !== 1) throw new Error("A leaf ModelProcessingManifestV2 must have one partition.");
@@ -4254,9 +4254,9 @@ function createCandidateAssetRef2(value) {
 }
 function createViews(value, resolutionId, candidateId) {
   const entries = asDenseArray(value, "ModelCandidateV2.views", 4, 4);
-  const parsed = entries.map((entry, index) => {
+  const parsed = entries.map((entry2, index) => {
     const fieldName = `ModelCandidateV2.views[${index}]`;
-    const record2 = asRecord(entry, fieldName);
+    const record2 = asRecord(entry2, fieldName);
     exactKeys(record2, ["kind", "imageUri", "sha256", "contentType", "width", "height"], fieldName);
     const kind = requireEnum(record2.kind, MODEL_CONFIRMATION_VIEW_KINDS, `${fieldName}.kind`);
     const expectedUri = `mcp://models/resolutions/${resolutionId}/candidates/${candidateId}/${kind}.png`;
@@ -4264,7 +4264,7 @@ function createViews(value, resolutionId, candidateId) {
     if (record2.contentType !== "image/png" || record2.width !== MODEL_CONFIRMATION_VIEW_SIZE_PX || record2.height !== MODEL_CONFIRMATION_VIEW_SIZE_PX) throw new Error(`${fieldName} must be an authenticated 1024x1024 PNG.`);
     return { kind, imageUri: expectedUri, sha256: requireSha256(record2.sha256, `${fieldName}.sha256`), contentType: "image/png", width: MODEL_CONFIRMATION_VIEW_SIZE_PX, height: MODEL_CONFIRMATION_VIEW_SIZE_PX };
   });
-  if (parsed.some((entry, index) => entry.kind !== MODEL_CONFIRMATION_VIEW_KINDS[index])) throw new Error("ModelCandidateV2.views must be ordered front, left, top, isometric.");
+  if (parsed.some((entry2, index) => entry2.kind !== MODEL_CONFIRMATION_VIEW_KINDS[index])) throw new Error("ModelCandidateV2.views must be ordered front, left, top, isometric.");
   return parsed;
 }
 function createRenderEvidence2(value) {
@@ -4463,7 +4463,7 @@ function createModelCandidateV2(input) {
   );
   const gateEntries = asDenseArray(record2.hardGates, "ModelCandidateV2.hardGates", PVOX_NON_OVERRIDABLE_GATE_KINDS.length, PVOX_NON_OVERRIDABLE_GATE_KINDS.length);
   const gates = gateEntries.map(createPvoxGateEvidence);
-  const byGate = new Map(gates.map((entry) => [entry.kind, entry]));
+  const byGate = new Map(gates.map((entry2) => [entry2.kind, entry2]));
   if (byGate.size !== PVOX_NON_OVERRIDABLE_GATE_KINDS.length || PVOX_NON_OVERRIDABLE_GATE_KINDS.some((kind) => !byGate.has(kind))) throw new Error("ModelCandidateV2 must contain every non-overridable hard gate exactly once.");
   const orderedGates = PVOX_NON_OVERRIDABLE_GATE_KINDS.map((kind) => byGate.get(kind));
   const concreteGateHashes = {
@@ -4486,7 +4486,7 @@ function createModelCandidateV2(input) {
     ...!match.hardConstraintPass ? ["semantic-hard-constraints-failed"] : [],
     ...!["allowed", "attribution-required"].includes(rights.status) ? [`rights:${rights.status}`] : [],
     ...processingManifest.requiredCapabilities.flatMap((capability) => {
-      const evidence = processingManifest.capabilities.find((entry) => entry.capability === capability);
+      const evidence = processingManifest.capabilities.find((entry2) => entry2.capability === capability);
       return evidence.status === "supported" ? [] : [`capability:${capability}:${evidence.status}`];
     }),
     ...orderedGates.flatMap((gate) => gate.outcome === "passed" ? [] : gate.reasonCodes.map((reason) => `${gate.kind}:${reason}`))
@@ -4514,7 +4514,7 @@ function createModelCandidateV2(input) {
     if (record2.confirmationRequired !== false) throw new Error("Diagnostic ModelCandidateV2 confirmationRequired must be false.");
     if (record2.blockingReasonCodes !== void 0) {
       const suppliedEntries = asDenseArray(record2.blockingReasonCodes, "ModelCandidateV2.blockingReasonCodes", 1, 256);
-      const suppliedBlockingReasons = suppliedEntries.map((entry, index) => requireReasonCode(entry, `ModelCandidateV2.blockingReasonCodes[${index}]`));
+      const suppliedBlockingReasons = suppliedEntries.map((entry2, index) => requireReasonCode(entry2, `ModelCandidateV2.blockingReasonCodes[${index}]`));
       if (JSON.stringify(suppliedBlockingReasons) !== JSON.stringify(blockingReasonCodes)) throw new Error("Diagnostic ModelCandidateV2 blockingReasonCodes must be derived from its evidence.");
     }
     return deepFreeze2({ ...common, admissionStatus: "diagnostic", blockingReasonCodes, confirmationRequired: false });
@@ -4568,7 +4568,7 @@ function createModelCandidateV2(input) {
   });
 }
 function isModelCandidateV2Confirmable(candidate) {
-  return candidate.admissionStatus === "confirmable" && candidate.confirmationRequired && candidate.match.hardConstraintPass && candidate.match.assurance !== "none" && (candidate.rights.status === "allowed" || candidate.rights.status === "attribution-required") && candidate.processingManifest.fidelity.outcome === "passed" && candidate.hardGates.length === PVOX_NON_OVERRIDABLE_GATE_KINDS.length && candidate.hardGates.every(({ outcome }) => outcome === "passed") && candidate.processingManifest.requiredCapabilities.every((name) => candidate.processingManifest.capabilities.find((entry) => entry.capability === name)?.status === "supported");
+  return candidate.admissionStatus === "confirmable" && candidate.confirmationRequired && candidate.match.hardConstraintPass && candidate.match.assurance !== "none" && (candidate.rights.status === "allowed" || candidate.rights.status === "attribution-required") && candidate.processingManifest.fidelity.outcome === "passed" && candidate.hardGates.length === PVOX_NON_OVERRIDABLE_GATE_KINDS.length && candidate.hardGates.every(({ outcome }) => outcome === "passed") && candidate.processingManifest.requiredCapabilities.every((name) => candidate.processingManifest.capabilities.find((entry2) => entry2.capability === name)?.status === "supported");
 }
 function createModelCandidateConfirmationV2(input, expectedCandidate, expectedResolutionId) {
   const record2 = asRecord(input, "ModelCandidateConfirmationV2");
@@ -4665,7 +4665,7 @@ function createModelPromotionReceiptV2(input, resolutionId, candidate, confirmat
   const candidateAssetRef = createCandidateAssetRef2(record2.candidateAssetRef);
   if (JSON.stringify(candidateAssetRef) !== JSON.stringify(candidate.assetRef)) throw new Error("ModelPromotionReceiptV2 must bind the exact proposed candidate identity.");
   const childClosureEntries = asDenseArray(record2.assemblyChildClosureHashes, "ModelPromotionReceiptV2.assemblyChildClosureHashes", 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren);
-  const assemblyChildClosureHashes = childClosureEntries.map((entry, index) => requireSha256(entry, `ModelPromotionReceiptV2.assemblyChildClosureHashes[${index}]`));
+  const assemblyChildClosureHashes = childClosureEntries.map((entry2, index) => requireSha256(entry2, `ModelPromotionReceiptV2.assemblyChildClosureHashes[${index}]`));
   const expectedChildClosureHashes = candidate.processingManifest.children.map(({ assetRef }) => assetRef.binaryClosureHash);
   if (JSON.stringify(assemblyChildClosureHashes) !== JSON.stringify(expectedChildClosureHashes)) throw new Error("ModelPromotionReceiptV2 child closure sequence must match the canonical assembly order.");
   assertDataOnlyTree(record2.finalAssetRef, "ModelPromotionReceiptV2.finalAssetRef");
@@ -4926,12 +4926,12 @@ function copyPvoxByteInput(value, fieldName, maximumByteLength) {
   if (!(value instanceof Uint8Array)) throw new Error(`${fieldName} must be a Uint8Array.`);
   let byteLength;
   try {
-    const typedArrayPrototype2 = Object.getPrototypeOf(Uint8Array.prototype);
-    const byteLengthGetter2 = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "byteLength")?.get;
-    const bufferGetter2 = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "buffer")?.get;
-    if (byteLengthGetter2 === void 0 || bufferGetter2 === void 0) throw new Error("Typed-array intrinsics are unavailable.");
-    byteLength = byteLengthGetter2.call(value);
-    const buffer = bufferGetter2.call(value);
+    const typedArrayPrototype3 = Object.getPrototypeOf(Uint8Array.prototype);
+    const byteLengthGetter3 = Object.getOwnPropertyDescriptor(typedArrayPrototype3, "byteLength")?.get;
+    const bufferGetter3 = Object.getOwnPropertyDescriptor(typedArrayPrototype3, "buffer")?.get;
+    if (byteLengthGetter3 === void 0 || bufferGetter3 === void 0) throw new Error("Typed-array intrinsics are unavailable.");
+    byteLength = byteLengthGetter3.call(value);
+    const buffer = bufferGetter3.call(value);
     if (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer) {
       throw new Error(`${fieldName} must not use shared mutable storage.`);
     }
@@ -6701,9 +6701,9 @@ function snapshot(value, budget, depth = 0) {
     return value;
   }
   if (Array.isArray(value)) return Object.freeze(list(value).map((item) => snapshot(item, budget, depth + 1)));
-  const fields3 = record(value);
-  for (const key of Object.keys(fields3)) fields3[key] = snapshot(fields3[key], budget, depth + 1);
-  return Object.freeze(fields3);
+  const fields4 = record(value);
+  for (const key of Object.keys(fields4)) fields4[key] = snapshot(fields4[key], budget, depth + 1);
+  return Object.freeze(fields4);
 }
 function path(value) {
   if (typeof value !== "string" || value.length > 1024 || !value.length) fail();
@@ -6775,14 +6775,14 @@ async function qualify(input) {
     contentType(file.contentType);
   }
   const entries = list(inventory.entries).map(record);
-  uniquePaths(entries.map((entry) => path(entry.path)));
+  uniquePaths(entries.map((entry2) => path(entry2.path)));
   const ids = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    if (Object.keys(entry).some((key) => !["id", "path", "role", "contentType"].includes(key)) || typeof entry.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(entry.id) || ids.has(entry.id) || !["mesh", "material", "texture", "animation", "auxiliary"].includes(entry.role)) fail();
-    ids.add(entry.id);
-    const descriptor = descriptors.get(entry.path);
+  for (const entry2 of entries) {
+    if (Object.keys(entry2).some((key) => !["id", "path", "role", "contentType"].includes(key)) || typeof entry2.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(entry2.id) || ids.has(entry2.id) || !["mesh", "material", "texture", "animation", "auxiliary"].includes(entry2.role)) fail();
+    ids.add(entry2.id);
+    const descriptor = descriptors.get(entry2.path);
     if (!descriptor) fail("inventory-mismatch");
-    if (entry.contentType !== void 0 && contentType(entry.contentType) !== descriptor.contentType) fail("content-mismatch");
+    if (entry2.contentType !== void 0 && contentType(entry2.contentType) !== descriptor.contentType) fail("content-mismatch");
   }
   if (entries.length !== descriptors.size) fail("inventory-mismatch");
   const payloads = list(root.files).map((value) => {
@@ -6925,12 +6925,12 @@ async function qualifyModelTextureResources(input, options = {}) {
     ]);
     check();
     const files = new Map(manifest.files.map((file) => [file.path, file]));
-    const roles = new Map(inventory.entries.map((entry) => [entry.path, entry.role]));
-    for (const entry of inventory.entries) storageRole(entry.role, files.get(entry.path));
+    const roles = new Map(inventory.entries.map((entry2) => [entry2.path, entry2.role]));
+    for (const entry2 of inventory.entries) storageRole(entry2.role, files.get(entry2.path));
     const resources = new Map(graph.nodes.filter((node) => node.kind === "resource").map((node) => [node.id, node.value]));
     if (bindings.length !== resources.size || new Set(bindings.map((b) => b.resourceId)).size !== bindings.length) fail2("resource-mismatch");
     const resourceFiles = /* @__PURE__ */ new Set();
-    const qualified = bindings.map((binding) => {
+    const qualified2 = bindings.map((binding) => {
       const value = resources.get(binding.resourceId);
       const file = files.get(binding.filePath);
       if (!value || !file) fail2("resource-mismatch");
@@ -6963,7 +6963,7 @@ async function qualifyModelTextureResources(input, options = {}) {
       contractVersion: 1,
       manifest,
       source: source.value,
-      resources: Object.freeze(qualified.sort((a, b) => compare(a.resourceId, b.resourceId))),
+      resources: Object.freeze(qualified2.sort((a, b) => compare(a.resourceId, b.resourceId))),
       materials: Object.freeze(materials),
       textures: Object.freeze(textures),
       derived: Object.freeze(derived.sort((a, b) => compare(a.filePath, b.filePath)))
@@ -6982,6 +6982,9 @@ function tokenPath(value) {
   return value;
 }
 
+// src/model-resource-promotion.ts
+import { canonicalizeGpuContract as canonicalizeGpuContract3, computeSha256 as computeSha2562 } from "@plasius/gpu-shader";
+
 // src/model-conversion-diagnostics.ts
 var MODEL_CONVERSION_DIAGNOSTIC_LIMITS = Object.freeze({ issues: 100, resources: 100, values: 16384, depth: 12, string: 2048, characters: 262144, timeoutMs: 6e4 });
 var ModelConversionDiagnosticsError = class extends TypeError {
@@ -7074,9 +7077,9 @@ async function qualifyModelConversionDiagnostics(input, options = {}) {
       only(binding, ["path", "resource"]);
       if (typeof binding.path !== "string" || !binding.path.startsWith("/") || binding.path === "/" || resources.has(binding.path)) fail3();
       const resource = createModelResourceRef(binding.resource);
-      const identity = JSON.stringify(resource);
-      if (identities.has(resource.uri) && identities.get(resource.uri) !== identity) fail3();
-      identities.set(resource.uri, identity);
+      const identity2 = JSON.stringify(resource);
+      if (identities.has(resource.uri) && identities.get(resource.uri) !== identity2) fail3();
+      identities.set(resource.uri, identity2);
       resources.set(binding.path, resource);
     }
     check();
@@ -7129,6 +7132,193 @@ async function qualifyModelConversionDiagnostics(input, options = {}) {
   }
 }
 
+// src/model-resource-promotion.ts
+var MODEL_RESOURCE_PROMOTION_LIMITS = Object.freeze({ bindings: 1024, values: 262144, characters: 2097152, depth: 24, timeoutMs: 6e4 });
+var ModelResourcePromotionError = class extends TypeError {
+  constructor(code) {
+    super(`Invalid model resource promotion: ${code}`);
+    this.code = code;
+    this.name = "ModelResourcePromotionError";
+  }
+  code;
+};
+var qualified = /* @__PURE__ */ new WeakSet();
+function fail4(code = "invalid-input") {
+  throw new ModelResourcePromotionError(code);
+}
+function fields3(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail4();
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > 1024) fail4("limit-exceeded");
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string" || key.length > 128 || ["__proto__", "constructor", "prototype"].includes(key) || allowed && !allowed.includes(key)) fail4();
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in property) || !property.enumerable) fail4();
+    result[key] = property.value;
+  }
+  return result;
+}
+function array2(value, maximum) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) fail4();
+  if (value.length > maximum) fail4("limit-exceeded");
+  if (Reflect.ownKeys(value).length !== value.length + 1) fail4();
+  return Array.from({ length: value.length }, (_, i) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) fail4();
+    return descriptor.value;
+  });
+}
+function snapshot4(value, budget, depth = 0) {
+  if (--budget.values < 0 || depth > MODEL_RESOURCE_PROMOTION_LIMITS.depth) fail4("limit-exceeded");
+  if (value === null || value === void 0 || typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    budget.characters -= value.length;
+    if (value.length > 2048 || budget.characters < 0) fail4("limit-exceeded");
+    return value;
+  }
+  if (Array.isArray(value)) return Object.freeze(array2(value, MODEL_RESOURCE_MANIFEST_LIMITS.files).map((v) => snapshot4(v, budget, depth + 1)));
+  const result = fields3(value);
+  for (const key of Object.keys(result)) {
+    budget.characters -= key.length;
+    if (budget.characters < 0) fail4("limit-exceeded");
+    result[key] = snapshot4(result[key], budget, depth + 1);
+  }
+  return Object.freeze(result);
+}
+var typedArrayPrototype2 = Object.getPrototypeOf(Uint8Array.prototype);
+var byteLengthGetter2 = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "byteLength").get;
+var bufferGetter2 = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "buffer").get;
+function copyFiles(value) {
+  let total = 0;
+  const files = array2(value, MODEL_RESOURCE_MANIFEST_LIMITS.files).map((v) => {
+    const file = fields3(v, ["path", "bytes", "contentType"]);
+    const bytes = file.bytes;
+    if (typeof file.path !== "string" || typeof file.contentType !== "string" || !(bytes instanceof Uint8Array) || Object.getPrototypeOf(bytes) !== Uint8Array.prototype || !(bufferGetter2.call(bytes) instanceof ArrayBuffer)) fail4();
+    const length = byteLengthGetter2.call(bytes);
+    total += length;
+    if (length > MODEL_RESOURCE_MANIFEST_LIMITS.fileBytes || total > MODEL_RESOURCE_MANIFEST_LIMITS.totalBytes) fail4("limit-exceeded");
+    return { path: file.path, bytes, contentType: file.contentType };
+  });
+  return files.map((f) => ({ ...f, bytes: new Uint8Array(f.bytes) }));
+}
+var same = (a, b) => canonicalizeGpuContract3(a) === canonicalizeGpuContract3(b);
+var entry = (m) => m.files.find((f) => f.path === m.entrypoint);
+var identity = (m) => `${m.assetId}/${m.version}`;
+async function createModelResourcePromotionRecord(input, options = {}) {
+  let timer;
+  let signal;
+  let onAbort;
+  try {
+    const started = performance.now();
+    const controls = fields3(options, ["signal", "timeoutMs"]);
+    const timeoutMs = controls.timeoutMs === void 0 ? 1e4 : controls.timeoutMs;
+    if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MODEL_RESOURCE_PROMOTION_LIMITS.timeoutMs) fail4();
+    signal = controls.signal;
+    const aborted = Object.getOwnPropertyDescriptor(AbortSignal.prototype, "aborted").get;
+    const check = () => {
+      if (signal !== void 0 && aborted.call(signal)) fail4("aborted");
+      if (performance.now() - started >= timeoutMs) fail4("deadline-exceeded");
+    };
+    check();
+    const root = fields3(input, ["promotion", "source", "output", "diagnostics", "resourceBindings", "candidate", "confirmation", "rollback"]);
+    const budget = { values: MODEL_RESOURCE_PROMOTION_LIMITS.values, characters: MODEL_RESOURCE_PROMOTION_LIMITS.characters };
+    const snap = (v) => snapshot4(v, budget);
+    const promotionInput = snap(root.promotion);
+    const sourceInput = fields3(root.source, ["manifest", "packageManifest", "files"]);
+    const outputInput = fields3(root.output, ["manifest", "packageManifest", "files", "graph", "resources", "derived"]);
+    const sourceMetadata = { manifest: snap(sourceInput.manifest), packageManifest: snap(sourceInput.packageManifest) };
+    const outputMetadata = {
+      manifest: snap(outputInput.manifest),
+      packageManifest: snap(outputInput.packageManifest),
+      graph: outputInput.graph,
+      resources: snap(outputInput.resources),
+      derived: snap(outputInput.derived)
+    };
+    const rawDiagnostics = snap(root.diagnostics);
+    const candidate = createModelCandidate(snap(root.candidate));
+    const confirmation = createModelCandidateConfirmation(snap(root.confirmation), candidate, candidate.resolutionId);
+    const bindings = array2(snap(root.resourceBindings), MODEL_RESOURCE_PROMOTION_LIMITS.bindings).map((v) => {
+      const b = fields3(v, ["resource", "package", "filePath"]);
+      if (b.package !== "source" && b.package !== "output" || typeof b.filePath !== "string") fail4();
+      return Object.freeze({ resource: createModelResourceRef(b.resource), package: b.package, filePath: b.filePath });
+    }).sort((a, b) => a.resource.uri < b.resource.uri ? -1 : a.resource.uri > b.resource.uri ? 1 : 0);
+    const history = root.rollback === void 0 ? void 0 : fields3(root.rollback, ["prior", "current"]);
+    if (history && (!qualified.has(history.prior) || !qualified.has(history.current))) fail4("rollback-mismatch");
+    const prior = history?.prior;
+    const current = history?.current;
+    const sourceFiles = copyFiles(sourceInput.files);
+    const outputFiles = copyFiles(outputInput.files);
+    check();
+    const interrupted = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => reject(new ModelResourcePromotionError("deadline-exceeded")), Math.max(1, timeoutMs - (performance.now() - started)));
+      onAbort = () => reject(new ModelResourcePromotionError("aborted"));
+      if (signal) AbortSignal.prototype.addEventListener.call(signal, "abort", onAbort, { once: true });
+    });
+    const work = async () => {
+      const source = await qualifyModelResourceManifest({ ...sourceMetadata, files: sourceFiles, signal, timeoutMs });
+      check();
+      const output = await qualifyModelTextureResources({ ...outputMetadata, files: outputFiles }, { signal, timeoutMs });
+      check();
+      const diagnostics = await qualifyModelConversionDiagnostics(rawDiagnostics, { signal, timeoutMs });
+      check();
+      assertImmutableAssetVersion(source.version);
+      assertImmutableAssetVersion(output.manifest.version);
+      if (identity(source) === identity(output.manifest) || !same(output.manifest, createModelAssetManifest({ ...promotionInput.manifest, files: [...promotionInput.manifest.files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0) })) || output.manifest.assetKind !== "model") fail4("package-mismatch");
+      const converter = candidate.processingManifest.converter;
+      if (!diagnostics.technicalAccepted || !same(diagnostics.source, candidate.provenance) || diagnostics.source.contentHash !== entry(source).sha256 || output.source.sourceContentHash !== entry(source).sha256 || converter.sourceContentHash !== entry(source).sha256 || converter.outputContentHash !== entry(output.manifest).sha256 || converter.id !== output.source.converterId || converter.version !== output.source.converterVersion || converter.sourceFormat !== output.source.sourceFormat || !same(diagnostics.converter.diagnostics, converter.diagnostics) || !same(diagnostics.converter.losses, converter.losses)) fail4("evidence-mismatch");
+      const byUri = /* @__PURE__ */ new Map();
+      for (const binding of bindings) {
+        const file = (binding.package === "source" ? source : output.manifest).files.find((f) => f.path === binding.filePath);
+        if (!file || byUri.has(binding.resource.uri) || file.sha256 !== binding.resource.sha256 || file.byteLength !== binding.resource.byteLength || file.contentType !== binding.resource.contentType) fail4("evidence-mismatch");
+        byUri.set(binding.resource.uri, binding);
+      }
+      const requireResource = (resource, outputOnly = false) => {
+        const binding = byUri.get(resource.uri);
+        if (!binding || !same(binding.resource, resource) || outputOnly && binding.package !== "output") fail4("evidence-mismatch");
+        return binding;
+      };
+      for (const d of diagnostics.diagnostics) if (d.resource) requireResource(d.resource);
+      for (const lod of candidate.processingManifest.lods) requireResource(lod.resource, true);
+      if (candidate.processingManifest.collision.resource) requireResource(candidate.processingManifest.collision.resource, true);
+      for (const f of candidate.processingManifest.fidelityEvidence) if (f.evidenceResource) requireResource(f.evidenceResource, true);
+      if (requireResource(candidate.processingManifest.lods[0].resource, true).filePath !== output.manifest.entrypoint) fail4("evidence-mismatch");
+      if (candidate.assetRef.disposition === "existing" && (candidate.assetRef.asset.assetId !== output.manifest.assetId || candidate.assetRef.asset.version !== output.manifest.version)) fail4("evidence-mismatch");
+      if (promotionInput.sourceAdapter !== output.manifest.sourceAdapter || promotionInput.reviewReport.passed !== true || promotionInput.reviewReport.findings.some((f) => f.severity === "blocking")) fail4("gate-blocked");
+      const expectedSuffix = `/${output.manifest.assetId}/${output.manifest.version}/${output.manifest.entrypoint}`;
+      const runtimeUri = new URL(promotionInput.runtimeManifestUri);
+      if (!runtimeUri.pathname.endsWith(expectedSuffix)) fail4("evidence-mismatch");
+      const promotion = await createGpuAssetPromotionRecord(promotionInput, new Map(outputFiles.map((f) => [f.path, f.bytes])));
+      check();
+      const closure = { contractVersion: 1, source, output, diagnostics, resourceBindings: Object.freeze(bindings), candidate, confirmation };
+      const closureHash = await computeSha2562(new TextEncoder().encode(canonicalizeGpuContract3({ contractVersion: 1, source, output, diagnostics, resourceBindings: bindings })));
+      check();
+      let rollback;
+      if (promotion.outcome === "rolled-back") {
+        if (!prior || !current || prior.promotion.assetId !== promotion.assetId || current.promotion.assetId !== promotion.assetId || prior.promotion.runtimeChannel !== promotion.runtimeChannel || current.promotion.runtimeChannel !== promotion.runtimeChannel || promotion.version !== prior.promotion.version || promotion.version === current.promotion.version || promotion.rollbackOfVersion !== current.promotion.version || closureHash !== prior.closureHash || !same(promotion.manifest, prior.promotion.manifest) || promotion.runtimeManifestUri !== prior.promotion.runtimeManifestUri) fail4("rollback-mismatch");
+        rollback = Object.freeze({ fromVersion: current.promotion.version, fromClosureHash: current.closureHash, toVersion: prior.promotion.version, toClosureHash: prior.closureHash });
+      } else if (history || promotion.rollbackOfVersion !== void 0) fail4("rollback-mismatch");
+      const result = Object.freeze({ ...closure, promotion, closureHash, ...rollback ? { rollback } : {} });
+      qualified.add(result);
+      return result;
+    };
+    return await Promise.race([work(), interrupted]);
+  } catch (error) {
+    let code;
+    try {
+      code = Object.getOwnPropertyDescriptor(error, "code")?.value;
+    } catch {
+      return fail4();
+    }
+    if (["invalid-input", "limit-exceeded", "package-mismatch", "evidence-mismatch", "gate-blocked", "rollback-mismatch", "aborted", "deadline-exceeded"].includes(code)) return fail4(code);
+    return fail4();
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (signal && onAbort) AbortSignal.prototype.removeEventListener.call(signal, "abort", onAbort);
+  }
+}
+
 // src/index.ts
 var ASSET_CONTRACTS_PACKAGE = "@plasius/asset-contracts";
 var UNIFIED_ASSET_PIPELINE_FEATURE_FLAG_ID = "asset.pipeline.unified-ai-assets.enabled";
@@ -7530,7 +7720,7 @@ async function validateGpuAssetFiles(input) {
     if (bytes.byteLength !== file.byteLength) {
       throw new Error(`GPU asset file ${file.path} byte length differs from its descriptor.`);
     }
-    if (await computeSha2562(bytes) !== file.sha256) {
+    if (await computeSha2563(bytes) !== file.sha256) {
       throw new Error(`GPU asset file ${file.path} digest differs from its descriptor.`);
     }
     if (file.contentType === ASSET_JSON_CONTENT_TYPE) {
@@ -7550,7 +7740,7 @@ async function validateGpuAssetFiles(input) {
   const expectedDomainManifest = domainManifestForAsset(manifest);
   if (expectedDomainManifest !== null) {
     const parsedEntrypoint = parseJsonBytes(entrypointBytes, "GPU asset manifest entrypoint");
-    if (canonicalizeGpuContract3(parsedEntrypoint) !== canonicalizeGpuContract3(expectedDomainManifest)) {
+    if (canonicalizeGpuContract4(parsedEntrypoint) !== canonicalizeGpuContract4(expectedDomainManifest)) {
       throw new Error("GPU asset entrypoint bytes differ from the validated domain manifest.");
     }
   } else if (manifest.assetKind === "shader-validation-evidence") {
@@ -7797,7 +7987,7 @@ function assertEvidenceEntrypointIdentity(value, ref2) {
 function assertCanonicalJsonBytes(bytes, fieldName) {
   const value = parseJsonBytes(bytes, fieldName);
   const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  if (canonicalizeGpuContract3(value) !== text) {
+  if (canonicalizeGpuContract4(value) !== text) {
     throw new Error(`${fieldName} must use canonical JSON serialization.`);
   }
 }
@@ -7807,10 +7997,10 @@ async function bindDomainManifestBytes(bytes, manifest, fieldName) {
   }
   assertCanonicalJsonBytes(bytes, `${fieldName} manifest`);
   const parsed = parseJsonBytes(bytes, `${fieldName} manifest`);
-  if (canonicalizeGpuContract3(parsed) !== canonicalizeGpuContract3(manifest)) {
+  if (canonicalizeGpuContract4(parsed) !== canonicalizeGpuContract4(manifest)) {
     throw new Error(`${fieldName} manifest bytes differ from the supplied manifest.`);
   }
-  return computeSha2562(bytes);
+  return computeSha2563(bytes);
 }
 function assertRoleCount(manifest, role, expectedCount) {
   if (manifest.files.filter((file) => file.role === role).length !== expectedCount) {
@@ -7931,11 +8121,13 @@ export {
   MODEL_RESOLUTION_V2_JSON_SCHEMAS,
   MODEL_RESOLUTION_V2_STATES,
   MODEL_RESOURCE_MANIFEST_LIMITS,
+  MODEL_RESOURCE_PROMOTION_LIMITS,
   MODEL_RIGHTS_STATUSES,
   MODEL_TEXTURE_RESOURCE_LIMITS,
   MODEL_TEXT_ONLY_ASSURANCE_CEILING_REASON_CODE,
   ModelConversionDiagnosticsError,
   ModelResourceManifestError,
+  ModelResourcePromotionError,
   ModelTextureResourceError,
   PVOX_ASSEMBLY_CLOSURE_HASH_DOMAIN,
   PVOX_ASSET_MANIFEST_VERSION,
@@ -8071,6 +8263,7 @@ export {
   createModelRequestSpecV2,
   createModelResolution,
   createModelResolutionV2,
+  createModelResourcePromotionRecord,
   createModelResourceRef,
   createModelRightsAssessment,
   createModelTechnicalProfile,