@plasius/asset-contracts 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -43,8 +43,8 @@ __export(index_exports, {
   ASSET_SOURCE_ADAPTERS: () => ASSET_SOURCE_ADAPTERS,
   ASSET_WGSL_CONTENT_TYPE: () => ASSET_WGSL_CONTENT_TYPE,
   CANONICAL_MODEL_COORDINATE_SYSTEM: () => CANONICAL_MODEL_COORDINATE_SYSTEM,
-  GPU_SHADER_STORE_FEATURE_FLAG: () => import_gpu_shader4.GPU_SHADER_STORE_FEATURE_FLAG,
-  GPU_SHADER_STYLE_SELECTION_CAPABILITY: () => import_gpu_shader4.GPU_SHADER_STYLE_SELECTION_CAPABILITY,
+  GPU_SHADER_STORE_FEATURE_FLAG: () => import_gpu_shader5.GPU_SHADER_STORE_FEATURE_FLAG,
+  GPU_SHADER_STYLE_SELECTION_CAPABILITY: () => import_gpu_shader5.GPU_SHADER_STYLE_SELECTION_CAPABILITY,
   MODEL_ASSET_KINDS: () => MODEL_ASSET_KINDS,
   MODEL_CANDIDATE_HARD_GATE_KINDS: () => MODEL_CANDIDATE_HARD_GATE_KINDS,
   MODEL_CONFIRMATION_VIEW_KINDS: () => MODEL_CONFIRMATION_VIEW_KINDS,
@@ -64,11 +64,13 @@ __export(index_exports, {
   MODEL_RESOLUTION_V2_JSON_SCHEMAS: () => MODEL_RESOLUTION_V2_JSON_SCHEMAS,
   MODEL_RESOLUTION_V2_STATES: () => MODEL_RESOLUTION_V2_STATES,
   MODEL_RESOURCE_MANIFEST_LIMITS: () => MODEL_RESOURCE_MANIFEST_LIMITS,
+  MODEL_RESOURCE_PROMOTION_LIMITS: () => MODEL_RESOURCE_PROMOTION_LIMITS,
   MODEL_RIGHTS_STATUSES: () => MODEL_RIGHTS_STATUSES,
   MODEL_TEXTURE_RESOURCE_LIMITS: () => MODEL_TEXTURE_RESOURCE_LIMITS,
   MODEL_TEXT_ONLY_ASSURANCE_CEILING_REASON_CODE: () => MODEL_TEXT_ONLY_ASSURANCE_CEILING_REASON_CODE,
   ModelConversionDiagnosticsError: () => ModelConversionDiagnosticsError,
   ModelResourceManifestError: () => ModelResourceManifestError,
+  ModelResourcePromotionError: () => ModelResourcePromotionError,
   ModelTextureResourceError: () => ModelTextureResourceError,
   PVOX_ASSEMBLY_CLOSURE_HASH_DOMAIN: () => PVOX_ASSEMBLY_CLOSURE_HASH_DOMAIN,
   PVOX_ASSET_MANIFEST_VERSION: () => PVOX_ASSET_MANIFEST_VERSION,
@@ -204,6 +206,7 @@ __export(index_exports, {
   createModelRequestSpecV2: () => createModelRequestSpecV2,
   createModelResolution: () => createModelResolution,
   createModelResolutionV2: () => createModelResolutionV2,
+  createModelResourcePromotionRecord: () => createModelResourcePromotionRecord,
   createModelResourceRef: () => createModelResourceRef,
   createModelRightsAssessment: () => createModelRightsAssessment,
   createModelTechnicalProfile: () => createModelTechnicalProfile,
@@ -267,7 +270,7 @@ __export(index_exports, {
   validateGpuAssetFiles: () => validateGpuAssetFiles
 });
 module.exports = __toCommonJS(index_exports);
-var import_gpu_shader4 = require("@plasius/gpu-shader");
+var import_gpu_shader5 = require("@plasius/gpu-shader");
 
 // src/asset-version.ts
 var ASSET_VERSION_PATTERN = /^[0-9A-Za-z][0-9A-Za-z._-]{0,127}$/u;
@@ -3052,7 +3055,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;
 }
@@ -3374,7 +3377,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.`);
   }
@@ -3537,7 +3540,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];
@@ -3773,7 +3776,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,
@@ -3796,9 +3799,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),
@@ -3807,7 +3810,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`);
@@ -3944,9 +3947,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.`);
@@ -3997,9 +4000,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.`);
@@ -4076,7 +4079,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,
@@ -4088,7 +4091,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.");
     }
@@ -4146,10 +4149,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) {
@@ -4317,10 +4320,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,
@@ -4329,7 +4332,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.");
@@ -4342,9 +4345,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}`))) {
@@ -4426,7 +4429,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.");
@@ -4509,9 +4512,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`;
@@ -4519,7 +4522,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) {
@@ -4718,7 +4721,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 = {
@@ -4741,7 +4744,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}`))
@@ -4769,7 +4772,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 });
@@ -4823,7 +4826,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");
@@ -4920,7 +4923,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");
@@ -5181,12 +5184,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.`);
     }
@@ -6956,9 +6959,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();
@@ -7030,14 +7033,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) => {
@@ -7180,12 +7183,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");
@@ -7218,7 +7221,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)))
@@ -7237,6 +7240,9 @@ function tokenPath(value) {
   return value;
 }
 
+// src/model-resource-promotion.ts
+var import_gpu_shader4 = require("@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 {
@@ -7329,9 +7335,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();
@@ -7384,6 +7390,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) => (0, import_gpu_shader4.canonicalizeGpuContract)(a) === (0, import_gpu_shader4.canonicalizeGpuContract)(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 (0, import_gpu_shader4.computeSha256)(new TextEncoder().encode((0, import_gpu_shader4.canonicalizeGpuContract)({ 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";
@@ -7564,7 +7757,7 @@ function createModelAssetManifest(input) {
     "screenshot",
     "metadata"
   ]);
-  const descriptor = (0, import_gpu_shader4.parseModelGpuCompatibilityDescriptor)({
+  const descriptor = (0, import_gpu_shader5.parseModelGpuCompatibilityDescriptor)({
     modelId: base.assetId,
     version: base.version,
     gpuInterface: input.gpuInterface,
@@ -7594,7 +7787,7 @@ function createGpuInterfaceAssetManifest(input) {
   );
   assertAllowedFileRoles(base, ["gpu-interface-manifest"]);
   assertRoleCount(base, "gpu-interface-manifest", 1);
-  const gpuInterfaceManifest = (0, import_gpu_shader4.parseGpuInterfaceManifest)(input.gpuInterfaceManifest);
+  const gpuInterfaceManifest = (0, import_gpu_shader5.parseGpuInterfaceManifest)(input.gpuInterfaceManifest);
   assertImmutableAssetVersion(gpuInterfaceManifest.interfaceVersion);
   assertDomainIdentity(
     base,
@@ -7617,7 +7810,7 @@ function createShaderAssetManifest(input) {
   );
   assertAllowedFileRoles(base, ["shader-manifest", "wgsl"]);
   assertRoleCount(base, "shader-manifest", 1);
-  const shaderManifest = (0, import_gpu_shader4.parseShaderVersionManifest)(input.shaderManifest);
+  const shaderManifest = (0, import_gpu_shader5.parseShaderVersionManifest)(input.shaderManifest);
   assertShaderManifestVersions(shaderManifest);
   assertDomainIdentity(base, shaderManifest.shaderId, shaderManifest.version, "Shader");
   assertShaderModuleFiles(base.files, shaderManifest);
@@ -7636,7 +7829,7 @@ function createShaderStyleProfileAssetManifest(input) {
   );
   assertAllowedFileRoles(base, ["shader-style-profile-manifest"]);
   assertRoleCount(base, "shader-style-profile-manifest", 1);
-  const styleProfileManifest = (0, import_gpu_shader4.parseShaderStyleProfileManifest)(input.styleProfileManifest);
+  const styleProfileManifest = (0, import_gpu_shader5.parseShaderStyleProfileManifest)(input.styleProfileManifest);
   assertStyleProfileManifestVersions(styleProfileManifest);
   assertDomainIdentity(base, styleProfileManifest.profileId, styleProfileManifest.version, "Style profile");
   return Object.freeze({ ...base, styleProfileManifest });
@@ -7700,8 +7893,8 @@ function createShaderValidationEvidenceRef(input) {
       sha256: assertSha256(attestation2.sha256, "Shader validation evidence attestation sha256")
     })
   };
-  const supportedUniversal = import_gpu_shader4.SUPPORTED_STABLE_WEBGPU_MATRIX_POLICIES.some((policy) => result.matrixId === policy.matrixId && result.matrixVersion === policy.matrixVersion && result.matrixSha256 === policy.matrixSha256);
-  const supportedAdditive = import_gpu_shader4.SUPPORTED_ADDITIVE_WEBGPU_MATRIX_POLICIES.some((policy) => result.matrixId === policy.matrixId && result.matrixVersion === policy.matrixVersion && result.matrixSha256 === policy.matrixSha256);
+  const supportedUniversal = import_gpu_shader5.SUPPORTED_STABLE_WEBGPU_MATRIX_POLICIES.some((policy) => result.matrixId === policy.matrixId && result.matrixVersion === policy.matrixVersion && result.matrixSha256 === policy.matrixSha256);
+  const supportedAdditive = import_gpu_shader5.SUPPORTED_ADDITIVE_WEBGPU_MATRIX_POLICIES.some((policy) => result.matrixId === policy.matrixId && result.matrixVersion === policy.matrixVersion && result.matrixSha256 === policy.matrixSha256);
   if (!supportedUniversal && !supportedAdditive) {
     throw new Error("Shader validation evidence must target a supported WebGPU matrix policy.");
   }
@@ -7712,7 +7905,7 @@ function createShaderValidationEvidenceRef(input) {
 }
 async function createGpuInterfaceRef(input) {
   assertImmutableAssetVersion(input.manifest.interfaceVersion);
-  const manifest = (0, import_gpu_shader4.parseGpuInterfaceManifest)(input.manifest);
+  const manifest = (0, import_gpu_shader5.parseGpuInterfaceManifest)(input.manifest);
   assertAssetId(manifest.interfaceId);
   assertImmutableAssetVersion(manifest.interfaceVersion);
   const manifestSha256 = await bindDomainManifestBytes(input.manifestBytes, manifest, "GPU interface");
@@ -7727,7 +7920,7 @@ async function createGpuInterfaceRef(input) {
 }
 async function createShaderVersionRef(input) {
   assertImmutableAssetVersion(input.manifest.version);
-  const manifest = (0, import_gpu_shader4.parseShaderVersionManifest)(input.manifest);
+  const manifest = (0, import_gpu_shader5.parseShaderVersionManifest)(input.manifest);
   assertAssetId(manifest.shaderId);
   assertShaderManifestVersions(manifest);
   const manifestSha256 = await bindDomainManifestBytes(input.manifestBytes, manifest, "Shader");
@@ -7740,7 +7933,7 @@ async function createShaderVersionRef(input) {
 }
 async function createShaderStyleProfileRef(input) {
   assertImmutableAssetVersion(input.manifest.version);
-  const manifest = (0, import_gpu_shader4.parseShaderStyleProfileManifest)(input.manifest);
+  const manifest = (0, import_gpu_shader5.parseShaderStyleProfileManifest)(input.manifest);
   assertAssetId(manifest.profileId);
   assertStyleProfileManifestVersions(manifest);
   const manifestSha256 = await bindDomainManifestBytes(input.manifestBytes, manifest, "Style profile");
@@ -7785,7 +7978,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 (0, import_gpu_shader4.computeSha256)(bytes) !== file.sha256) {
+    if (await (0, import_gpu_shader5.computeSha256)(bytes) !== file.sha256) {
       throw new Error(`GPU asset file ${file.path} digest differs from its descriptor.`);
     }
     if (file.contentType === ASSET_JSON_CONTENT_TYPE) {
@@ -7804,13 +7997,13 @@ async function validateGpuAssetFiles(input) {
   }
   const expectedDomainManifest = domainManifestForAsset(manifest);
   if (expectedDomainManifest !== null) {
-    const parsedEntrypoint = (0, import_gpu_shader4.parseJsonBytes)(entrypointBytes, "GPU asset manifest entrypoint");
-    if ((0, import_gpu_shader4.canonicalizeGpuContract)(parsedEntrypoint) !== (0, import_gpu_shader4.canonicalizeGpuContract)(expectedDomainManifest)) {
+    const parsedEntrypoint = (0, import_gpu_shader5.parseJsonBytes)(entrypointBytes, "GPU asset manifest entrypoint");
+    if ((0, import_gpu_shader5.canonicalizeGpuContract)(parsedEntrypoint) !== (0, import_gpu_shader5.canonicalizeGpuContract)(expectedDomainManifest)) {
       throw new Error("GPU asset entrypoint bytes differ from the validated domain manifest.");
     }
   } else if (manifest.assetKind === "shader-validation-evidence") {
     assertEvidenceEntrypointIdentity(
-      (0, import_gpu_shader4.parseJsonBytes)(entrypointBytes, "Shader validation evidence entrypoint"),
+      (0, import_gpu_shader5.parseJsonBytes)(entrypointBytes, "Shader validation evidence entrypoint"),
       manifest.validationEvidence
     );
   }
@@ -8034,7 +8227,7 @@ function assertTypedRuntimeManifestUri(manifest, value) {
 }
 function assertEvidenceEntrypointIdentity(value, ref2) {
   const evidence = assertRecord2(value, "Shader validation evidence entrypoint");
-  if (evidence.contractVersion !== import_gpu_shader4.SHADER_VALIDATION_EVIDENCE_VERSION || evidence.evidenceId !== ref2.evidenceId || evidence.status !== "passed") {
+  if (evidence.contractVersion !== import_gpu_shader5.SHADER_VALIDATION_EVIDENCE_VERSION || evidence.evidenceId !== ref2.evidenceId || evidence.status !== "passed") {
     throw new Error("Shader validation evidence bytes do not identify passing declared evidence.");
   }
   const matrixRef = assertRecord2(evidence.matrixRef, "Shader validation evidence matrixRef");
@@ -8050,9 +8243,9 @@ function assertEvidenceEntrypointIdentity(value, ref2) {
   }
 }
 function assertCanonicalJsonBytes(bytes, fieldName) {
-  const value = (0, import_gpu_shader4.parseJsonBytes)(bytes, fieldName);
+  const value = (0, import_gpu_shader5.parseJsonBytes)(bytes, fieldName);
   const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  if ((0, import_gpu_shader4.canonicalizeGpuContract)(value) !== text) {
+  if ((0, import_gpu_shader5.canonicalizeGpuContract)(value) !== text) {
     throw new Error(`${fieldName} must use canonical JSON serialization.`);
   }
 }
@@ -8061,11 +8254,11 @@ async function bindDomainManifestBytes(bytes, manifest, fieldName) {
     throw new Error(`${fieldName} manifest bytes must be a Uint8Array.`);
   }
   assertCanonicalJsonBytes(bytes, `${fieldName} manifest`);
-  const parsed = (0, import_gpu_shader4.parseJsonBytes)(bytes, `${fieldName} manifest`);
-  if ((0, import_gpu_shader4.canonicalizeGpuContract)(parsed) !== (0, import_gpu_shader4.canonicalizeGpuContract)(manifest)) {
+  const parsed = (0, import_gpu_shader5.parseJsonBytes)(bytes, `${fieldName} manifest`);
+  if ((0, import_gpu_shader5.canonicalizeGpuContract)(parsed) !== (0, import_gpu_shader5.canonicalizeGpuContract)(manifest)) {
     throw new Error(`${fieldName} manifest bytes differ from the supplied manifest.`);
   }
-  return (0, import_gpu_shader4.computeSha256)(bytes);
+  return (0, import_gpu_shader5.computeSha256)(bytes);
 }
 function assertRoleCount(manifest, role, expectedCount) {
   if (manifest.files.filter((file) => file.role === role).length !== expectedCount) {
@@ -8187,11 +8380,13 @@ function assertRequiredString(value, fieldName) {
   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,
@@ -8327,6 +8522,7 @@ function assertRequiredString(value, fieldName) {
   createModelRequestSpecV2,
   createModelResolution,
   createModelResolutionV2,
+  createModelResourcePromotionRecord,
   createModelResourceRef,
   createModelRightsAssessment,
   createModelTechnicalProfile,