@plasius/asset-contracts 0.4.5 → 0.5.0

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   SUPPORTED_ADDITIVE_WEBGPU_MATRIX_POLICIES,
   SUPPORTED_STABLE_WEBGPU_MATRIX_POLICIES,
   canonicalizeGpuContract as canonicalizeGpuContract3,
-  computeSha256,
+  computeSha256 as computeSha2562,
   parseGpuInterfaceManifest,
   parseJsonBytes,
   parseModelGpuCompatibilityDescriptor,
@@ -160,14 +160,14 @@ function assertRecord(value, fieldName) {
   }
   return value;
 }
-function assertAllowedKeys(record, allowedKeys, fieldName) {
-  const unexpected = Object.keys(record).find((key) => !allowedKeys.includes(key));
+function assertAllowedKeys(record2, allowedKeys, fieldName) {
+  const unexpected = Object.keys(record2).find((key) => !allowedKeys.includes(key));
   if (unexpected !== void 0) {
     throw new Error(`${fieldName} contains unexpected field ${unexpected}.`);
   }
 }
-function assertContractVersion(record, fieldName) {
-  if (record.contractVersion !== void 0 && record.contractVersion !== MODEL_RESOLUTION_CONTRACT_VERSION) {
+function assertContractVersion(record2, fieldName) {
+  if (record2.contractVersion !== void 0 && record2.contractVersion !== MODEL_RESOLUTION_CONTRACT_VERSION) {
     throw new Error(`${fieldName} contractVersion is not supported.`);
   }
 }
@@ -290,22 +290,22 @@ function requiredVector3(value, fieldName, positive = false) {
   ];
 }
 function createBounds(value, fieldName) {
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["min", "max"], fieldName);
-  const min = requiredVector3(record.min, `${fieldName}.min`);
-  const max = requiredVector3(record.max, `${fieldName}.max`);
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["min", "max"], fieldName);
+  const min = requiredVector3(record2.min, `${fieldName}.min`);
+  const max = requiredVector3(record2.max, `${fieldName}.max`);
   if (min.some((axis, index) => axis >= max[index])) {
     throw new Error(`${fieldName} min axes must be lower than max axes.`);
   }
   return { min, max };
 }
 function createDimensions(value, fieldName) {
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["width", "height", "depth"], fieldName);
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["width", "height", "depth"], fieldName);
   return {
-    width: requiredFiniteNumber(record.width, `${fieldName}.width`, Number.EPSILON),
-    height: requiredFiniteNumber(record.height, `${fieldName}.height`, Number.EPSILON),
-    depth: requiredFiniteNumber(record.depth, `${fieldName}.depth`, Number.EPSILON)
+    width: requiredFiniteNumber(record2.width, `${fieldName}.width`, Number.EPSILON),
+    height: requiredFiniteNumber(record2.height, `${fieldName}.height`, Number.EPSILON),
+    depth: requiredFiniteNumber(record2.depth, `${fieldName}.depth`, Number.EPSILON)
   };
 }
 function assertModelUri(value, fieldName) {
@@ -389,8 +389,8 @@ function opaqueSourceAssetId(value, fieldName = "ModelProvenance.sourceAssetId")
   return value;
 }
 function createHardConstraints(value) {
-  const record = value === void 0 ? {} : assertRecord(value, "ModelRequestSpec.hardConstraints");
-  assertAllowedKeys(record, [
+  const record2 = value === void 0 ? {} : assertRecord(value, "ModelRequestSpec.hardConstraints");
+  assertAllowedKeys(record2, [
     "boundsMetres",
     "dimensionsMetres",
     "maxTriangles",
@@ -412,62 +412,62 @@ function createHardConstraints(value) {
     collision: "optional",
     partition: "allowed"
   };
-  if (record.boundsMetres !== void 0) {
-    result.boundsMetres = createBounds(record.boundsMetres, "ModelRequestSpec.hardConstraints.boundsMetres");
+  if (record2.boundsMetres !== void 0) {
+    result.boundsMetres = createBounds(record2.boundsMetres, "ModelRequestSpec.hardConstraints.boundsMetres");
   }
-  if (record.dimensionsMetres !== void 0) {
-    result.dimensionsMetres = createDimensions(record.dimensionsMetres, "ModelRequestSpec.hardConstraints.dimensionsMetres");
+  if (record2.dimensionsMetres !== void 0) {
+    result.dimensionsMetres = createDimensions(record2.dimensionsMetres, "ModelRequestSpec.hardConstraints.dimensionsMetres");
   }
-  if (record.maxTriangles !== void 0) {
+  if (record2.maxTriangles !== void 0) {
     result.maxTriangles = requiredInteger(
-      record.maxTriangles,
+      record2.maxTriangles,
       "ModelRequestSpec.hardConstraints.maxTriangles",
       1,
       STATIC_WORLD_V1_MODEL_POLICY.maxTriangles
     );
   }
-  if (record.maxBytes !== void 0) {
+  if (record2.maxBytes !== void 0) {
     result.maxBytes = requiredInteger(
-      record.maxBytes,
+      record2.maxBytes,
       "ModelRequestSpec.hardConstraints.maxBytes",
       1,
       STATIC_WORLD_V1_MODEL_POLICY.maxBytes
     );
   }
-  if (record.maxTextureBytes !== void 0) {
+  if (record2.maxTextureBytes !== void 0) {
     result.maxTextureBytes = requiredInteger(
-      record.maxTextureBytes,
+      record2.maxTextureBytes,
       "ModelRequestSpec.hardConstraints.maxTextureBytes",
       1,
       STATIC_WORLD_V1_MODEL_POLICY.maxTextureBytes
     );
   }
-  if (record.maxTextureDimensionPx !== void 0) {
+  if (record2.maxTextureDimensionPx !== void 0) {
     result.maxTextureDimensionPx = requiredInteger(
-      record.maxTextureDimensionPx,
+      record2.maxTextureDimensionPx,
       "ModelRequestSpec.hardConstraints.maxTextureDimensionPx",
       1,
       STATIC_WORLD_V1_MODEL_POLICY.maxTextureDimensionPx
     );
   }
-  if (record.maxPartitionCellMetres !== void 0) {
+  if (record2.maxPartitionCellMetres !== void 0) {
     result.maxPartitionCellMetres = requiredFiniteNumber(
-      record.maxPartitionCellMetres,
+      record2.maxPartitionCellMetres,
       "ModelRequestSpec.hardConstraints.maxPartitionCellMetres",
       Number.EPSILON,
       STATIC_WORLD_V1_MODEL_POLICY.maxPartitionCellMetres
     );
   }
-  if (record.lod !== void 0) {
-    result.lod = requiredEnum(record.lod, ["required", "optional", "forbidden"], "ModelRequestSpec.hardConstraints.lod");
+  if (record2.lod !== void 0) {
+    result.lod = requiredEnum(record2.lod, ["required", "optional", "forbidden"], "ModelRequestSpec.hardConstraints.lod");
   }
-  if (record.collision !== void 0) {
-    result.collision = requiredEnum(record.collision, ["required", "optional", "forbidden"], "ModelRequestSpec.hardConstraints.collision");
+  if (record2.collision !== void 0) {
+    result.collision = requiredEnum(record2.collision, ["required", "optional", "forbidden"], "ModelRequestSpec.hardConstraints.collision");
   }
-  if (record.partition !== void 0) {
-    result.partition = requiredEnum(record.partition, ["single", "allowed", "required"], "ModelRequestSpec.hardConstraints.partition");
+  if (record2.partition !== void 0) {
+    result.partition = requiredEnum(record2.partition, ["single", "allowed", "required"], "ModelRequestSpec.hardConstraints.partition");
   }
-  if (record.maxTextureBytes === void 0 && result.maxBytes !== void 0) {
+  if (record2.maxTextureBytes === void 0 && result.maxBytes !== void 0) {
     result.maxTextureBytes = Math.min(result.maxTextureBytes ?? result.maxBytes, result.maxBytes);
   }
   if (result.maxBytes !== void 0 && result.maxTextureBytes !== void 0 && result.maxTextureBytes > result.maxBytes) {
@@ -492,8 +492,8 @@ function createSoftPreferences(value) {
   if (value === void 0) {
     return {};
   }
-  const record = assertRecord(value, "ModelRequestSpec.softPreferences");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelRequestSpec.softPreferences");
+  assertAllowedKeys(record2, [
     "category",
     "style",
     "materials",
@@ -504,22 +504,22 @@ function createSoftPreferences(value) {
   ], "ModelRequestSpec.softPreferences");
   const result = {};
   for (const field of ["category", "style", "era", "condition"]) {
-    const normalized = optionalString(record[field], `ModelRequestSpec.softPreferences.${field}`, 80);
+    const normalized = optionalString(record2[field], `ModelRequestSpec.softPreferences.${field}`, 80);
     if (normalized !== void 0) {
       assertNoDirectUrl(normalized, `ModelRequestSpec.softPreferences.${field}`);
       result[field] = normalized;
     }
   }
   for (const field of ["materials", "colors", "tags"]) {
-    if (record[field] !== void 0) {
-      result[field] = stringList(record[field], `ModelRequestSpec.softPreferences.${field}`);
+    if (record2[field] !== void 0) {
+      result[field] = stringList(record2[field], `ModelRequestSpec.softPreferences.${field}`);
     }
   }
   return result;
 }
 function createModelRequestSpec(input) {
-  const record = assertRecord(input, "ModelRequestSpec");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelRequestSpec");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "policyProfileId",
     "query",
@@ -530,21 +530,21 @@ function createModelRequestSpec(input) {
     "softPreferences",
     "exclusions"
   ], "ModelRequestSpec");
-  assertContractVersion(record, "ModelRequestSpec");
-  if (record.policyProfileId !== void 0 && record.policyProfileId !== STATIC_WORLD_V1_MODEL_POLICY.id) {
+  assertContractVersion(record2, "ModelRequestSpec");
+  if (record2.policyProfileId !== void 0 && record2.policyProfileId !== STATIC_WORLD_V1_MODEL_POLICY.id) {
     throw new Error("ModelRequestSpec.policyProfileId must be static-world-v1.");
   }
-  const query = requiredString(record.query, "ModelRequestSpec.query", MAX_QUERY_LENGTH);
+  const query = requiredString(record2.query, "ModelRequestSpec.query", MAX_QUERY_LENGTH);
   assertNoDirectUrl(query, "ModelRequestSpec.query");
   const revision = requiredInteger(
-    record.revision,
+    record2.revision,
     `ModelRequestSpec revision (maximum ${MODEL_REQUEST_MAX_REVISION})`,
     0,
     MODEL_REQUEST_MAX_REVISION
   );
   let locale;
-  if (record.locale !== void 0) {
-    const requestedLocale = requiredString(record.locale, "ModelRequestSpec.locale", 64);
+  if (record2.locale !== void 0) {
+    const requestedLocale = requiredString(record2.locale, "ModelRequestSpec.locale", 64);
     try {
       [locale] = Intl.getCanonicalLocales(requestedLocale);
     } catch {
@@ -554,7 +554,7 @@ function createModelRequestSpec(input) {
       throw new Error("ModelRequestSpec.locale must be a valid BCP 47 locale.");
     }
   }
-  const rankerId = record.rankerId === void 0 ? void 0 : requiredToken(record.rankerId, "ModelRequestSpec.rankerId");
+  const rankerId = record2.rankerId === void 0 ? void 0 : requiredToken(record2.rankerId, "ModelRequestSpec.rankerId");
   const result = {
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
     policyProfileId: STATIC_WORLD_V1_MODEL_POLICY.id,
@@ -562,9 +562,9 @@ function createModelRequestSpec(input) {
     revision,
     ...locale === void 0 ? {} : { locale },
     ...rankerId === void 0 ? {} : { rankerId },
-    hardConstraints: createHardConstraints(record.hardConstraints),
-    softPreferences: createSoftPreferences(record.softPreferences),
-    exclusions: record.exclusions === void 0 ? [] : stringList(record.exclusions, "ModelRequestSpec.exclusions")
+    hardConstraints: createHardConstraints(record2.hardConstraints),
+    softPreferences: createSoftPreferences(record2.softPreferences),
+    exclusions: record2.exclusions === void 0 ? [] : stringList(record2.exclusions, "ModelRequestSpec.exclusions")
   };
   return deepFreeze(result);
 }
@@ -602,8 +602,8 @@ function classifyModelMatchAssurance(score, hardConstraintPass, evidenceMode, ex
   return MODEL_MATCH_ASSURANCE_ORDER[rawAssurance] <= MODEL_MATCH_ASSURANCE_ORDER[assuranceCeiling] ? rawAssurance : assuranceCeiling;
 }
 function createRankerRef(value) {
-  const record = assertRecord(value, "ModelMatchAssessment.ranker");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelMatchAssessment.ranker");
+  assertAllowedKeys(record2, [
     "id",
     "version",
     "calibrationId",
@@ -612,25 +612,25 @@ function createRankerRef(value) {
     "assuranceCeiling"
   ], "ModelMatchAssessment.ranker");
   return {
-    id: requiredToken(record.id, "ModelMatchAssessment.ranker.id"),
-    version: assetVersion(record.version, "ModelMatchAssessment.ranker.version"),
-    calibrationId: requiredToken(record.calibrationId, "ModelMatchAssessment.ranker.calibrationId"),
-    calibrationVersion: assetVersion(record.calibrationVersion, "ModelMatchAssessment.ranker.calibrationVersion"),
+    id: requiredToken(record2.id, "ModelMatchAssessment.ranker.id"),
+    version: assetVersion(record2.version, "ModelMatchAssessment.ranker.version"),
+    calibrationId: requiredToken(record2.calibrationId, "ModelMatchAssessment.ranker.calibrationId"),
+    calibrationVersion: assetVersion(record2.calibrationVersion, "ModelMatchAssessment.ranker.calibrationVersion"),
     evidenceMode: requiredEnum(
-      record.evidenceMode,
+      record2.evidenceMode,
       MODEL_RANKER_EVIDENCE_MODES,
       "ModelMatchAssessment.ranker.evidenceMode"
     ),
     assuranceCeiling: requiredEnum(
-      record.assuranceCeiling,
+      record2.assuranceCeiling,
       MODEL_MATCH_ASSURANCE_BANDS,
       "ModelMatchAssessment.ranker.assuranceCeiling"
     )
   };
 }
 function createModelMatchAssessment(input) {
-  const record = assertRecord(input, "ModelMatchAssessment");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelMatchAssessment");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "score",
     "assurance",
@@ -643,19 +643,19 @@ function createModelMatchAssessment(input) {
     "candidateId",
     "candidateContentHash"
   ], "ModelMatchAssessment");
-  assertContractVersion(record, "ModelMatchAssessment");
-  const score = requiredFiniteNumber(record.score, "ModelMatchAssessment.score", 0, 1);
-  const hardConstraintPass = requiredBoolean(record.hardConstraintPass, "ModelMatchAssessment.hardConstraintPass");
-  const exactMatch = requiredBoolean(record.exactMatch, "ModelMatchAssessment.exactMatch");
-  const ranker = createRankerRef(record.ranker);
-  const request = createModelRequestSpec(record.request);
+  assertContractVersion(record2, "ModelMatchAssessment");
+  const score = requiredFiniteNumber(record2.score, "ModelMatchAssessment.score", 0, 1);
+  const hardConstraintPass = requiredBoolean(record2.hardConstraintPass, "ModelMatchAssessment.hardConstraintPass");
+  const exactMatch = requiredBoolean(record2.exactMatch, "ModelMatchAssessment.exactMatch");
+  const ranker = createRankerRef(record2.ranker);
+  const request = createModelRequestSpec(record2.request);
   if (request.rankerId !== void 0 && request.rankerId !== ranker.id) {
     throw new Error("ModelMatchAssessment ranker.id must match the caller-selected request rankerId.");
   }
-  if (record.assurance !== void 0) {
-    requiredEnum(record.assurance, MODEL_MATCH_ASSURANCE_BANDS, "ModelMatchAssessment.assurance");
+  if (record2.assurance !== void 0) {
+    requiredEnum(record2.assurance, MODEL_MATCH_ASSURANCE_BANDS, "ModelMatchAssessment.assurance");
   }
-  let reasonCodes2 = stringList(record.reasonCodes, "ModelMatchAssessment.reasonCodes", {
+  let reasonCodes2 = stringList(record2.reasonCodes, "ModelMatchAssessment.reasonCodes", {
     tokens: true
   });
   if (!hardConstraintPass && reasonCodes2.length === 0) {
@@ -688,18 +688,18 @@ function createModelMatchAssessment(input) {
     exactMatch,
     reasonCodes: reasonCodes2,
     ranker,
-    fidelityWarnings: stringList(record.fidelityWarnings ?? [], "ModelMatchAssessment.fidelityWarnings"),
+    fidelityWarnings: stringList(record2.fidelityWarnings ?? [], "ModelMatchAssessment.fidelityWarnings"),
     request,
-    candidateId: requiredToken(record.candidateId, "ModelMatchAssessment.candidateId"),
+    candidateId: requiredToken(record2.candidateId, "ModelMatchAssessment.candidateId"),
     candidateContentHash: requiredSha256(
-      record.candidateContentHash,
+      record2.candidateContentHash,
       "ModelMatchAssessment.candidateContentHash"
     )
   });
 }
 function createModelTechnicalProfile(input) {
-  const record = assertRecord(input, "ModelTechnicalProfile");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelTechnicalProfile");
+  assertAllowedKeys(record2, [
     "boundsMetres",
     "dimensionsMetres",
     "triangleCount",
@@ -711,22 +711,22 @@ function createModelTechnicalProfile(input) {
     "partitionCount",
     "partitionCellMetres"
   ], "ModelTechnicalProfile");
-  const boundsMetres = createBounds(record.boundsMetres, "ModelTechnicalProfile.boundsMetres");
-  const dimensionsMetres = createDimensions(record.dimensionsMetres, "ModelTechnicalProfile.dimensionsMetres");
+  const boundsMetres = createBounds(record2.boundsMetres, "ModelTechnicalProfile.boundsMetres");
+  const dimensionsMetres = createDimensions(record2.dimensionsMetres, "ModelTechnicalProfile.dimensionsMetres");
   const derivedDimensions = boundsMetres.max.map((axis, index) => axis - boundsMetres.min[index]);
   const suppliedDimensions = [dimensionsMetres.width, dimensionsMetres.height, dimensionsMetres.depth];
   if (derivedDimensions.some((axis, index) => Math.abs(axis - suppliedDimensions[index]) > Math.max(1e-6, Math.abs(axis) * 1e-6))) {
     throw new Error("ModelTechnicalProfile dimensionsMetres must match boundsMetres.");
   }
-  const byteLength = requiredInteger(record.byteLength, "ModelTechnicalProfile.byteLength", 1, Number.MAX_SAFE_INTEGER);
+  const byteLength = requiredInteger(record2.byteLength, "ModelTechnicalProfile.byteLength", 1, Number.MAX_SAFE_INTEGER);
   const textureByteLength = requiredInteger(
-    record.textureByteLength,
+    record2.textureByteLength,
     "ModelTechnicalProfile.textureByteLength",
     0,
     Number.MAX_SAFE_INTEGER
   );
   const maxTextureDimensionPx = requiredInteger(
-    record.maxTextureDimensionPx,
+    record2.maxTextureDimensionPx,
     "ModelTechnicalProfile.maxTextureDimensionPx",
     0,
     32768
@@ -742,15 +742,15 @@ function createModelTechnicalProfile(input) {
   return deepFreeze({
     boundsMetres,
     dimensionsMetres,
-    triangleCount: requiredInteger(record.triangleCount, "ModelTechnicalProfile.triangleCount", 1, 1e9),
+    triangleCount: requiredInteger(record2.triangleCount, "ModelTechnicalProfile.triangleCount", 1, 1e9),
     byteLength,
     textureByteLength,
     maxTextureDimensionPx,
-    lodCount: requiredInteger(record.lodCount, "ModelTechnicalProfile.lodCount", 1, 4),
-    hasCollision: requiredBoolean(record.hasCollision, "ModelTechnicalProfile.hasCollision"),
-    partitionCount: requiredInteger(record.partitionCount, "ModelTechnicalProfile.partitionCount", 1, 1e4),
+    lodCount: requiredInteger(record2.lodCount, "ModelTechnicalProfile.lodCount", 1, 4),
+    hasCollision: requiredBoolean(record2.hasCollision, "ModelTechnicalProfile.hasCollision"),
+    partitionCount: requiredInteger(record2.partitionCount, "ModelTechnicalProfile.partitionCount", 1, 1e4),
     partitionCellMetres: requiredFiniteNumber(
-      record.partitionCellMetres,
+      record2.partitionCellMetres,
       "ModelTechnicalProfile.partitionCellMetres",
       Number.EPSILON,
       1e6
@@ -758,19 +758,19 @@ function createModelTechnicalProfile(input) {
   });
 }
 function createAttribution(value) {
-  const record = assertRecord(value, "ModelRightsAssessment.attribution");
-  assertAllowedKeys(record, ["title", "creator", "notice", "sourcePageUri"], "ModelRightsAssessment.attribution");
-  const sourcePageUri = record.sourcePageUri === void 0 ? void 0 : assertPublicPageUri(record.sourcePageUri, "ModelRightsAssessment.attribution.sourcePageUri");
+  const record2 = assertRecord(value, "ModelRightsAssessment.attribution");
+  assertAllowedKeys(record2, ["title", "creator", "notice", "sourcePageUri"], "ModelRightsAssessment.attribution");
+  const sourcePageUri = record2.sourcePageUri === void 0 ? void 0 : assertPublicPageUri(record2.sourcePageUri, "ModelRightsAssessment.attribution.sourcePageUri");
   return {
-    title: requiredString(record.title, "ModelRightsAssessment.attribution.title", 256),
-    creator: requiredString(record.creator, "ModelRightsAssessment.attribution.creator", 256),
-    notice: requiredString(record.notice, "ModelRightsAssessment.attribution.notice", 512),
+    title: requiredString(record2.title, "ModelRightsAssessment.attribution.title", 256),
+    creator: requiredString(record2.creator, "ModelRightsAssessment.attribution.creator", 256),
+    notice: requiredString(record2.notice, "ModelRightsAssessment.attribution.notice", 512),
     ...sourcePageUri === void 0 ? {} : { sourcePageUri }
   };
 }
 function createModelRightsAssessment(input) {
-  const record = assertRecord(input, "ModelRightsAssessment");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelRightsAssessment");
+  assertAllowedKeys(record2, [
     "decisionId",
     "decisionToken",
     "policyId",
@@ -784,8 +784,8 @@ function createModelRightsAssessment(input) {
     "attribution",
     "reviewedAt"
   ], "ModelRightsAssessment");
-  const status = requiredEnum(record.status, MODEL_RIGHTS_STATUSES, "ModelRightsAssessment.status");
-  const attribution = record.attribution === void 0 ? void 0 : createAttribution(record.attribution);
+  const status = requiredEnum(record2.status, MODEL_RIGHTS_STATUSES, "ModelRightsAssessment.status");
+  const attribution = record2.attribution === void 0 ? void 0 : createAttribution(record2.attribution);
   if (status === "attribution-required" && attribution === void 0) {
     throw new Error("ModelRightsAssessment attribution is required for attribution-required rights.");
   }
@@ -793,29 +793,29 @@ function createModelRightsAssessment(input) {
     throw new Error("ModelRightsAssessment attribution-required rights require a public attribution sourcePageUri.");
   }
   return deepFreeze({
-    decisionId: requiredToken(record.decisionId, "ModelRightsAssessment.decisionId"),
+    decisionId: requiredToken(record2.decisionId, "ModelRightsAssessment.decisionId"),
     decisionToken: requiredAttestationToken(
-      record.decisionToken,
+      record2.decisionToken,
       "ModelRightsAssessment.decisionToken"
     ),
-    policyId: requiredToken(record.policyId, "ModelRightsAssessment.policyId"),
-    policyVersion: assetVersion(record.policyVersion, "ModelRightsAssessment.policyVersion"),
-    sourceId: requiredToken(record.sourceId, "ModelRightsAssessment.sourceId"),
-    sourceAssetId: opaqueSourceAssetId(record.sourceAssetId, "ModelRightsAssessment.sourceAssetId"),
+    policyId: requiredToken(record2.policyId, "ModelRightsAssessment.policyId"),
+    policyVersion: assetVersion(record2.policyVersion, "ModelRightsAssessment.policyVersion"),
+    sourceId: requiredToken(record2.sourceId, "ModelRightsAssessment.sourceId"),
+    sourceAssetId: opaqueSourceAssetId(record2.sourceAssetId, "ModelRightsAssessment.sourceAssetId"),
     sourceContentHash: requiredSha256(
-      record.sourceContentHash,
+      record2.sourceContentHash,
       "ModelRightsAssessment.sourceContentHash"
     ),
     status,
-    licenseId: requiredToken(record.licenseId, "ModelRightsAssessment.licenseId"),
-    evidencePageUri: assertPublicPageUri(record.evidencePageUri, "ModelRightsAssessment.evidencePageUri"),
+    licenseId: requiredToken(record2.licenseId, "ModelRightsAssessment.licenseId"),
+    evidencePageUri: assertPublicPageUri(record2.evidencePageUri, "ModelRightsAssessment.evidencePageUri"),
     ...attribution === void 0 ? {} : { attribution },
-    reviewedAt: requiredTimestamp(record.reviewedAt, "ModelRightsAssessment.reviewedAt")
+    reviewedAt: requiredTimestamp(record2.reviewedAt, "ModelRightsAssessment.reviewedAt")
   });
 }
 function createModelProvenance(input) {
-  const record = assertRecord(input, "ModelProvenance");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelProvenance");
+  assertAllowedKeys(record2, [
     "kind",
     "sourceId",
     "sourceAssetId",
@@ -823,9 +823,9 @@ function createModelProvenance(input) {
     "contentHash",
     "capturedAt"
   ], "ModelProvenance");
-  const kind = requiredEnum(record.kind, MODEL_PROVENANCE_KINDS, "ModelProvenance kind");
-  const sourceAssetId = opaqueSourceAssetId(record.sourceAssetId);
-  const sourcePageUri = record.sourcePageUri === void 0 ? void 0 : assertPublicPageUri(record.sourcePageUri, "ModelProvenance.sourcePageUri");
+  const kind = requiredEnum(record2.kind, MODEL_PROVENANCE_KINDS, "ModelProvenance kind");
+  const sourceAssetId = opaqueSourceAssetId(record2.sourceAssetId);
+  const sourcePageUri = record2.sourcePageUri === void 0 ? void 0 : assertPublicPageUri(record2.sourcePageUri, "ModelProvenance.sourcePageUri");
   if (kind === "provider" && sourcePageUri === void 0) {
     throw new Error("ModelProvenance provider provenance requires sourcePageUri.");
   }
@@ -834,16 +834,16 @@ function createModelProvenance(input) {
   }
   return deepFreeze({
     kind,
-    sourceId: requiredToken(record.sourceId, "ModelProvenance.sourceId"),
+    sourceId: requiredToken(record2.sourceId, "ModelProvenance.sourceId"),
     sourceAssetId,
     ...sourcePageUri === void 0 ? {} : { sourcePageUri },
-    contentHash: requiredSha256(record.contentHash, "ModelProvenance.contentHash"),
-    capturedAt: requiredTimestamp(record.capturedAt, "ModelProvenance.capturedAt")
+    contentHash: requiredSha256(record2.contentHash, "ModelProvenance.contentHash"),
+    capturedAt: requiredTimestamp(record2.capturedAt, "ModelProvenance.capturedAt")
   });
 }
 function createModelAssetRef(input) {
-  const record = assertRecord(input, "ModelAssetRef");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelAssetRef");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "assetId",
     "version",
@@ -851,10 +851,10 @@ function createModelAssetRef(input) {
     "contentHash",
     "runtimeManifestUri"
   ], "ModelAssetRef");
-  assertContractVersion(record, "ModelAssetRef");
-  const validatedAssetId = assetId(record.assetId, "ModelAssetRef.assetId");
-  const validatedVersion = assertImmutableAssetVersion(record.version);
-  const runtimeManifestUri = assertModelUri(record.runtimeManifestUri, "ModelAssetRef.runtimeManifestUri");
+  assertContractVersion(record2, "ModelAssetRef");
+  const validatedAssetId = assetId(record2.assetId, "ModelAssetRef.assetId");
+  const validatedVersion = assertImmutableAssetVersion(record2.version);
+  const runtimeManifestUri = assertModelUri(record2.runtimeManifestUri, "ModelAssetRef.runtimeManifestUri");
   const expectedManifestUri = `mcp://models/catalog/${validatedAssetId}/versions/${validatedVersion}/manifest`;
   if (runtimeManifestUri !== expectedManifestUri) {
     throw new Error(
@@ -865,21 +865,21 @@ function createModelAssetRef(input) {
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
     assetId: validatedAssetId,
     version: validatedVersion,
-    kind: requiredEnum(record.kind, MODEL_ASSET_KINDS, "ModelAssetRef.kind"),
-    contentHash: requiredSha256(record.contentHash, "ModelAssetRef.contentHash"),
+    kind: requiredEnum(record2.kind, MODEL_ASSET_KINDS, "ModelAssetRef.kind"),
+    contentHash: requiredSha256(record2.contentHash, "ModelAssetRef.contentHash"),
     runtimeManifestUri
   });
 }
 function createCandidateAssetRef(value) {
-  const record = assertRecord(value, "ModelCandidate.assetRef");
-  const disposition = requiredEnum(record.disposition, ["existing", "proposed"], "ModelCandidate.assetRef.disposition");
+  const record2 = assertRecord(value, "ModelCandidate.assetRef");
+  const disposition = requiredEnum(record2.disposition, ["existing", "proposed"], "ModelCandidate.assetRef.disposition");
   if (disposition === "existing") {
-    assertAllowedKeys(record, ["disposition", "asset", "kind", "contentHash"], "ModelCandidate.assetRef");
-    const asset = createModelAssetRef(record.asset);
-    if (record.kind !== void 0 && record.kind !== asset.kind) {
+    assertAllowedKeys(record2, ["disposition", "asset", "kind", "contentHash"], "ModelCandidate.assetRef");
+    const asset = createModelAssetRef(record2.asset);
+    if (record2.kind !== void 0 && record2.kind !== asset.kind) {
       throw new Error("ModelCandidate existing assetRef kind must match asset.");
     }
-    if (record.contentHash !== void 0 && record.contentHash !== asset.contentHash) {
+    if (record2.contentHash !== void 0 && record2.contentHash !== asset.contentHash) {
       throw new Error("ModelCandidate existing assetRef contentHash must match asset.");
     }
     return {
@@ -889,27 +889,27 @@ function createCandidateAssetRef(value) {
       asset
     };
   }
-  assertAllowedKeys(record, ["disposition", "proposalId", "kind", "contentHash"], "ModelCandidate.assetRef");
+  assertAllowedKeys(record2, ["disposition", "proposalId", "kind", "contentHash"], "ModelCandidate.assetRef");
   return {
     disposition,
-    proposalId: requiredToken(record.proposalId, "ModelCandidate.assetRef.proposalId"),
-    kind: requiredEnum(record.kind, MODEL_ASSET_KINDS, "ModelCandidate.assetRef.kind"),
-    contentHash: requiredSha256(record.contentHash, "ModelCandidate.assetRef.contentHash")
+    proposalId: requiredToken(record2.proposalId, "ModelCandidate.assetRef.proposalId"),
+    kind: requiredEnum(record2.kind, MODEL_ASSET_KINDS, "ModelCandidate.assetRef.kind"),
+    contentHash: requiredSha256(record2.contentHash, "ModelCandidate.assetRef.contentHash")
   };
 }
 function createConfirmationView(value, index) {
   const fieldName = `ModelCandidate.views[${index}]`;
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["kind", "imageUri", "sha256", "contentType", "width", "height"], fieldName);
-  const width = requiredInteger(record.width, `${fieldName}.width`, MODEL_CONFIRMATION_VIEW_SIZE_PX, MODEL_CONFIRMATION_VIEW_SIZE_PX);
-  const height = requiredInteger(record.height, `${fieldName}.height`, MODEL_CONFIRMATION_VIEW_SIZE_PX, MODEL_CONFIRMATION_VIEW_SIZE_PX);
-  if (record.contentType !== "image/png") {
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["kind", "imageUri", "sha256", "contentType", "width", "height"], fieldName);
+  const width = requiredInteger(record2.width, `${fieldName}.width`, MODEL_CONFIRMATION_VIEW_SIZE_PX, MODEL_CONFIRMATION_VIEW_SIZE_PX);
+  const height = requiredInteger(record2.height, `${fieldName}.height`, MODEL_CONFIRMATION_VIEW_SIZE_PX, MODEL_CONFIRMATION_VIEW_SIZE_PX);
+  if (record2.contentType !== "image/png") {
     throw new Error(`${fieldName}.contentType must be image/png.`);
   }
   return {
-    kind: requiredEnum(record.kind, MODEL_CONFIRMATION_VIEW_KINDS, `${fieldName}.kind`),
-    imageUri: assertModelUri(record.imageUri, `${fieldName}.imageUri`),
-    sha256: requiredSha256(record.sha256, `${fieldName}.sha256`),
+    kind: requiredEnum(record2.kind, MODEL_CONFIRMATION_VIEW_KINDS, `${fieldName}.kind`),
+    imageUri: assertModelUri(record2.imageUri, `${fieldName}.imageUri`),
+    sha256: requiredSha256(record2.sha256, `${fieldName}.sha256`),
     contentType: "image/png",
     width,
     height
@@ -943,8 +943,8 @@ function createConfirmationViews(value, resolutionId, candidateId) {
   return [ordered[0], ordered[1], ordered[2], ordered[3]];
 }
 function createRenderEvidence(value, manifest, views) {
-  const record = assertRecord(value, "ModelCandidate.renderEvidence");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelCandidate.renderEvidence");
+  assertAllowedKeys(record2, [
     "renderId",
     "rendererId",
     "rendererVersion",
@@ -956,35 +956,35 @@ function createRenderEvidence(value, manifest, views) {
     "renderedAt",
     "attestationToken"
   ], "ModelCandidate.renderEvidence");
-  if (record.processingManifestId !== manifest.manifestId) {
+  if (record2.processingManifestId !== manifest.manifestId) {
     throw new Error("ModelCandidate.renderEvidence.processingManifestId must match processingManifest.");
   }
-  if (record.sourceContentHash !== manifest.lods[0]?.resource.sha256) {
+  if (record2.sourceContentHash !== manifest.lods[0]?.resource.sha256) {
     throw new Error("ModelCandidate.renderEvidence.sourceContentHash must match canonical LOD0.");
   }
-  if (!Array.isArray(record.viewSha256s) || record.viewSha256s.length !== 4) {
+  if (!Array.isArray(record2.viewSha256s) || record2.viewSha256s.length !== 4) {
     throw new Error("ModelCandidate.renderEvidence.viewSha256s must contain four ordered hashes.");
   }
-  const viewSha256s = record.viewSha256s.map((digest, index) => requiredSha256(digest, `ModelCandidate.renderEvidence.viewSha256s[${index}]`));
+  const viewSha256s = record2.viewSha256s.map((digest, index) => requiredSha256(digest, `ModelCandidate.renderEvidence.viewSha256s[${index}]`));
   if (viewSha256s.some((digest, index) => digest !== views[index]?.sha256)) {
     throw new Error("ModelCandidate.renderEvidence view hashes must match the candidate view pack.");
   }
-  const renderedAt = requiredTimestamp(record.renderedAt, "ModelCandidate.renderEvidence.renderedAt");
+  const renderedAt = requiredTimestamp(record2.renderedAt, "ModelCandidate.renderEvidence.renderedAt");
   if (Date.parse(renderedAt) < Date.parse(manifest.processedAt)) {
     throw new Error("ModelCandidate.renderEvidence.renderedAt must not precede processing.");
   }
   return {
-    renderId: requiredToken(record.renderId, "ModelCandidate.renderEvidence.renderId"),
-    rendererId: requiredToken(record.rendererId, "ModelCandidate.renderEvidence.rendererId"),
-    rendererVersion: assetVersion(record.rendererVersion, "ModelCandidate.renderEvidence.rendererVersion"),
-    settingsId: requiredToken(record.settingsId, "ModelCandidate.renderEvidence.settingsId"),
-    settingsVersion: assetVersion(record.settingsVersion, "ModelCandidate.renderEvidence.settingsVersion"),
+    renderId: requiredToken(record2.renderId, "ModelCandidate.renderEvidence.renderId"),
+    rendererId: requiredToken(record2.rendererId, "ModelCandidate.renderEvidence.rendererId"),
+    rendererVersion: assetVersion(record2.rendererVersion, "ModelCandidate.renderEvidence.rendererVersion"),
+    settingsId: requiredToken(record2.settingsId, "ModelCandidate.renderEvidence.settingsId"),
+    settingsVersion: assetVersion(record2.settingsVersion, "ModelCandidate.renderEvidence.settingsVersion"),
     processingManifestId: manifest.manifestId,
     sourceContentHash: manifest.contentHash,
     viewSha256s: [viewSha256s[0], viewSha256s[1], viewSha256s[2], viewSha256s[3]],
     renderedAt,
     attestationToken: requiredAttestationToken(
-      record.attestationToken,
+      record2.attestationToken,
       "ModelCandidate.renderEvidence.attestationToken"
     )
   };
@@ -995,8 +995,8 @@ function createCandidateHardGates(value, provenance, manifest) {
   }
   const gates = value.map((item, index) => {
     const fieldName = `ModelCandidate.hardGates[${index}]`;
-    const record = assertRecord(item, fieldName);
-    assertAllowedKeys(record, [
+    const record2 = assertRecord(item, fieldName);
+    assertAllowedKeys(record2, [
       "kind",
       "outcome",
       "validatorId",
@@ -1006,26 +1006,26 @@ function createCandidateHardGates(value, provenance, manifest) {
       "evaluatedAt",
       "attestationToken"
     ], fieldName);
-    const kind = requiredEnum(record.kind, MODEL_CANDIDATE_HARD_GATE_KINDS, `${fieldName}.kind`);
-    const subjectContentHash = requiredSha256(record.subjectContentHash, `${fieldName}.subjectContentHash`);
+    const kind = requiredEnum(record2.kind, MODEL_CANDIDATE_HARD_GATE_KINDS, `${fieldName}.kind`);
+    const subjectContentHash = requiredSha256(record2.subjectContentHash, `${fieldName}.subjectContentHash`);
     const expectedHash = kind === "malware-scan" ? provenance.contentHash : manifest.closureHash;
     if (subjectContentHash !== expectedHash) {
       throw new Error(`${fieldName}.subjectContentHash must match the gate subject.`);
     }
-    const outcome = requiredEnum(record.outcome, ["passed", "blocked"], `${fieldName}.outcome`);
-    const reasonCodes2 = stringList(record.reasonCodes ?? [], `${fieldName}.reasonCodes`, { tokens: true });
+    const outcome = requiredEnum(record2.outcome, ["passed", "blocked"], `${fieldName}.outcome`);
+    const reasonCodes2 = stringList(record2.reasonCodes ?? [], `${fieldName}.reasonCodes`, { tokens: true });
     if (outcome === "blocked" && reasonCodes2.length === 0) {
       throw new Error(`${fieldName}.reasonCodes must explain a blocked hard gate.`);
     }
     return {
       kind,
       outcome,
-      validatorId: requiredToken(record.validatorId, `${fieldName}.validatorId`),
-      validatorVersion: assetVersion(record.validatorVersion, `${fieldName}.validatorVersion`),
+      validatorId: requiredToken(record2.validatorId, `${fieldName}.validatorId`),
+      validatorVersion: assetVersion(record2.validatorVersion, `${fieldName}.validatorVersion`),
       subjectContentHash,
       reasonCodes: reasonCodes2,
-      evaluatedAt: requiredTimestamp(record.evaluatedAt, `${fieldName}.evaluatedAt`),
-      attestationToken: requiredAttestationToken(record.attestationToken, `${fieldName}.attestationToken`)
+      evaluatedAt: requiredTimestamp(record2.evaluatedAt, `${fieldName}.evaluatedAt`),
+      attestationToken: requiredAttestationToken(record2.attestationToken, `${fieldName}.attestationToken`)
     };
   });
   if (new Set(gates.map((gate) => gate.kind)).size !== MODEL_CANDIDATE_HARD_GATE_KINDS.length) {
@@ -1038,8 +1038,8 @@ function createCandidateHardGates(value, provenance, manifest) {
   return MODEL_CANDIDATE_HARD_GATE_KINDS.map((kind) => byKind.get(kind));
 }
 function createModelCandidate(input) {
-  const record = assertRecord(input, "ModelCandidate");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelCandidate");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "resolutionId",
     "candidateId",
@@ -1055,24 +1055,24 @@ function createModelCandidate(input) {
     "confirmationToken",
     "confirmationRequired"
   ], "ModelCandidate");
-  assertContractVersion(record, "ModelCandidate");
-  if (record.confirmationRequired !== void 0 && record.confirmationRequired !== true) {
+  assertContractVersion(record2, "ModelCandidate");
+  if (record2.confirmationRequired !== void 0 && record2.confirmationRequired !== true) {
     throw new Error("ModelCandidate confirmationRequired must always be true.");
   }
-  if (typeof record.confirmationToken !== "string" || !CONFIRMATION_TOKEN_PATTERN.test(record.confirmationToken)) {
+  if (typeof record2.confirmationToken !== "string" || !CONFIRMATION_TOKEN_PATTERN.test(record2.confirmationToken)) {
     throw new Error("ModelCandidate confirmationToken must be a bounded opaque token.");
   }
-  const resolutionId = requiredModelPathSegment(record.resolutionId, "ModelCandidate.resolutionId");
-  const candidateId = requiredModelPathSegment(record.candidateId, "ModelCandidate.candidateId");
-  const assetRef = createCandidateAssetRef(record.assetRef);
-  const technicalProfile = createModelTechnicalProfile(record.technicalProfile);
-  const processingManifest = createModelProcessingManifest(record.processingManifest);
+  const resolutionId = requiredModelPathSegment(record2.resolutionId, "ModelCandidate.resolutionId");
+  const candidateId = requiredModelPathSegment(record2.candidateId, "ModelCandidate.candidateId");
+  const assetRef = createCandidateAssetRef(record2.assetRef);
+  const technicalProfile = createModelTechnicalProfile(record2.technicalProfile);
+  const processingManifest = createModelProcessingManifest(record2.processingManifest);
   if (processingManifest.resolutionId !== resolutionId || processingManifest.candidateId !== candidateId || processingManifest.kind !== assetRef.kind || processingManifest.contentHash !== assetRef.contentHash || JSON.stringify(processingManifest.technicalProfile) !== JSON.stringify(technicalProfile)) {
     throw new Error(
       "ModelCandidate processingManifest must match candidateId, asset kind/contentHash, and technicalProfile."
     );
   }
-  const match = createModelMatchAssessment(record.match);
+  const match = createModelMatchAssessment(record2.match);
   if (match.candidateId !== candidateId || match.candidateContentHash !== assetRef.contentHash) {
     throw new Error("ModelCandidate match assessment must bind candidateId and candidate contentHash.");
   }
@@ -1092,11 +1092,11 @@ function createModelCandidate(input) {
       "ModelCandidate match reasonCodes must include every failed hard constraint."
     );
   }
-  const provenance = createModelProvenance(record.provenance);
+  const provenance = createModelProvenance(record2.provenance);
   if (provenance.contentHash !== processingManifest.converter.sourceContentHash) {
     throw new Error("ModelCandidate provenance contentHash must match converter sourceContentHash.");
   }
-  const rights = createModelRightsAssessment(record.rights);
+  const rights = createModelRightsAssessment(record2.rights);
   if (rights.sourceId !== provenance.sourceId || rights.sourceAssetId !== provenance.sourceAssetId || rights.sourceContentHash !== provenance.contentHash) {
     throw new Error("ModelCandidate rights decision must bind the exact provenance source and content hash.");
   }
@@ -1108,9 +1108,9 @@ function createModelCandidate(input) {
   if (processingManifest.fidelityGate.outcome === "blocked" && !match.reasonCodes.includes("fidelity-blocked")) {
     throw new Error("ModelCandidate blocked fidelity must be recorded in match reasonCodes.");
   }
-  const views = createConfirmationViews(record.views, resolutionId, candidateId);
-  const renderEvidence = createRenderEvidence(record.renderEvidence, processingManifest, views);
-  const hardGates = createCandidateHardGates(record.hardGates, provenance, processingManifest);
+  const views = createConfirmationViews(record2.views, resolutionId, candidateId);
+  const renderEvidence = createRenderEvidence(record2.renderEvidence, processingManifest, views);
+  const hardGates = createCandidateHardGates(record2.hardGates, provenance, processingManifest);
   return deepFreeze({
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
     resolutionId,
@@ -1124,7 +1124,7 @@ function createModelCandidate(input) {
     views,
     renderEvidence,
     hardGates,
-    confirmationToken: record.confirmationToken,
+    confirmationToken: record2.confirmationToken,
     confirmationRequired: true
   });
 }
@@ -1136,8 +1136,8 @@ function isModelCandidateConfirmable(candidate) {
   return candidate.confirmationRequired && candidate.match.hardConstraintPass && candidate.match.assurance !== "none" && (candidate.rights.status === "allowed" || candidate.rights.status === "attribution-required") && !blockingEvidence && candidate.processingManifest.fidelityGate.outcome !== "blocked" && candidate.hardGates.length === MODEL_CANDIDATE_HARD_GATE_KINDS.length && candidate.hardGates.every((gate) => gate.outcome === "passed") && candidate.views.length === MODEL_CONFIRMATION_VIEW_KINDS.length;
 }
 function createModelCandidateConfirmation(input, expectedCandidate, expectedResolutionId) {
-  const record = assertRecord(input, "ModelCandidateConfirmation");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelCandidateConfirmation");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "confirmationId",
     "resolutionId",
@@ -1148,7 +1148,7 @@ function createModelCandidateConfirmation(input, expectedCandidate, expectedReso
     "confirmedAt",
     "semanticRiskAccepted"
   ], "ModelCandidateConfirmation");
-  assertContractVersion(record, "ModelCandidateConfirmation");
+  assertContractVersion(record2, "ModelCandidateConfirmation");
   const candidate = createModelCandidate(expectedCandidate);
   const resolutionId = requiredModelPathSegment(
     expectedResolutionId,
@@ -1159,19 +1159,19 @@ function createModelCandidateConfirmation(input, expectedCandidate, expectedReso
       "ModelCandidateConfirmation expected candidate must belong to the expected resolutionId."
     );
   }
-  if (record.resolutionId !== resolutionId) {
+  if (record2.resolutionId !== resolutionId) {
     throw new Error("ModelCandidateConfirmation.resolutionId must match the expected resolutionId.");
   }
-  if (record.candidateId !== candidate.candidateId) {
+  if (record2.candidateId !== candidate.candidateId) {
     throw new Error("ModelCandidateConfirmation.candidateId must match the confirmed candidate.");
   }
-  if (typeof record.confirmationToken !== "string" || !CONFIRMATION_TOKEN_PATTERN.test(record.confirmationToken) || record.confirmationToken !== candidate.confirmationToken) {
+  if (typeof record2.confirmationToken !== "string" || !CONFIRMATION_TOKEN_PATTERN.test(record2.confirmationToken) || record2.confirmationToken !== candidate.confirmationToken) {
     throw new Error("ModelCandidateConfirmation.confirmationToken must match the signed candidate token.");
   }
-  if (!Array.isArray(record.viewSha256s) || record.viewSha256s.length !== 4) {
+  if (!Array.isArray(record2.viewSha256s) || record2.viewSha256s.length !== 4) {
     throw new Error("ModelCandidateConfirmation.viewSha256s must contain the ordered four candidate view hashes.");
   }
-  const viewSha256s = record.viewSha256s.map((value, index) => requiredSha256(value, `ModelCandidateConfirmation.viewSha256s[${index}]`));
+  const viewSha256s = record2.viewSha256s.map((value, index) => requiredSha256(value, `ModelCandidateConfirmation.viewSha256s[${index}]`));
   const expectedHashes = candidate.views.map((view) => view.sha256);
   if (viewSha256s.some((digest, index) => digest !== expectedHashes[index])) {
     throw new Error("ModelCandidateConfirmation view hashes must match the ordered candidate views.");
@@ -1180,7 +1180,7 @@ function createModelCandidateConfirmation(input, expectedCandidate, expectedReso
     throw new Error("ModelCandidateConfirmation candidate is not confirmable because a hard review gate is blocking.");
   }
   const semanticRiskAccepted = requiredBoolean(
-    record.semanticRiskAccepted,
+    record2.semanticRiskAccepted,
     "ModelCandidateConfirmation.semanticRiskAccepted"
   );
   if (candidate.match.assurance === "low" && !semanticRiskAccepted) {
@@ -1189,10 +1189,10 @@ function createModelCandidateConfirmation(input, expectedCandidate, expectedReso
   if (candidate.match.assurance === "high" && semanticRiskAccepted) {
     throw new Error("ModelCandidateConfirmation high assurance must not record a semantic risk override.");
   }
-  const confirmedBy = requiredString(record.confirmedBy, "ModelCandidateConfirmation.confirmedBy", 256);
+  const confirmedBy = requiredString(record2.confirmedBy, "ModelCandidateConfirmation.confirmedBy", 256);
   assertNoDirectUrl(confirmedBy, "ModelCandidateConfirmation.confirmedBy");
   const confirmedAt = requiredTimestamp(
-    record.confirmedAt,
+    record2.confirmedAt,
     "ModelCandidateConfirmation.confirmedAt"
   );
   const latestEvidenceTime = Math.max(
@@ -1210,7 +1210,7 @@ function createModelCandidateConfirmation(input, expectedCandidate, expectedReso
   }
   return deepFreeze({
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
-    confirmationId: requiredToken(record.confirmationId, "ModelCandidateConfirmation.confirmationId"),
+    confirmationId: requiredToken(record2.confirmationId, "ModelCandidateConfirmation.confirmationId"),
     resolutionId,
     candidateId: candidate.candidateId,
     confirmationToken: candidate.confirmationToken,
@@ -1221,33 +1221,33 @@ function createModelCandidateConfirmation(input, expectedCandidate, expectedReso
   });
 }
 function createModelResourceRef(input) {
-  const record = assertRecord(input, "ModelResourceRef");
-  assertAllowedKeys(record, ["uri", "byteLength", "sha256", "contentType"], "ModelResourceRef");
-  const contentType = requiredString(record.contentType, "ModelResourceRef.contentType", 128);
-  if (!CONTENT_TYPE_PATTERN.test(contentType)) {
+  const record2 = assertRecord(input, "ModelResourceRef");
+  assertAllowedKeys(record2, ["uri", "byteLength", "sha256", "contentType"], "ModelResourceRef");
+  const contentType2 = requiredString(record2.contentType, "ModelResourceRef.contentType", 128);
+  if (!CONTENT_TYPE_PATTERN.test(contentType2)) {
     throw new Error("ModelResourceRef.contentType must be a valid media type.");
   }
   return deepFreeze({
-    uri: assertModelUri(record.uri, "ModelResourceRef.uri"),
-    byteLength: requiredInteger(record.byteLength, "ModelResourceRef.byteLength", 1, Number.MAX_SAFE_INTEGER),
-    sha256: requiredSha256(record.sha256, "ModelResourceRef.sha256"),
-    contentType
+    uri: assertModelUri(record2.uri, "ModelResourceRef.uri"),
+    byteLength: requiredInteger(record2.byteLength, "ModelResourceRef.byteLength", 1, Number.MAX_SAFE_INTEGER),
+    sha256: requiredSha256(record2.sha256, "ModelResourceRef.sha256"),
+    contentType: contentType2
   });
 }
 function createLodRecord(value, index) {
   const fieldName = `ModelProcessingManifest.lods[${index}]`;
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["level", "resource", "triangleCount", "geometricErrorMetres"], fieldName);
-  const resource = createModelResourceRef(record.resource);
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["level", "resource", "triangleCount", "geometricErrorMetres"], fieldName);
+  const resource = createModelResourceRef(record2.resource);
   if (resource.contentType !== "model/gltf-binary") {
     throw new Error(`${fieldName}.resource.contentType must be model/gltf-binary for canonical GLB output.`);
   }
   return {
-    level: requiredInteger(record.level, `${fieldName}.level`, 0, 3),
+    level: requiredInteger(record2.level, `${fieldName}.level`, 0, 3),
     resource,
-    triangleCount: requiredInteger(record.triangleCount, `${fieldName}.triangleCount`, 1, 1e9),
+    triangleCount: requiredInteger(record2.triangleCount, `${fieldName}.triangleCount`, 1, 1e9),
     geometricErrorMetres: requiredFiniteNumber(
-      record.geometricErrorMetres,
+      record2.geometricErrorMetres,
       `${fieldName}.geometricErrorMetres`,
       0,
       1e6
@@ -1255,40 +1255,40 @@ function createLodRecord(value, index) {
   };
 }
 function createCollisionRecord(value) {
-  const record = assertRecord(value, "ModelProcessingManifest.collision");
-  assertAllowedKeys(record, ["kind", "resource"], "ModelProcessingManifest.collision");
+  const record2 = assertRecord(value, "ModelProcessingManifest.collision");
+  assertAllowedKeys(record2, ["kind", "resource"], "ModelProcessingManifest.collision");
   const kind = requiredEnum(
-    record.kind,
+    record2.kind,
     ["none", "box", "convex-hull", "triangle-mesh", "compound"],
     "ModelProcessingManifest.collision.kind"
   );
   if (kind === "none") {
-    if (record.resource !== void 0) {
+    if (record2.resource !== void 0) {
       throw new Error("ModelProcessingManifest collision kind none must not include a resource.");
     }
     return { kind };
   }
-  if (record.resource === void 0) {
+  if (record2.resource === void 0) {
     throw new Error("ModelProcessingManifest non-empty collision kinds require a resource.");
   }
-  const resource = createModelResourceRef(record.resource);
+  const resource = createModelResourceRef(record2.resource);
   if (resource.contentType !== "model/gltf-binary") {
     throw new Error("ModelProcessingManifest collision resources must be model/gltf-binary GLBs.");
   }
   return { kind, resource };
 }
 function createTransform(value, fieldName) {
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["translationMetres", "rotationQuaternion", "scale"], fieldName);
-  const translationMetres = requiredVector3(record.translationMetres, `${fieldName}.translationMetres`);
-  if (!Array.isArray(record.rotationQuaternion) || record.rotationQuaternion.length !== 4) {
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["translationMetres", "rotationQuaternion", "scale"], fieldName);
+  const translationMetres = requiredVector3(record2.translationMetres, `${fieldName}.translationMetres`);
+  if (!Array.isArray(record2.rotationQuaternion) || record2.rotationQuaternion.length !== 4) {
     throw new Error(`${fieldName}.rotationQuaternion must contain exactly four numbers.`);
   }
   const rotationQuaternion = [
-    requiredFiniteNumber(record.rotationQuaternion[0], `${fieldName}.rotationQuaternion[0]`, -1, 1),
-    requiredFiniteNumber(record.rotationQuaternion[1], `${fieldName}.rotationQuaternion[1]`, -1, 1),
-    requiredFiniteNumber(record.rotationQuaternion[2], `${fieldName}.rotationQuaternion[2]`, -1, 1),
-    requiredFiniteNumber(record.rotationQuaternion[3], `${fieldName}.rotationQuaternion[3]`, -1, 1)
+    requiredFiniteNumber(record2.rotationQuaternion[0], `${fieldName}.rotationQuaternion[0]`, -1, 1),
+    requiredFiniteNumber(record2.rotationQuaternion[1], `${fieldName}.rotationQuaternion[1]`, -1, 1),
+    requiredFiniteNumber(record2.rotationQuaternion[2], `${fieldName}.rotationQuaternion[2]`, -1, 1),
+    requiredFiniteNumber(record2.rotationQuaternion[3], `${fieldName}.rotationQuaternion[3]`, -1, 1)
   ];
   const magnitude = Math.hypot(...rotationQuaternion);
   if (Math.abs(magnitude - 1) > 1e-4) {
@@ -1297,31 +1297,31 @@ function createTransform(value, fieldName) {
   return {
     translationMetres,
     rotationQuaternion,
-    scale: requiredVector3(record.scale, `${fieldName}.scale`, true)
+    scale: requiredVector3(record2.scale, `${fieldName}.scale`, true)
   };
 }
 function createAssemblyChildAssetRef(value, resolutionId, candidateId, fieldName) {
-  const record = assertRecord(value, fieldName);
-  if (record.disposition !== "staged-derived") {
+  const record2 = assertRecord(value, fieldName);
+  if (record2.disposition !== "staged-derived") {
     const catalogRef = createModelAssetRef(value);
     if (catalogRef.kind !== "leaf") {
       throw new Error("ModelProcessingManifest v1 assembly child assetRef values must be leaf assets.");
     }
     return catalogRef;
   }
-  assertAllowedKeys(record, [
+  assertAllowedKeys(record2, [
     "disposition",
     "derivedId",
     "kind",
     "contentHash",
     "processingManifestUri"
   ], fieldName);
-  if (record.kind !== "leaf") {
+  if (record2.kind !== "leaf") {
     throw new Error("ModelProcessingManifest staged-derived child assetRef kind must be leaf.");
   }
-  const derivedId = requiredModelPathSegment(record.derivedId, `${fieldName}.derivedId`);
+  const derivedId = requiredModelPathSegment(record2.derivedId, `${fieldName}.derivedId`);
   const processingManifestUri = assertModelUri(
-    record.processingManifestUri,
+    record2.processingManifestUri,
     `${fieldName}.processingManifestUri`
   );
   const expectedUri = `mcp://models/resolutions/${resolutionId}/candidates/${candidateId}/children/${derivedId}/manifest`;
@@ -1332,18 +1332,18 @@ function createAssemblyChildAssetRef(value, resolutionId, candidateId, fieldName
     disposition: "staged-derived",
     derivedId,
     kind: "leaf",
-    contentHash: requiredSha256(record.contentHash, `${fieldName}.contentHash`),
+    contentHash: requiredSha256(record2.contentHash, `${fieldName}.contentHash`),
     processingManifestUri
   };
 }
 function createAssemblyChild(value, index, resolutionId, candidateId) {
   const fieldName = `ModelProcessingManifest.children[${index}]`;
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["instanceId", "parentInstanceId", "assetRef", "transform"], fieldName);
-  const instanceId = requiredToken(record.instanceId, `${fieldName}.instanceId`);
-  const parentInstanceId = record.parentInstanceId === void 0 ? void 0 : requiredToken(record.parentInstanceId, `${fieldName}.parentInstanceId`);
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["instanceId", "parentInstanceId", "assetRef", "transform"], fieldName);
+  const instanceId = requiredToken(record2.instanceId, `${fieldName}.instanceId`);
+  const parentInstanceId = record2.parentInstanceId === void 0 ? void 0 : requiredToken(record2.parentInstanceId, `${fieldName}.parentInstanceId`);
   const childAssetRef = createAssemblyChildAssetRef(
-    record.assetRef,
+    record2.assetRef,
     resolutionId,
     candidateId,
     `${fieldName}.assetRef`
@@ -1352,21 +1352,21 @@ function createAssemblyChild(value, index, resolutionId, candidateId) {
     instanceId,
     ...parentInstanceId === void 0 ? {} : { parentInstanceId },
     assetRef: childAssetRef,
-    transform: createTransform(record.transform, `${fieldName}.transform`)
+    transform: createTransform(record2.transform, `${fieldName}.transform`)
   };
 }
 function createDiagnostic(value, fieldName) {
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["severity", "code", "message"], fieldName);
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["severity", "code", "message"], fieldName);
   return {
-    severity: requiredEnum(record.severity, ["info", "warning", "blocking"], `${fieldName}.severity`),
-    code: requiredToken(record.code, `${fieldName}.code`),
-    message: requiredString(record.message, `${fieldName}.message`, 1024)
+    severity: requiredEnum(record2.severity, ["info", "warning", "blocking"], `${fieldName}.severity`),
+    code: requiredToken(record2.code, `${fieldName}.code`),
+    message: requiredString(record2.message, `${fieldName}.message`, 1024)
   };
 }
 function createConverterEvidence(value) {
-  const record = assertRecord(value, "ModelProcessingManifest.converter");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelProcessingManifest.converter");
+  assertAllowedKeys(record2, [
     "id",
     "version",
     "sourceFormat",
@@ -1376,42 +1376,42 @@ function createConverterEvidence(value) {
     "diagnostics",
     "losses"
   ], "ModelProcessingManifest.converter");
-  if (!Array.isArray(record.diagnostics) || record.diagnostics.length > 100) {
+  if (!Array.isArray(record2.diagnostics) || record2.diagnostics.length > 100) {
     throw new Error("ModelProcessingManifest.converter.diagnostics must be a bounded array.");
   }
-  if (!Array.isArray(record.losses) || record.losses.length > 100) {
+  if (!Array.isArray(record2.losses) || record2.losses.length > 100) {
     throw new Error("ModelProcessingManifest.converter.losses must be a bounded array.");
   }
   return {
-    id: requiredToken(record.id, "ModelProcessingManifest.converter.id"),
-    version: assetVersion(record.version, "ModelProcessingManifest.converter.version"),
-    sourceFormat: requiredToken(record.sourceFormat, "ModelProcessingManifest.converter.sourceFormat"),
-    targetFormat: requiredToken(record.targetFormat, "ModelProcessingManifest.converter.targetFormat"),
-    sourceContentHash: requiredSha256(record.sourceContentHash, "ModelProcessingManifest.converter.sourceContentHash"),
-    outputContentHash: requiredSha256(record.outputContentHash, "ModelProcessingManifest.converter.outputContentHash"),
-    diagnostics: record.diagnostics.map((item, index) => createDiagnostic(item, `ModelProcessingManifest.converter.diagnostics[${index}]`)),
-    losses: record.losses.map((item, index) => createDiagnostic(item, `ModelProcessingManifest.converter.losses[${index}]`))
+    id: requiredToken(record2.id, "ModelProcessingManifest.converter.id"),
+    version: assetVersion(record2.version, "ModelProcessingManifest.converter.version"),
+    sourceFormat: requiredToken(record2.sourceFormat, "ModelProcessingManifest.converter.sourceFormat"),
+    targetFormat: requiredToken(record2.targetFormat, "ModelProcessingManifest.converter.targetFormat"),
+    sourceContentHash: requiredSha256(record2.sourceContentHash, "ModelProcessingManifest.converter.sourceContentHash"),
+    outputContentHash: requiredSha256(record2.outputContentHash, "ModelProcessingManifest.converter.outputContentHash"),
+    diagnostics: record2.diagnostics.map((item, index) => createDiagnostic(item, `ModelProcessingManifest.converter.diagnostics[${index}]`)),
+    losses: record2.losses.map((item, index) => createDiagnostic(item, `ModelProcessingManifest.converter.losses[${index}]`))
   };
 }
 function createFidelityEvidence(value, index) {
   const fieldName = `ModelProcessingManifest.fidelityEvidence[${index}]`;
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, ["aspect", "outcome", "message", "evidenceResource"], fieldName);
-  const evidenceResource = record.evidenceResource === void 0 ? void 0 : createModelResourceRef(record.evidenceResource);
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, ["aspect", "outcome", "message", "evidenceResource"], fieldName);
+  const evidenceResource = record2.evidenceResource === void 0 ? void 0 : createModelResourceRef(record2.evidenceResource);
   return {
     aspect: requiredEnum(
-      record.aspect,
+      record2.aspect,
       ["geometry", "materials", "textures", "rigging", "animation", "metadata"],
       `${fieldName}.aspect`
     ),
-    outcome: requiredEnum(record.outcome, ["preserved", "approximated", "lost"], `${fieldName}.outcome`),
-    message: requiredString(record.message, `${fieldName}.message`, 1024),
+    outcome: requiredEnum(record2.outcome, ["preserved", "approximated", "lost"], `${fieldName}.outcome`),
+    message: requiredString(record2.message, `${fieldName}.message`, 1024),
     ...evidenceResource === void 0 ? {} : { evidenceResource }
   };
 }
 function createCollisionPolicyEvidence(value, collision) {
-  const record = assertRecord(value, "ModelProcessingManifest.collisionPolicy");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelProcessingManifest.collisionPolicy");
+  assertAllowedKeys(record2, [
     "profileId",
     "profileVersion",
     "disposition",
@@ -1419,7 +1419,7 @@ function createCollisionPolicyEvidence(value, collision) {
     "decisionToken"
   ], "ModelProcessingManifest.collisionPolicy");
   const disposition = requiredEnum(
-    record.disposition,
+    record2.disposition,
     ["proxy-required", "none-allowed"],
     "ModelProcessingManifest.collisionPolicy.disposition"
   );
@@ -1427,22 +1427,22 @@ function createCollisionPolicyEvidence(value, collision) {
     throw new Error("ModelProcessingManifest collisionPolicy must explicitly authorize collision none or require a proxy.");
   }
   return {
-    profileId: requiredToken(record.profileId, "ModelProcessingManifest.collisionPolicy.profileId"),
+    profileId: requiredToken(record2.profileId, "ModelProcessingManifest.collisionPolicy.profileId"),
     profileVersion: assetVersion(
-      record.profileVersion,
+      record2.profileVersion,
       "ModelProcessingManifest.collisionPolicy.profileVersion"
     ),
     disposition,
-    category: requiredToken(record.category, "ModelProcessingManifest.collisionPolicy.category"),
+    category: requiredToken(record2.category, "ModelProcessingManifest.collisionPolicy.category"),
     decisionToken: requiredAttestationToken(
-      record.decisionToken,
+      record2.decisionToken,
       "ModelProcessingManifest.collisionPolicy.decisionToken"
     )
   };
 }
 function createFidelityGateEvidence(value, fidelityEvidence, converter) {
-  const record = assertRecord(value, "ModelProcessingManifest.fidelityGate");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelProcessingManifest.fidelityGate");
+  assertAllowedKeys(record2, [
     "profileId",
     "profileVersion",
     "outcome",
@@ -1451,7 +1451,7 @@ function createFidelityGateEvidence(value, fidelityEvidence, converter) {
     "decisionToken"
   ], "ModelProcessingManifest.fidelityGate");
   const expectedAspects = ["geometry", "materials", "textures"];
-  if (!Array.isArray(record.requiredAspects) || record.requiredAspects.length !== expectedAspects.length || record.requiredAspects.some((aspect, index) => aspect !== expectedAspects[index])) {
+  if (!Array.isArray(record2.requiredAspects) || record2.requiredAspects.length !== expectedAspects.length || record2.requiredAspects.some((aspect, index) => aspect !== expectedAspects[index])) {
     throw new Error("ModelProcessingManifest.fidelityGate.requiredAspects must be geometry, materials, textures.");
   }
   const byAspect = new Map(fidelityEvidence.map((evidence) => [evidence.aspect, evidence]));
@@ -1469,7 +1469,7 @@ function createFidelityGateEvidence(value, fidelityEvidence, converter) {
   ) || hasWarningLoss;
   const derivedOutcome = hasBlockingConverterEvidence || geometryLost ? "blocked" : hasUnresolvedFidelity ? "low-only" : "passed";
   const outcome = requiredEnum(
-    record.outcome,
+    record2.outcome,
     ["passed", "low-only", "blocked"],
     "ModelProcessingManifest.fidelityGate.outcome"
   );
@@ -1477,13 +1477,13 @@ function createFidelityGateEvidence(value, fidelityEvidence, converter) {
     throw new Error("ModelProcessingManifest fidelityGate outcome must match converter and fidelity evidence.");
   }
   return {
-    profileId: requiredToken(record.profileId, "ModelProcessingManifest.fidelityGate.profileId"),
-    profileVersion: assetVersion(record.profileVersion, "ModelProcessingManifest.fidelityGate.profileVersion"),
+    profileId: requiredToken(record2.profileId, "ModelProcessingManifest.fidelityGate.profileId"),
+    profileVersion: assetVersion(record2.profileVersion, "ModelProcessingManifest.fidelityGate.profileVersion"),
     outcome,
     requiredAspects: expectedAspects,
-    evaluatedAt: requiredTimestamp(record.evaluatedAt, "ModelProcessingManifest.fidelityGate.evaluatedAt"),
+    evaluatedAt: requiredTimestamp(record2.evaluatedAt, "ModelProcessingManifest.fidelityGate.evaluatedAt"),
     decisionToken: requiredAttestationToken(
-      record.decisionToken,
+      record2.decisionToken,
       "ModelProcessingManifest.fidelityGate.decisionToken"
     )
   };
@@ -1492,15 +1492,15 @@ function assertCoordinateSystem(value) {
   if (value === void 0) {
     return;
   }
-  const record = assertRecord(value, "ModelProcessingManifest.coordinateSystem");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelProcessingManifest.coordinateSystem");
+  assertAllowedKeys(record2, [
     "unit",
     "upAxis",
     "forwardAxis",
     "origin",
     "outwardFaceWinding"
   ], "ModelProcessingManifest.coordinateSystem");
-  if (record.unit !== CANONICAL_MODEL_COORDINATE_SYSTEM.unit || record.upAxis !== CANONICAL_MODEL_COORDINATE_SYSTEM.upAxis || record.forwardAxis !== CANONICAL_MODEL_COORDINATE_SYSTEM.forwardAxis || record.origin !== CANONICAL_MODEL_COORDINATE_SYSTEM.origin || record.outwardFaceWinding !== CANONICAL_MODEL_COORDINATE_SYSTEM.outwardFaceWinding) {
+  if (record2.unit !== CANONICAL_MODEL_COORDINATE_SYSTEM.unit || record2.upAxis !== CANONICAL_MODEL_COORDINATE_SYSTEM.upAxis || record2.forwardAxis !== CANONICAL_MODEL_COORDINATE_SYSTEM.forwardAxis || record2.origin !== CANONICAL_MODEL_COORDINATE_SYSTEM.origin || record2.outwardFaceWinding !== CANONICAL_MODEL_COORDINATE_SYSTEM.outwardFaceWinding) {
     throw new Error(
       "ModelProcessingManifest.coordinateSystem must be metres, Y-up, -Z forward, floor-centred, and counter-clockwise outward."
     );
@@ -1544,8 +1544,8 @@ function assertAssemblyHierarchy(children) {
   }
 }
 function createModelProcessingManifest(input) {
-  const record = assertRecord(input, "ModelProcessingManifest");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelProcessingManifest");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "manifestId",
     "resolutionId",
@@ -1564,23 +1564,23 @@ function createModelProcessingManifest(input) {
     "fidelityGate",
     "processedAt"
   ], "ModelProcessingManifest");
-  assertContractVersion(record, "ModelProcessingManifest");
+  assertContractVersion(record2, "ModelProcessingManifest");
   const resolutionId = requiredModelPathSegment(
-    record.resolutionId,
+    record2.resolutionId,
     "ModelProcessingManifest.resolutionId"
   );
   const candidateId = requiredModelPathSegment(
-    record.candidateId,
+    record2.candidateId,
     "ModelProcessingManifest.candidateId"
   );
-  assertCoordinateSystem(record.coordinateSystem);
-  const kind = requiredEnum(record.kind, MODEL_ASSET_KINDS, "ModelProcessingManifest.kind");
-  const contentHash = requiredSha256(record.contentHash, "ModelProcessingManifest.contentHash");
-  const closureHash = requiredSha256(record.closureHash, "ModelProcessingManifest.closureHash");
+  assertCoordinateSystem(record2.coordinateSystem);
+  const kind = requiredEnum(record2.kind, MODEL_ASSET_KINDS, "ModelProcessingManifest.kind");
+  const contentHash = requiredSha256(record2.contentHash, "ModelProcessingManifest.contentHash");
+  const closureHash = requiredSha256(record2.closureHash, "ModelProcessingManifest.closureHash");
   if (kind === "leaf" && closureHash !== contentHash) {
     throw new Error("ModelProcessingManifest leaf closureHash must match contentHash.");
   }
-  const technicalProfile = createModelTechnicalProfile(record.technicalProfile);
+  const technicalProfile = createModelTechnicalProfile(record2.technicalProfile);
   const [minimumX, minimumY, minimumZ] = technicalProfile.boundsMetres.min;
   const [maximumX, , maximumZ] = technicalProfile.boundsMetres.max;
   if (Math.abs(minimumY) > MODEL_CANONICAL_ORIGIN_TOLERANCE_METRES || Math.abs((minimumX + maximumX) / 2) > MODEL_CANONICAL_ORIGIN_TOLERANCE_METRES || Math.abs((minimumZ + maximumZ) / 2) > MODEL_CANONICAL_ORIGIN_TOLERANCE_METRES) {
@@ -1588,10 +1588,10 @@ function createModelProcessingManifest(input) {
       "ModelProcessingManifest floor-centred origin requires minY and the X/Z bounds centre to be zero."
     );
   }
-  if (!Array.isArray(record.lods) || record.lods.length < 1 || record.lods.length > 4) {
+  if (!Array.isArray(record2.lods) || record2.lods.length < 1 || record2.lods.length > 4) {
     throw new Error("ModelProcessingManifest.lods must contain one to four adaptive levels beginning with LOD0.");
   }
-  const lods = record.lods.map(createLodRecord);
+  const lods = record2.lods.map(createLodRecord);
   for (const [index, lod] of lods.entries()) {
     if (lod.level !== index) {
       throw new Error("ModelProcessingManifest LOD levels must be contiguous and begin with LOD0.");
@@ -1637,8 +1637,8 @@ function createModelProcessingManifest(input) {
       `ModelProcessingManifest.lods[${index}].resource`
     );
   }
-  const collision = createCollisionRecord(record.collision);
-  const collisionPolicy = createCollisionPolicyEvidence(record.collisionPolicy, collision);
+  const collision = createCollisionRecord(record2.collision);
+  const collisionPolicy = createCollisionPolicyEvidence(record2.collisionPolicy, collision);
   if (technicalProfile.hasCollision !== (collision.kind !== "none")) {
     throw new Error("ModelProcessingManifest technicalProfile.hasCollision must match collision evidence.");
   }
@@ -1653,10 +1653,10 @@ function createModelProcessingManifest(input) {
       "ModelProcessingManifest.collision.resource"
     );
   }
-  if (!Array.isArray(record.children) || record.children.length > 256) {
+  if (!Array.isArray(record2.children) || record2.children.length > 256) {
     throw new Error("ModelProcessingManifest.children must be a bounded array.");
   }
-  const children = record.children.map((child, index) => createAssemblyChild(child, index, resolutionId, candidateId));
+  const children = record2.children.map((child, index) => createAssemblyChild(child, index, resolutionId, candidateId));
   if (kind === "leaf" && children.length !== 0) {
     throw new Error("ModelProcessingManifest leaf models must not contain assembly children.");
   }
@@ -1670,17 +1670,17 @@ function createModelProcessingManifest(input) {
     throw new Error("ModelProcessingManifest assembly instanceId values must be unique.");
   }
   assertAssemblyHierarchy(children);
-  const converter = createConverterEvidence(record.converter);
+  const converter = createConverterEvidence(record2.converter);
   if (converter.targetFormat !== "glb") {
     throw new Error("ModelProcessingManifest converter.targetFormat must be glb.");
   }
   if (converter.outputContentHash !== contentHash) {
     throw new Error("ModelProcessingManifest converter outputContentHash must match contentHash.");
   }
-  if (!Array.isArray(record.fidelityEvidence) || record.fidelityEvidence.length > 100) {
+  if (!Array.isArray(record2.fidelityEvidence) || record2.fidelityEvidence.length > 100) {
     throw new Error("ModelProcessingManifest.fidelityEvidence must be a bounded array.");
   }
-  const fidelityEvidence = record.fidelityEvidence.map(createFidelityEvidence);
+  const fidelityEvidence = record2.fidelityEvidence.map(createFidelityEvidence);
   if (new Set(fidelityEvidence.map((evidence) => evidence.aspect)).size !== fidelityEvidence.length) {
     throw new Error("ModelProcessingManifest fidelity evidence aspects must be unique.");
   }
@@ -1694,10 +1694,10 @@ function createModelProcessingManifest(input) {
       );
     }
   }
-  const fidelityGate = createFidelityGateEvidence(record.fidelityGate, fidelityEvidence, converter);
+  const fidelityGate = createFidelityGateEvidence(record2.fidelityGate, fidelityEvidence, converter);
   return deepFreeze({
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
-    manifestId: requiredToken(record.manifestId, "ModelProcessingManifest.manifestId"),
+    manifestId: requiredToken(record2.manifestId, "ModelProcessingManifest.manifestId"),
     resolutionId,
     candidateId,
     kind,
@@ -1712,7 +1712,7 @@ function createModelProcessingManifest(input) {
     converter,
     fidelityEvidence,
     fidelityGate,
-    processedAt: requiredTimestamp(record.processedAt, "ModelProcessingManifest.processedAt")
+    processedAt: requiredTimestamp(record2.processedAt, "ModelProcessingManifest.processedAt")
   });
 }
 function modelCandidateEquivalent(left, right) {
@@ -1731,8 +1731,8 @@ function createModelPromotionReceipt(input, resolutionId, candidate, confirmatio
   if (candidate.assetRef.disposition !== "proposed") {
     throw new Error("ModelPromotionReceipt is only valid for a staged proposed candidate.");
   }
-  const record = assertRecord(input, "ModelPromotionReceipt");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelPromotionReceipt");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "promotionId",
     "resolutionId",
@@ -1746,17 +1746,17 @@ function createModelPromotionReceipt(input, resolutionId, candidate, confirmatio
     "promotedAt",
     "publicationToken"
   ], "ModelPromotionReceipt");
-  assertContractVersion(record, "ModelPromotionReceipt");
-  if (record.resolutionId !== resolutionId || record.candidateId !== candidate.candidateId || record.proposalId !== candidate.assetRef.proposalId || record.confirmationId !== confirmation.confirmationId || record.processingManifestId !== candidate.processingManifest.manifestId || record.processingContentHash !== candidate.processingManifest.contentHash || record.closureHash !== candidate.processingManifest.closureHash) {
+  assertContractVersion(record2, "ModelPromotionReceipt");
+  if (record2.resolutionId !== resolutionId || record2.candidateId !== candidate.candidateId || record2.proposalId !== candidate.assetRef.proposalId || record2.confirmationId !== confirmation.confirmationId || record2.processingManifestId !== candidate.processingManifest.manifestId || record2.processingContentHash !== candidate.processingManifest.contentHash || record2.closureHash !== candidate.processingManifest.closureHash) {
     throw new Error("ModelPromotionReceipt must bind the exact proposal, confirmation, manifest, and closure.");
   }
-  const receiptAssetRef = createModelAssetRef(record.finalAssetRef);
+  const receiptAssetRef = createModelAssetRef(record2.finalAssetRef);
   if (JSON.stringify(receiptAssetRef) !== JSON.stringify(finalAssetRef)) {
     throw new Error("ModelPromotionReceipt.finalAssetRef must match the completed finalAssetRef.");
   }
   return deepFreeze({
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
-    promotionId: requiredToken(record.promotionId, "ModelPromotionReceipt.promotionId"),
+    promotionId: requiredToken(record2.promotionId, "ModelPromotionReceipt.promotionId"),
     resolutionId,
     candidateId: candidate.candidateId,
     proposalId: candidate.assetRef.proposalId,
@@ -1765,9 +1765,9 @@ function createModelPromotionReceipt(input, resolutionId, candidate, confirmatio
     processingContentHash: candidate.processingManifest.contentHash,
     closureHash: candidate.processingManifest.closureHash,
     finalAssetRef: receiptAssetRef,
-    promotedAt: requiredTimestamp(record.promotedAt, "ModelPromotionReceipt.promotedAt"),
+    promotedAt: requiredTimestamp(record2.promotedAt, "ModelPromotionReceipt.promotedAt"),
     publicationToken: requiredAttestationToken(
-      record.publicationToken,
+      record2.publicationToken,
       "ModelPromotionReceipt.publicationToken"
     )
   });
@@ -1828,8 +1828,8 @@ function isModelResolutionState(value) {
   return typeof value === "string" && MODEL_RESOLUTION_STATES.includes(value);
 }
 function createModelResolution(input) {
-  const record = assertRecord(input, "ModelResolution");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelResolution");
+  assertAllowedKeys(record2, [
     "contractVersion",
     "resolutionId",
     "request",
@@ -1845,19 +1845,19 @@ function createModelResolution(input) {
     "createdAt",
     "updatedAt"
   ], "ModelResolution");
-  assertContractVersion(record, "ModelResolution");
-  const resolutionId = requiredModelPathSegment(record.resolutionId, "ModelResolution.resolutionId");
-  const request = createModelRequestSpec(record.request);
-  const createdAt = requiredTimestamp(record.createdAt, "ModelResolution.createdAt");
-  const updatedAt = requiredTimestamp(record.updatedAt, "ModelResolution.updatedAt");
+  assertContractVersion(record2, "ModelResolution");
+  const resolutionId = requiredModelPathSegment(record2.resolutionId, "ModelResolution.resolutionId");
+  const request = createModelRequestSpec(record2.request);
+  const createdAt = requiredTimestamp(record2.createdAt, "ModelResolution.createdAt");
+  const updatedAt = requiredTimestamp(record2.updatedAt, "ModelResolution.updatedAt");
   if (Date.parse(updatedAt) < Date.parse(createdAt)) {
     throw new Error("ModelResolution.updatedAt must not precede createdAt.");
   }
-  const state = requiredEnum(record.state, MODEL_RESOLUTION_STATES, "ModelResolution.state");
-  if (!Array.isArray(record.candidates) || record.candidates.length > MAX_CANDIDATES) {
+  const state = requiredEnum(record2.state, MODEL_RESOLUTION_STATES, "ModelResolution.state");
+  if (!Array.isArray(record2.candidates) || record2.candidates.length > MAX_CANDIDATES) {
     throw new Error(`ModelResolution.candidates must contain at most ${MAX_CANDIDATES} items.`);
   }
-  const candidates = record.candidates.map(createModelCandidate);
+  const candidates = record2.candidates.map(createModelCandidate);
   if (new Set(candidates.map((candidate) => candidate.candidateId)).size !== candidates.length) {
     throw new Error("ModelResolution candidateId values must be unique.");
   }
@@ -1891,8 +1891,8 @@ function createModelResolution(input) {
     }
   }
   let bestCandidate;
-  if (record.bestCandidate !== void 0) {
-    const requestedBest = createModelCandidate(record.bestCandidate);
+  if (record2.bestCandidate !== void 0) {
+    const requestedBest = createModelCandidate(record2.bestCandidate);
     bestCandidate = candidates.find((candidate) => candidate.candidateId === requestedBest.candidateId);
     if (bestCandidate === void 0 || !modelCandidateEquivalent(bestCandidate, requestedBest)) {
       throw new Error("ModelResolution.bestCandidate must exactly match a candidate.");
@@ -1907,11 +1907,11 @@ function createModelResolution(input) {
     );
   }
   let confirmation;
-  if (record.confirmation !== void 0) {
+  if (record2.confirmation !== void 0) {
     if (bestCandidate === void 0) {
       throw new Error("ModelResolution confirmation requires bestCandidate.");
     }
-    confirmation = createModelCandidateConfirmation(record.confirmation, bestCandidate, resolutionId);
+    confirmation = createModelCandidateConfirmation(record2.confirmation, bestCandidate, resolutionId);
     if (Date.parse(confirmation.confirmedAt) < Date.parse(createdAt) || Date.parse(confirmation.confirmedAt) > Date.parse(updatedAt)) {
       throw new Error("ModelResolution confirmation.confirmedAt must fall between createdAt and updatedAt.");
     }
@@ -1925,15 +1925,15 @@ function createModelResolution(input) {
   if (confirmation !== void 0 && !["promoting", "completed", "failed", "cancelled"].includes(state)) {
     throw new Error(`ModelResolution confirmation evidence is not allowed in ${state} state.`);
   }
-  const refinementQuestions = record.refinementQuestions === void 0 ? [] : stringList(record.refinementQuestions, "ModelResolution.refinementQuestions", { maxItems: 3 });
-  const stateReasonCode = record.stateReasonCode === void 0 ? void 0 : requiredToken(record.stateReasonCode, "ModelResolution.stateReasonCode");
+  const refinementQuestions = record2.refinementQuestions === void 0 ? [] : stringList(record2.refinementQuestions, "ModelResolution.refinementQuestions", { maxItems: 3 });
+  const stateReasonCode = record2.stateReasonCode === void 0 ? void 0 : requiredToken(record2.stateReasonCode, "ModelResolution.stateReasonCode");
   if (["failed", "cancelled", "unresolved"].includes(state) && stateReasonCode === void 0) {
     throw new Error(`ModelResolution ${state} state requires stateReasonCode.`);
   }
   if (state === "awaiting-confirmation" && bestCandidate?.match.assurance === "low" && refinementQuestions.length === 0) {
     throw new Error("ModelResolution low-assurance bestCandidate requires refinementQuestions.");
   }
-  const finalAssetRef = record.finalAssetRef === void 0 ? void 0 : createModelAssetRef(record.finalAssetRef);
+  const finalAssetRef = record2.finalAssetRef === void 0 ? void 0 : createModelAssetRef(record2.finalAssetRef);
   if (state === "completed" && finalAssetRef === void 0) {
     throw new Error("ModelResolution completed state requires finalAssetRef.");
   }
@@ -1944,12 +1944,12 @@ function createModelResolution(input) {
     throw new Error("ModelResolution finalAssetRef must match bestCandidate kind, hash, and immutable identity.");
   }
   let promotionReceipt;
-  if (record.promotionReceipt !== void 0) {
+  if (record2.promotionReceipt !== void 0) {
     if (state !== "completed" || bestCandidate === void 0 || confirmation === void 0 || finalAssetRef === void 0) {
       throw new Error("ModelResolution promotionReceipt is only allowed for a completed staged promotion.");
     }
     promotionReceipt = createModelPromotionReceipt(
-      record.promotionReceipt,
+      record2.promotionReceipt,
       resolutionId,
       bestCandidate,
       confirmation,
@@ -1969,7 +1969,7 @@ function createModelResolution(input) {
     contractVersion: MODEL_RESOLUTION_CONTRACT_VERSION,
     resolutionId,
     request,
-    attempts: requiredInteger(record.attempts, "ModelResolution.attempts", 1, MAX_ATTEMPTS),
+    attempts: requiredInteger(record2.attempts, "ModelResolution.attempts", 1, MAX_ATTEMPTS),
     state,
     candidates,
     ...bestCandidate === void 0 ? {} : { bestCandidate },
@@ -1991,15 +1991,15 @@ function createGeneratorSeed(value, fieldName) {
   return seed;
 }
 function createModelGeneratorRequest(input) {
-  const record = assertRecord(input, "ModelGeneratorRequest");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(input, "ModelGeneratorRequest");
+  assertAllowedKeys(record2, [
     "generationId",
     "request",
     "budgets",
     "seed",
     "deadline"
   ], "ModelGeneratorRequest");
-  const budgets = assertRecord(record.budgets, "ModelGeneratorRequest.budgets");
+  const budgets = assertRecord(record2.budgets, "ModelGeneratorRequest.budgets");
   assertAllowedKeys(budgets, [
     "maxDurationMs",
     "maxTriangles",
@@ -2007,7 +2007,7 @@ function createModelGeneratorRequest(input) {
     "maxTextureBytes",
     "maxTextureDimensionPx"
   ], "ModelGeneratorRequest.budgets");
-  const seed = createGeneratorSeed(record.seed, "ModelGeneratorRequest.seed");
+  const seed = createGeneratorSeed(record2.seed, "ModelGeneratorRequest.seed");
   const maxBytes = requiredInteger(
     budgets.maxBytes,
     "ModelGeneratorRequest budget maxBytes",
@@ -2024,8 +2024,8 @@ function createModelGeneratorRequest(input) {
     throw new Error("ModelGeneratorRequest maxTextureBytes must not exceed maxBytes.");
   }
   return deepFreeze({
-    generationId: requiredModelPathSegment(record.generationId, "ModelGeneratorRequest.generationId"),
-    request: createModelRequestSpec(record.request),
+    generationId: requiredModelPathSegment(record2.generationId, "ModelGeneratorRequest.generationId"),
+    request: createModelRequestSpec(record2.request),
     budgets: {
       maxDurationMs: requiredInteger(budgets.maxDurationMs, "ModelGeneratorRequest budget maxDurationMs", 1, 3e5),
       maxTriangles: requiredInteger(budgets.maxTriangles, "ModelGeneratorRequest budget maxTriangles", 1, 1e7),
@@ -2034,7 +2034,7 @@ function createModelGeneratorRequest(input) {
       maxTextureDimensionPx: requiredInteger(budgets.maxTextureDimensionPx, "ModelGeneratorRequest budget maxTextureDimensionPx", 1, 32768)
     },
     seed,
-    deadline: requiredTimestamp(record.deadline, "ModelGeneratorRequest.deadline")
+    deadline: requiredTimestamp(record2.deadline, "ModelGeneratorRequest.deadline")
   });
 }
 var MODEL_GENERATOR_ARTIFACT_ROLES = [
@@ -2072,8 +2072,8 @@ function assertGeneratorRetryability(reasonCode2, retryable) {
 }
 function createModelGeneratorArtifact(value, index) {
   const fieldName = `ModelGeneratorResult.sourceBundle.artifacts[${index}]`;
-  const record = assertRecord(value, fieldName);
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, fieldName);
+  assertAllowedKeys(record2, [
     "uri",
     "byteLength",
     "sha256",
@@ -2083,12 +2083,12 @@ function createModelGeneratorArtifact(value, index) {
     "maxTextureDimensionPx"
   ], fieldName);
   const resource = createModelResourceRef({
-    uri: record.uri,
-    byteLength: record.byteLength,
-    sha256: record.sha256,
-    contentType: record.contentType
+    uri: record2.uri,
+    byteLength: record2.byteLength,
+    sha256: record2.sha256,
+    contentType: record2.contentType
   });
-  const role = requiredEnum(record.role, MODEL_GENERATOR_ARTIFACT_ROLES, `${fieldName}.role`);
+  const role = requiredEnum(record2.role, MODEL_GENERATOR_ARTIFACT_ROLES, `${fieldName}.role`);
   const compatibleContentTypes = {
     "model-entrypoint": ["model/gltf-binary", "model/gltf+json"],
     "model-dependency": ["model/gltf-binary", "model/gltf+json"],
@@ -2100,13 +2100,13 @@ function createModelGeneratorArtifact(value, index) {
     throw new Error(`${fieldName}.contentType is not compatible with artifact role ${role}.`);
   }
   const textureByteLength = requiredInteger(
-    record.textureByteLength,
+    record2.textureByteLength,
     `${fieldName}.textureByteLength`,
     0,
     resource.byteLength
   );
   const maxTextureDimensionPx = requiredInteger(
-    record.maxTextureDimensionPx,
+    record2.maxTextureDimensionPx,
     `${fieldName}.maxTextureDimensionPx`,
     0,
     32768
@@ -2123,8 +2123,8 @@ function createModelGeneratorArtifact(value, index) {
   return { ...resource, role, textureByteLength, maxTextureDimensionPx };
 }
 function createModelGeneratorUsage(value) {
-  const record = assertRecord(value, "ModelGeneratorResult.sourceBundle.usage");
-  assertAllowedKeys(record, [
+  const record2 = assertRecord(value, "ModelGeneratorResult.sourceBundle.usage");
+  assertAllowedKeys(record2, [
     "durationMs",
     "triangleCount",
     "byteLength",
@@ -2132,13 +2132,13 @@ function createModelGeneratorUsage(value) {
     "maxTextureDimensionPx"
   ], "ModelGeneratorResult.sourceBundle.usage");
   const textureByteLength = requiredInteger(
-    record.textureByteLength,
+    record2.textureByteLength,
     "ModelGeneratorResult.sourceBundle.usage.textureByteLength",
     0,
     Number.MAX_SAFE_INTEGER
   );
   const maxTextureDimensionPx = requiredInteger(
-    record.maxTextureDimensionPx,
+    record2.maxTextureDimensionPx,
     "ModelGeneratorResult.sourceBundle.usage.maxTextureDimensionPx",
     0,
     32768
@@ -2147,30 +2147,30 @@ function createModelGeneratorUsage(value) {
     throw new Error("ModelGeneratorResult texture usage bytes and dimensions must both be zero or both positive.");
   }
   return {
-    durationMs: requiredInteger(record.durationMs, "ModelGeneratorResult.sourceBundle.usage.durationMs", 0, 3e5),
-    triangleCount: requiredInteger(record.triangleCount, "ModelGeneratorResult.sourceBundle.usage.triangleCount", 1, 1e7),
-    byteLength: requiredInteger(record.byteLength, "ModelGeneratorResult.sourceBundle.usage.byteLength", 1, Number.MAX_SAFE_INTEGER),
+    durationMs: requiredInteger(record2.durationMs, "ModelGeneratorResult.sourceBundle.usage.durationMs", 0, 3e5),
+    triangleCount: requiredInteger(record2.triangleCount, "ModelGeneratorResult.sourceBundle.usage.triangleCount", 1, 1e7),
+    byteLength: requiredInteger(record2.byteLength, "ModelGeneratorResult.sourceBundle.usage.byteLength", 1, Number.MAX_SAFE_INTEGER),
     textureByteLength,
     maxTextureDimensionPx
   };
 }
-function createGeneratorTerminalEvidence(record, expected) {
-  const generationId = requiredModelPathSegment(record.generationId, "ModelGeneratorResult.generationId");
+function createGeneratorTerminalEvidence(record2, expected) {
+  const generationId = requiredModelPathSegment(record2.generationId, "ModelGeneratorResult.generationId");
   if (generationId !== expected.generationId) {
     throw new Error("ModelGeneratorResult.generationId must match the generator request.");
   }
-  const diagnosticId = record.diagnosticId === void 0 ? void 0 : requiredToken(record.diagnosticId, "ModelGeneratorResult.diagnosticId");
+  const diagnosticId = record2.diagnosticId === void 0 ? void 0 : requiredToken(record2.diagnosticId, "ModelGeneratorResult.diagnosticId");
   return {
     generationId,
-    retryable: requiredBoolean(record.retryable, "ModelGeneratorResult.retryable"),
-    occurredAt: requiredTimestamp(record.occurredAt, "ModelGeneratorResult.occurredAt"),
+    retryable: requiredBoolean(record2.retryable, "ModelGeneratorResult.retryable"),
+    occurredAt: requiredTimestamp(record2.occurredAt, "ModelGeneratorResult.occurredAt"),
     ...diagnosticId === void 0 ? {} : { diagnosticId }
   };
 }
 function createModelGeneratorResult(input, expectedRequest) {
   const expected = createModelGeneratorRequest(expectedRequest);
-  const record = assertRecord(input, "ModelGeneratorResult");
-  const status = requiredEnum(record.status, [
+  const record2 = assertRecord(input, "ModelGeneratorResult");
+  const status = requiredEnum(record2.status, [
     "disabled",
     "generated",
     "unavailable",
@@ -2178,13 +2178,13 @@ function createModelGeneratorResult(input, expectedRequest) {
     "cancelled",
     "budget-exceeded"
   ], "ModelGeneratorResult.status");
-  const generationId = requiredModelPathSegment(record.generationId, "ModelGeneratorResult.generationId");
+  const generationId = requiredModelPathSegment(record2.generationId, "ModelGeneratorResult.generationId");
   if (generationId !== expected.generationId) {
     throw new Error("ModelGeneratorResult.generationId must match the generator request.");
   }
   if (status === "disabled") {
-    assertAllowedKeys(record, ["status", "generationId", "reasonCode"], "ModelGeneratorResult");
-    if (record.reasonCode !== MODEL_GENERATOR_DISABLED_REASON_CODE) {
+    assertAllowedKeys(record2, ["status", "generationId", "reasonCode"], "ModelGeneratorResult");
+    if (record2.reasonCode !== MODEL_GENERATOR_DISABLED_REASON_CODE) {
       throw new Error(
         `ModelGeneratorResult.reasonCode must be ${MODEL_GENERATOR_DISABLED_REASON_CODE}.`
       );
@@ -2196,8 +2196,8 @@ function createModelGeneratorResult(input, expectedRequest) {
     });
   }
   if (status === "generated") {
-    assertAllowedKeys(record, ["status", "generationId", "sourceBundle"], "ModelGeneratorResult");
-    const sourceBundle = assertRecord(record.sourceBundle, "ModelGeneratorResult.sourceBundle");
+    assertAllowedKeys(record2, ["status", "generationId", "sourceBundle"], "ModelGeneratorResult");
+    const sourceBundle = assertRecord(record2.sourceBundle, "ModelGeneratorResult.sourceBundle");
     assertAllowedKeys(sourceBundle, [
       "bundleId",
       "generationId",
@@ -2297,14 +2297,14 @@ function createModelGeneratorResult(input, expectedRequest) {
     "diagnosticId"
   ];
   if (status === "budget-exceeded") {
-    assertAllowedKeys(record, [...terminalAllowedKeys, "violations"], "ModelGeneratorResult");
-    if (record.reasonCode !== "generator-budget-exceeded" || record.retryable !== false) {
+    assertAllowedKeys(record2, [...terminalAllowedKeys, "violations"], "ModelGeneratorResult");
+    if (record2.reasonCode !== "generator-budget-exceeded" || record2.retryable !== false) {
       throw new Error("ModelGeneratorResult budget-exceeded must use its fixed reasonCode and retryable false.");
     }
-    if (!Array.isArray(record.violations) || record.violations.length < 1 || record.violations.length > 5) {
+    if (!Array.isArray(record2.violations) || record2.violations.length < 1 || record2.violations.length > 5) {
       throw new Error("ModelGeneratorResult budget violations must contain one to five entries.");
     }
-    const violations = record.violations.map((value, index) => {
+    const violations = record2.violations.map((value, index) => {
       const fieldName = `ModelGeneratorResult.violations[${index}]`;
       const violation = assertRecord(value, fieldName);
       assertAllowedKeys(violation, ["budget", "limit", "observed"], fieldName);
@@ -2319,7 +2319,7 @@ function createModelGeneratorResult(input, expectedRequest) {
     if (new Set(violations.map((violation) => violation.budget)).size !== violations.length) {
       throw new Error("ModelGeneratorResult budget violation names must be unique.");
     }
-    const terminal2 = createGeneratorTerminalEvidence(record, expected);
+    const terminal2 = createGeneratorTerminalEvidence(record2, expected);
     return deepFreeze({
       status,
       ...terminal2,
@@ -2328,10 +2328,10 @@ function createModelGeneratorResult(input, expectedRequest) {
       violations
     });
   }
-  assertAllowedKeys(record, terminalAllowedKeys, "ModelGeneratorResult");
-  const terminal = createGeneratorTerminalEvidence(record, expected);
+  assertAllowedKeys(record2, terminalAllowedKeys, "ModelGeneratorResult");
+  const terminal = createGeneratorTerminalEvidence(record2, expected);
   if (status === "unavailable") {
-    const reasonCode3 = requiredEnum(record.reasonCode, [
+    const reasonCode3 = requiredEnum(record2.reasonCode, [
       "capacity-unavailable",
       "provider-unavailable",
       "authentication-required",
@@ -2342,7 +2342,7 @@ function createModelGeneratorResult(input, expectedRequest) {
     return deepFreeze({ status, ...terminal, reasonCode: reasonCode3 });
   }
   if (status === "failed") {
-    const reasonCode3 = requiredEnum(record.reasonCode, [
+    const reasonCode3 = requiredEnum(record2.reasonCode, [
       "provider-failed",
       "invalid-generator-output",
       "internal-failure"
@@ -2350,7 +2350,7 @@ function createModelGeneratorResult(input, expectedRequest) {
     assertGeneratorRetryability(reasonCode3, terminal.retryable);
     return deepFreeze({ status, ...terminal, reasonCode: reasonCode3 });
   }
-  const reasonCode2 = requiredEnum(record.reasonCode, [
+  const reasonCode2 = requiredEnum(record2.reasonCode, [
     "caller-aborted",
     "deadline-exceeded",
     "superseded",
@@ -2699,9 +2699,9 @@ function asRecord(value, fieldName) {
   }
   return value;
 }
-function exactKeys(record, allowed, fieldName) {
+function exactKeys(record2, allowed, fieldName) {
   const set = new Set(allowed);
-  const unsupported = Object.keys(record).find((key) => !set.has(key));
+  const unsupported = Object.keys(record2).find((key) => !set.has(key));
   if (unsupported !== void 0) throw new Error(`${fieldName} contains an unsupported field.`);
 }
 function asDenseArray(value, fieldName, minimum, maximum) {
@@ -2732,9 +2732,9 @@ function assertDataOnlyTree(value, fieldName, seen = /* @__PURE__ */ new WeakSet
       assertDataOnlyTree(descriptor.value, `${fieldName}[${index}]`, seen, depth + 1);
     }
   } else {
-    const record = asRecord(value, fieldName);
-    for (const key of Object.keys(record)) {
-      const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    const record2 = asRecord(value, fieldName);
+    for (const key of Object.keys(record2)) {
+      const descriptor = Object.getOwnPropertyDescriptor(record2, key);
       assertDataOnlyTree(descriptor.value, `${fieldName}.${key}`, seen, depth + 1);
     }
   }
@@ -2819,10 +2819,10 @@ function requireVector(value, fieldName) {
   ];
 }
 function createBounds2(value, fieldName) {
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["min", "max"], fieldName);
-  const min = requireVector(record.min, `${fieldName}.min`);
-  const max = requireVector(record.max, `${fieldName}.max`);
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, ["min", "max"], fieldName);
+  const min = requireVector(record2.min, `${fieldName}.min`);
+  const max = requireVector(record2.max, `${fieldName}.max`);
   if (min.some((coordinate, index) => coordinate >= max[index])) throw new Error(`${fieldName} minimum values must be below maximum values.`);
   return { min, max };
 }
@@ -2830,18 +2830,18 @@ function approximatelyEqual(left, right) {
   return Math.abs(left - right) <= Math.max(1e-6, Math.abs(left) * 1e-6, Math.abs(right) * 1e-6);
 }
 function createHashAttestation(value, expectedDomain, expectedDigest, fieldName) {
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["algorithm", "domain", "digest", "attestationToken"], fieldName);
-  if (record.algorithm !== "sha256" || record.domain !== expectedDomain) {
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, ["algorithm", "domain", "digest", "attestationToken"], fieldName);
+  if (record2.algorithm !== "sha256" || record2.domain !== expectedDomain) {
     throw new Error(`${fieldName} must use the governed SHA-256 domain.`);
   }
-  const digest = requireSha256(record.digest, `${fieldName}.digest`);
+  const digest = requireSha256(record2.digest, `${fieldName}.digest`);
   if (digest !== expectedDigest) throw new Error(`${fieldName}.digest must match its bound contract hash.`);
   return {
     algorithm: "sha256",
     domain: expectedDomain,
     digest,
-    attestationToken: requireAttestation(record.attestationToken, `${fieldName}.attestationToken`)
+    attestationToken: requireAttestation(record2.attestationToken, `${fieldName}.attestationToken`)
   };
 }
 function canonicalizePvoxHashProjectionV1(value) {
@@ -2898,19 +2898,19 @@ function assertFloorCentredBounds(bounds, fieldName) {
   }
 }
 function createDimensions2(value, fieldName) {
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["width", "height", "depth"], fieldName);
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, ["width", "height", "depth"], fieldName);
   return {
-    width: requireNumber(record.width, `${fieldName}.width`, Number.EPSILON, 1e9),
-    height: requireNumber(record.height, `${fieldName}.height`, Number.EPSILON, 1e9),
-    depth: requireNumber(record.depth, `${fieldName}.depth`, Number.EPSILON, 1e9)
+    width: requireNumber(record2.width, `${fieldName}.width`, Number.EPSILON, 1e9),
+    height: requireNumber(record2.height, `${fieldName}.height`, Number.EPSILON, 1e9),
+    depth: requireNumber(record2.depth, `${fieldName}.depth`, Number.EPSILON, 1e9)
   };
 }
 function assertCoordinateSystem2(value, fieldName) {
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["unit", "upAxis", "forwardAxis", "origin", "outwardFaceWinding"], fieldName);
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, ["unit", "upAxis", "forwardAxis", "origin", "outwardFaceWinding"], fieldName);
   for (const [key, expected] of Object.entries(CANONICAL_MODEL_COORDINATE_SYSTEM)) {
-    if (record[key] !== expected) throw new Error(`${fieldName} must use the canonical model coordinate system.`);
+    if (record2[key] !== expected) throw new Error(`${fieldName} must use the canonical model coordinate system.`);
   }
 }
 function parsePvoxResourceScope(uri) {
@@ -2935,20 +2935,20 @@ function parsePvoxResourceScope(uri) {
   throw new Error("PVOX artifact URI must be an authenticated canonical PVOX MCP resource.");
 }
 function createResource(value) {
-  const record = asRecord(value, "PvoxAssetManifestV1.artifact");
-  exactKeys(record, ["uri", "byteLength", "sha256", "contentType", "authenticated"], "PvoxAssetManifestV1.artifact");
-  const uri = requireString(record.uri, "PvoxAssetManifestV1.artifact.uri", 512);
+  const record2 = asRecord(value, "PvoxAssetManifestV1.artifact");
+  exactKeys(record2, ["uri", "byteLength", "sha256", "contentType", "authenticated"], "PvoxAssetManifestV1.artifact");
+  const uri = requireString(record2.uri, "PvoxAssetManifestV1.artifact.uri", 512);
   if (uri.includes("%") || uri.includes("?") || uri.includes("#") || uri.includes("..") || DIRECT_URL.test(uri)) {
     throw new Error("PvoxAssetManifestV1.artifact.uri must be an authenticated canonical MCP resource.");
   }
   const scope = parsePvoxResourceScope(uri);
-  const sha2562 = requireSha256(record.sha256, "PvoxAssetManifestV1.artifact.sha256");
+  const sha2562 = requireSha256(record2.sha256, "PvoxAssetManifestV1.artifact.sha256");
   if (scope.sha256 !== sha2562) throw new Error("PvoxAssetManifestV1.artifact URI hash must match sha256.");
-  if (record.contentType !== PVOX_CONTENT_TYPE) throw new Error("PvoxAssetManifestV1.artifact.contentType must be the PVOX content type.");
-  if (record.authenticated !== true) throw new Error("PvoxAssetManifestV1.artifact must be authenticated.");
+  if (record2.contentType !== PVOX_CONTENT_TYPE) throw new Error("PvoxAssetManifestV1.artifact.contentType must be the PVOX content type.");
+  if (record2.authenticated !== true) throw new Error("PvoxAssetManifestV1.artifact must be authenticated.");
   return {
     uri,
-    byteLength: requireInteger(record.byteLength, "PvoxAssetManifestV1.artifact.byteLength", 1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes),
+    byteLength: requireInteger(record2.byteLength, "PvoxAssetManifestV1.artifact.byteLength", 1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes),
     sha256: sha2562,
     contentType: PVOX_CONTENT_TYPE,
     authenticated: true
@@ -2956,15 +2956,15 @@ function createResource(value) {
 }
 function createPage(value, index) {
   const fieldName = `PvoxAssetManifestV1.pages[${index}]`;
-  const record = asRecord(value, fieldName);
-  const pageKind = requireEnum(record.pageKind, PVOX_PAGE_KINDS, `${fieldName}.pageKind`);
-  exactKeys(record, ["pageIndex", "pageKind", "byteOffset", "byteLength", "decodedByteLength", "sha256", "spatialKey"], fieldName);
-  const byteLength = requireInteger(record.byteLength, `${fieldName}.byteLength`, PVOX_PAGE_SIZE_BYTES, PVOX_PAGE_SIZE_BYTES);
-  const decodedByteLength = requireInteger(record.decodedByteLength, `${fieldName}.decodedByteLength`, PVOX_PAGE_SIZE_BYTES, PVOX_PAGE_SIZE_BYTES);
+  const record2 = asRecord(value, fieldName);
+  const pageKind = requireEnum(record2.pageKind, PVOX_PAGE_KINDS, `${fieldName}.pageKind`);
+  exactKeys(record2, ["pageIndex", "pageKind", "byteOffset", "byteLength", "decodedByteLength", "sha256", "spatialKey"], fieldName);
+  const byteLength = requireInteger(record2.byteLength, `${fieldName}.byteLength`, PVOX_PAGE_SIZE_BYTES, PVOX_PAGE_SIZE_BYTES);
+  const decodedByteLength = requireInteger(record2.decodedByteLength, `${fieldName}.decodedByteLength`, PVOX_PAGE_SIZE_BYTES, PVOX_PAGE_SIZE_BYTES);
   if (decodedByteLength !== byteLength) throw new Error(`${fieldName} decodedByteLength must equal byteLength because PVOX pages are never compressed.`);
   let spatialKey;
-  if (record.spatialKey !== void 0) {
-    const spatialRecord = asRecord(record.spatialKey, `${fieldName}.spatialKey`);
+  if (record2.spatialKey !== void 0) {
+    const spatialRecord = asRecord(record2.spatialKey, `${fieldName}.spatialKey`);
     exactKeys(spatialRecord, ["lodLevel", "partitionIndex", "hierarchyDepth", "minimumMortonCode", "maximumMortonCode"], `${fieldName}.spatialKey`);
     const minimumMortonCode = requireString(spatialRecord.minimumMortonCode, `${fieldName}.spatialKey.minimumMortonCode`, 16);
     const maximumMortonCode = requireString(spatialRecord.maximumMortonCode, `${fieldName}.spatialKey.maximumMortonCode`, 16);
@@ -2984,19 +2984,19 @@ function createPage(value, index) {
     throw new Error(`${fieldName} render/collision field pages require spatialKey; metadata/LOD-structure pages forbid it.`);
   }
   return {
-    pageIndex: requireInteger(record.pageIndex, `${fieldName}.pageIndex`, 0, PVOX_DEFAULT_LIMITS.maximumPages - 1),
+    pageIndex: requireInteger(record2.pageIndex, `${fieldName}.pageIndex`, 0, PVOX_DEFAULT_LIMITS.maximumPages - 1),
     pageKind,
-    byteOffset: requireInteger(record.byteOffset, `${fieldName}.byteOffset`, 0, PVOX_DEFAULT_LIMITS.maximumArtifactBytes - 1),
+    byteOffset: requireInteger(record2.byteOffset, `${fieldName}.byteOffset`, 0, PVOX_DEFAULT_LIMITS.maximumArtifactBytes - 1),
     byteLength,
     decodedByteLength,
-    sha256: requireSha256(record.sha256, `${fieldName}.sha256`),
+    sha256: requireSha256(record2.sha256, `${fieldName}.sha256`),
     ...spatialKey === void 0 ? {} : { spatialKey }
   };
 }
 function createLod(value, index, pageCount) {
   const fieldName = `PvoxAssetManifestV1.lods[${index}]`;
-  const record = asRecord(value, fieldName);
-  exactKeys(record, [
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, [
     "level",
     "firstPageIndex",
     "pageCount",
@@ -3010,30 +3010,30 @@ function createLod(value, index, pageCount) {
     "p95DeltaE2000",
     "normalizedMaterialError"
   ], fieldName);
-  const firstPageIndex = requireInteger(record.firstPageIndex, `${fieldName}.firstPageIndex`, 0, pageCount - 1);
-  const lodPageCount = requireInteger(record.pageCount, `${fieldName}.pageCount`, 1, pageCount);
+  const firstPageIndex = requireInteger(record2.firstPageIndex, `${fieldName}.firstPageIndex`, 0, pageCount - 1);
+  const lodPageCount = requireInteger(record2.pageCount, `${fieldName}.pageCount`, 1, pageCount);
   if (firstPageIndex + lodPageCount > pageCount) throw new Error(`${fieldName} page range exceeds the PVOX page set.`);
-  const maximumSurfaceErrorMetres = requireNumber(record.maximumSurfaceErrorMetres, `${fieldName}.maximumSurfaceErrorMetres`, 0, 1e6);
-  const p99SurfaceErrorMetres = requireNumber(record.p99SurfaceErrorMetres, `${fieldName}.p99SurfaceErrorMetres`, 0, maximumSurfaceErrorMetres);
+  const maximumSurfaceErrorMetres = requireNumber(record2.maximumSurfaceErrorMetres, `${fieldName}.maximumSurfaceErrorMetres`, 0, 1e6);
+  const p99SurfaceErrorMetres = requireNumber(record2.p99SurfaceErrorMetres, `${fieldName}.p99SurfaceErrorMetres`, 0, maximumSurfaceErrorMetres);
   return {
-    level: requireInteger(record.level, `${fieldName}.level`, 0, 3),
+    level: requireInteger(record2.level, `${fieldName}.level`, 0, 3),
     firstPageIndex,
     pageCount: lodPageCount,
-    brickCount: requireInteger(record.brickCount, `${fieldName}.brickCount`, 1, PVOX_DEFAULT_LIMITS.maximumBricks),
-    cellSizeMetres: requireNumber(record.cellSizeMetres, `${fieldName}.cellSizeMetres`, Number.EPSILON, 1e6),
+    brickCount: requireInteger(record2.brickCount, `${fieldName}.brickCount`, 1, PVOX_DEFAULT_LIMITS.maximumBricks),
+    cellSizeMetres: requireNumber(record2.cellSizeMetres, `${fieldName}.cellSizeMetres`, Number.EPSILON, 1e6),
     maximumSurfaceErrorMetres,
     p99SurfaceErrorMetres,
-    silhouetteIou: requireNumber(record.silhouetteIou, `${fieldName}.silhouetteIou`, 0, 1),
-    maximumContourDisplacementPx: requireNumber(record.maximumContourDisplacementPx, `${fieldName}.maximumContourDisplacementPx`, 0, 1e6),
-    renderedSsim: requireNumber(record.renderedSsim, `${fieldName}.renderedSsim`, 0, 1),
-    p95DeltaE2000: requireNumber(record.p95DeltaE2000, `${fieldName}.p95DeltaE2000`, 0, 100),
-    normalizedMaterialError: requireNumber(record.normalizedMaterialError, `${fieldName}.normalizedMaterialError`, 0, 1)
+    silhouetteIou: requireNumber(record2.silhouetteIou, `${fieldName}.silhouetteIou`, 0, 1),
+    maximumContourDisplacementPx: requireNumber(record2.maximumContourDisplacementPx, `${fieldName}.maximumContourDisplacementPx`, 0, 1e6),
+    renderedSsim: requireNumber(record2.renderedSsim, `${fieldName}.renderedSsim`, 0, 1),
+    p95DeltaE2000: requireNumber(record2.p95DeltaE2000, `${fieldName}.p95DeltaE2000`, 0, 100),
+    normalizedMaterialError: requireNumber(record2.normalizedMaterialError, `${fieldName}.normalizedMaterialError`, 0, 1)
   };
 }
 function createSourceIngestionLimitsV2(value) {
   const fieldName = "ModelRequestSpecV2.sourceIngestionLimits";
-  const record = asRecord(value, fieldName);
-  exactKeys(record, [
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, [
     "maximumDownloadBytes",
     "maximumExpandedBytes",
     "maximumArchiveEntries",
@@ -3042,12 +3042,12 @@ function createSourceIngestionLimitsV2(value) {
     "maximumTextureDimensionPx"
   ], fieldName);
   const limits = {
-    maximumDownloadBytes: requireInteger(record.maximumDownloadBytes, `${fieldName}.maximumDownloadBytes`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumDownloadBytes),
-    maximumExpandedBytes: requireInteger(record.maximumExpandedBytes, `${fieldName}.maximumExpandedBytes`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumExpandedBytes),
-    maximumArchiveEntries: requireInteger(record.maximumArchiveEntries, `${fieldName}.maximumArchiveEntries`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumArchiveEntries),
-    maximumSourceFiles: requireInteger(record.maximumSourceFiles, `${fieldName}.maximumSourceFiles`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumSourceFiles),
-    maximumDecodedTextureBytes: requireInteger(record.maximumDecodedTextureBytes, `${fieldName}.maximumDecodedTextureBytes`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumDecodedTextureBytes),
-    maximumTextureDimensionPx: requireInteger(record.maximumTextureDimensionPx, `${fieldName}.maximumTextureDimensionPx`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumTextureDimensionPx)
+    maximumDownloadBytes: requireInteger(record2.maximumDownloadBytes, `${fieldName}.maximumDownloadBytes`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumDownloadBytes),
+    maximumExpandedBytes: requireInteger(record2.maximumExpandedBytes, `${fieldName}.maximumExpandedBytes`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumExpandedBytes),
+    maximumArchiveEntries: requireInteger(record2.maximumArchiveEntries, `${fieldName}.maximumArchiveEntries`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumArchiveEntries),
+    maximumSourceFiles: requireInteger(record2.maximumSourceFiles, `${fieldName}.maximumSourceFiles`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumSourceFiles),
+    maximumDecodedTextureBytes: requireInteger(record2.maximumDecodedTextureBytes, `${fieldName}.maximumDecodedTextureBytes`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumDecodedTextureBytes),
+    maximumTextureDimensionPx: requireInteger(record2.maximumTextureDimensionPx, `${fieldName}.maximumTextureDimensionPx`, 1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumTextureDimensionPx)
   };
   if (limits.maximumExpandedBytes < limits.maximumDownloadBytes) {
     throw new Error(`${fieldName}.maximumExpandedBytes must cover maximumDownloadBytes.`);
@@ -3062,8 +3062,8 @@ function createSourceIngestionLimitsV2(value) {
 }
 function createPvoxRuntimeLimitsV1(value) {
   const fieldName = "ModelRequestSpecV2.pvoxRuntimeProfile.limits";
-  const record = asRecord(value, fieldName);
-  exactKeys(record, [
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, [
     "maximumArtifactBytes",
     "maximumPages",
     "maximumHierarchyDepth",
@@ -3084,24 +3084,24 @@ function createPvoxRuntimeLimitsV1(value) {
     "maximumGpuResidentBytes"
   ], fieldName);
   const limits = {
-    maximumArtifactBytes: requireInteger(record.maximumArtifactBytes, `${fieldName}.maximumArtifactBytes`, 1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes),
-    maximumPages: requireInteger(record.maximumPages, `${fieldName}.maximumPages`, 1, PVOX_DEFAULT_LIMITS.maximumPages),
-    maximumHierarchyDepth: requireInteger(record.maximumHierarchyDepth, `${fieldName}.maximumHierarchyDepth`, 0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth),
-    maximumHierarchyNodes: requireInteger(record.maximumHierarchyNodes, `${fieldName}.maximumHierarchyNodes`, 1, PVOX_DEFAULT_LIMITS.maximumHierarchyNodes),
-    maximumBricks: requireInteger(record.maximumBricks, `${fieldName}.maximumBricks`, 1, PVOX_DEFAULT_LIMITS.maximumBricks),
-    maximumLogicalVoxels: requireInteger(record.maximumLogicalVoxels, `${fieldName}.maximumLogicalVoxels`, 1, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels),
-    maximumEncodedSurfaceSamples: requireInteger(record.maximumEncodedSurfaceSamples, `${fieldName}.maximumEncodedSurfaceSamples`, 1, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples),
-    maximumSurfaceProperties: requireInteger(record.maximumSurfaceProperties, `${fieldName}.maximumSurfaceProperties`, 1, PVOX_DEFAULT_LIMITS.maximumSurfaceProperties),
-    maximumPhysicalPaletteRecords: requireInteger(record.maximumPhysicalPaletteRecords, `${fieldName}.maximumPhysicalPaletteRecords`, 1, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties),
-    maximumPhysicalEvidenceEntries: requireInteger(record.maximumPhysicalEvidenceEntries, `${fieldName}.maximumPhysicalEvidenceEntries`, 1, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries),
-    maximumMaterialRegions: requireInteger(record.maximumMaterialRegions, `${fieldName}.maximumMaterialRegions`, 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions),
-    maximumInteriorLayers: requireInteger(record.maximumInteriorLayers, `${fieldName}.maximumInteriorLayers`, 1, PVOX_DEFAULT_LIMITS.maximumInteriorLayers),
-    maximumMassPropertyRecords: requireInteger(record.maximumMassPropertyRecords, `${fieldName}.maximumMassPropertyRecords`, 1, PVOX_DEFAULT_LIMITS.maximumMassPropertyRecords),
-    maximumBondRecords: requireInteger(record.maximumBondRecords, `${fieldName}.maximumBondRecords`, 0, PVOX_DEFAULT_LIMITS.maximumBondRecords),
-    maximumPartitions: requireInteger(record.maximumPartitions, `${fieldName}.maximumPartitions`, 1, PVOX_DEFAULT_LIMITS.maximumPartitions),
-    maximumLodCount: requireInteger(record.maximumLodCount, `${fieldName}.maximumLodCount`, 1, PVOX_DEFAULT_LIMITS.maximumLodCount),
-    maximumCpuResidentBytes: requireInteger(record.maximumCpuResidentBytes, `${fieldName}.maximumCpuResidentBytes`, 1, PVOX_DEFAULT_LIMITS.maximumCpuResidentBytes),
-    maximumGpuResidentBytes: requireInteger(record.maximumGpuResidentBytes, `${fieldName}.maximumGpuResidentBytes`, 1, PVOX_DEFAULT_LIMITS.maximumGpuResidentBytes)
+    maximumArtifactBytes: requireInteger(record2.maximumArtifactBytes, `${fieldName}.maximumArtifactBytes`, 1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes),
+    maximumPages: requireInteger(record2.maximumPages, `${fieldName}.maximumPages`, 1, PVOX_DEFAULT_LIMITS.maximumPages),
+    maximumHierarchyDepth: requireInteger(record2.maximumHierarchyDepth, `${fieldName}.maximumHierarchyDepth`, 0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth),
+    maximumHierarchyNodes: requireInteger(record2.maximumHierarchyNodes, `${fieldName}.maximumHierarchyNodes`, 1, PVOX_DEFAULT_LIMITS.maximumHierarchyNodes),
+    maximumBricks: requireInteger(record2.maximumBricks, `${fieldName}.maximumBricks`, 1, PVOX_DEFAULT_LIMITS.maximumBricks),
+    maximumLogicalVoxels: requireInteger(record2.maximumLogicalVoxels, `${fieldName}.maximumLogicalVoxels`, 1, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels),
+    maximumEncodedSurfaceSamples: requireInteger(record2.maximumEncodedSurfaceSamples, `${fieldName}.maximumEncodedSurfaceSamples`, 1, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples),
+    maximumSurfaceProperties: requireInteger(record2.maximumSurfaceProperties, `${fieldName}.maximumSurfaceProperties`, 1, PVOX_DEFAULT_LIMITS.maximumSurfaceProperties),
+    maximumPhysicalPaletteRecords: requireInteger(record2.maximumPhysicalPaletteRecords, `${fieldName}.maximumPhysicalPaletteRecords`, 1, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties),
+    maximumPhysicalEvidenceEntries: requireInteger(record2.maximumPhysicalEvidenceEntries, `${fieldName}.maximumPhysicalEvidenceEntries`, 1, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries),
+    maximumMaterialRegions: requireInteger(record2.maximumMaterialRegions, `${fieldName}.maximumMaterialRegions`, 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions),
+    maximumInteriorLayers: requireInteger(record2.maximumInteriorLayers, `${fieldName}.maximumInteriorLayers`, 1, PVOX_DEFAULT_LIMITS.maximumInteriorLayers),
+    maximumMassPropertyRecords: requireInteger(record2.maximumMassPropertyRecords, `${fieldName}.maximumMassPropertyRecords`, 1, PVOX_DEFAULT_LIMITS.maximumMassPropertyRecords),
+    maximumBondRecords: requireInteger(record2.maximumBondRecords, `${fieldName}.maximumBondRecords`, 0, PVOX_DEFAULT_LIMITS.maximumBondRecords),
+    maximumPartitions: requireInteger(record2.maximumPartitions, `${fieldName}.maximumPartitions`, 1, PVOX_DEFAULT_LIMITS.maximumPartitions),
+    maximumLodCount: requireInteger(record2.maximumLodCount, `${fieldName}.maximumLodCount`, 1, PVOX_DEFAULT_LIMITS.maximumLodCount),
+    maximumCpuResidentBytes: requireInteger(record2.maximumCpuResidentBytes, `${fieldName}.maximumCpuResidentBytes`, 1, PVOX_DEFAULT_LIMITS.maximumCpuResidentBytes),
+    maximumGpuResidentBytes: requireInteger(record2.maximumGpuResidentBytes, `${fieldName}.maximumGpuResidentBytes`, 1, PVOX_DEFAULT_LIMITS.maximumGpuResidentBytes)
   };
   if (limits.maximumArtifactBytes > limits.maximumPages * PVOX_PAGE_SIZE_BYTES) {
     throw new Error(`${fieldName}.maximumPages cannot contain maximumArtifactBytes.`);
@@ -3116,9 +3116,9 @@ function createPvoxRuntimeLimitsV1(value) {
 }
 function createPvoxRuntimeRequestProfileV1(value) {
   const fieldName = "ModelRequestSpecV2.pvoxRuntimeProfile";
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["profileId", "fidelityProfileId", "capabilityProfileId", "geometryMode", "requiredCapabilities", "limits"], fieldName);
-  const requestedCapabilityEntries = asDenseArray(record.requiredCapabilities, `${fieldName}.requiredCapabilities`, 1, PVOX_CAPABILITIES.length);
+  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}]`));
   if (new Set(requiredCapabilities).size !== requiredCapabilities.length) {
     throw new Error(`${fieldName}.requiredCapabilities must not contain duplicates.`);
@@ -3126,7 +3126,7 @@ function createPvoxRuntimeRequestProfileV1(value) {
   if (!requiredCapabilities.includes("rendering")) {
     throw new Error(`${fieldName}.requiredCapabilities must include rendering.`);
   }
-  const capabilityProfileId = requireEnum(record.capabilityProfileId, PVOX_RUNTIME_CAPABILITY_PROFILE_IDS, `${fieldName}.capabilityProfileId`);
+  const capabilityProfileId = requireEnum(record2.capabilityProfileId, PVOX_RUNTIME_CAPABILITY_PROFILE_IDS, `${fieldName}.capabilityProfileId`);
   const profileRequirements = {
     "static-render-v1": ["rendering"],
     "world-editable-v1": ["rendering", "collision", "destruction", "thermal", "moisture", "fluid-boundary"],
@@ -3135,24 +3135,24 @@ function createPvoxRuntimeRequestProfileV1(value) {
   if (profileRequirements[capabilityProfileId].some((capability) => !requiredCapabilities.includes(capability))) {
     throw new Error(`${fieldName}.requiredCapabilities do not satisfy capabilityProfileId.`);
   }
-  const limits = createPvoxRuntimeLimitsV1(record.limits);
+  const limits = createPvoxRuntimeLimitsV1(record2.limits);
   if (capabilityProfileId === "world-editable-v1" && limits.maximumPhysicalEvidenceEntries < limits.maximumMaterialRegions * PVOX_PHYSICAL_PROPERTIES.length) {
     throw new Error(`${fieldName}.limits must budget a complete physical-property matrix for every allowed material region.`);
   }
   return {
-    profileId: requireToken(record.profileId, `${fieldName}.profileId`),
-    fidelityProfileId: requireEnum(record.fidelityProfileId, PVOX_FIDELITY_PROFILE_IDS, `${fieldName}.fidelityProfileId`),
+    profileId: requireToken(record2.profileId, `${fieldName}.profileId`),
+    fidelityProfileId: requireEnum(record2.fidelityProfileId, PVOX_FIDELITY_PROFILE_IDS, `${fieldName}.fidelityProfileId`),
     capabilityProfileId,
-    geometryMode: requireEnum(record.geometryMode, ["solid", "shell", "mixed", "auto"], `${fieldName}.geometryMode`),
+    geometryMode: requireEnum(record2.geometryMode, ["solid", "shell", "mixed", "auto"], `${fieldName}.geometryMode`),
     requiredCapabilities,
     limits
   };
 }
 function createModelRequestSpecV2(input) {
   const fieldName = "ModelRequestSpecV2";
-  const record = asRecord(input, fieldName);
-  assertDataOnlyTree(record, fieldName);
-  exactKeys(record, [
+  const record2 = asRecord(input, fieldName);
+  assertDataOnlyTree(record2, fieldName);
+  exactKeys(record2, [
     "contractVersion",
     "policyProfileId",
     "requestSemanticProfileHash",
@@ -3166,26 +3166,26 @@ function createModelRequestSpecV2(input) {
     "sourceIngestionLimits",
     "pvoxRuntimeProfile"
   ], fieldName);
-  if (record.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) {
+  if (record2.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) {
     throw new Error(`${fieldName}.contractVersion is unsupported.`);
   }
-  if (record.policyProfileId !== PVOX_MODEL_REQUEST_POLICY_ID) {
+  if (record2.policyProfileId !== PVOX_MODEL_REQUEST_POLICY_ID) {
     throw new Error(`${fieldName}.policyProfileId must be ${PVOX_MODEL_REQUEST_POLICY_ID}.`);
   }
-  const hardConstraintsRecord = asRecord(record.hardConstraints ?? {}, `${fieldName}.hardConstraints`);
+  const hardConstraintsRecord = asRecord(record2.hardConstraints ?? {}, `${fieldName}.hardConstraints`);
   exactKeys(hardConstraintsRecord, ["boundsMetres", "dimensionsMetres", "collision", "partition"], `${fieldName}.hardConstraints`);
-  const softPreferencesRecord = asRecord(record.softPreferences ?? {}, `${fieldName}.softPreferences`);
+  const softPreferencesRecord = asRecord(record2.softPreferences ?? {}, `${fieldName}.softPreferences`);
   for (const field of ["materials", "colors", "tags"]) {
     if (softPreferencesRecord[field] !== void 0) {
       asDenseArray(softPreferencesRecord[field], `${fieldName}.softPreferences.${field}`, 0, 32);
     }
   }
-  const exclusions = asDenseArray(record.exclusions ?? [], `${fieldName}.exclusions`, 0, 32);
+  const exclusions = asDenseArray(record2.exclusions ?? [], `${fieldName}.exclusions`, 0, 32);
   const normalizedV1 = createModelRequestSpec({
-    query: record.query,
-    revision: record.revision,
-    ...record.locale === void 0 ? {} : { locale: record.locale },
-    ...record.rankerId === void 0 ? {} : { rankerId: record.rankerId },
+    query: record2.query,
+    revision: record2.revision,
+    ...record2.locale === void 0 ? {} : { locale: record2.locale },
+    ...record2.rankerId === void 0 ? {} : { rankerId: record2.rankerId },
     hardConstraints: hardConstraintsRecord,
     softPreferences: softPreferencesRecord,
     exclusions
@@ -3199,7 +3199,7 @@ function createModelRequestSpecV2(input) {
   return deepFreeze2({
     contractVersion: MODEL_RESOLUTION_V2_CONTRACT_VERSION,
     policyProfileId: PVOX_MODEL_REQUEST_POLICY_ID,
-    requestSemanticProfileHash: requireSha256(record.requestSemanticProfileHash, `${fieldName}.requestSemanticProfileHash`),
+    requestSemanticProfileHash: requireSha256(record2.requestSemanticProfileHash, `${fieldName}.requestSemanticProfileHash`),
     query: normalizedV1.query,
     revision: normalizedV1.revision,
     ...normalizedV1.locale === void 0 ? {} : { locale: normalizedV1.locale },
@@ -3207,13 +3207,13 @@ function createModelRequestSpecV2(input) {
     hardConstraints,
     softPreferences: normalizedV1.softPreferences,
     exclusions: normalizedV1.exclusions,
-    sourceIngestionLimits: createSourceIngestionLimitsV2(record.sourceIngestionLimits),
-    pvoxRuntimeProfile: createPvoxRuntimeRequestProfileV1(record.pvoxRuntimeProfile)
+    sourceIngestionLimits: createSourceIngestionLimitsV2(record2.sourceIngestionLimits),
+    pvoxRuntimeProfile: createPvoxRuntimeRequestProfileV1(record2.pvoxRuntimeProfile)
   });
 }
 function createPvoxAssetManifestV1(input) {
-  const record = asRecord(input, "PvoxAssetManifestV1");
-  exactKeys(record, [
+  const record2 = asRecord(input, "PvoxAssetManifestV1");
+  exactKeys(record2, [
     "manifestVersion",
     "representation",
     "formatVersion",
@@ -3244,23 +3244,23 @@ function createPvoxAssetManifestV1(input) {
     "pages",
     "lods"
   ], "PvoxAssetManifestV1");
-  if (record.manifestVersion !== PVOX_ASSET_MANIFEST_VERSION) throw new Error("PvoxAssetManifestV1.manifestVersion is unsupported.");
-  if (record.representation !== "pvox") throw new Error("PvoxAssetManifestV1.representation must be pvox.");
-  const formatVersion = asRecord(record.formatVersion, "PvoxAssetManifestV1.formatVersion");
+  if (record2.manifestVersion !== PVOX_ASSET_MANIFEST_VERSION) throw new Error("PvoxAssetManifestV1.manifestVersion is unsupported.");
+  if (record2.representation !== "pvox") throw new Error("PvoxAssetManifestV1.representation must be pvox.");
+  const formatVersion = asRecord(record2.formatVersion, "PvoxAssetManifestV1.formatVersion");
   exactKeys(formatVersion, ["major", "minor"], "PvoxAssetManifestV1.formatVersion");
   if (formatVersion.major !== PVOX_FORMAT_VERSION.major || formatVersion.minor !== PVOX_FORMAT_VERSION.minor) throw new Error("PvoxAssetManifestV1.formatVersion is unsupported.");
-  if (record.contentType !== PVOX_CONTENT_TYPE || record.fileExtension !== PVOX_FILE_EXTENSION || record.magic !== PVOX_MAGIC) {
+  if (record2.contentType !== PVOX_CONTENT_TYPE || record2.fileExtension !== PVOX_FILE_EXTENSION || record2.magic !== PVOX_MAGIC) {
     throw new Error("PvoxAssetManifestV1 must declare the canonical PVOX content type, extension, and magic.");
   }
-  if (record.brickEdgeVoxels !== PVOX_BRICK_EDGE_VOXELS || record.pageSizeBytes !== PVOX_PAGE_SIZE_BYTES) {
+  if (record2.brickEdgeVoxels !== PVOX_BRICK_EDGE_VOXELS || record2.pageSizeBytes !== PVOX_PAGE_SIZE_BYTES) {
     throw new Error("PvoxAssetManifestV1 must use fixed 8-cubed bricks and 64-KiB pages.");
   }
-  assertCoordinateSystem2(record.coordinateSystem, "PvoxAssetManifestV1.coordinateSystem");
-  const boundsMetres = createBounds2(record.boundsMetres, "PvoxAssetManifestV1.boundsMetres");
+  assertCoordinateSystem2(record2.coordinateSystem, "PvoxAssetManifestV1.coordinateSystem");
+  const boundsMetres = createBounds2(record2.boundsMetres, "PvoxAssetManifestV1.boundsMetres");
   assertFloorCentredBounds(boundsMetres, "PvoxAssetManifestV1.boundsMetres");
-  const artifact = createResource(record.artifact);
+  const artifact = createResource(record2.artifact);
   if (artifact.byteLength % PVOX_PAGE_SIZE_BYTES !== 0) throw new Error("PvoxAssetManifestV1 artifact byteLength must contain whole 64-KiB pages.");
-  const pageEntries = asDenseArray(record.pages, "PvoxAssetManifestV1.pages", 1, PVOX_DEFAULT_LIMITS.maximumPages);
+  const pageEntries = asDenseArray(record2.pages, "PvoxAssetManifestV1.pages", 1, PVOX_DEFAULT_LIMITS.maximumPages);
   const pages = pageEntries.map(createPage);
   let expectedOffset = 0;
   const previousSpatialMaximumByScope = /* @__PURE__ */ new Map();
@@ -3281,7 +3281,7 @@ function createPvoxAssetManifestV1(input) {
     expectedOffset += current.byteLength;
   }
   if (expectedOffset !== artifact.byteLength) throw new Error("PvoxAssetManifestV1 pages must exactly cover the artifact bytes.");
-  const lodEntries = asDenseArray(record.lods, "PvoxAssetManifestV1.lods", 1, 4);
+  const lodEntries = asDenseArray(record2.lods, "PvoxAssetManifestV1.lods", 1, 4);
   const lods = lodEntries.map((entry, index) => createLod(entry, 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.");
@@ -3291,14 +3291,14 @@ function createPvoxAssetManifestV1(input) {
       throw new Error("PvoxAssetManifestV1 LOD page ranges must reference render-field pages in the matching LOD scope.");
     }
   }
-  const sourceContentHash = requireSha256(record.sourceContentHash, "PvoxAssetManifestV1.sourceContentHash");
-  const canonicalDocumentHash = requireSha256(record.canonicalDocumentHash, "PvoxAssetManifestV1.canonicalDocumentHash");
-  const compilationInputHash = requireSha256(record.compilationInputHash, "PvoxAssetManifestV1.compilationInputHash");
-  const runtimeRequestProfileHash = requireSha256(record.runtimeRequestProfileHash, "PvoxAssetManifestV1.runtimeRequestProfileHash");
+  const sourceContentHash = requireSha256(record2.sourceContentHash, "PvoxAssetManifestV1.sourceContentHash");
+  const canonicalDocumentHash = requireSha256(record2.canonicalDocumentHash, "PvoxAssetManifestV1.canonicalDocumentHash");
+  const compilationInputHash = requireSha256(record2.compilationInputHash, "PvoxAssetManifestV1.compilationInputHash");
+  const runtimeRequestProfileHash = requireSha256(record2.runtimeRequestProfileHash, "PvoxAssetManifestV1.runtimeRequestProfileHash");
   if ((/* @__PURE__ */ new Set([sourceContentHash, canonicalDocumentHash, compilationInputHash, runtimeRequestProfileHash])).size !== 4) {
     throw new Error("PvoxAssetManifestV1 source, canonical document, compilation input, and runtime request profile hashes must be distinct attestations.");
   }
-  if (record.headerByteLength !== PVOX_HEADER_BYTE_LENGTH || record.directoryEntryByteLength !== PVOX_DIRECTORY_ENTRY_BYTE_LENGTH || record.maximumRunsPerBrick !== PVOX_MAX_RUNS_PER_BRICK || record.maximumLocalSamplesPerBrick !== PVOX_MAX_LOCAL_SAMPLES_PER_BRICK || record.maximumEncodedBrickPayloadBytes !== PVOX_MAX_ENCODED_BRICK_PAYLOAD_BYTES) {
+  if (record2.headerByteLength !== PVOX_HEADER_BYTE_LENGTH || record2.directoryEntryByteLength !== PVOX_DIRECTORY_ENTRY_BYTE_LENGTH || record2.maximumRunsPerBrick !== PVOX_MAX_RUNS_PER_BRICK || record2.maximumLocalSamplesPerBrick !== PVOX_MAX_LOCAL_SAMPLES_PER_BRICK || record2.maximumEncodedBrickPayloadBytes !== PVOX_MAX_ENCODED_BRICK_PAYLOAD_BYTES) {
     throw new Error("PvoxAssetManifestV1 must declare the fixed PVOX 1.0 layout and brick codec limits.");
   }
   return deepFreeze2({
@@ -3310,19 +3310,19 @@ function createPvoxAssetManifestV1(input) {
     magic: PVOX_MAGIC,
     brickEdgeVoxels: PVOX_BRICK_EDGE_VOXELS,
     pageSizeBytes: PVOX_PAGE_SIZE_BYTES,
-    geometryMode: requireEnum(record.geometryMode, ["solid", "shell", "mixed"], "PvoxAssetManifestV1.geometryMode"),
+    geometryMode: requireEnum(record2.geometryMode, ["solid", "shell", "mixed"], "PvoxAssetManifestV1.geometryMode"),
     sourceContentHash,
     canonicalDocumentHash,
-    rootHash: requireSha256(record.rootHash, "PvoxAssetManifestV1.rootHash"),
-    directoryHash: requireSha256(record.directoryHash, "PvoxAssetManifestV1.directoryHash"),
-    pageSetHash: requireSha256(record.pageSetHash, "PvoxAssetManifestV1.pageSetHash"),
-    binaryClosureHash: requireSha256(record.binaryClosureHash, "PvoxAssetManifestV1.binaryClosureHash"),
-    validationEvidenceHash: requireSha256(record.validationEvidenceHash, "PvoxAssetManifestV1.validationEvidenceHash"),
+    rootHash: requireSha256(record2.rootHash, "PvoxAssetManifestV1.rootHash"),
+    directoryHash: requireSha256(record2.directoryHash, "PvoxAssetManifestV1.directoryHash"),
+    pageSetHash: requireSha256(record2.pageSetHash, "PvoxAssetManifestV1.pageSetHash"),
+    binaryClosureHash: requireSha256(record2.binaryClosureHash, "PvoxAssetManifestV1.binaryClosureHash"),
+    validationEvidenceHash: requireSha256(record2.validationEvidenceHash, "PvoxAssetManifestV1.validationEvidenceHash"),
     compilationInputHash,
     runtimeRequestProfileHash,
     headerByteLength: PVOX_HEADER_BYTE_LENGTH,
     directoryEntryByteLength: PVOX_DIRECTORY_ENTRY_BYTE_LENGTH,
-    sectionCount: requireInteger(record.sectionCount, "PvoxAssetManifestV1.sectionCount", PVOX_MIN_STATIC_SECTION_COUNT, PVOX_MAX_SECTIONS),
+    sectionCount: requireInteger(record2.sectionCount, "PvoxAssetManifestV1.sectionCount", PVOX_MIN_STATIC_SECTION_COUNT, PVOX_MAX_SECTIONS),
     maximumRunsPerBrick: PVOX_MAX_RUNS_PER_BRICK,
     maximumLocalSamplesPerBrick: PVOX_MAX_LOCAL_SAMPLES_PER_BRICK,
     maximumEncodedBrickPayloadBytes: PVOX_MAX_ENCODED_BRICK_PAYLOAD_BYTES,
@@ -3337,8 +3337,8 @@ function createPvoxAssetManifest(input) {
   return createPvoxAssetManifestV1(input);
 }
 function createVoxelTechnicalProfile(input) {
-  const record = asRecord(input, "VoxelTechnicalProfile");
-  exactKeys(record, [
+  const record2 = asRecord(input, "VoxelTechnicalProfile");
+  exactKeys(record2, [
     "boundsMetres",
     "dimensionsMetres",
     "geometryMode",
@@ -3370,49 +3370,49 @@ function createVoxelTechnicalProfile(input) {
     "maximumPartitionExtentMetres",
     "maximumPartitionDiagonalMetres"
   ], "VoxelTechnicalProfile");
-  const boundsMetres = createBounds2(record.boundsMetres, "VoxelTechnicalProfile.boundsMetres");
+  const boundsMetres = createBounds2(record2.boundsMetres, "VoxelTechnicalProfile.boundsMetres");
   assertFloorCentredBounds(boundsMetres, "VoxelTechnicalProfile.boundsMetres");
-  const dimensionsMetres = createDimensions2(record.dimensionsMetres, "VoxelTechnicalProfile.dimensionsMetres");
+  const dimensionsMetres = createDimensions2(record2.dimensionsMetres, "VoxelTechnicalProfile.dimensionsMetres");
   const derived = boundsMetres.max.map((coordinate, index) => coordinate - boundsMetres.min[index]);
   const supplied = [dimensionsMetres.width, dimensionsMetres.height, dimensionsMetres.depth];
   if (derived.some((coordinate, index) => Math.abs(coordinate - supplied[index]) > Math.max(1e-6, Math.abs(coordinate) * 1e-6))) {
     throw new Error("VoxelTechnicalProfile dimensionsMetres must match boundsMetres.");
   }
-  const artifactByteLength = requireInteger(record.artifactByteLength, "VoxelTechnicalProfile.artifactByteLength", 1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes);
-  const pageCount = requireInteger(record.pageCount, "VoxelTechnicalProfile.pageCount", 1, PVOX_DEFAULT_LIMITS.maximumPages);
+  const artifactByteLength = requireInteger(record2.artifactByteLength, "VoxelTechnicalProfile.artifactByteLength", 1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes);
+  const pageCount = requireInteger(record2.pageCount, "VoxelTechnicalProfile.pageCount", 1, PVOX_DEFAULT_LIMITS.maximumPages);
   if (artifactByteLength !== pageCount * PVOX_PAGE_SIZE_BYTES) {
     throw new Error("VoxelTechnicalProfile artifactByteLength must equal pageCount multiplied by the fixed PVOX page size.");
   }
-  const brickCount = requireInteger(record.brickCount, "VoxelTechnicalProfile.brickCount", 1, PVOX_DEFAULT_LIMITS.maximumBricks);
-  const logicalVoxelCapacity = requireInteger(record.logicalVoxelCapacity, "VoxelTechnicalProfile.logicalVoxelCapacity", 1, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels);
+  const brickCount = requireInteger(record2.brickCount, "VoxelTechnicalProfile.brickCount", 1, PVOX_DEFAULT_LIMITS.maximumBricks);
+  const logicalVoxelCapacity = requireInteger(record2.logicalVoxelCapacity, "VoxelTechnicalProfile.logicalVoxelCapacity", 1, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels);
   if (logicalVoxelCapacity !== brickCount * PVOX_BRICK_EDGE_VOXELS ** 3) {
     throw new Error("VoxelTechnicalProfile logicalVoxelCapacity must equal brickCount multiplied by 512 voxels per brick.");
   }
-  const encodedSurfaceSampleCount = requireInteger(record.encodedSurfaceSampleCount, "VoxelTechnicalProfile.encodedSurfaceSampleCount", 1, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples);
+  const encodedSurfaceSampleCount = requireInteger(record2.encodedSurfaceSampleCount, "VoxelTechnicalProfile.encodedSurfaceSampleCount", 1, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples);
   if (encodedSurfaceSampleCount > logicalVoxelCapacity) {
     throw new Error("VoxelTechnicalProfile encodedSurfaceSampleCount cannot exceed logicalVoxelCapacity.");
   }
-  const surfacePropertyCount = requireInteger(record.surfacePropertyCount, "VoxelTechnicalProfile.surfacePropertyCount", 1, PVOX_DEFAULT_LIMITS.maximumSurfaceProperties);
-  const sectionCount = requireInteger(record.sectionCount, "VoxelTechnicalProfile.sectionCount", PVOX_MIN_STATIC_SECTION_COUNT, PVOX_MAX_SECTIONS);
-  const hierarchyDepth = requireInteger(record.hierarchyDepth, "VoxelTechnicalProfile.hierarchyDepth", 0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth);
-  const hierarchyNodeCount = requireInteger(record.hierarchyNodeCount, "VoxelTechnicalProfile.hierarchyNodeCount", 1, PVOX_DEFAULT_LIMITS.maximumHierarchyNodes);
-  const lodCount = requireInteger(record.lodCount, "VoxelTechnicalProfile.lodCount", 1, PVOX_DEFAULT_LIMITS.maximumLodCount);
-  const partitionCount = requireInteger(record.partitionCount, "VoxelTechnicalProfile.partitionCount", 1, PVOX_DEFAULT_LIMITS.maximumPartitions);
-  const levelSpanRecordCount = requireInteger(record.levelSpanRecordCount, "VoxelTechnicalProfile.levelSpanRecordCount", partitionCount * lodCount, partitionCount * lodCount * (hierarchyDepth + 1));
-  const physicalPaletteRecordCount = requireInteger(record.physicalPaletteRecordCount, "VoxelTechnicalProfile.physicalPaletteRecordCount", 1, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties);
-  const physicalEvidenceRecordCount = requireInteger(record.physicalEvidenceRecordCount, "VoxelTechnicalProfile.physicalEvidenceRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries);
-  const materialRegionCount = requireInteger(record.materialRegionCount, "VoxelTechnicalProfile.materialRegionCount", 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions);
-  const interiorLayerRecordCount = requireInteger(record.interiorLayerRecordCount, "VoxelTechnicalProfile.interiorLayerRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumInteriorLayers);
-  const massPropertyRecordCount = requireInteger(record.massPropertyRecordCount, "VoxelTechnicalProfile.massPropertyRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumMassPropertyRecords);
-  const bondRecordCount = requireInteger(record.bondRecordCount, "VoxelTechnicalProfile.bondRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumBondRecords);
-  const hasCollision = requireBoolean(record.hasCollision, "VoxelTechnicalProfile.hasCollision");
-  const collisionHierarchyNodeCount = requireInteger(record.collisionHierarchyNodeCount, "VoxelTechnicalProfile.collisionHierarchyNodeCount", hasCollision ? 1 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumHierarchyNodes : 0);
-  const collisionBrickCount = requireInteger(record.collisionBrickCount, "VoxelTechnicalProfile.collisionBrickCount", hasCollision ? 1 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumBricks : 0);
-  const collisionLogicalVoxelCapacity = requireInteger(record.collisionLogicalVoxelCapacity, "VoxelTechnicalProfile.collisionLogicalVoxelCapacity", hasCollision ? PVOX_BRICK_EDGE_VOXELS ** 3 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumLogicalVoxels : 0);
+  const surfacePropertyCount = requireInteger(record2.surfacePropertyCount, "VoxelTechnicalProfile.surfacePropertyCount", 1, PVOX_DEFAULT_LIMITS.maximumSurfaceProperties);
+  const sectionCount = requireInteger(record2.sectionCount, "VoxelTechnicalProfile.sectionCount", PVOX_MIN_STATIC_SECTION_COUNT, PVOX_MAX_SECTIONS);
+  const hierarchyDepth = requireInteger(record2.hierarchyDepth, "VoxelTechnicalProfile.hierarchyDepth", 0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth);
+  const hierarchyNodeCount = requireInteger(record2.hierarchyNodeCount, "VoxelTechnicalProfile.hierarchyNodeCount", 1, PVOX_DEFAULT_LIMITS.maximumHierarchyNodes);
+  const lodCount = requireInteger(record2.lodCount, "VoxelTechnicalProfile.lodCount", 1, PVOX_DEFAULT_LIMITS.maximumLodCount);
+  const partitionCount = requireInteger(record2.partitionCount, "VoxelTechnicalProfile.partitionCount", 1, PVOX_DEFAULT_LIMITS.maximumPartitions);
+  const levelSpanRecordCount = requireInteger(record2.levelSpanRecordCount, "VoxelTechnicalProfile.levelSpanRecordCount", partitionCount * lodCount, partitionCount * lodCount * (hierarchyDepth + 1));
+  const physicalPaletteRecordCount = requireInteger(record2.physicalPaletteRecordCount, "VoxelTechnicalProfile.physicalPaletteRecordCount", 1, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties);
+  const physicalEvidenceRecordCount = requireInteger(record2.physicalEvidenceRecordCount, "VoxelTechnicalProfile.physicalEvidenceRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries);
+  const materialRegionCount = requireInteger(record2.materialRegionCount, "VoxelTechnicalProfile.materialRegionCount", 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions);
+  const interiorLayerRecordCount = requireInteger(record2.interiorLayerRecordCount, "VoxelTechnicalProfile.interiorLayerRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumInteriorLayers);
+  const massPropertyRecordCount = requireInteger(record2.massPropertyRecordCount, "VoxelTechnicalProfile.massPropertyRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumMassPropertyRecords);
+  const bondRecordCount = requireInteger(record2.bondRecordCount, "VoxelTechnicalProfile.bondRecordCount", 0, PVOX_DEFAULT_LIMITS.maximumBondRecords);
+  const hasCollision = requireBoolean(record2.hasCollision, "VoxelTechnicalProfile.hasCollision");
+  const collisionHierarchyNodeCount = requireInteger(record2.collisionHierarchyNodeCount, "VoxelTechnicalProfile.collisionHierarchyNodeCount", hasCollision ? 1 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumHierarchyNodes : 0);
+  const collisionBrickCount = requireInteger(record2.collisionBrickCount, "VoxelTechnicalProfile.collisionBrickCount", hasCollision ? 1 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumBricks : 0);
+  const collisionLogicalVoxelCapacity = requireInteger(record2.collisionLogicalVoxelCapacity, "VoxelTechnicalProfile.collisionLogicalVoxelCapacity", hasCollision ? PVOX_BRICK_EDGE_VOXELS ** 3 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumLogicalVoxels : 0);
   if (collisionLogicalVoxelCapacity !== collisionBrickCount * PVOX_BRICK_EDGE_VOXELS ** 3) {
     throw new Error("VoxelTechnicalProfile collisionLogicalVoxelCapacity must equal collisionBrickCount multiplied by 512.");
   }
-  const collisionEncodedSurfaceSampleCount = requireInteger(record.collisionEncodedSurfaceSampleCount, "VoxelTechnicalProfile.collisionEncodedSurfaceSampleCount", hasCollision ? 1 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples : 0);
+  const collisionEncodedSurfaceSampleCount = requireInteger(record2.collisionEncodedSurfaceSampleCount, "VoxelTechnicalProfile.collisionEncodedSurfaceSampleCount", hasCollision ? 1 : 0, hasCollision ? PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples : 0);
   if (collisionEncodedSurfaceSampleCount > collisionLogicalVoxelCapacity) {
     throw new Error("VoxelTechnicalProfile collision encoded sample count cannot exceed its logical voxel capacity.");
   }
@@ -3422,15 +3422,15 @@ function createVoxelTechnicalProfile(input) {
   }
   const maximumDimensionMetres = Math.max(...supplied);
   const fullDiagonalMetres = Math.hypot(...supplied);
-  const maximumPartitionExtentMetres = requireNumber(record.maximumPartitionExtentMetres, "VoxelTechnicalProfile.maximumPartitionExtentMetres", Number.EPSILON, maximumDimensionMetres + Math.max(1e-9, maximumDimensionMetres * 1e-9));
-  const maximumPartitionDiagonalMetres = requireNumber(record.maximumPartitionDiagonalMetres, "VoxelTechnicalProfile.maximumPartitionDiagonalMetres", maximumPartitionExtentMetres, fullDiagonalMetres + Math.max(1e-9, fullDiagonalMetres * 1e-9));
+  const maximumPartitionExtentMetres = requireNumber(record2.maximumPartitionExtentMetres, "VoxelTechnicalProfile.maximumPartitionExtentMetres", Number.EPSILON, maximumDimensionMetres + Math.max(1e-9, maximumDimensionMetres * 1e-9));
+  const maximumPartitionDiagonalMetres = requireNumber(record2.maximumPartitionDiagonalMetres, "VoxelTechnicalProfile.maximumPartitionDiagonalMetres", maximumPartitionExtentMetres, fullDiagonalMetres + Math.max(1e-9, fullDiagonalMetres * 1e-9));
   if (partitionCount === 1 && (!approximatelyEqual(maximumPartitionExtentMetres, maximumDimensionMetres) || !approximatelyEqual(maximumPartitionDiagonalMetres, fullDiagonalMetres))) {
     throw new Error("VoxelTechnicalProfile single-partition extent and diagonal must cover the complete bounds.");
   }
   const profile = {
     boundsMetres,
     dimensionsMetres,
-    geometryMode: requireEnum(record.geometryMode, ["solid", "shell", "mixed"], "VoxelTechnicalProfile.geometryMode"),
+    geometryMode: requireEnum(record2.geometryMode, ["solid", "shell", "mixed"], "VoxelTechnicalProfile.geometryMode"),
     artifactByteLength,
     pageCount,
     brickCount,
@@ -3452,8 +3452,8 @@ function createVoxelTechnicalProfile(input) {
     collisionBrickCount,
     collisionLogicalVoxelCapacity,
     collisionEncodedSurfaceSampleCount,
-    cpuResidentByteLength: requireInteger(record.cpuResidentByteLength, "VoxelTechnicalProfile.cpuResidentByteLength", 1, PVOX_DEFAULT_LIMITS.maximumCpuResidentBytes),
-    gpuResidentByteLength: requireInteger(record.gpuResidentByteLength, "VoxelTechnicalProfile.gpuResidentByteLength", 1, PVOX_DEFAULT_LIMITS.maximumGpuResidentBytes),
+    cpuResidentByteLength: requireInteger(record2.cpuResidentByteLength, "VoxelTechnicalProfile.cpuResidentByteLength", 1, PVOX_DEFAULT_LIMITS.maximumCpuResidentBytes),
+    gpuResidentByteLength: requireInteger(record2.gpuResidentByteLength, "VoxelTechnicalProfile.gpuResidentByteLength", 1, PVOX_DEFAULT_LIMITS.maximumGpuResidentBytes),
     hasCollision,
     partitionCount,
     maximumPartitionExtentMetres,
@@ -3466,21 +3466,21 @@ function createVoxelTechnicalProfile(input) {
   return deepFreeze2(profile);
 }
 function createVoxelCapabilityAssessment(input) {
-  const record = asRecord(input, "VoxelCapabilityAssessment");
-  exactKeys(record, ["capability", "status", "evaluatorId", "evaluatorVersion", "subjectContentHash", "evidenceHash", "reasonCodes", "evaluatedAt"], "VoxelCapabilityAssessment");
-  const status = requireEnum(record.status, ["supported", "unsupported", "not-applicable"], "VoxelCapabilityAssessment.status");
-  const reasonCodes2 = requireReasonCodes(record.reasonCodes, "VoxelCapabilityAssessment.reasonCodes");
+  const record2 = asRecord(input, "VoxelCapabilityAssessment");
+  exactKeys(record2, ["capability", "status", "evaluatorId", "evaluatorVersion", "subjectContentHash", "evidenceHash", "reasonCodes", "evaluatedAt"], "VoxelCapabilityAssessment");
+  const status = requireEnum(record2.status, ["supported", "unsupported", "not-applicable"], "VoxelCapabilityAssessment.status");
+  const reasonCodes2 = requireReasonCodes(record2.reasonCodes, "VoxelCapabilityAssessment.reasonCodes");
   if (status === "supported" && reasonCodes2.length !== 0) throw new Error("Supported capability evidence must not contain failure reason codes.");
   if (status !== "supported" && reasonCodes2.length === 0) throw new Error("Unavailable capability evidence requires a reason code.");
   return deepFreeze2({
-    capability: requireEnum(record.capability, PVOX_CAPABILITIES, "VoxelCapabilityAssessment.capability"),
+    capability: requireEnum(record2.capability, PVOX_CAPABILITIES, "VoxelCapabilityAssessment.capability"),
     status,
-    evaluatorId: requireToken(record.evaluatorId, "VoxelCapabilityAssessment.evaluatorId"),
-    evaluatorVersion: assertImmutableAssetVersion(record.evaluatorVersion),
-    subjectContentHash: requireSha256(record.subjectContentHash, "VoxelCapabilityAssessment.subjectContentHash"),
-    evidenceHash: requireSha256(record.evidenceHash, "VoxelCapabilityAssessment.evidenceHash"),
+    evaluatorId: requireToken(record2.evaluatorId, "VoxelCapabilityAssessment.evaluatorId"),
+    evaluatorVersion: assertImmutableAssetVersion(record2.evaluatorVersion),
+    subjectContentHash: requireSha256(record2.subjectContentHash, "VoxelCapabilityAssessment.subjectContentHash"),
+    evidenceHash: requireSha256(record2.evidenceHash, "VoxelCapabilityAssessment.evidenceHash"),
     reasonCodes: reasonCodes2,
-    evaluatedAt: requireTimestamp(record.evaluatedAt, "VoxelCapabilityAssessment.evaluatedAt")
+    evaluatedAt: requireTimestamp(record2.evaluatedAt, "VoxelCapabilityAssessment.evaluatedAt")
   });
 }
 var PVOX_PHYSICAL_PROPERTY_POLICIES = deepFreeze2({
@@ -3505,42 +3505,42 @@ var PVOX_PHYSICAL_PROPERTY_POLICIES = deepFreeze2({
   "interior-thickness": { unit: "m", minimum: Number.EPSILON, maximum: 1e6 }
 });
 function createPhysicalPropertyEvidence(input) {
-  const record = asRecord(input, "PhysicalPropertyEvidence");
-  exactKeys(record, ["property", "value", "unit", "provenance", "confidence", "subjectContentHash", "regionId", "materialId", "policyId", "policyVersion", "evidenceHash", "reviewedBy", "reviewedAt", "reviewToken"], "PhysicalPropertyEvidence");
-  const property = requireEnum(record.property, PVOX_PHYSICAL_PROPERTIES, "PhysicalPropertyEvidence.property");
+  const record2 = asRecord(input, "PhysicalPropertyEvidence");
+  exactKeys(record2, ["property", "value", "unit", "provenance", "confidence", "subjectContentHash", "regionId", "materialId", "policyId", "policyVersion", "evidenceHash", "reviewedBy", "reviewedAt", "reviewToken"], "PhysicalPropertyEvidence");
+  const property = requireEnum(record2.property, PVOX_PHYSICAL_PROPERTIES, "PhysicalPropertyEvidence.property");
   const policy = PVOX_PHYSICAL_PROPERTY_POLICIES[property];
-  if (record.policyId !== PVOX_PHYSICAL_PROPERTY_POLICY_ID || record.policyVersion !== PVOX_PHYSICAL_PROPERTY_POLICY_VERSION) {
+  if (record2.policyId !== PVOX_PHYSICAL_PROPERTY_POLICY_ID || record2.policyVersion !== PVOX_PHYSICAL_PROPERTY_POLICY_VERSION) {
     throw new Error("PhysicalPropertyEvidence must use the governed immutable physical-property policy.");
   }
-  assertImmutableAssetVersion(record.policyVersion);
-  if (record.unit !== policy.unit) throw new Error("PhysicalPropertyEvidence unit must match its governed property policy.");
-  const provenance = requireEnum(record.provenance, ["source", "authored", "derived", "inferred", "default"], "PhysicalPropertyEvidence.provenance");
-  const reviewedBy = record.reviewedBy === void 0 ? void 0 : requireToken(record.reviewedBy, "PhysicalPropertyEvidence.reviewedBy");
-  const reviewedAt = record.reviewedAt === void 0 ? void 0 : requireTimestamp(record.reviewedAt, "PhysicalPropertyEvidence.reviewedAt");
-  const reviewToken = record.reviewToken === void 0 ? void 0 : requireAttestation(record.reviewToken, "PhysicalPropertyEvidence.reviewToken");
+  assertImmutableAssetVersion(record2.policyVersion);
+  if (record2.unit !== policy.unit) throw new Error("PhysicalPropertyEvidence unit must match its governed property policy.");
+  const provenance = requireEnum(record2.provenance, ["source", "authored", "derived", "inferred", "default"], "PhysicalPropertyEvidence.provenance");
+  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 (provenance === "inferred" && reviewedBy === void 0) throw new Error("Inferred PhysicalPropertyEvidence requires human review.");
   return deepFreeze2({
     property,
-    value: requireNumber(record.value, "PhysicalPropertyEvidence.value", policy.minimum, policy.maximum),
+    value: requireNumber(record2.value, "PhysicalPropertyEvidence.value", policy.minimum, policy.maximum),
     unit: policy.unit,
     provenance,
-    confidence: requireNumber(record.confidence, "PhysicalPropertyEvidence.confidence", 0, 1),
-    subjectContentHash: requireSha256(record.subjectContentHash, "PhysicalPropertyEvidence.subjectContentHash"),
-    regionId: requireToken(record.regionId, "PhysicalPropertyEvidence.regionId"),
-    materialId: requireToken(record.materialId, "PhysicalPropertyEvidence.materialId"),
+    confidence: requireNumber(record2.confidence, "PhysicalPropertyEvidence.confidence", 0, 1),
+    subjectContentHash: requireSha256(record2.subjectContentHash, "PhysicalPropertyEvidence.subjectContentHash"),
+    regionId: requireToken(record2.regionId, "PhysicalPropertyEvidence.regionId"),
+    materialId: requireToken(record2.materialId, "PhysicalPropertyEvidence.materialId"),
     policyId: PVOX_PHYSICAL_PROPERTY_POLICY_ID,
     policyVersion: PVOX_PHYSICAL_PROPERTY_POLICY_VERSION,
-    evidenceHash: requireSha256(record.evidenceHash, "PhysicalPropertyEvidence.evidenceHash"),
+    evidenceHash: requireSha256(record2.evidenceHash, "PhysicalPropertyEvidence.evidenceHash"),
     ...reviewedBy === void 0 ? {} : { reviewedBy, reviewedAt, reviewToken }
   });
 }
 function createPvoxPhysicalRegionInventoryV1(input) {
   const fieldName = "PvoxPhysicalRegionInventoryV1";
-  const record = asRecord(input, fieldName);
-  exactKeys(record, ["inventoryVersion", "subjectContentHash", "inventoryHash", "inventoryHashAttestation", "validationEvidenceHash", "entries"], fieldName);
-  if (record.inventoryVersion !== PVOX_PHYSICAL_REGION_INVENTORY_VERSION) throw new Error(`${fieldName}.inventoryVersion is unsupported.`);
-  const entriesInput = asDenseArray(record.entries, `${fieldName}.entries`, 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions);
+  const record2 = asRecord(input, fieldName);
+  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 entryName = `${fieldName}.entries[${index}]`;
     const item = asRecord(entry, entryName);
@@ -3555,23 +3555,23 @@ function createPvoxPhysicalRegionInventoryV1(input) {
   if (entries.some((entry, index) => entry.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(record.inventoryHash, `${fieldName}.inventoryHash`);
+  const inventoryHash = requireSha256(record2.inventoryHash, `${fieldName}.inventoryHash`);
   return deepFreeze2({
     inventoryVersion: PVOX_PHYSICAL_REGION_INVENTORY_VERSION,
-    subjectContentHash: requireSha256(record.subjectContentHash, `${fieldName}.subjectContentHash`),
+    subjectContentHash: requireSha256(record2.subjectContentHash, `${fieldName}.subjectContentHash`),
     inventoryHash,
-    inventoryHashAttestation: createHashAttestation(record.inventoryHashAttestation, PVOX_PHYSICAL_INVENTORY_HASH_DOMAIN, inventoryHash, `${fieldName}.inventoryHashAttestation`),
-    validationEvidenceHash: requireSha256(record.validationEvidenceHash, `${fieldName}.validationEvidenceHash`),
+    inventoryHashAttestation: createHashAttestation(record2.inventoryHashAttestation, PVOX_PHYSICAL_INVENTORY_HASH_DOMAIN, inventoryHash, `${fieldName}.inventoryHashAttestation`),
+    validationEvidenceHash: requireSha256(record2.validationEvidenceHash, `${fieldName}.validationEvidenceHash`),
     entries
   });
 }
 function createReviewedStructuralEvidence(input, expectedKind, expectedSubjectHash, expectedInventoryHash, expectedRecordCount, fieldName) {
-  const record = asRecord(input, fieldName);
-  exactKeys(record, ["kind", "subjectContentHash", "physicalInventoryHash", "recordCount", "evidenceHash", "reviewerId", "reviewedAt", "reviewToken"], fieldName);
-  if (record.kind !== expectedKind) throw new Error(`${fieldName}.kind must be ${expectedKind}.`);
-  const subjectContentHash = requireSha256(record.subjectContentHash, `${fieldName}.subjectContentHash`);
-  const physicalInventoryHash = requireSha256(record.physicalInventoryHash, `${fieldName}.physicalInventoryHash`);
-  const recordCount = requireInteger(record.recordCount, `${fieldName}.recordCount`, 0, PVOX_DEFAULT_LIMITS.maximumBondRecords);
+  const record2 = asRecord(input, fieldName);
+  exactKeys(record2, ["kind", "subjectContentHash", "physicalInventoryHash", "recordCount", "evidenceHash", "reviewerId", "reviewedAt", "reviewToken"], fieldName);
+  if (record2.kind !== expectedKind) throw new Error(`${fieldName}.kind must be ${expectedKind}.`);
+  const subjectContentHash = requireSha256(record2.subjectContentHash, `${fieldName}.subjectContentHash`);
+  const physicalInventoryHash = requireSha256(record2.physicalInventoryHash, `${fieldName}.physicalInventoryHash`);
+  const recordCount = requireInteger(record2.recordCount, `${fieldName}.recordCount`, 0, PVOX_DEFAULT_LIMITS.maximumBondRecords);
   if (subjectContentHash !== expectedSubjectHash || physicalInventoryHash !== expectedInventoryHash || recordCount !== expectedRecordCount) {
     throw new Error(`${fieldName} must bind the exact PVOX closure, physical inventory, and binary record count.`);
   }
@@ -3580,15 +3580,15 @@ function createReviewedStructuralEvidence(input, expectedKind, expectedSubjectHa
     subjectContentHash,
     physicalInventoryHash,
     recordCount,
-    evidenceHash: requireSha256(record.evidenceHash, `${fieldName}.evidenceHash`),
-    reviewerId: requireToken(record.reviewerId, `${fieldName}.reviewerId`),
-    reviewedAt: requireTimestamp(record.reviewedAt, `${fieldName}.reviewedAt`),
-    reviewToken: requireAttestation(record.reviewToken, `${fieldName}.reviewToken`)
+    evidenceHash: requireSha256(record2.evidenceHash, `${fieldName}.evidenceHash`),
+    reviewerId: requireToken(record2.reviewerId, `${fieldName}.reviewerId`),
+    reviewedAt: requireTimestamp(record2.reviewedAt, `${fieldName}.reviewedAt`),
+    reviewToken: requireAttestation(record2.reviewToken, `${fieldName}.reviewToken`)
   });
 }
 function createPvoxFidelityEvidence(input) {
-  const record = asRecord(input, "PvoxFidelityEvidence");
-  exactKeys(record, [
+  const record2 = asRecord(input, "PvoxFidelityEvidence");
+  exactKeys(record2, [
     "profileId",
     "surfaceProfileId",
     "profileVersion",
@@ -3615,8 +3615,8 @@ function createPvoxFidelityEvidence(input) {
     "evaluatedAt",
     "decisionToken"
   ], "PvoxFidelityEvidence");
-  const profileId = requireEnum(record.profileId, PVOX_FIDELITY_PROFILE_IDS, "PvoxFidelityEvidence.profileId");
-  const surfaceProfileId = requireEnum(record.surfaceProfileId, [
+  const profileId = requireEnum(record2.profileId, PVOX_FIDELITY_PROFILE_IDS, "PvoxFidelityEvidence.profileId");
+  const surfaceProfileId = requireEnum(record2.surfaceProfileId, [
     "precision-hero-v1",
     "props-furniture-v1",
     "rocks-organic-shells-v1",
@@ -3625,12 +3625,12 @@ function createPvoxFidelityEvidence(input) {
   if (profileId !== "deformable-v1" && profileId !== surfaceProfileId) {
     throw new Error("PvoxFidelityEvidence surfaceProfileId must match its governed profileId.");
   }
-  if (record.profileVersion !== PVOX_FIDELITY_PROFILE_VERSION) {
+  if (record2.profileVersion !== PVOX_FIDELITY_PROFILE_VERSION) {
     throw new Error("PvoxFidelityEvidence.profileVersion must use the governed profile version.");
   }
-  assertImmutableAssetVersion(record.profileVersion);
-  const evaluatedDiagonalMetres = requireNumber(record.evaluatedDiagonalMetres, "PvoxFidelityEvidence.evaluatedDiagonalMetres", Number.EPSILON, 1e9);
-  const lod0CellSizeMetres = requireNumber(record.lod0CellSizeMetres, "PvoxFidelityEvidence.lod0CellSizeMetres", Number.EPSILON, 1e6);
+  assertImmutableAssetVersion(record2.profileVersion);
+  const evaluatedDiagonalMetres = requireNumber(record2.evaluatedDiagonalMetres, "PvoxFidelityEvidence.evaluatedDiagonalMetres", Number.EPSILON, 1e9);
+  const lod0CellSizeMetres = requireNumber(record2.lod0CellSizeMetres, "PvoxFidelityEvidence.lod0CellSizeMetres", Number.EPSILON, 1e6);
   const profileFormula = {
     "precision-hero-v1": [25e-5, 1e-4],
     "props-furniture-v1": [5e-4, 25e-5],
@@ -3640,16 +3640,16 @@ function createPvoxFidelityEvidence(input) {
   const [absoluteFloor, diagonalFactor] = profileFormula[surfaceProfileId];
   const governedP99Ceiling = Math.max(absoluteFloor, evaluatedDiagonalMetres * diagonalFactor);
   const governedMaximumCeiling = Math.min(3 * governedP99Ceiling, 1.5 * lod0CellSizeMetres);
-  const suppliedP99Ceiling = requireNumber(record.p99AllowedSurfaceErrorMetres, "PvoxFidelityEvidence.p99AllowedSurfaceErrorMetres", 0, 1e6);
-  const suppliedMaximumCeiling = requireNumber(record.maximumAllowedSurfaceErrorMetres, "PvoxFidelityEvidence.maximumAllowedSurfaceErrorMetres", 0, 1e6);
+  const suppliedP99Ceiling = requireNumber(record2.p99AllowedSurfaceErrorMetres, "PvoxFidelityEvidence.p99AllowedSurfaceErrorMetres", 0, 1e6);
+  const suppliedMaximumCeiling = requireNumber(record2.maximumAllowedSurfaceErrorMetres, "PvoxFidelityEvidence.maximumAllowedSurfaceErrorMetres", 0, 1e6);
   if (!approximatelyEqual(suppliedP99Ceiling, governedP99Ceiling) || !approximatelyEqual(suppliedMaximumCeiling, governedMaximumCeiling)) {
     throw new Error("PvoxFidelityEvidence surface ceilings must match the governed profile formula and LOD0 cell limit.");
   }
-  const minimumSilhouetteIou = requireNumber(record.minimumSilhouetteIou, "PvoxFidelityEvidence.minimumSilhouetteIou", 0, 1);
-  const maximumAllowedContourDisplacementPx = requireNumber(record.maximumAllowedContourDisplacementPx, "PvoxFidelityEvidence.maximumAllowedContourDisplacementPx", 0, 1e6);
-  const minimumRenderedSsim = requireNumber(record.minimumRenderedSsim, "PvoxFidelityEvidence.minimumRenderedSsim", 0, 1);
-  const maximumP95DeltaE2000 = requireNumber(record.maximumP95DeltaE2000, "PvoxFidelityEvidence.maximumP95DeltaE2000", 0, 100);
-  const maximumNormalizedMaterialError = requireNumber(record.maximumNormalizedMaterialError, "PvoxFidelityEvidence.maximumNormalizedMaterialError", 0, 1);
+  const minimumSilhouetteIou = requireNumber(record2.minimumSilhouetteIou, "PvoxFidelityEvidence.minimumSilhouetteIou", 0, 1);
+  const maximumAllowedContourDisplacementPx = requireNumber(record2.maximumAllowedContourDisplacementPx, "PvoxFidelityEvidence.maximumAllowedContourDisplacementPx", 0, 1e6);
+  const minimumRenderedSsim = requireNumber(record2.minimumRenderedSsim, "PvoxFidelityEvidence.minimumRenderedSsim", 0, 1);
+  const maximumP95DeltaE2000 = requireNumber(record2.maximumP95DeltaE2000, "PvoxFidelityEvidence.maximumP95DeltaE2000", 0, 100);
+  const maximumNormalizedMaterialError = requireNumber(record2.maximumNormalizedMaterialError, "PvoxFidelityEvidence.maximumNormalizedMaterialError", 0, 1);
   if (!approximatelyEqual(minimumSilhouetteIou, 0.995) || !approximatelyEqual(maximumAllowedContourDisplacementPx, 0.5) || !approximatelyEqual(minimumRenderedSsim, 0.98) || !approximatelyEqual(maximumP95DeltaE2000, 3) || !approximatelyEqual(maximumNormalizedMaterialError, 1 / 255)) {
     throw new Error("PvoxFidelityEvidence must use the governed silhouette, contour, render, colour, and material thresholds.");
   }
@@ -3657,38 +3657,38 @@ function createPvoxFidelityEvidence(input) {
     profileId,
     surfaceProfileId,
     profileVersion: PVOX_FIDELITY_PROFILE_VERSION,
-    canonicalDocumentHash: requireSha256(record.canonicalDocumentHash, "PvoxFidelityEvidence.canonicalDocumentHash"),
-    pvoxBinaryClosureHash: requireSha256(record.pvoxBinaryClosureHash, "PvoxFidelityEvidence.pvoxBinaryClosureHash"),
+    canonicalDocumentHash: requireSha256(record2.canonicalDocumentHash, "PvoxFidelityEvidence.canonicalDocumentHash"),
+    pvoxBinaryClosureHash: requireSha256(record2.pvoxBinaryClosureHash, "PvoxFidelityEvidence.pvoxBinaryClosureHash"),
     evaluatedDiagonalMetres,
     lod0CellSizeMetres,
     maximumAllowedSurfaceErrorMetres: governedMaximumCeiling,
-    maximumSurfaceErrorMetres: requireNumber(record.maximumSurfaceErrorMetres, "PvoxFidelityEvidence.maximumSurfaceErrorMetres", 0, 1e6),
+    maximumSurfaceErrorMetres: requireNumber(record2.maximumSurfaceErrorMetres, "PvoxFidelityEvidence.maximumSurfaceErrorMetres", 0, 1e6),
     p99AllowedSurfaceErrorMetres: governedP99Ceiling,
-    p99SurfaceErrorMetres: requireNumber(record.p99SurfaceErrorMetres, "PvoxFidelityEvidence.p99SurfaceErrorMetres", 0, 1e6),
+    p99SurfaceErrorMetres: requireNumber(record2.p99SurfaceErrorMetres, "PvoxFidelityEvidence.p99SurfaceErrorMetres", 0, 1e6),
     minimumSilhouetteIou,
-    silhouetteIou: requireNumber(record.silhouetteIou, "PvoxFidelityEvidence.silhouetteIou", 0, 1),
+    silhouetteIou: requireNumber(record2.silhouetteIou, "PvoxFidelityEvidence.silhouetteIou", 0, 1),
     maximumAllowedContourDisplacementPx,
-    maximumContourDisplacementPx: requireNumber(record.maximumContourDisplacementPx, "PvoxFidelityEvidence.maximumContourDisplacementPx", 0, 1e6),
+    maximumContourDisplacementPx: requireNumber(record2.maximumContourDisplacementPx, "PvoxFidelityEvidence.maximumContourDisplacementPx", 0, 1e6),
     minimumRenderedSsim,
-    renderedSsim: requireNumber(record.renderedSsim, "PvoxFidelityEvidence.renderedSsim", 0, 1),
+    renderedSsim: requireNumber(record2.renderedSsim, "PvoxFidelityEvidence.renderedSsim", 0, 1),
     maximumP95DeltaE2000,
-    p95DeltaE2000: requireNumber(record.p95DeltaE2000, "PvoxFidelityEvidence.p95DeltaE2000", 0, 100),
+    p95DeltaE2000: requireNumber(record2.p95DeltaE2000, "PvoxFidelityEvidence.p95DeltaE2000", 0, 100),
     maximumNormalizedMaterialError,
-    normalizedMaterialError: requireNumber(record.normalizedMaterialError, "PvoxFidelityEvidence.normalizedMaterialError", 0, 1),
-    evidenceHash: requireSha256(record.evidenceHash, "PvoxFidelityEvidence.evidenceHash"),
-    evaluatedAt: requireTimestamp(record.evaluatedAt, "PvoxFidelityEvidence.evaluatedAt"),
-    decisionToken: requireAttestation(record.decisionToken, "PvoxFidelityEvidence.decisionToken")
+    normalizedMaterialError: requireNumber(record2.normalizedMaterialError, "PvoxFidelityEvidence.normalizedMaterialError", 0, 1),
+    evidenceHash: requireSha256(record2.evidenceHash, "PvoxFidelityEvidence.evidenceHash"),
+    evaluatedAt: requireTimestamp(record2.evaluatedAt, "PvoxFidelityEvidence.evaluatedAt"),
+    decisionToken: requireAttestation(record2.decisionToken, "PvoxFidelityEvidence.decisionToken")
   };
   const passed = output.maximumSurfaceErrorMetres <= output.maximumAllowedSurfaceErrorMetres && output.p99SurfaceErrorMetres <= output.p99AllowedSurfaceErrorMetres && output.silhouetteIou >= output.minimumSilhouetteIou && output.maximumContourDisplacementPx <= output.maximumAllowedContourDisplacementPx && output.renderedSsim >= output.minimumRenderedSsim && output.p95DeltaE2000 <= output.maximumP95DeltaE2000 && output.normalizedMaterialError <= output.maximumNormalizedMaterialError;
-  const outcome = requireEnum(record.outcome, ["passed", "blocked"], "PvoxFidelityEvidence.outcome");
+  const outcome = requireEnum(record2.outcome, ["passed", "blocked"], "PvoxFidelityEvidence.outcome");
   if (outcome !== (passed ? "passed" : "blocked")) throw new Error("PvoxFidelityEvidence outcome must match its measured fidelity thresholds.");
   return deepFreeze2({ ...output, outcome });
 }
 function createPvoxEditJournalCurrentState(input, baseManifest) {
   const fieldName = "PvoxEditJournalCurrentState";
-  const record = asRecord(input, fieldName);
-  exactKeys(record, ["baseContentHash", "basePageSetHash", "placementId", "gridVersion", "revision", "rootHash", "latestJournalHash", "pageHashes"], fieldName);
-  const pageEntries = asDenseArray(record.pageHashes, `${fieldName}.pageHashes`, baseManifest.pages.length, baseManifest.pages.length);
+  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 entryName = `${fieldName}.pageHashes[${index}]`;
     const page = asRecord(entry, entryName);
@@ -3698,38 +3698,38 @@ function createPvoxEditJournalCurrentState(input, baseManifest) {
     return { pageIndex, sha256: requireSha256(page.sha256, `${entryName}.sha256`) };
   });
   return deepFreeze2({
-    baseContentHash: requireSha256(record.baseContentHash, `${fieldName}.baseContentHash`),
-    basePageSetHash: requireSha256(record.basePageSetHash, `${fieldName}.basePageSetHash`),
-    placementId: requireToken(record.placementId, `${fieldName}.placementId`),
-    gridVersion: requireToken(record.gridVersion, `${fieldName}.gridVersion`),
-    revision: requireInteger(record.revision, `${fieldName}.revision`, 1, Number.MAX_SAFE_INTEGER),
-    rootHash: requireSha256(record.rootHash, `${fieldName}.rootHash`),
-    latestJournalHash: requireSha256(record.latestJournalHash, `${fieldName}.latestJournalHash`),
+    baseContentHash: requireSha256(record2.baseContentHash, `${fieldName}.baseContentHash`),
+    basePageSetHash: requireSha256(record2.basePageSetHash, `${fieldName}.basePageSetHash`),
+    placementId: requireToken(record2.placementId, `${fieldName}.placementId`),
+    gridVersion: requireToken(record2.gridVersion, `${fieldName}.gridVersion`),
+    revision: requireInteger(record2.revision, `${fieldName}.revision`, 1, Number.MAX_SAFE_INTEGER),
+    rootHash: requireSha256(record2.rootHash, `${fieldName}.rootHash`),
+    latestJournalHash: requireSha256(record2.latestJournalHash, `${fieldName}.latestJournalHash`),
     pageHashes
   });
 }
 function createPvoxEditJournal(input, baseManifestInput, currentStateInput) {
-  const record = asRecord(input, "PvoxEditJournal");
-  exactKeys(record, ["journalVersion", "baseContentHash", "basePageSetHash", "placementId", "gridVersion", "operationId", "expectedRevision", "resultingRevision", "previousJournalHash", "expectedRootHash", "resultingRootHash", "resultingRootHashAttestation", "patches", "dirtyBoundsMetres", "massDeltaKg", "journalHash", "journalHashAttestation", "recordedAt"], "PvoxEditJournal");
-  if (record.journalVersion !== PVOX_EDIT_JOURNAL_VERSION) throw new Error("PvoxEditJournal.journalVersion is unsupported.");
+  const record2 = asRecord(input, "PvoxEditJournal");
+  exactKeys(record2, ["journalVersion", "baseContentHash", "basePageSetHash", "placementId", "gridVersion", "operationId", "expectedRevision", "resultingRevision", "previousJournalHash", "expectedRootHash", "resultingRootHash", "resultingRootHashAttestation", "patches", "dirtyBoundsMetres", "massDeltaKg", "journalHash", "journalHashAttestation", "recordedAt"], "PvoxEditJournal");
+  if (record2.journalVersion !== PVOX_EDIT_JOURNAL_VERSION) throw new Error("PvoxEditJournal.journalVersion is unsupported.");
   const baseManifest = createPvoxAssetManifestV1(baseManifestInput);
-  const baseContentHash = requireSha256(record.baseContentHash, "PvoxEditJournal.baseContentHash");
-  const basePageSetHash = requireSha256(record.basePageSetHash, "PvoxEditJournal.basePageSetHash");
+  const baseContentHash = requireSha256(record2.baseContentHash, "PvoxEditJournal.baseContentHash");
+  const basePageSetHash = requireSha256(record2.basePageSetHash, "PvoxEditJournal.basePageSetHash");
   if (baseContentHash !== baseManifest.artifact.sha256 || basePageSetHash !== baseManifest.pageSetHash) {
     throw new Error("PvoxEditJournal must bind the exact base PVOX artifact and page inventory.");
   }
-  const expectedRevision = requireInteger(record.expectedRevision, "PvoxEditJournal.expectedRevision", 0, Number.MAX_SAFE_INTEGER - 1);
-  const resultingRevision = requireInteger(record.resultingRevision, "PvoxEditJournal.resultingRevision", 1, Number.MAX_SAFE_INTEGER);
+  const expectedRevision = requireInteger(record2.expectedRevision, "PvoxEditJournal.expectedRevision", 0, Number.MAX_SAFE_INTEGER - 1);
+  const resultingRevision = requireInteger(record2.resultingRevision, "PvoxEditJournal.resultingRevision", 1, Number.MAX_SAFE_INTEGER);
   if (resultingRevision !== expectedRevision + 1) throw new Error("PvoxEditJournal revisions must be sequential.");
-  const previousJournalHash = requireSha256(record.previousJournalHash, "PvoxEditJournal.previousJournalHash");
+  const previousJournalHash = requireSha256(record2.previousJournalHash, "PvoxEditJournal.previousJournalHash");
   if (expectedRevision === 0 !== (previousJournalHash === PVOX_EDIT_JOURNAL_GENESIS_HASH)) {
     throw new Error("PvoxEditJournal genesis revision must use only the canonical genesis previousJournalHash.");
   }
-  const expectedRootHash = requireSha256(record.expectedRootHash, "PvoxEditJournal.expectedRootHash");
-  const resultingRootHash = requireSha256(record.resultingRootHash, "PvoxEditJournal.resultingRootHash");
+  const expectedRootHash = requireSha256(record2.expectedRootHash, "PvoxEditJournal.expectedRootHash");
+  const resultingRootHash = requireSha256(record2.resultingRootHash, "PvoxEditJournal.resultingRootHash");
   if (expectedRootHash === resultingRootHash) throw new Error("PvoxEditJournal copy-on-write operation must change the overlay root hash.");
-  const placementId = requireToken(record.placementId, "PvoxEditJournal.placementId");
-  const gridVersion = requireToken(record.gridVersion, "PvoxEditJournal.gridVersion");
+  const placementId = requireToken(record2.placementId, "PvoxEditJournal.placementId");
+  const gridVersion = requireToken(record2.gridVersion, "PvoxEditJournal.gridVersion");
   let currentState;
   if (expectedRevision === 0) {
     if (currentStateInput !== void 0) throw new Error("PvoxEditJournal genesis must not supply a non-genesis current state.");
@@ -3741,7 +3741,7 @@ function createPvoxEditJournal(input, baseManifestInput, currentStateInput) {
       throw new Error("PvoxEditJournal non-genesis CAS subject must match the authenticated current placement state.");
     }
   }
-  const patchEntries = asDenseArray(record.patches, "PvoxEditJournal.patches", 1, PVOX_MAX_EDIT_PATCHES);
+  const patchEntries = asDenseArray(record2.patches, "PvoxEditJournal.patches", 1, PVOX_MAX_EDIT_PATCHES);
   const patches = patchEntries.map((entry, index) => {
     const fieldName = `PvoxEditJournal.patches[${index}]`;
     const patch = asRecord(entry, fieldName);
@@ -3793,26 +3793,26 @@ function createPvoxEditJournal(input, baseManifestInput, currentStateInput) {
   if (new Set(patches.map(({ expectedPageIndex }) => expectedPageIndex)).size !== patches.length) {
     throw new Error("PvoxEditJournal permits only one coherent patch transition per page.");
   }
-  const journalHash = requireSha256(record.journalHash, "PvoxEditJournal.journalHash");
+  const journalHash = requireSha256(record2.journalHash, "PvoxEditJournal.journalHash");
   return deepFreeze2({
     journalVersion: PVOX_EDIT_JOURNAL_VERSION,
     baseContentHash,
     basePageSetHash,
     placementId,
     gridVersion,
-    operationId: requireToken(record.operationId, "PvoxEditJournal.operationId"),
+    operationId: requireToken(record2.operationId, "PvoxEditJournal.operationId"),
     expectedRevision,
     resultingRevision,
     previousJournalHash,
     expectedRootHash,
     resultingRootHash,
-    resultingRootHashAttestation: createHashAttestation(record.resultingRootHashAttestation, PVOX_EDIT_OVERLAY_ROOT_HASH_DOMAIN, resultingRootHash, "PvoxEditJournal.resultingRootHashAttestation"),
+    resultingRootHashAttestation: createHashAttestation(record2.resultingRootHashAttestation, PVOX_EDIT_OVERLAY_ROOT_HASH_DOMAIN, resultingRootHash, "PvoxEditJournal.resultingRootHashAttestation"),
     patches,
-    dirtyBoundsMetres: createBounds2(record.dirtyBoundsMetres, "PvoxEditJournal.dirtyBoundsMetres"),
-    massDeltaKg: requireNumber(record.massDeltaKg, "PvoxEditJournal.massDeltaKg", -Number.MAX_VALUE, Number.MAX_VALUE),
+    dirtyBoundsMetres: createBounds2(record2.dirtyBoundsMetres, "PvoxEditJournal.dirtyBoundsMetres"),
+    massDeltaKg: requireNumber(record2.massDeltaKg, "PvoxEditJournal.massDeltaKg", -Number.MAX_VALUE, Number.MAX_VALUE),
     journalHash,
-    journalHashAttestation: createHashAttestation(record.journalHashAttestation, PVOX_EDIT_JOURNAL_HASH_DOMAIN, journalHash, "PvoxEditJournal.journalHashAttestation"),
-    recordedAt: requireTimestamp(record.recordedAt, "PvoxEditJournal.recordedAt")
+    journalHashAttestation: createHashAttestation(record2.journalHashAttestation, PVOX_EDIT_JOURNAL_HASH_DOMAIN, journalHash, "PvoxEditJournal.journalHashAttestation"),
+    recordedAt: requireTimestamp(record2.recordedAt, "PvoxEditJournal.recordedAt")
   });
 }
 function createPvoxEditJournalChain(input, baseManifestInput) {
@@ -3853,55 +3853,55 @@ function createPvoxEditJournalChain(input, baseManifestInput) {
   return deepFreeze2(journals);
 }
 function createCompilerEvidence(value) {
-  const record = asRecord(value, "ModelProcessingManifestV2.converter");
-  exactKeys(record, ["compilerId", "compilerVersion", "sourceFormat", "sourceContentHash", "canonicalDocumentHash", "compilationInputHash", "runtimeRequestProfileHash", "outputContentHash", "evidenceHash", "compiledAt"], "ModelProcessingManifestV2.converter");
+  const record2 = asRecord(value, "ModelProcessingManifestV2.converter");
+  exactKeys(record2, ["compilerId", "compilerVersion", "sourceFormat", "sourceContentHash", "canonicalDocumentHash", "compilationInputHash", "runtimeRequestProfileHash", "outputContentHash", "evidenceHash", "compiledAt"], "ModelProcessingManifestV2.converter");
   return {
-    compilerId: requireToken(record.compilerId, "ModelProcessingManifestV2.converter.compilerId"),
-    compilerVersion: assertImmutableAssetVersion(record.compilerVersion),
-    sourceFormat: requireToken(record.sourceFormat, "ModelProcessingManifestV2.converter.sourceFormat"),
-    sourceContentHash: requireSha256(record.sourceContentHash, "ModelProcessingManifestV2.converter.sourceContentHash"),
-    canonicalDocumentHash: requireSha256(record.canonicalDocumentHash, "ModelProcessingManifestV2.converter.canonicalDocumentHash"),
-    compilationInputHash: requireSha256(record.compilationInputHash, "ModelProcessingManifestV2.converter.compilationInputHash"),
-    runtimeRequestProfileHash: requireSha256(record.runtimeRequestProfileHash, "ModelProcessingManifestV2.converter.runtimeRequestProfileHash"),
-    outputContentHash: requireSha256(record.outputContentHash, "ModelProcessingManifestV2.converter.outputContentHash"),
-    evidenceHash: requireSha256(record.evidenceHash, "ModelProcessingManifestV2.converter.evidenceHash"),
-    compiledAt: requireTimestamp(record.compiledAt, "ModelProcessingManifestV2.converter.compiledAt")
+    compilerId: requireToken(record2.compilerId, "ModelProcessingManifestV2.converter.compilerId"),
+    compilerVersion: assertImmutableAssetVersion(record2.compilerVersion),
+    sourceFormat: requireToken(record2.sourceFormat, "ModelProcessingManifestV2.converter.sourceFormat"),
+    sourceContentHash: requireSha256(record2.sourceContentHash, "ModelProcessingManifestV2.converter.sourceContentHash"),
+    canonicalDocumentHash: requireSha256(record2.canonicalDocumentHash, "ModelProcessingManifestV2.converter.canonicalDocumentHash"),
+    compilationInputHash: requireSha256(record2.compilationInputHash, "ModelProcessingManifestV2.converter.compilationInputHash"),
+    runtimeRequestProfileHash: requireSha256(record2.runtimeRequestProfileHash, "ModelProcessingManifestV2.converter.runtimeRequestProfileHash"),
+    outputContentHash: requireSha256(record2.outputContentHash, "ModelProcessingManifestV2.converter.outputContentHash"),
+    evidenceHash: requireSha256(record2.evidenceHash, "ModelProcessingManifestV2.converter.evidenceHash"),
+    compiledAt: requireTimestamp(record2.compiledAt, "ModelProcessingManifestV2.converter.compiledAt")
   };
 }
 function createPvoxGateEvidence(input) {
-  const record = asRecord(input, "PvoxGateEvidence");
-  exactKeys(record, ["kind", "outcome", "validatorId", "validatorVersion", "subjectContentHash", "evidenceHash", "reasonCodes", "evaluatedAt", "attestationToken"], "PvoxGateEvidence");
-  const outcome = requireEnum(record.outcome, ["passed", "blocked"], "PvoxGateEvidence.outcome");
-  const reasonCodes2 = requireReasonCodes(record.reasonCodes, "PvoxGateEvidence.reasonCodes");
+  const record2 = asRecord(input, "PvoxGateEvidence");
+  exactKeys(record2, ["kind", "outcome", "validatorId", "validatorVersion", "subjectContentHash", "evidenceHash", "reasonCodes", "evaluatedAt", "attestationToken"], "PvoxGateEvidence");
+  const outcome = requireEnum(record2.outcome, ["passed", "blocked"], "PvoxGateEvidence.outcome");
+  const reasonCodes2 = requireReasonCodes(record2.reasonCodes, "PvoxGateEvidence.reasonCodes");
   if (outcome === "blocked" && reasonCodes2.length === 0) throw new Error("Blocked PvoxGateEvidence requires a reason code.");
   return deepFreeze2({
-    kind: requireEnum(record.kind, PVOX_NON_OVERRIDABLE_GATE_KINDS, "PvoxGateEvidence.kind"),
+    kind: requireEnum(record2.kind, PVOX_NON_OVERRIDABLE_GATE_KINDS, "PvoxGateEvidence.kind"),
     outcome,
-    validatorId: requireToken(record.validatorId, "PvoxGateEvidence.validatorId"),
-    validatorVersion: assertImmutableAssetVersion(record.validatorVersion),
-    subjectContentHash: requireSha256(record.subjectContentHash, "PvoxGateEvidence.subjectContentHash"),
-    evidenceHash: requireSha256(record.evidenceHash, "PvoxGateEvidence.evidenceHash"),
+    validatorId: requireToken(record2.validatorId, "PvoxGateEvidence.validatorId"),
+    validatorVersion: assertImmutableAssetVersion(record2.validatorVersion),
+    subjectContentHash: requireSha256(record2.subjectContentHash, "PvoxGateEvidence.subjectContentHash"),
+    evidenceHash: requireSha256(record2.evidenceHash, "PvoxGateEvidence.evidenceHash"),
     reasonCodes: reasonCodes2,
-    evaluatedAt: requireTimestamp(record.evaluatedAt, "PvoxGateEvidence.evaluatedAt"),
-    attestationToken: requireAttestation(record.attestationToken, "PvoxGateEvidence.attestationToken")
+    evaluatedAt: requireTimestamp(record2.evaluatedAt, "PvoxGateEvidence.evaluatedAt"),
+    attestationToken: requireAttestation(record2.attestationToken, "PvoxGateEvidence.attestationToken")
   });
 }
 function createTransform2(value, fieldName) {
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["translationMetres", "rotationQuaternion", "scale"], fieldName);
-  const translationMetres = requireVector(record.translationMetres, `${fieldName}.translationMetres`);
-  const rotationEntries = asDenseArray(record.rotationQuaternion, `${fieldName}.rotationQuaternion`, 4, 4);
+  const record2 = asRecord(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));
   if (Math.abs(Math.hypot(...rotationQuaternion) - 1) > 1e-4) throw new Error(`${fieldName}.rotationQuaternion must be normalized.`);
-  const scale = requireVector(record.scale, `${fieldName}.scale`);
+  const scale = requireVector(record2.scale, `${fieldName}.scale`);
   if (scale.some((entry) => entry <= 0)) throw new Error(`${fieldName}.scale values must be positive.`);
   return { translationMetres, rotationQuaternion, scale };
 }
 function createAssemblyChild2(value, index, resolutionId, candidateId) {
   const fieldName = `ModelProcessingManifestV2.children[${index}]`;
-  const record = asRecord(value, fieldName);
-  exactKeys(record, ["instanceId", "parentInstanceId", "assetRef", "transform"], fieldName);
-  const childRef = asRecord(record.assetRef, `${fieldName}.assetRef`);
+  const record2 = asRecord(value, fieldName);
+  exactKeys(record2, ["instanceId", "parentInstanceId", "assetRef", "transform"], fieldName);
+  const childRef = asRecord(record2.assetRef, `${fieldName}.assetRef`);
   let assetRef;
   if (childRef.disposition === "staged-derived") {
     exactKeys(childRef, ["disposition", "representation", "derivedId", "kind", "contentHash", "binaryClosureHash", "processingClosureHash", "processingManifestId", "processingManifestUri"], `${fieldName}.assetRef`);
@@ -3938,12 +3938,12 @@ function createAssemblyChild2(value, index, resolutionId, candidateId) {
       processingManifestUri: expectedUri
     };
   }
-  const parentInstanceId = record.parentInstanceId === void 0 ? void 0 : requireToken(record.parentInstanceId, `${fieldName}.parentInstanceId`);
+  const parentInstanceId = record2.parentInstanceId === void 0 ? void 0 : requireToken(record2.parentInstanceId, `${fieldName}.parentInstanceId`);
   return {
-    instanceId: requireToken(record.instanceId, `${fieldName}.instanceId`),
+    instanceId: requireToken(record2.instanceId, `${fieldName}.instanceId`),
     ...parentInstanceId === void 0 ? {} : { parentInstanceId },
     assetRef,
-    transform: createTransform2(record.transform, `${fieldName}.transform`)
+    transform: createTransform2(record2.transform, `${fieldName}.transform`)
   };
 }
 function assertAssembly(children) {
@@ -3985,8 +3985,8 @@ var NON_DEFAULT_CRITICAL_PROPERTIES = /* @__PURE__ */ new Set([
   "melting-temperature"
 ]);
 function createModelProcessingManifestV2(input) {
-  const record = asRecord(input, "ModelProcessingManifestV2");
-  exactKeys(record, [
+  const record2 = asRecord(input, "ModelProcessingManifestV2");
+  exactKeys(record2, [
     "contractVersion",
     "representation",
     "manifestId",
@@ -4023,24 +4023,24 @@ function createModelProcessingManifestV2(input) {
     "children",
     "processedAt"
   ], "ModelProcessingManifestV2");
-  if (record.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelProcessingManifestV2.contractVersion is unsupported.");
-  if (record.representation !== "pvox") throw new Error("ModelProcessingManifestV2.representation must be pvox.");
-  const resolutionId = requirePathSegment(record.resolutionId, "ModelProcessingManifestV2.resolutionId");
-  const candidateId = requirePathSegment(record.candidateId, "ModelProcessingManifestV2.candidateId");
-  assertCoordinateSystem2(record.coordinateSystem, "ModelProcessingManifestV2.coordinateSystem");
-  const pvox = createPvoxAssetManifestV1(record.pvox);
+  if (record2.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelProcessingManifestV2.contractVersion is unsupported.");
+  if (record2.representation !== "pvox") throw new Error("ModelProcessingManifestV2.representation must be pvox.");
+  const resolutionId = requirePathSegment(record2.resolutionId, "ModelProcessingManifestV2.resolutionId");
+  const candidateId = requirePathSegment(record2.candidateId, "ModelProcessingManifestV2.candidateId");
+  assertCoordinateSystem2(record2.coordinateSystem, "ModelProcessingManifestV2.coordinateSystem");
+  const pvox = createPvoxAssetManifestV1(record2.pvox);
   const resourceScope = parsePvoxResourceScope(pvox.artifact.uri);
   if (resourceScope.kind === "resolution" && (resourceScope.resolutionId !== resolutionId || resourceScope.candidateId !== candidateId)) {
     throw new Error("ModelProcessingManifestV2 PVOX resource namespace must match resolutionId and candidateId.");
   }
-  const technicalProfile = createVoxelTechnicalProfile(record.technicalProfile);
-  const contentHash = requireSha256(record.contentHash, "ModelProcessingManifestV2.contentHash");
-  const binaryClosureHash = requireSha256(record.binaryClosureHash, "ModelProcessingManifestV2.binaryClosureHash");
-  const processingClosureHash = requireSha256(record.processingClosureHash, "ModelProcessingManifestV2.processingClosureHash");
-  const assemblyClosureHash = requireSha256(record.assemblyClosureHash, "ModelProcessingManifestV2.assemblyClosureHash");
-  const requestSemanticProfileHash = requireSha256(record.requestSemanticProfileHash, "ModelProcessingManifestV2.requestSemanticProfileHash");
-  const compilationInputHash = requireSha256(record.compilationInputHash, "ModelProcessingManifestV2.compilationInputHash");
-  const runtimeRequestProfileHash = requireSha256(record.runtimeRequestProfileHash, "ModelProcessingManifestV2.runtimeRequestProfileHash");
+  const technicalProfile = createVoxelTechnicalProfile(record2.technicalProfile);
+  const contentHash = requireSha256(record2.contentHash, "ModelProcessingManifestV2.contentHash");
+  const binaryClosureHash = requireSha256(record2.binaryClosureHash, "ModelProcessingManifestV2.binaryClosureHash");
+  const processingClosureHash = requireSha256(record2.processingClosureHash, "ModelProcessingManifestV2.processingClosureHash");
+  const assemblyClosureHash = requireSha256(record2.assemblyClosureHash, "ModelProcessingManifestV2.assemblyClosureHash");
+  const requestSemanticProfileHash = requireSha256(record2.requestSemanticProfileHash, "ModelProcessingManifestV2.requestSemanticProfileHash");
+  const compilationInputHash = requireSha256(record2.compilationInputHash, "ModelProcessingManifestV2.compilationInputHash");
+  const runtimeRequestProfileHash = requireSha256(record2.runtimeRequestProfileHash, "ModelProcessingManifestV2.runtimeRequestProfileHash");
   if (contentHash !== pvox.artifact.sha256) throw new Error("ModelProcessingManifestV2 contentHash must match the PVOX artifact.");
   if (binaryClosureHash !== pvox.binaryClosureHash) throw new Error("ModelProcessingManifestV2 binaryClosureHash must match the PVOX binary closure.");
   if (compilationInputHash !== pvox.compilationInputHash || runtimeRequestProfileHash !== pvox.runtimeRequestProfileHash) {
@@ -4060,20 +4060,20 @@ function createModelProcessingManifestV2(input) {
   if (technicalProfile.maximumPartitionExtentMetres > maximumGridExtentMetres && !approximatelyEqual(technicalProfile.maximumPartitionExtentMetres, maximumGridExtentMetres)) {
     throw new Error("ModelProcessingManifestV2 partition extent exceeds the LOD0 cell and hierarchy grid capacity; use smaller fidelity-driven partitions.");
   }
-  const capabilityEntries = asDenseArray(record.capabilities, "ModelProcessingManifestV2.capabilities", PVOX_CAPABILITIES.length, PVOX_CAPABILITIES.length);
+  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]));
   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.");
-  const capabilityEvidenceSetHash = requireSha256(record.capabilityEvidenceSetHash, "ModelProcessingManifestV2.capabilityEvidenceSetHash");
+  const capabilityEvidenceSetHash = requireSha256(record2.capabilityEvidenceSetHash, "ModelProcessingManifestV2.capabilityEvidenceSetHash");
   const capabilityEvidenceSetAttestation = createHashAttestation(
-    record.capabilityEvidenceSetAttestation,
+    record2.capabilityEvidenceSetAttestation,
     PVOX_CAPABILITY_SET_HASH_DOMAIN,
     capabilityEvidenceSetHash,
     "ModelProcessingManifestV2.capabilityEvidenceSetAttestation"
   );
-  const requiredCapabilityEntries = asDenseArray(record.requiredCapabilities, "ModelProcessingManifestV2.requiredCapabilities", 1, PVOX_CAPABILITIES.length);
+  const requiredCapabilityEntries = asDenseArray(record2.requiredCapabilities, "ModelProcessingManifestV2.requiredCapabilities", 1, PVOX_CAPABILITIES.length);
   const requiredCapabilities = requiredCapabilityEntries.map((entry, index) => requireEnum(entry, 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.");
@@ -4081,11 +4081,11 @@ function createModelProcessingManifestV2(input) {
   if (technicalProfile.hasCollision && collisionPages.every(({ spatialKey }) => spatialKey?.lodLevel !== 0)) {
     throw new Error("ModelProcessingManifestV2 supported collision requires LOD0 collision-field evidence.");
   }
-  const physicalRegionInventory = createPvoxPhysicalRegionInventoryV1(record.physicalRegionInventory);
+  const physicalRegionInventory = createPvoxPhysicalRegionInventoryV1(record2.physicalRegionInventory);
   if (physicalRegionInventory.subjectContentHash !== binaryClosureHash || physicalRegionInventory.validationEvidenceHash !== pvox.validationEvidenceHash || physicalRegionInventory.entries.length !== technicalProfile.materialRegionCount || physicalRegionInventory.entries.some(({ physicalPaletteIndex }) => physicalPaletteIndex >= technicalProfile.physicalPaletteRecordCount)) {
     throw new Error("ModelProcessingManifestV2 authoritative physical region inventory must bind the PVOX validator, closure, region count, and palette records.");
   }
-  const physicalEntries = asDenseArray(record.physicalProperties, "ModelProcessingManifestV2.physicalProperties", 0, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries);
+  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]));
   if (byRegionProperty.size !== physicalProperties.length) throw new Error("ModelProcessingManifestV2 physical properties must be unique per region, material, and property.");
@@ -4125,15 +4125,15 @@ function createModelProcessingManifestV2(input) {
   if (physicalProperties.length !== technicalProfile.physicalEvidenceRecordCount) {
     throw new Error("ModelProcessingManifestV2 authoritative material-region evidence count must match the PVOX PEVI record count.");
   }
-  const physicalEvidenceHash = requireSha256(record.physicalEvidenceHash, "ModelProcessingManifestV2.physicalEvidenceHash");
+  const physicalEvidenceHash = requireSha256(record2.physicalEvidenceHash, "ModelProcessingManifestV2.physicalEvidenceHash");
   const physicalEvidenceAttestation = createHashAttestation(
-    record.physicalEvidenceAttestation,
+    record2.physicalEvidenceAttestation,
     PVOX_PHYSICAL_EVIDENCE_HASH_DOMAIN,
     physicalEvidenceHash,
     "ModelProcessingManifestV2.physicalEvidenceAttestation"
   );
   const massPropertiesEvidence = createReviewedStructuralEvidence(
-    record.massPropertiesEvidence,
+    record2.massPropertiesEvidence,
     "mass-properties",
     binaryClosureHash,
     physicalRegionInventory.inventoryHash,
@@ -4141,7 +4141,7 @@ function createModelProcessingManifestV2(input) {
     "ModelProcessingManifestV2.massPropertiesEvidence"
   );
   const bondGraphEvidence = createReviewedStructuralEvidence(
-    record.bondGraphEvidence,
+    record2.bondGraphEvidence,
     "bond-graph",
     binaryClosureHash,
     physicalRegionInventory.inventoryHash,
@@ -4149,7 +4149,7 @@ function createModelProcessingManifestV2(input) {
     "ModelProcessingManifestV2.bondGraphEvidence"
   );
   const interiorLayerEvidence = createReviewedStructuralEvidence(
-    record.interiorLayerEvidence,
+    record2.interiorLayerEvidence,
     "interior-layers",
     binaryClosureHash,
     physicalRegionInventory.inventoryHash,
@@ -4159,9 +4159,9 @@ function createModelProcessingManifestV2(input) {
   if (byCapability.get("destruction")?.status === "supported" && (technicalProfile.massPropertyRecordCount === 0 || technicalProfile.bondRecordCount === 0 || technicalProfile.interiorLayerRecordCount === 0)) {
     throw new Error("ModelProcessingManifestV2 destruction capability requires reviewed mass, bond-graph, and interior-layer records.");
   }
-  const converter = createCompilerEvidence(record.converter);
+  const converter = createCompilerEvidence(record2.converter);
   if (converter.sourceContentHash !== pvox.sourceContentHash || converter.canonicalDocumentHash !== pvox.canonicalDocumentHash || converter.compilationInputHash !== compilationInputHash || converter.runtimeRequestProfileHash !== runtimeRequestProfileHash || converter.outputContentHash !== contentHash) throw new Error("ModelProcessingManifestV2 converter hashes must match source, canonical document, compilation input, runtime request profile, and PVOX outputContentHash.");
-  const fidelity = createPvoxFidelityEvidence(record.fidelity);
+  const fidelity = createPvoxFidelityEvidence(record2.fidelity);
   const diagonalMetres = technicalProfile.maximumPartitionDiagonalMetres;
   if (fidelity.canonicalDocumentHash !== pvox.canonicalDocumentHash || fidelity.pvoxBinaryClosureHash !== binaryClosureHash || !approximatelyEqual(fidelity.evaluatedDiagonalMetres, diagonalMetres) || !approximatelyEqual(fidelity.lod0CellSizeMetres, pvox.lods[0].cellSizeMetres)) {
     throw new Error("ModelProcessingManifestV2 fidelity evidence must bind the canonical document, PVOX closure, evaluated bounds, and LOD0 cell size.");
@@ -4170,22 +4170,22 @@ function createModelProcessingManifestV2(input) {
   if (!approximatelyEqual(fidelity.maximumSurfaceErrorMetres, lod0.maximumSurfaceErrorMetres) || !approximatelyEqual(fidelity.p99SurfaceErrorMetres, lod0.p99SurfaceErrorMetres) || !approximatelyEqual(fidelity.silhouetteIou, lod0.silhouetteIou) || !approximatelyEqual(fidelity.maximumContourDisplacementPx, lod0.maximumContourDisplacementPx) || !approximatelyEqual(fidelity.renderedSsim, lod0.renderedSsim) || !approximatelyEqual(fidelity.p95DeltaE2000, lod0.p95DeltaE2000) || !approximatelyEqual(fidelity.normalizedMaterialError, lod0.normalizedMaterialError)) {
     throw new Error("ModelProcessingManifestV2 fidelity evidence must exactly match every governed PVOX LOD0 metric.");
   }
-  const childEntries = asDenseArray(record.children, "ModelProcessingManifestV2.children", 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren);
+  const childEntries = asDenseArray(record2.children, "ModelProcessingManifestV2.children", 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren);
   const children = childEntries.map((entry, index) => createAssemblyChild2(entry, index, resolutionId, candidateId));
-  const kind = requireEnum(record.kind, ["leaf", "assembly"], "ModelProcessingManifestV2.kind");
+  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.");
   if (kind === "leaf" && assemblyClosureHash === binaryClosureHash) throw new Error("A leaf ModelProcessingManifestV2 requires a distinct domain-separated empty-child assemblyClosureHash.");
   if (kind === "assembly" && children.length === 0) throw new Error("An assembly ModelProcessingManifestV2 requires children.");
   if (kind === "assembly") assertAssembly(children);
-  const assemblyClosureAttestation = createHashAttestation(record.assemblyClosureAttestation, PVOX_ASSEMBLY_CLOSURE_HASH_DOMAIN, assemblyClosureHash, "ModelProcessingManifestV2.assemblyClosureAttestation");
+  const assemblyClosureAttestation = createHashAttestation(record2.assemblyClosureAttestation, PVOX_ASSEMBLY_CLOSURE_HASH_DOMAIN, assemblyClosureHash, "ModelProcessingManifestV2.assemblyClosureAttestation");
   const processingClosureAttestation = createHashAttestation(
-    record.processingClosureAttestation,
+    record2.processingClosureAttestation,
     PVOX_PROCESSING_CLOSURE_HASH_DOMAIN,
     processingClosureHash,
     "ModelProcessingManifestV2.processingClosureAttestation"
   );
-  const processedAt = requireTimestamp(record.processedAt, "ModelProcessingManifestV2.processedAt");
+  const processedAt = requireTimestamp(record2.processedAt, "ModelProcessingManifestV2.processedAt");
   const latestEvidence = Math.max(
     Date.parse(converter.compiledAt),
     Date.parse(fidelity.evaluatedAt),
@@ -4199,13 +4199,13 @@ function createModelProcessingManifestV2(input) {
   return deepFreeze2({
     contractVersion: MODEL_RESOLUTION_V2_CONTRACT_VERSION,
     representation: "pvox",
-    manifestId: requireToken(record.manifestId, "ModelProcessingManifestV2.manifestId"),
+    manifestId: requireToken(record2.manifestId, "ModelProcessingManifestV2.manifestId"),
     resolutionId,
     candidateId,
     kind,
-    requestProfileId: requireToken(record.requestProfileId, "ModelProcessingManifestV2.requestProfileId"),
+    requestProfileId: requireToken(record2.requestProfileId, "ModelProcessingManifestV2.requestProfileId"),
     requestSemanticProfileHash,
-    capabilityProfileId: requireEnum(record.capabilityProfileId, PVOX_RUNTIME_CAPABILITY_PROFILE_IDS, "ModelProcessingManifestV2.capabilityProfileId"),
+    capabilityProfileId: requireEnum(record2.capabilityProfileId, PVOX_RUNTIME_CAPABILITY_PROFILE_IDS, "ModelProcessingManifestV2.capabilityProfileId"),
     contentHash,
     binaryClosureHash,
     processingClosureHash,
@@ -4235,76 +4235,76 @@ function createModelProcessingManifestV2(input) {
   });
 }
 function createCandidateAssetRef2(value) {
-  const record = asRecord(value, "ModelCandidateV2.assetRef");
-  if (record.disposition === "existing") {
-    exactKeys(record, ["disposition", "kind", "contentHash", "asset"], "ModelCandidateV2.assetRef");
-    assertDataOnlyTree(record.asset, "ModelCandidateV2.assetRef.asset");
-    const asset = createModelAssetRef(record.asset);
-    if (record.kind !== asset.kind || record.contentHash !== asset.contentHash) throw new Error("ModelCandidateV2 existing assetRef must match the immutable asset.");
+  const record2 = asRecord(value, "ModelCandidateV2.assetRef");
+  if (record2.disposition === "existing") {
+    exactKeys(record2, ["disposition", "kind", "contentHash", "asset"], "ModelCandidateV2.assetRef");
+    assertDataOnlyTree(record2.asset, "ModelCandidateV2.assetRef.asset");
+    const asset = createModelAssetRef(record2.asset);
+    if (record2.kind !== asset.kind || record2.contentHash !== asset.contentHash) throw new Error("ModelCandidateV2 existing assetRef must match the immutable asset.");
     return { disposition: "existing", kind: asset.kind, contentHash: asset.contentHash, asset };
   }
-  exactKeys(record, ["disposition", "proposalId", "kind", "contentHash"], "ModelCandidateV2.assetRef");
-  if (record.disposition !== "proposed") throw new Error("ModelCandidateV2.assetRef disposition is unsupported.");
+  exactKeys(record2, ["disposition", "proposalId", "kind", "contentHash"], "ModelCandidateV2.assetRef");
+  if (record2.disposition !== "proposed") throw new Error("ModelCandidateV2.assetRef disposition is unsupported.");
   return {
     disposition: "proposed",
-    proposalId: requireToken(record.proposalId, "ModelCandidateV2.assetRef.proposalId"),
-    kind: requireEnum(record.kind, ["leaf", "assembly"], "ModelCandidateV2.assetRef.kind"),
-    contentHash: requireSha256(record.contentHash, "ModelCandidateV2.assetRef.contentHash")
+    proposalId: requireToken(record2.proposalId, "ModelCandidateV2.assetRef.proposalId"),
+    kind: requireEnum(record2.kind, ["leaf", "assembly"], "ModelCandidateV2.assetRef.kind"),
+    contentHash: requireSha256(record2.contentHash, "ModelCandidateV2.assetRef.contentHash")
   };
 }
 function createViews(value, resolutionId, candidateId) {
   const entries = asDenseArray(value, "ModelCandidateV2.views", 4, 4);
   const parsed = entries.map((entry, index) => {
     const fieldName = `ModelCandidateV2.views[${index}]`;
-    const record = asRecord(entry, fieldName);
-    exactKeys(record, ["kind", "imageUri", "sha256", "contentType", "width", "height"], fieldName);
-    const kind = requireEnum(record.kind, MODEL_CONFIRMATION_VIEW_KINDS, `${fieldName}.kind`);
+    const record2 = asRecord(entry, 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`;
-    if (record.imageUri !== expectedUri) throw new Error(`${fieldName}.imageUri must match the candidate view identity.`);
-    if (record.contentType !== "image/png" || record.width !== MODEL_CONFIRMATION_VIEW_SIZE_PX || record.height !== MODEL_CONFIRMATION_VIEW_SIZE_PX) throw new Error(`${fieldName} must be an authenticated 1024x1024 PNG.`);
-    return { kind, imageUri: expectedUri, sha256: requireSha256(record.sha256, `${fieldName}.sha256`), contentType: "image/png", width: MODEL_CONFIRMATION_VIEW_SIZE_PX, height: MODEL_CONFIRMATION_VIEW_SIZE_PX };
+    if (record2.imageUri !== expectedUri) throw new Error(`${fieldName}.imageUri must match the candidate view identity.`);
+    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.");
   return parsed;
 }
 function createRenderEvidence2(value) {
-  const record = asRecord(value, "ModelCandidateV2.renderEvidence");
-  exactKeys(record, ["renderId", "representation", "lodLevel", "traversalBackend", "rendererId", "rendererVersion", "rendererQualificationHash", "settingsId", "settingsVersion", "cameraQualificationHash", "processingManifestId", "processingClosureHash", "pvoxContentHash", "pvoxRootHash", "pvoxDirectoryHash", "pvoxPageSetHash", "viewSha256s", "renderedAt", "evidenceHash", "evidenceHashAttestation"], "ModelCandidateV2.renderEvidence");
-  if (record.representation !== "pvox" || record.lodLevel !== 0 || record.traversalBackend !== "native-pvox") {
+  const record2 = asRecord(value, "ModelCandidateV2.renderEvidence");
+  exactKeys(record2, ["renderId", "representation", "lodLevel", "traversalBackend", "rendererId", "rendererVersion", "rendererQualificationHash", "settingsId", "settingsVersion", "cameraQualificationHash", "processingManifestId", "processingClosureHash", "pvoxContentHash", "pvoxRootHash", "pvoxDirectoryHash", "pvoxPageSetHash", "viewSha256s", "renderedAt", "evidenceHash", "evidenceHashAttestation"], "ModelCandidateV2.renderEvidence");
+  if (record2.representation !== "pvox" || record2.lodLevel !== 0 || record2.traversalBackend !== "native-pvox") {
     throw new Error("ModelCandidateV2 render evidence must use native PVOX LOD0 traversal.");
   }
-  if (record.rendererId !== PVOX_NATIVE_RENDERER_ID || record.settingsId !== PVOX_NATIVE_REVIEW_SETTINGS_ID) {
+  if (record2.rendererId !== PVOX_NATIVE_RENDERER_ID || record2.settingsId !== PVOX_NATIVE_REVIEW_SETTINGS_ID) {
     throw new Error("ModelCandidateV2 render evidence must use the governed native renderer and review settings.");
   }
-  const evidenceHash = requireSha256(record.evidenceHash, "ModelCandidateV2.renderEvidence.evidenceHash");
+  const evidenceHash = requireSha256(record2.evidenceHash, "ModelCandidateV2.renderEvidence.evidenceHash");
   return {
-    renderId: requireToken(record.renderId, "ModelCandidateV2.renderEvidence.renderId"),
+    renderId: requireToken(record2.renderId, "ModelCandidateV2.renderEvidence.renderId"),
     representation: "pvox",
     lodLevel: 0,
     traversalBackend: "native-pvox",
     rendererId: PVOX_NATIVE_RENDERER_ID,
-    rendererVersion: assertImmutableAssetVersion(record.rendererVersion),
-    rendererQualificationHash: requireSha256(record.rendererQualificationHash, "ModelCandidateV2.renderEvidence.rendererQualificationHash"),
+    rendererVersion: assertImmutableAssetVersion(record2.rendererVersion),
+    rendererQualificationHash: requireSha256(record2.rendererQualificationHash, "ModelCandidateV2.renderEvidence.rendererQualificationHash"),
     settingsId: PVOX_NATIVE_REVIEW_SETTINGS_ID,
-    settingsVersion: assertImmutableAssetVersion(record.settingsVersion),
-    cameraQualificationHash: requireSha256(record.cameraQualificationHash, "ModelCandidateV2.renderEvidence.cameraQualificationHash"),
-    processingManifestId: requireToken(record.processingManifestId, "ModelCandidateV2.renderEvidence.processingManifestId"),
-    processingClosureHash: requireSha256(record.processingClosureHash, "ModelCandidateV2.renderEvidence.processingClosureHash"),
-    pvoxContentHash: requireSha256(record.pvoxContentHash, "ModelCandidateV2.renderEvidence.pvoxContentHash"),
-    pvoxRootHash: requireSha256(record.pvoxRootHash, "ModelCandidateV2.renderEvidence.pvoxRootHash"),
-    pvoxDirectoryHash: requireSha256(record.pvoxDirectoryHash, "ModelCandidateV2.renderEvidence.pvoxDirectoryHash"),
-    pvoxPageSetHash: requireSha256(record.pvoxPageSetHash, "ModelCandidateV2.renderEvidence.pvoxPageSetHash"),
-    viewSha256s: requireShaTuple(record.viewSha256s, "ModelCandidateV2.renderEvidence.viewSha256s"),
-    renderedAt: requireTimestamp(record.renderedAt, "ModelCandidateV2.renderEvidence.renderedAt"),
+    settingsVersion: assertImmutableAssetVersion(record2.settingsVersion),
+    cameraQualificationHash: requireSha256(record2.cameraQualificationHash, "ModelCandidateV2.renderEvidence.cameraQualificationHash"),
+    processingManifestId: requireToken(record2.processingManifestId, "ModelCandidateV2.renderEvidence.processingManifestId"),
+    processingClosureHash: requireSha256(record2.processingClosureHash, "ModelCandidateV2.renderEvidence.processingClosureHash"),
+    pvoxContentHash: requireSha256(record2.pvoxContentHash, "ModelCandidateV2.renderEvidence.pvoxContentHash"),
+    pvoxRootHash: requireSha256(record2.pvoxRootHash, "ModelCandidateV2.renderEvidence.pvoxRootHash"),
+    pvoxDirectoryHash: requireSha256(record2.pvoxDirectoryHash, "ModelCandidateV2.renderEvidence.pvoxDirectoryHash"),
+    pvoxPageSetHash: requireSha256(record2.pvoxPageSetHash, "ModelCandidateV2.renderEvidence.pvoxPageSetHash"),
+    viewSha256s: requireShaTuple(record2.viewSha256s, "ModelCandidateV2.renderEvidence.viewSha256s"),
+    renderedAt: requireTimestamp(record2.renderedAt, "ModelCandidateV2.renderEvidence.renderedAt"),
     evidenceHash,
-    evidenceHashAttestation: createHashAttestation(record.evidenceHashAttestation, PVOX_RENDER_EVIDENCE_HASH_DOMAIN, evidenceHash, "ModelCandidateV2.renderEvidence.evidenceHashAttestation")
+    evidenceHashAttestation: createHashAttestation(record2.evidenceHashAttestation, PVOX_RENDER_EVIDENCE_HASH_DOMAIN, evidenceHash, "ModelCandidateV2.renderEvidence.evidenceHashAttestation")
   };
 }
 function createPvoxModelMatchAssessmentV2(input) {
   const fieldName = "PvoxModelMatchAssessmentV2";
-  const record = asRecord(input, fieldName);
-  assertDataOnlyTree(record, fieldName);
-  exactKeys(record, [
+  const record2 = asRecord(input, fieldName);
+  assertDataOnlyTree(record2, fieldName);
+  exactKeys(record2, [
     "contractVersion",
     "score",
     "assurance",
@@ -4321,65 +4321,65 @@ function createPvoxModelMatchAssessmentV2(input) {
     "evidenceHash"
   ], fieldName);
   const assessment = createModelMatchAssessment({
-    ...record.contractVersion === void 0 ? {} : { contractVersion: record.contractVersion },
-    score: record.score,
-    ...record.assurance === void 0 ? {} : { assurance: record.assurance },
-    hardConstraintPass: record.hardConstraintPass,
-    exactMatch: record.exactMatch,
-    reasonCodes: record.reasonCodes,
-    ranker: record.ranker,
-    fidelityWarnings: record.fidelityWarnings,
-    request: record.request,
-    candidateId: record.candidateId,
-    candidateContentHash: record.candidateContentHash
+    ...record2.contractVersion === void 0 ? {} : { contractVersion: record2.contractVersion },
+    score: record2.score,
+    ...record2.assurance === void 0 ? {} : { assurance: record2.assurance },
+    hardConstraintPass: record2.hardConstraintPass,
+    exactMatch: record2.exactMatch,
+    reasonCodes: record2.reasonCodes,
+    ranker: record2.ranker,
+    fidelityWarnings: record2.fidelityWarnings,
+    request: record2.request,
+    candidateId: record2.candidateId,
+    candidateContentHash: record2.candidateContentHash
   });
   return deepFreeze2({
     ...assessment,
-    requestSemanticProfileHash: requireSha256(record.requestSemanticProfileHash, `${fieldName}.requestSemanticProfileHash`),
-    requestSemanticProfileCanonical: requireString(record.requestSemanticProfileCanonical, `${fieldName}.requestSemanticProfileCanonical`, 65536),
-    evidenceHash: requireSha256(record.evidenceHash, `${fieldName}.evidenceHash`)
+    requestSemanticProfileHash: requireSha256(record2.requestSemanticProfileHash, `${fieldName}.requestSemanticProfileHash`),
+    requestSemanticProfileCanonical: requireString(record2.requestSemanticProfileCanonical, `${fieldName}.requestSemanticProfileCanonical`, 65536),
+    evidenceHash: requireSha256(record2.evidenceHash, `${fieldName}.evidenceHash`)
   });
 }
 function createConfirmationBinding(value) {
-  const record = asRecord(value, "ModelCandidateV2.confirmationBinding");
-  assertDataOnlyTree(record, "ModelCandidateV2.confirmationBinding");
-  exactKeys(record, ["bindingHash", "bindingHashAttestation", "resolutionId", "requesterId", "request", "requestSemanticProfileHash", "requestRevision", "candidateId", "candidateContentHash", "candidateAssetRef", "match", "provenance", "rights", "sourceContentHash", "binaryClosureHash", "pvoxRootHash", "pvoxDirectoryHash", "pvoxPageSetHash", "compilationInputHash", "runtimeRequestProfileHash", "processingClosureHash", "assemblyClosureHash", "evaluationClosureHash", "capabilityEvidenceSetHash", "hardGates", "viewSha256s", "rightsDecisionId", "fidelityEvidenceHash", "physicalEvidenceHash", "rendererId", "rendererVersion", "rendererEvidenceHash", "renderEvidence"], "ModelCandidateV2.confirmationBinding");
-  const bindingHash = requireSha256(record.bindingHash, "ModelCandidateV2.confirmationBinding.bindingHash");
-  const hardGateEntries = asDenseArray(record.hardGates, "ModelCandidateV2.confirmationBinding.hardGates", PVOX_NON_OVERRIDABLE_GATE_KINDS.length, PVOX_NON_OVERRIDABLE_GATE_KINDS.length);
+  const record2 = asRecord(value, "ModelCandidateV2.confirmationBinding");
+  assertDataOnlyTree(record2, "ModelCandidateV2.confirmationBinding");
+  exactKeys(record2, ["bindingHash", "bindingHashAttestation", "resolutionId", "requesterId", "request", "requestSemanticProfileHash", "requestRevision", "candidateId", "candidateContentHash", "candidateAssetRef", "match", "provenance", "rights", "sourceContentHash", "binaryClosureHash", "pvoxRootHash", "pvoxDirectoryHash", "pvoxPageSetHash", "compilationInputHash", "runtimeRequestProfileHash", "processingClosureHash", "assemblyClosureHash", "evaluationClosureHash", "capabilityEvidenceSetHash", "hardGates", "viewSha256s", "rightsDecisionId", "fidelityEvidenceHash", "physicalEvidenceHash", "rendererId", "rendererVersion", "rendererEvidenceHash", "renderEvidence"], "ModelCandidateV2.confirmationBinding");
+  const bindingHash = requireSha256(record2.bindingHash, "ModelCandidateV2.confirmationBinding.bindingHash");
+  const hardGateEntries = asDenseArray(record2.hardGates, "ModelCandidateV2.confirmationBinding.hardGates", PVOX_NON_OVERRIDABLE_GATE_KINDS.length, PVOX_NON_OVERRIDABLE_GATE_KINDS.length);
   return {
     bindingHash,
-    bindingHashAttestation: createHashAttestation(record.bindingHashAttestation, PVOX_CONFIRMATION_BINDING_HASH_DOMAIN, bindingHash, "ModelCandidateV2.confirmationBinding.bindingHashAttestation"),
-    resolutionId: requirePathSegment(record.resolutionId, "ModelCandidateV2.confirmationBinding.resolutionId"),
-    requesterId: requireToken(record.requesterId, "ModelCandidateV2.confirmationBinding.requesterId"),
-    request: createModelRequestSpecV2(record.request),
-    requestSemanticProfileHash: requireSha256(record.requestSemanticProfileHash, "ModelCandidateV2.confirmationBinding.requestSemanticProfileHash"),
-    requestRevision: requireInteger(record.requestRevision, "ModelCandidateV2.confirmationBinding.requestRevision", 0, MODEL_REQUEST_MAX_REVISION),
-    candidateId: requirePathSegment(record.candidateId, "ModelCandidateV2.confirmationBinding.candidateId"),
-    candidateContentHash: requireSha256(record.candidateContentHash, "ModelCandidateV2.confirmationBinding.candidateContentHash"),
-    candidateAssetRef: createCandidateAssetRef2(record.candidateAssetRef),
-    match: createPvoxModelMatchAssessmentV2(record.match),
-    provenance: createModelProvenance(record.provenance),
-    rights: createModelRightsAssessment(record.rights),
-    sourceContentHash: requireSha256(record.sourceContentHash, "ModelCandidateV2.confirmationBinding.sourceContentHash"),
-    binaryClosureHash: requireSha256(record.binaryClosureHash, "ModelCandidateV2.confirmationBinding.binaryClosureHash"),
-    pvoxRootHash: requireSha256(record.pvoxRootHash, "ModelCandidateV2.confirmationBinding.pvoxRootHash"),
-    pvoxDirectoryHash: requireSha256(record.pvoxDirectoryHash, "ModelCandidateV2.confirmationBinding.pvoxDirectoryHash"),
-    pvoxPageSetHash: requireSha256(record.pvoxPageSetHash, "ModelCandidateV2.confirmationBinding.pvoxPageSetHash"),
-    compilationInputHash: requireSha256(record.compilationInputHash, "ModelCandidateV2.confirmationBinding.compilationInputHash"),
-    runtimeRequestProfileHash: requireSha256(record.runtimeRequestProfileHash, "ModelCandidateV2.confirmationBinding.runtimeRequestProfileHash"),
-    processingClosureHash: requireSha256(record.processingClosureHash, "ModelCandidateV2.confirmationBinding.processingClosureHash"),
-    assemblyClosureHash: requireSha256(record.assemblyClosureHash, "ModelCandidateV2.confirmationBinding.assemblyClosureHash"),
-    evaluationClosureHash: requireSha256(record.evaluationClosureHash, "ModelCandidateV2.confirmationBinding.evaluationClosureHash"),
-    capabilityEvidenceSetHash: requireSha256(record.capabilityEvidenceSetHash, "ModelCandidateV2.confirmationBinding.capabilityEvidenceSetHash"),
+    bindingHashAttestation: createHashAttestation(record2.bindingHashAttestation, PVOX_CONFIRMATION_BINDING_HASH_DOMAIN, bindingHash, "ModelCandidateV2.confirmationBinding.bindingHashAttestation"),
+    resolutionId: requirePathSegment(record2.resolutionId, "ModelCandidateV2.confirmationBinding.resolutionId"),
+    requesterId: requireToken(record2.requesterId, "ModelCandidateV2.confirmationBinding.requesterId"),
+    request: createModelRequestSpecV2(record2.request),
+    requestSemanticProfileHash: requireSha256(record2.requestSemanticProfileHash, "ModelCandidateV2.confirmationBinding.requestSemanticProfileHash"),
+    requestRevision: requireInteger(record2.requestRevision, "ModelCandidateV2.confirmationBinding.requestRevision", 0, MODEL_REQUEST_MAX_REVISION),
+    candidateId: requirePathSegment(record2.candidateId, "ModelCandidateV2.confirmationBinding.candidateId"),
+    candidateContentHash: requireSha256(record2.candidateContentHash, "ModelCandidateV2.confirmationBinding.candidateContentHash"),
+    candidateAssetRef: createCandidateAssetRef2(record2.candidateAssetRef),
+    match: createPvoxModelMatchAssessmentV2(record2.match),
+    provenance: createModelProvenance(record2.provenance),
+    rights: createModelRightsAssessment(record2.rights),
+    sourceContentHash: requireSha256(record2.sourceContentHash, "ModelCandidateV2.confirmationBinding.sourceContentHash"),
+    binaryClosureHash: requireSha256(record2.binaryClosureHash, "ModelCandidateV2.confirmationBinding.binaryClosureHash"),
+    pvoxRootHash: requireSha256(record2.pvoxRootHash, "ModelCandidateV2.confirmationBinding.pvoxRootHash"),
+    pvoxDirectoryHash: requireSha256(record2.pvoxDirectoryHash, "ModelCandidateV2.confirmationBinding.pvoxDirectoryHash"),
+    pvoxPageSetHash: requireSha256(record2.pvoxPageSetHash, "ModelCandidateV2.confirmationBinding.pvoxPageSetHash"),
+    compilationInputHash: requireSha256(record2.compilationInputHash, "ModelCandidateV2.confirmationBinding.compilationInputHash"),
+    runtimeRequestProfileHash: requireSha256(record2.runtimeRequestProfileHash, "ModelCandidateV2.confirmationBinding.runtimeRequestProfileHash"),
+    processingClosureHash: requireSha256(record2.processingClosureHash, "ModelCandidateV2.confirmationBinding.processingClosureHash"),
+    assemblyClosureHash: requireSha256(record2.assemblyClosureHash, "ModelCandidateV2.confirmationBinding.assemblyClosureHash"),
+    evaluationClosureHash: requireSha256(record2.evaluationClosureHash, "ModelCandidateV2.confirmationBinding.evaluationClosureHash"),
+    capabilityEvidenceSetHash: requireSha256(record2.capabilityEvidenceSetHash, "ModelCandidateV2.confirmationBinding.capabilityEvidenceSetHash"),
     hardGates: hardGateEntries.map(createPvoxGateEvidence),
-    viewSha256s: requireShaTuple(record.viewSha256s, "ModelCandidateV2.confirmationBinding.viewSha256s"),
-    rightsDecisionId: requireToken(record.rightsDecisionId, "ModelCandidateV2.confirmationBinding.rightsDecisionId"),
-    fidelityEvidenceHash: requireSha256(record.fidelityEvidenceHash, "ModelCandidateV2.confirmationBinding.fidelityEvidenceHash"),
-    physicalEvidenceHash: requireSha256(record.physicalEvidenceHash, "ModelCandidateV2.confirmationBinding.physicalEvidenceHash"),
-    rendererId: requireToken(record.rendererId, "ModelCandidateV2.confirmationBinding.rendererId"),
-    rendererVersion: assertImmutableAssetVersion(record.rendererVersion),
-    rendererEvidenceHash: requireSha256(record.rendererEvidenceHash, "ModelCandidateV2.confirmationBinding.rendererEvidenceHash"),
-    renderEvidence: createRenderEvidence2(record.renderEvidence)
+    viewSha256s: requireShaTuple(record2.viewSha256s, "ModelCandidateV2.confirmationBinding.viewSha256s"),
+    rightsDecisionId: requireToken(record2.rightsDecisionId, "ModelCandidateV2.confirmationBinding.rightsDecisionId"),
+    fidelityEvidenceHash: requireSha256(record2.fidelityEvidenceHash, "ModelCandidateV2.confirmationBinding.fidelityEvidenceHash"),
+    physicalEvidenceHash: requireSha256(record2.physicalEvidenceHash, "ModelCandidateV2.confirmationBinding.physicalEvidenceHash"),
+    rendererId: requireToken(record2.rendererId, "ModelCandidateV2.confirmationBinding.rendererId"),
+    rendererVersion: assertImmutableAssetVersion(record2.rendererVersion),
+    rendererEvidenceHash: requireSha256(record2.rendererEvidenceHash, "ModelCandidateV2.confirmationBinding.rendererEvidenceHash"),
+    renderEvidence: createRenderEvidence2(record2.renderEvidence)
   };
 }
 function assertRequestMatchesProcessing(request, processing) {
@@ -4414,27 +4414,27 @@ function assertRequestMatchesProcessing(request, processing) {
   }
 }
 function createModelCandidateV2(input) {
-  const record = asRecord(input, "ModelCandidateV2");
-  assertDataOnlyTree(record, "ModelCandidateV2");
+  const record2 = asRecord(input, "ModelCandidateV2");
+  assertDataOnlyTree(record2, "ModelCandidateV2");
   const commonKeys = ["contractVersion", "resolutionId", "requesterId", "candidateId", "request", "admissionStatus", "assetRef", "match", "provenance", "rights", "processingManifest", "views", "renderEvidence", "evaluationClosureHash", "evaluationClosureAttestation", "hardGates", "confirmationRequired"];
-  const admissionStatus = requireEnum(record.admissionStatus, ["confirmable", "diagnostic"], "ModelCandidateV2.admissionStatus");
-  exactKeys(record, admissionStatus === "confirmable" ? [...commonKeys, "confirmationBinding", "confirmationToken"] : [...commonKeys, "blockingReasonCodes"], "ModelCandidateV2");
-  if (record.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelCandidateV2.contractVersion is unsupported.");
-  const resolutionId = requirePathSegment(record.resolutionId, "ModelCandidateV2.resolutionId");
-  const requesterId = requireToken(record.requesterId, "ModelCandidateV2.requesterId");
-  const candidateId = requirePathSegment(record.candidateId, "ModelCandidateV2.candidateId");
-  const request = createModelRequestSpecV2(record.request);
-  const assetRef = createCandidateAssetRef2(record.assetRef);
-  assertDataOnlyTree(record.match, "ModelCandidateV2.match");
-  assertDataOnlyTree(record.provenance, "ModelCandidateV2.provenance");
-  assertDataOnlyTree(record.rights, "ModelCandidateV2.rights");
-  const match = createPvoxModelMatchAssessmentV2(record.match);
+  const admissionStatus = requireEnum(record2.admissionStatus, ["confirmable", "diagnostic"], "ModelCandidateV2.admissionStatus");
+  exactKeys(record2, admissionStatus === "confirmable" ? [...commonKeys, "confirmationBinding", "confirmationToken"] : [...commonKeys, "blockingReasonCodes"], "ModelCandidateV2");
+  if (record2.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelCandidateV2.contractVersion is unsupported.");
+  const resolutionId = requirePathSegment(record2.resolutionId, "ModelCandidateV2.resolutionId");
+  const requesterId = requireToken(record2.requesterId, "ModelCandidateV2.requesterId");
+  const candidateId = requirePathSegment(record2.candidateId, "ModelCandidateV2.candidateId");
+  const request = createModelRequestSpecV2(record2.request);
+  const assetRef = createCandidateAssetRef2(record2.assetRef);
+  assertDataOnlyTree(record2.match, "ModelCandidateV2.match");
+  assertDataOnlyTree(record2.provenance, "ModelCandidateV2.provenance");
+  assertDataOnlyTree(record2.rights, "ModelCandidateV2.rights");
+  const match = createPvoxModelMatchAssessmentV2(record2.match);
   assertImmutableAssetVersion(match.ranker.version);
   assertImmutableAssetVersion(match.ranker.calibrationVersion);
-  const provenance = createModelProvenance(record.provenance);
-  const rights = createModelRightsAssessment(record.rights);
+  const provenance = createModelProvenance(record2.provenance);
+  const rights = createModelRightsAssessment(record2.rights);
   assertImmutableAssetVersion(rights.policyVersion);
-  const processingManifest = createModelProcessingManifestV2(record.processingManifest);
+  const processingManifest = createModelProcessingManifestV2(record2.processingManifest);
   if (processingManifest.resolutionId !== resolutionId || processingManifest.candidateId !== candidateId || processingManifest.kind !== assetRef.kind || processingManifest.contentHash !== assetRef.contentHash) throw new Error("ModelCandidateV2 processing manifest must match candidate identity and contentHash.");
   if (match.candidateId !== candidateId || match.candidateContentHash !== assetRef.contentHash) throw new Error("ModelCandidateV2 match must bind the exact candidate content.");
   if (match.requestSemanticProfileHash !== request.requestSemanticProfileHash) throw new Error("ModelCandidateV2 semantic assessment must bind the complete normalized v2 request profile hash.");
@@ -4450,18 +4450,18 @@ function createModelCandidateV2(input) {
   if (assetRef.disposition === "existing" && (resourceScope.kind !== "catalog" || resourceScope.assetId !== assetRef.asset.assetId || resourceScope.version !== assetRef.asset.version)) {
     throw new Error("ModelCandidateV2 existing asset must prove the same immutable catalog PVOX representation.");
   }
-  const views = createViews(record.views, resolutionId, candidateId);
-  const renderEvidence = createRenderEvidence2(record.renderEvidence);
+  const views = createViews(record2.views, resolutionId, candidateId);
+  const renderEvidence = createRenderEvidence2(record2.renderEvidence);
   if (renderEvidence.processingManifestId !== processingManifest.manifestId || renderEvidence.processingClosureHash !== processingManifest.processingClosureHash || renderEvidence.pvoxContentHash !== processingManifest.contentHash || renderEvidence.pvoxRootHash !== processingManifest.pvox.rootHash || renderEvidence.pvoxDirectoryHash !== processingManifest.pvox.directoryHash || renderEvidence.pvoxPageSetHash !== processingManifest.pvox.pageSetHash || renderEvidence.viewSha256s.some((digest, index) => digest !== views[index].sha256)) throw new Error("ModelCandidateV2 renderer evidence must bind the PVOX manifest and ordered views.");
   if (Date.parse(renderEvidence.renderedAt) < Date.parse(processingManifest.processedAt)) throw new Error("ModelCandidateV2 render evidence must follow processing.");
-  const evaluationClosureHash = requireSha256(record.evaluationClosureHash, "ModelCandidateV2.evaluationClosureHash");
+  const evaluationClosureHash = requireSha256(record2.evaluationClosureHash, "ModelCandidateV2.evaluationClosureHash");
   const evaluationClosureAttestation = createHashAttestation(
-    record.evaluationClosureAttestation,
+    record2.evaluationClosureAttestation,
     PVOX_EVALUATION_CLOSURE_HASH_DOMAIN,
     evaluationClosureHash,
     "ModelCandidateV2.evaluationClosureAttestation"
   );
-  const gateEntries = asDenseArray(record.hardGates, "ModelCandidateV2.hardGates", PVOX_NON_OVERRIDABLE_GATE_KINDS.length, PVOX_NON_OVERRIDABLE_GATE_KINDS.length);
+  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]));
   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.");
@@ -4511,16 +4511,16 @@ function createModelCandidateV2(input) {
     hardGates: orderedGates
   };
   if (admissionStatus === "diagnostic") {
-    if (record.confirmationRequired !== false) throw new Error("Diagnostic ModelCandidateV2 confirmationRequired must be false.");
-    if (record.blockingReasonCodes !== void 0) {
-      const suppliedEntries = asDenseArray(record.blockingReasonCodes, "ModelCandidateV2.blockingReasonCodes", 1, 256);
+    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}]`));
       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 });
   }
-  if (record.confirmationRequired !== true) throw new Error("Confirmable ModelCandidateV2 confirmationRequired must be true.");
-  const confirmationBinding = createConfirmationBinding(record.confirmationBinding);
+  if (record2.confirmationRequired !== true) throw new Error("Confirmable ModelCandidateV2 confirmationRequired must be true.");
+  const confirmationBinding = createConfirmationBinding(record2.confirmationBinding);
   const expectedBinding = {
     resolutionId,
     requesterId,
@@ -4557,7 +4557,7 @@ function createModelCandidateV2(input) {
   if (JSON.stringify(confirmationBinding.renderEvidence) !== JSON.stringify(renderEvidence)) throw new Error("ModelCandidateV2 confirmationBinding must bind the complete native renderer evidence.");
   if (JSON.stringify(confirmationBinding.hardGates) !== JSON.stringify(orderedGates)) throw new Error("ModelCandidateV2 confirmationBinding must contain the complete ordered hard-gate evidence set.");
   if (confirmationBinding.viewSha256s.some((digest, index) => digest !== views[index].sha256)) throw new Error("ModelCandidateV2 confirmationBinding view hashes must match candidate views.");
-  const confirmationToken = requireAttestation(record.confirmationToken, "ModelCandidateV2.confirmationToken");
+  const confirmationToken = requireAttestation(record2.confirmationToken, "ModelCandidateV2.confirmationToken");
   if (confirmationBinding.bindingHashAttestation.attestationToken !== confirmationToken) throw new Error("ModelCandidateV2 confirmation token must attest the exact confirmation binding hash.");
   return deepFreeze2({
     ...common,
@@ -4571,21 +4571,21 @@ 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");
 }
 function createModelCandidateConfirmationV2(input, expectedCandidate, expectedResolutionId) {
-  const record = asRecord(input, "ModelCandidateConfirmationV2");
-  exactKeys(record, ["contractVersion", "confirmationId", "resolutionId", "requesterId", "candidateId", "confirmationToken", "confirmationBindingHash", "viewSha256s", "confirmedBy", "confirmedAt", "semanticRiskAccepted"], "ModelCandidateConfirmationV2");
-  if (record.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelCandidateConfirmationV2.contractVersion is unsupported.");
+  const record2 = asRecord(input, "ModelCandidateConfirmationV2");
+  exactKeys(record2, ["contractVersion", "confirmationId", "resolutionId", "requesterId", "candidateId", "confirmationToken", "confirmationBindingHash", "viewSha256s", "confirmedBy", "confirmedAt", "semanticRiskAccepted"], "ModelCandidateConfirmationV2");
+  if (record2.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelCandidateConfirmationV2.contractVersion is unsupported.");
   const candidate = createModelCandidateV2(expectedCandidate);
   if (candidate.admissionStatus !== "confirmable") throw new Error("ModelCandidateConfirmationV2 cannot confirm a diagnostic candidate.");
   const resolutionId = requirePathSegment(expectedResolutionId, "ModelCandidateConfirmationV2 expected resolutionId");
-  if (candidate.resolutionId !== resolutionId || record.resolutionId !== resolutionId || record.requesterId !== candidate.requesterId || record.candidateId !== candidate.candidateId) throw new Error("ModelCandidateConfirmationV2 must match the candidate, requester, and resolution.");
-  if (record.confirmationToken !== candidate.confirmationToken) throw new Error("ModelCandidateConfirmationV2 confirmationToken must match the candidate.");
-  if (record.confirmationBindingHash !== candidate.confirmationBinding.bindingHash) throw new Error("ModelCandidateConfirmationV2 confirmation binding must match the candidate.");
-  const viewSha256s = requireShaTuple(record.viewSha256s, "ModelCandidateConfirmationV2.viewSha256s");
+  if (candidate.resolutionId !== resolutionId || record2.resolutionId !== resolutionId || record2.requesterId !== candidate.requesterId || record2.candidateId !== candidate.candidateId) throw new Error("ModelCandidateConfirmationV2 must match the candidate, requester, and resolution.");
+  if (record2.confirmationToken !== candidate.confirmationToken) throw new Error("ModelCandidateConfirmationV2 confirmationToken must match the candidate.");
+  if (record2.confirmationBindingHash !== candidate.confirmationBinding.bindingHash) throw new Error("ModelCandidateConfirmationV2 confirmation binding must match the candidate.");
+  const viewSha256s = requireShaTuple(record2.viewSha256s, "ModelCandidateConfirmationV2.viewSha256s");
   if (viewSha256s.some((digest, index) => digest !== candidate.views[index].sha256)) throw new Error("ModelCandidateConfirmationV2 view hashes must match candidate evidence.");
   if (!isModelCandidateV2Confirmable(candidate)) throw new Error("ModelCandidateConfirmationV2 candidate is not confirmable because a hard gate is blocked.");
-  const semanticRiskAccepted = requireBoolean(record.semanticRiskAccepted, "ModelCandidateConfirmationV2.semanticRiskAccepted");
+  const semanticRiskAccepted = requireBoolean(record2.semanticRiskAccepted, "ModelCandidateConfirmationV2.semanticRiskAccepted");
   if (candidate.match.assurance === "low" !== semanticRiskAccepted) throw new Error("Only low semantic assurance requires and permits semantic risk acceptance.");
-  const confirmedAt = requireTimestamp(record.confirmedAt, "ModelCandidateConfirmationV2.confirmedAt");
+  const confirmedAt = requireTimestamp(record2.confirmedAt, "ModelCandidateConfirmationV2.confirmedAt");
   const latestEvidence = Math.max(
     Date.parse(candidate.provenance.capturedAt),
     Date.parse(candidate.rights.reviewedAt),
@@ -4594,12 +4594,12 @@ function createModelCandidateConfirmationV2(input, expectedCandidate, expectedRe
     ...candidate.hardGates.map(({ evaluatedAt }) => Date.parse(evaluatedAt))
   );
   if (Date.parse(confirmedAt) < latestEvidence) throw new Error("ModelCandidateConfirmationV2 confirmation must follow all required evidence.");
-  const confirmedBy = requireString(record.confirmedBy, "ModelCandidateConfirmationV2.confirmedBy", 256);
+  const confirmedBy = requireString(record2.confirmedBy, "ModelCandidateConfirmationV2.confirmedBy", 256);
   if (DIRECT_URL.test(confirmedBy)) throw new Error("ModelCandidateConfirmationV2.confirmedBy must not expose a URL.");
   if (confirmedBy !== candidate.requesterId) throw new Error("ModelCandidateConfirmationV2 confirmedBy must be the requester bound to the resolution.");
   return deepFreeze2({
     contractVersion: MODEL_RESOLUTION_V2_CONTRACT_VERSION,
-    confirmationId: requireToken(record.confirmationId, "ModelCandidateConfirmationV2.confirmationId"),
+    confirmationId: requireToken(record2.confirmationId, "ModelCandidateConfirmationV2.confirmationId"),
     resolutionId,
     requesterId: candidate.requesterId,
     candidateId: candidate.candidateId,
@@ -4623,8 +4623,8 @@ function candidatesEquivalent(left, right) {
 }
 function createModelPromotionReceiptV2(input, resolutionId, candidate, confirmation, finalAssetRef) {
   if (candidate.assetRef.disposition !== "proposed") throw new Error("ModelPromotionReceiptV2 is only valid for a proposed candidate.");
-  const record = asRecord(input, "ModelPromotionReceiptV2");
-  exactKeys(record, [
+  const record2 = asRecord(input, "ModelPromotionReceiptV2");
+  exactKeys(record2, [
     "contractVersion",
     "promotionId",
     "resolutionId",
@@ -4655,38 +4655,38 @@ function createModelPromotionReceiptV2(input, resolutionId, candidate, confirmat
     "promotedAt",
     "publicationToken"
   ], "ModelPromotionReceiptV2");
-  if (record.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION || record.publicationState !== "pointer-last-complete") {
+  if (record2.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION || record2.publicationState !== "pointer-last-complete") {
     throw new Error("ModelPromotionReceiptV2 must use the v2 contract and prove pointer-last completion.");
   }
-  if (record.resolutionId !== resolutionId || record.requesterId !== candidate.requesterId || record.candidateId !== candidate.candidateId || record.proposalId !== candidate.assetRef.proposalId || record.confirmationId !== confirmation.confirmationId || record.confirmationBindingHash !== confirmation.confirmationBindingHash || record.processingManifestId !== candidate.processingManifest.manifestId || record.processingContentHash !== candidate.processingManifest.contentHash || record.processingClosureHash !== candidate.processingManifest.processingClosureHash || record.assemblyClosureHash !== candidate.processingManifest.assemblyClosureHash) {
+  if (record2.resolutionId !== resolutionId || record2.requesterId !== candidate.requesterId || record2.candidateId !== candidate.candidateId || record2.proposalId !== candidate.assetRef.proposalId || record2.confirmationId !== confirmation.confirmationId || record2.confirmationBindingHash !== confirmation.confirmationBindingHash || record2.processingManifestId !== candidate.processingManifest.manifestId || record2.processingContentHash !== candidate.processingManifest.contentHash || record2.processingClosureHash !== candidate.processingManifest.processingClosureHash || record2.assemblyClosureHash !== candidate.processingManifest.assemblyClosureHash) {
     throw new Error("ModelPromotionReceiptV2 must bind the exact proposal, confirmation, processing content, and PVOX assembly closure.");
   }
-  assertDataOnlyTree(record.candidateAssetRef, "ModelPromotionReceiptV2.candidateAssetRef");
-  const candidateAssetRef = createCandidateAssetRef2(record.candidateAssetRef);
+  assertDataOnlyTree(record2.candidateAssetRef, "ModelPromotionReceiptV2.candidateAssetRef");
+  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(record.assemblyChildClosureHashes, "ModelPromotionReceiptV2.assemblyChildClosureHashes", 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren);
+  const childClosureEntries = asDenseArray(record2.assemblyChildClosureHashes, "ModelPromotionReceiptV2.assemblyChildClosureHashes", 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren);
   const assemblyChildClosureHashes = childClosureEntries.map((entry, index) => requireSha256(entry, `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(record.finalAssetRef, "ModelPromotionReceiptV2.finalAssetRef");
-  const receiptAssetRef = createModelAssetRef(record.finalAssetRef);
+  assertDataOnlyTree(record2.finalAssetRef, "ModelPromotionReceiptV2.finalAssetRef");
+  const receiptAssetRef = createModelAssetRef(record2.finalAssetRef);
   if (JSON.stringify(receiptAssetRef) !== JSON.stringify(finalAssetRef)) throw new Error("ModelPromotionReceiptV2 finalAssetRef must match the completed resolution.");
-  const creditsWrittenAt = requireTimestamp(record.creditsWrittenAt, "ModelPromotionReceiptV2.creditsWrittenAt");
-  const catalogRowWrittenAt = requireTimestamp(record.catalogRowWrittenAt, "ModelPromotionReceiptV2.catalogRowWrittenAt");
-  const indexSnapshotWrittenAt = requireTimestamp(record.indexSnapshotWrittenAt, "ModelPromotionReceiptV2.indexSnapshotWrittenAt");
-  const pointerPublishedAt = requireTimestamp(record.pointerPublishedAt, "ModelPromotionReceiptV2.pointerPublishedAt");
-  const promotedAt = requireTimestamp(record.promotedAt, "ModelPromotionReceiptV2.promotedAt");
+  const creditsWrittenAt = requireTimestamp(record2.creditsWrittenAt, "ModelPromotionReceiptV2.creditsWrittenAt");
+  const catalogRowWrittenAt = requireTimestamp(record2.catalogRowWrittenAt, "ModelPromotionReceiptV2.catalogRowWrittenAt");
+  const indexSnapshotWrittenAt = requireTimestamp(record2.indexSnapshotWrittenAt, "ModelPromotionReceiptV2.indexSnapshotWrittenAt");
+  const pointerPublishedAt = requireTimestamp(record2.pointerPublishedAt, "ModelPromotionReceiptV2.pointerPublishedAt");
+  const promotedAt = requireTimestamp(record2.promotedAt, "ModelPromotionReceiptV2.promotedAt");
   const publicationSequence = [confirmation.confirmedAt, creditsWrittenAt, catalogRowWrittenAt, indexSnapshotWrittenAt, pointerPublishedAt, promotedAt].map(Date.parse);
   if (publicationSequence.some((time, index) => index > 0 && time < publicationSequence[index - 1])) {
     throw new Error("ModelPromotionReceiptV2 must prove credits, catalog row, index snapshot, and pointers were published in pointer-last order.");
   }
-  const publicationHash = requireSha256(record.publicationHash, "ModelPromotionReceiptV2.publicationHash");
-  const publicationHashAttestation = createHashAttestation(record.publicationHashAttestation, PVOX_PUBLICATION_HASH_DOMAIN, publicationHash, "ModelPromotionReceiptV2.publicationHashAttestation");
-  const publicationToken = requireAttestation(record.publicationToken, "ModelPromotionReceiptV2.publicationToken");
+  const publicationHash = requireSha256(record2.publicationHash, "ModelPromotionReceiptV2.publicationHash");
+  const publicationHashAttestation = createHashAttestation(record2.publicationHashAttestation, PVOX_PUBLICATION_HASH_DOMAIN, publicationHash, "ModelPromotionReceiptV2.publicationHashAttestation");
+  const publicationToken = requireAttestation(record2.publicationToken, "ModelPromotionReceiptV2.publicationToken");
   if (publicationHashAttestation.attestationToken !== publicationToken) throw new Error("ModelPromotionReceiptV2 publication token must attest the exact publication hash.");
   return deepFreeze2({
     contractVersion: MODEL_RESOLUTION_V2_CONTRACT_VERSION,
-    promotionId: requireToken(record.promotionId, "ModelPromotionReceiptV2.promotionId"),
+    promotionId: requireToken(record2.promotionId, "ModelPromotionReceiptV2.promotionId"),
     resolutionId,
     requesterId: candidate.requesterId,
     candidateId: candidate.candidateId,
@@ -4700,11 +4700,11 @@ function createModelPromotionReceiptV2(input, resolutionId, candidate, confirmat
     assemblyClosureHash: candidate.processingManifest.assemblyClosureHash,
     assemblyChildClosureHashes,
     finalAssetRef: receiptAssetRef,
-    creditsRecordHash: requireSha256(record.creditsRecordHash, "ModelPromotionReceiptV2.creditsRecordHash"),
-    catalogRowHash: requireSha256(record.catalogRowHash, "ModelPromotionReceiptV2.catalogRowHash"),
-    indexSnapshotHash: requireSha256(record.indexSnapshotHash, "ModelPromotionReceiptV2.indexSnapshotHash"),
-    catalogPointerEtag: requireToken(record.catalogPointerEtag, "ModelPromotionReceiptV2.catalogPointerEtag"),
-    indexPointerEtag: requireToken(record.indexPointerEtag, "ModelPromotionReceiptV2.indexPointerEtag"),
+    creditsRecordHash: requireSha256(record2.creditsRecordHash, "ModelPromotionReceiptV2.creditsRecordHash"),
+    catalogRowHash: requireSha256(record2.catalogRowHash, "ModelPromotionReceiptV2.catalogRowHash"),
+    indexSnapshotHash: requireSha256(record2.indexSnapshotHash, "ModelPromotionReceiptV2.indexSnapshotHash"),
+    catalogPointerEtag: requireToken(record2.catalogPointerEtag, "ModelPromotionReceiptV2.catalogPointerEtag"),
+    indexPointerEtag: requireToken(record2.indexPointerEtag, "ModelPromotionReceiptV2.indexPointerEtag"),
     publicationState: "pointer-last-complete",
     creditsWrittenAt,
     catalogRowWrittenAt,
@@ -4718,43 +4718,43 @@ function createModelPromotionReceiptV2(input, resolutionId, candidate, confirmat
 }
 function createModelRefinementQuestionV2(input, index) {
   const fieldName = `ModelResolutionV2.refinementQuestions[${index}]`;
-  const record = asRecord(input, fieldName);
-  exactKeys(record, ["questionId", "prompt", "reasonCodes"], fieldName);
+  const record2 = asRecord(input, fieldName);
+  exactKeys(record2, ["questionId", "prompt", "reasonCodes"], fieldName);
   return deepFreeze2({
-    questionId: requireToken(record.questionId, `${fieldName}.questionId`),
-    prompt: requireString(record.prompt, `${fieldName}.prompt`, 500),
-    reasonCodes: requireReasonCodes(record.reasonCodes, `${fieldName}.reasonCodes`)
+    questionId: requireToken(record2.questionId, `${fieldName}.questionId`),
+    prompt: requireString(record2.prompt, `${fieldName}.prompt`, 500),
+    reasonCodes: requireReasonCodes(record2.reasonCodes, `${fieldName}.reasonCodes`)
   });
 }
 function createModelResolutionV2(input) {
-  const record = asRecord(input, "ModelResolutionV2");
-  exactKeys(record, ["contractVersion", "resolutionId", "requesterId", "request", "attempts", "state", "compatibilityState", "candidates", "bestCandidate", "confirmation", "promotionReceipt", "refinementQuestions", "finalAssetRef", "stateReasonCode", "createdAt", "updatedAt"], "ModelResolutionV2");
-  if (record.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelResolutionV2.contractVersion is unsupported.");
-  const resolutionId = requirePathSegment(record.resolutionId, "ModelResolutionV2.resolutionId");
-  const requesterId = requireToken(record.requesterId, "ModelResolutionV2.requesterId");
-  const request = createModelRequestSpecV2(record.request);
-  const state = requireEnum(record.state, MODEL_RESOLUTION_V2_STATES, "ModelResolutionV2.state");
+  const record2 = asRecord(input, "ModelResolutionV2");
+  exactKeys(record2, ["contractVersion", "resolutionId", "requesterId", "request", "attempts", "state", "compatibilityState", "candidates", "bestCandidate", "confirmation", "promotionReceipt", "refinementQuestions", "finalAssetRef", "stateReasonCode", "createdAt", "updatedAt"], "ModelResolutionV2");
+  if (record2.contractVersion !== MODEL_RESOLUTION_V2_CONTRACT_VERSION) throw new Error("ModelResolutionV2.contractVersion is unsupported.");
+  const resolutionId = requirePathSegment(record2.resolutionId, "ModelResolutionV2.resolutionId");
+  const requesterId = requireToken(record2.requesterId, "ModelResolutionV2.requesterId");
+  const request = createModelRequestSpecV2(record2.request);
+  const state = requireEnum(record2.state, MODEL_RESOLUTION_V2_STATES, "ModelResolutionV2.state");
   const compatibilityState = toLegacyModelResolutionState(state);
-  if (record.compatibilityState !== void 0 && record.compatibilityState !== compatibilityState) throw new Error("ModelResolutionV2 compatibilityState must match its deterministic legacy projection.");
-  const candidateEntries = asDenseArray(record.candidates, "ModelResolutionV2.candidates", 0, 20);
+  if (record2.compatibilityState !== void 0 && record2.compatibilityState !== compatibilityState) throw new Error("ModelResolutionV2 compatibilityState must match its deterministic legacy projection.");
+  const candidateEntries = asDenseArray(record2.candidates, "ModelResolutionV2.candidates", 0, 20);
   const candidates = candidateEntries.map(createModelCandidateV2);
   if (new Set(candidates.map(({ candidateId }) => candidateId)).size !== candidates.length) throw new Error("ModelResolutionV2 candidate IDs must be unique.");
   if (candidates.some((candidate) => candidate.resolutionId !== resolutionId || candidate.requesterId !== requesterId || JSON.stringify(candidate.request) !== JSON.stringify(request))) throw new Error("ModelResolutionV2 candidates must bind the exact requester, v2 resolution request, and profiles.");
-  const bestCandidate = record.bestCandidate === void 0 ? void 0 : createModelCandidateV2(record.bestCandidate);
+  const bestCandidate = record2.bestCandidate === void 0 ? void 0 : createModelCandidateV2(record2.bestCandidate);
   if (bestCandidate !== void 0 && !candidates.some((candidate) => candidatesEquivalent(candidate, bestCandidate))) throw new Error("ModelResolutionV2 bestCandidate must be one exact candidate in the resolution.");
   if (state === "awaiting-confirmation" && (bestCandidate === void 0 || !isModelCandidateV2Confirmable(bestCandidate))) throw new Error("ModelResolutionV2 awaiting-confirmation requires one confirmable bestCandidate.");
-  const refinementEntries = asDenseArray(record.refinementQuestions, "ModelResolutionV2.refinementQuestions", 0, 3);
+  const refinementEntries = asDenseArray(record2.refinementQuestions, "ModelResolutionV2.refinementQuestions", 0, 3);
   const refinementQuestions = refinementEntries.map(createModelRefinementQuestionV2);
   if (new Set(refinementQuestions.map(({ questionId }) => questionId)).size !== refinementQuestions.length) throw new Error("ModelResolutionV2 refinement question IDs must be unique.");
   if (state === "awaiting-confirmation" && bestCandidate?.match.assurance === "low" && refinementQuestions.length === 0) throw new Error("Low-assurance ModelResolutionV2 requires refinement questions.");
-  if (state === "completed" && record.finalAssetRef === void 0) throw new Error("ModelResolutionV2 completed state requires finalAssetRef.");
-  const confirmation = record.confirmation === void 0 ? void 0 : bestCandidate === void 0 ? (() => {
+  if (state === "completed" && record2.finalAssetRef === void 0) throw new Error("ModelResolutionV2 completed state requires finalAssetRef.");
+  const confirmation = record2.confirmation === void 0 ? void 0 : bestCandidate === void 0 ? (() => {
     throw new Error("ModelResolutionV2 confirmation requires bestCandidate.");
-  })() : createModelCandidateConfirmationV2(record.confirmation, bestCandidate, resolutionId);
+  })() : createModelCandidateConfirmationV2(record2.confirmation, bestCandidate, resolutionId);
   if (["promoting", "completed"].includes(state) && confirmation === void 0) throw new Error(`ModelResolutionV2 ${state} requires confirmation.`);
   if (!["promoting", "completed"].includes(state) && confirmation !== void 0) throw new Error("ModelResolutionV2 confirmation is only allowed while promoting or completed.");
-  if (record.finalAssetRef !== void 0) assertDataOnlyTree(record.finalAssetRef, "ModelResolutionV2.finalAssetRef");
-  const finalAssetRef = record.finalAssetRef === void 0 ? void 0 : createModelAssetRef(record.finalAssetRef);
+  if (record2.finalAssetRef !== void 0) assertDataOnlyTree(record2.finalAssetRef, "ModelResolutionV2.finalAssetRef");
+  const finalAssetRef = record2.finalAssetRef === void 0 ? void 0 : createModelAssetRef(record2.finalAssetRef);
   if (state === "completed" && finalAssetRef === void 0) throw new Error("ModelResolutionV2 completed state requires finalAssetRef.");
   if (state !== "completed" && finalAssetRef !== void 0) throw new Error("ModelResolutionV2 finalAssetRef is only allowed for completed state.");
   if (finalAssetRef !== void 0 && bestCandidate !== void 0) {
@@ -4769,21 +4769,21 @@ function createModelResolutionV2(input) {
     }
   }
   let promotionReceipt;
-  if (record.promotionReceipt !== void 0) {
+  if (record2.promotionReceipt !== void 0) {
     if (state !== "completed" || finalAssetRef === void 0 || confirmation === void 0 || bestCandidate?.admissionStatus !== "confirmable" || bestCandidate.assetRef.disposition !== "proposed") {
       throw new Error("ModelResolutionV2 promotionReceipt is only allowed for a completed confirmed proposed candidate.");
     }
-    promotionReceipt = createModelPromotionReceiptV2(record.promotionReceipt, resolutionId, bestCandidate, confirmation, finalAssetRef);
+    promotionReceipt = createModelPromotionReceiptV2(record2.promotionReceipt, resolutionId, bestCandidate, confirmation, finalAssetRef);
   }
   if (state === "completed" && bestCandidate?.assetRef.disposition === "proposed" && promotionReceipt === void 0) {
     throw new Error("ModelResolutionV2 completed proposed candidates require a pointer-last promotionReceipt.");
   }
   if (bestCandidate?.assetRef.disposition === "existing" && promotionReceipt !== void 0) throw new Error("ModelResolutionV2 existing selections must not include a promotionReceipt.");
-  const stateReasonCode = record.stateReasonCode === void 0 ? void 0 : requireReasonCode(record.stateReasonCode, "ModelResolutionV2.stateReasonCode");
+  const stateReasonCode = record2.stateReasonCode === void 0 ? void 0 : requireReasonCode(record2.stateReasonCode, "ModelResolutionV2.stateReasonCode");
   if (["unresolved", "failed", "cancelled"].includes(state) && stateReasonCode === void 0) throw new Error(`ModelResolutionV2 ${state} state requires stateReasonCode.`);
   if (!["unresolved", "failed", "cancelled"].includes(state) && stateReasonCode !== void 0) throw new Error("ModelResolutionV2 stateReasonCode is reserved for terminal non-success states.");
-  const createdAt = requireTimestamp(record.createdAt, "ModelResolutionV2.createdAt");
-  const updatedAt = requireTimestamp(record.updatedAt, "ModelResolutionV2.updatedAt");
+  const createdAt = requireTimestamp(record2.createdAt, "ModelResolutionV2.createdAt");
+  const updatedAt = requireTimestamp(record2.updatedAt, "ModelResolutionV2.updatedAt");
   if (Date.parse(updatedAt) < Date.parse(createdAt)) throw new Error("ModelResolutionV2.updatedAt must not precede createdAt.");
   if (confirmation !== void 0 && Date.parse(confirmation.confirmedAt) > Date.parse(updatedAt)) {
     throw new Error("ModelResolutionV2 confirmation confirmedAt must not exceed updatedAt.");
@@ -4796,7 +4796,7 @@ function createModelResolutionV2(input) {
     resolutionId,
     requesterId,
     request,
-    attempts: requireInteger(record.attempts, "ModelResolutionV2.attempts", 1, 12),
+    attempts: requireInteger(record2.attempts, "ModelResolutionV2.attempts", 1, 12),
     state,
     compatibilityState,
     candidates,
@@ -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 typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-    const byteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength")?.get;
-    const bufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer")?.get;
-    if (byteLengthGetter === void 0 || bufferGetter === void 0) throw new Error("Typed-array intrinsics are unavailable.");
-    byteLength = byteLengthGetter.call(value);
-    const buffer = bufferGetter.call(value);
+    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);
     if (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer) {
       throw new Error(`${fieldName} must not use shared mutable storage.`);
     }
@@ -5137,18 +5137,18 @@ function encodePvoxPageSetHashPreimageV1(records) {
   preflightPvoxArrayCardinality(records, 1, PVOX_DEFAULT_LIMITS.maximumPages, "PVOX page-set hash input");
   assertPvoxPreimageDataOnly(records, "PVOX page-set hash input");
   let previousEnd = 0n;
-  const encoded = records.map((record, position) => {
-    assertExactPvoxPreimageKeys(record, ["pageIndex", "byteOffset", "byteLength", "pageSha256"], `records[${position}]`);
-    if (record.pageIndex !== position) throw new Error("Page-set records must have contiguous page indexes starting at zero.");
-    const offset = asUnsignedBigInt(record.byteOffset, `records[${position}].byteOffset`);
-    const byteLength = assertSafeIntegerInRange(record.byteLength, PVOX_PAGE_SIZE_BYTES, PVOX_PAGE_SIZE_BYTES, `records[${position}].byteLength`);
+  const encoded = records.map((record2, position) => {
+    assertExactPvoxPreimageKeys(record2, ["pageIndex", "byteOffset", "byteLength", "pageSha256"], `records[${position}]`);
+    if (record2.pageIndex !== position) throw new Error("Page-set records must have contiguous page indexes starting at zero.");
+    const offset = asUnsignedBigInt(record2.byteOffset, `records[${position}].byteOffset`);
+    const byteLength = assertSafeIntegerInRange(record2.byteLength, PVOX_PAGE_SIZE_BYTES, PVOX_PAGE_SIZE_BYTES, `records[${position}].byteLength`);
     if (offset !== previousEnd || offset !== BigInt(position) * BigInt(PVOX_PAGE_SIZE_BYTES)) throw new Error("Page-set records must exactly cover contiguous 64-KiB PVOX pages.");
     previousEnd = offset + BigInt(byteLength);
     return concatenateBytes([
-      encodePvoxU32LeV1(record.pageIndex),
+      encodePvoxU32LeV1(record2.pageIndex),
       encodePvoxU64LeV1(offset),
       encodePvoxU32LeV1(byteLength),
-      decodePvoxSha256HexV1(record.pageSha256, `records[${position}].pageSha256`)
+      decodePvoxSha256HexV1(record2.pageSha256, `records[${position}].pageSha256`)
     ]);
   });
   return concatenateBytes([
@@ -5169,12 +5169,12 @@ function encodeCanonicalJsonRecords(values) {
   const encoded = [];
   let aggregateByteLength = 0;
   for (const value of normalized) {
-    const record = encodeCanonicalJsonRecord(value);
-    aggregateByteLength += record.byteLength;
+    const record2 = encodeCanonicalJsonRecord(value);
+    aggregateByteLength += record2.byteLength;
     if (aggregateByteLength > PVOX_MAX_CANONICAL_HASH_UTF8_BYTES_V1) {
       throw new Error("Canonical JSON records exceed the governed PVOX hash-input byte limit.");
     }
-    encoded.push(record);
+    encoded.push(record2);
   }
   return encoded;
 }
@@ -5241,15 +5241,15 @@ function encodePvoxPhysicalInventoryHashPreimageV1(input) {
   assertPvoxPreimageDataOnly(input, "PVOX physical-inventory hash input");
   assertExactPvoxPreimageKeys(input, ["inventoryVersion", "subjectBinaryClosureHash", "validationEvidenceHash", "entries"], "PVOX physical-inventory hash input");
   if (input.entries.length < 1 || input.entries.length > PVOX_DEFAULT_LIMITS.maximumMaterialRegions) throw new Error("Physical inventory must fit the governed material-region limit.");
-  const encoded = input.entries.map((record, index) => {
-    assertExactPvoxPreimageKeys(record, ["regionIndex", "physicalPaletteIndex", "regionId", "materialId"], `entries[${index}]`);
-    const regionIndex = assertSafeIntegerInRange(record.regionIndex, 0, U32_MAXIMUM, `entries[${index}].regionIndex`);
+  const encoded = input.entries.map((record2, index) => {
+    assertExactPvoxPreimageKeys(record2, ["regionIndex", "physicalPaletteIndex", "regionId", "materialId"], `entries[${index}]`);
+    const regionIndex = assertSafeIntegerInRange(record2.regionIndex, 0, U32_MAXIMUM, `entries[${index}].regionIndex`);
     if (regionIndex !== index) throw new Error("Physical inventory records must have contiguous canonical region indexes starting at zero.");
     return concatenateBytes([
       encodePvoxU32LeV1(regionIndex),
-      encodePvoxU32LeV1(record.physicalPaletteIndex),
-      encodePvoxCanonicalUtf8V1(record.regionId),
-      encodePvoxCanonicalUtf8V1(record.materialId)
+      encodePvoxU32LeV1(record2.physicalPaletteIndex),
+      encodePvoxCanonicalUtf8V1(record2.regionId),
+      encodePvoxCanonicalUtf8V1(record2.materialId)
     ]);
   });
   return concatenateBytes([
@@ -5297,12 +5297,12 @@ function encodePvoxPhysicalEvidenceHashPreimageV1(input) {
   let previousOrder = -1;
   for (const [index, evidence] of normalizedEvidence.entries()) {
     if (evidence === null || typeof evidence !== "object" || Array.isArray(evidence)) throw new Error(`Physical evidence[${index}] must be an object.`);
-    const record = evidence;
-    if (typeof record.regionId !== "string" || typeof record.materialId !== "string" || typeof record.property !== "string") {
+    const record2 = evidence;
+    if (typeof record2.regionId !== "string" || typeof record2.materialId !== "string" || typeof record2.property !== "string") {
       throw new Error(`Physical evidence[${index}] must declare regionId, materialId, and property.`);
     }
-    const regionIndex = regionOrder.get(`${record.regionId}\0${record.materialId}`);
-    const propertyIndex = PVOX_PHYSICAL_PROPERTIES.indexOf(record.property);
+    const regionIndex = regionOrder.get(`${record2.regionId}\0${record2.materialId}`);
+    const propertyIndex = PVOX_PHYSICAL_PROPERTIES.indexOf(record2.property);
     if (regionIndex === void 0 || propertyIndex < 0) throw new Error(`Physical evidence[${index}] is absent from the governed inventory/property registry.`);
     const order = regionIndex * PVOX_PHYSICAL_PROPERTIES.length + propertyIndex;
     if (order <= previousOrder) throw new Error("Physical evidence must use canonical inventory-region and governed-property order.");
@@ -5434,33 +5434,33 @@ function encodePvoxEditOverlayRootHashPreimageV1(input) {
   const pageIndexes = /* @__PURE__ */ new Set();
   normalizedPatches.forEach((patch, index) => {
     if (patch === null || typeof patch !== "object" || Array.isArray(patch)) throw new Error(`Edit-overlay patch[${index}] must be an object.`);
-    const record = patch;
-    if (Object.keys(record).length !== requiredKeys.length || requiredKeys.some((key) => !(key in record))) throw new Error(`Edit-overlay patch[${index}] must contain the complete fixed patch address and transition.`);
-    if (record.fieldKind !== "render-field" && record.fieldKind !== "collision-field") throw new Error(`Edit-overlay patch[${index}].fieldKind is invalid.`);
-    const lodLevel = assertSafeIntegerInRange(record.lodLevel, 0, PVOX_DEFAULT_LIMITS.maximumLodCount - 1, `orderedPatches[${index}].lodLevel`);
-    const partitionIndex = assertSafeIntegerInRange(record.partitionIndex, 0, PVOX_DEFAULT_LIMITS.maximumPartitions - 1, `orderedPatches[${index}].partitionIndex`);
-    const hierarchyDepth = assertSafeIntegerInRange(record.hierarchyDepth, 0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth, `orderedPatches[${index}].hierarchyDepth`);
-    if (typeof record.mortonCode !== "string" || !/^[0-9a-f]{16}$/u.test(record.mortonCode)) throw new Error(`Edit-overlay patch[${index}].mortonCode is invalid.`);
-    const expectedPageIndex = assertSafeIntegerInRange(record.expectedPageIndex, 0, PVOX_DEFAULT_LIMITS.maximumPages - 1, `orderedPatches[${index}].expectedPageIndex`);
+    const record2 = patch;
+    if (Object.keys(record2).length !== requiredKeys.length || requiredKeys.some((key) => !(key in record2))) throw new Error(`Edit-overlay patch[${index}] must contain the complete fixed patch address and transition.`);
+    if (record2.fieldKind !== "render-field" && record2.fieldKind !== "collision-field") throw new Error(`Edit-overlay patch[${index}].fieldKind is invalid.`);
+    const lodLevel = assertSafeIntegerInRange(record2.lodLevel, 0, PVOX_DEFAULT_LIMITS.maximumLodCount - 1, `orderedPatches[${index}].lodLevel`);
+    const partitionIndex = assertSafeIntegerInRange(record2.partitionIndex, 0, PVOX_DEFAULT_LIMITS.maximumPartitions - 1, `orderedPatches[${index}].partitionIndex`);
+    const hierarchyDepth = assertSafeIntegerInRange(record2.hierarchyDepth, 0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth, `orderedPatches[${index}].hierarchyDepth`);
+    if (typeof record2.mortonCode !== "string" || !/^[0-9a-f]{16}$/u.test(record2.mortonCode)) throw new Error(`Edit-overlay patch[${index}].mortonCode is invalid.`);
+    const expectedPageIndex = assertSafeIntegerInRange(record2.expectedPageIndex, 0, PVOX_DEFAULT_LIMITS.maximumPages - 1, `orderedPatches[${index}].expectedPageIndex`);
     if (pageIndexes.has(expectedPageIndex)) throw new Error("Edit-overlay permits only one transition per page.");
     pageIndexes.add(expectedPageIndex);
-    const expectedPageHash = decodePvoxSha256HexV1(record.expectedPageHash, `orderedPatches[${index}].expectedPageHash`);
-    const resultingPageHash = decodePvoxSha256HexV1(record.resultingPageHash, `orderedPatches[${index}].resultingPageHash`);
+    const expectedPageHash = decodePvoxSha256HexV1(record2.expectedPageHash, `orderedPatches[${index}].expectedPageHash`);
+    const resultingPageHash = decodePvoxSha256HexV1(record2.resultingPageHash, `orderedPatches[${index}].resultingPageHash`);
     if (expectedPageHash.every((value, offset) => value === resultingPageHash[offset])) throw new Error("Edit-overlay page transitions must change the page hash.");
-    const expectedBrickHash = record.expectedBrickHash;
-    const resultingBrickHash = record.resultingBrickHash;
+    const expectedBrickHash = record2.expectedBrickHash;
+    const resultingBrickHash = record2.resultingBrickHash;
     decodePvoxSha256HexV1(expectedBrickHash, `orderedPatches[${index}].expectedBrickHash`);
     decodePvoxSha256HexV1(resultingBrickHash, `orderedPatches[${index}].resultingBrickHash`);
-    if (record.operation === "insert") {
+    if (record2.operation === "insert") {
       if (expectedBrickHash !== PVOX_EDIT_JOURNAL_GENESIS_HASH || resultingBrickHash === PVOX_EDIT_JOURNAL_GENESIS_HASH) throw new Error("Edit-overlay insert must change an empty brick to a non-empty result.");
-    } else if (record.operation === "remove") {
+    } else if (record2.operation === "remove") {
       if (expectedBrickHash === PVOX_EDIT_JOURNAL_GENESIS_HASH || resultingBrickHash !== PVOX_EDIT_JOURNAL_GENESIS_HASH) throw new Error("Edit-overlay remove must change a non-empty brick to the empty result.");
-    } else if (record.operation === "replace") {
+    } else if (record2.operation === "replace") {
       if (expectedBrickHash === PVOX_EDIT_JOURNAL_GENESIS_HASH || resultingBrickHash === PVOX_EDIT_JOURNAL_GENESIS_HASH || expectedBrickHash === resultingBrickHash) throw new Error("Edit-overlay replace must change one non-empty brick to another.");
     } else {
       throw new Error(`Edit-overlay patch[${index}].operation is invalid.`);
     }
-    const address = [record.fieldKind, String(lodLevel).padStart(2, "0"), String(partitionIndex).padStart(6, "0"), String(hierarchyDepth).padStart(2, "0"), record.mortonCode].join("\0");
+    const address = [record2.fieldKind, String(lodLevel).padStart(2, "0"), String(partitionIndex).padStart(6, "0"), String(hierarchyDepth).padStart(2, "0"), record2.mortonCode].join("\0");
     if (index > 0 && address <= previousAddress) throw new Error("Edit-overlay patches must be unique and canonically ordered by their complete spatial address.");
     previousAddress = address;
   });
@@ -5597,17 +5597,17 @@ function encodePvoxRootHashPreimageV1(exactHeader, orderedSectionHashes) {
   const sectionCount = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint16(PVOX_ROOT_HEADER_SECTION_COUNT_OFFSET, true);
   if (orderedSectionHashes.length !== sectionCount) throw new Error("Root section hashes must match the header sectionCount.");
   let previousKey = -1n;
-  const sections = orderedSectionHashes.map((record, index) => {
-    assertExactPvoxPreimageKeys(record, ["sectionType", "sectionVersion", "sectionHash"], `orderedSectionHashes[${index}]`);
-    const sectionType = assertSafeIntegerInRange(record.sectionType, 0, U32_MAXIMUM, `orderedSectionHashes[${index}].sectionType`);
-    const sectionVersion = assertSafeIntegerInRange(record.sectionVersion, 0, U16_MAXIMUM, `orderedSectionHashes[${index}].sectionVersion`);
+  const sections = orderedSectionHashes.map((record2, index) => {
+    assertExactPvoxPreimageKeys(record2, ["sectionType", "sectionVersion", "sectionHash"], `orderedSectionHashes[${index}]`);
+    const sectionType = assertSafeIntegerInRange(record2.sectionType, 0, U32_MAXIMUM, `orderedSectionHashes[${index}].sectionType`);
+    const sectionVersion = assertSafeIntegerInRange(record2.sectionVersion, 0, U16_MAXIMUM, `orderedSectionHashes[${index}].sectionVersion`);
     const key = BigInt(sectionType) << 16n | BigInt(sectionVersion);
     if (key <= previousKey) throw new Error("Root section hashes must be unique and strictly ordered by type then version.");
     previousKey = key;
     return concatenateBytes([
       encodePvoxU32LeV1(sectionType),
       encodePvoxU16LeV1(sectionVersion),
-      decodePvoxSha256HexV1(record.sectionHash, `orderedSectionHashes[${index}].sectionHash`)
+      decodePvoxSha256HexV1(record2.sectionHash, `orderedSectionHashes[${index}].sectionHash`)
     ]);
   });
   return concatenateBytes([TEXT_ENCODER.encode(PVOX_ROOT_HASH_DOMAIN), header, ...sections]);
@@ -6642,6 +6642,176 @@ var MODEL_RESOLUTION_V2_JSON_SCHEMAS = deepFreeze3({
   modelResolution: standaloneSchema("modelResolution", "ModelResolutionV2")
 });
 
+// src/model-resource-manifest.ts
+import { computeSha256 } from "@plasius/gpu-shader";
+var MODEL_RESOURCE_MANIFEST_LIMITS = Object.freeze({
+  files: 16384,
+  fileBytes: 64 * 1024 * 1024,
+  totalBytes: 128 * 1024 * 1024,
+  metadataValues: 262144,
+  metadataDepth: 16,
+  timeoutMs: 6e4
+});
+var ModelResourceManifestError = class extends TypeError {
+  constructor(code) {
+    super(`Invalid model resource manifest: ${code}`);
+    this.code = code;
+    this.name = "ModelResourceManifestError";
+  }
+  code;
+};
+function fail(code = "invalid-input") {
+  throw new ModelResourceManifestError(code);
+}
+function record(value) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail();
+  const output = /* @__PURE__ */ Object.create(null);
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > MODEL_RESOURCE_MANIFEST_LIMITS.files) fail("limit-exceeded");
+  for (const key of keys) {
+    if (typeof key !== "string" || ["__proto__", "constructor", "prototype"].includes(key)) fail();
+    if (key.length > 128) fail("limit-exceeded");
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in property) || !property.enumerable) fail();
+    output[key] = property.value;
+  }
+  return output;
+}
+function list(value) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) fail();
+  if (value.length > MODEL_RESOURCE_MANIFEST_LIMITS.files) fail("limit-exceeded");
+  if (Reflect.ownKeys(value).length !== value.length + 1) fail();
+  const output = [];
+  for (let i = 0; i < value.length; i++) {
+    const property = Object.getOwnPropertyDescriptor(value, String(i));
+    if (!property || !("value" in property) || !property.enumerable) fail();
+    output.push(property.value);
+  }
+  return output;
+}
+function snapshot(value, budget, depth = 0) {
+  if (--budget.remaining < 0 || depth > MODEL_RESOURCE_MANIFEST_LIMITS.metadataDepth) fail("limit-exceeded");
+  if (value === null || value === void 0 || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    if (value.length > 2048) fail("limit-exceeded");
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) fail();
+    return value;
+  }
+  if (Array.isArray(value)) return Object.freeze(list(value).map((item) => snapshot(item, budget, depth + 1)));
+  const fields = record(value);
+  for (const key of Object.keys(fields)) fields[key] = snapshot(fields[key], budget, depth + 1);
+  return Object.freeze(fields);
+}
+function path(value) {
+  if (typeof value !== "string" || value.length > 1024 || !value.length) fail();
+  for (const part of value.split("/")) {
+    if (part.length > 255 || !/^[A-Za-z0-9_][A-Za-z0-9_.-]*$/u.test(part) || part.endsWith(".") || /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\.|$)/iu.test(part)) fail();
+  }
+  return value;
+}
+function contentType(value) {
+  if (typeof value !== "string" || value.length > 128 || !/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+(?:; charset=utf-8)?$/u.test(value)) fail();
+  return value;
+}
+function uniquePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of paths) {
+    const normalized = path(value).toLowerCase();
+    if (seen.has(normalized)) fail("path-conflict");
+    seen.add(normalized);
+  }
+  for (const value of seen) {
+    for (let offset = value.indexOf("/"); offset !== -1; offset = value.indexOf("/", offset + 1)) {
+      if (seen.has(value.slice(0, offset))) fail("path-conflict");
+    }
+  }
+}
+var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+var byteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+var bufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+async function qualifyModelResourceManifest(input) {
+  try {
+    return await qualify(input);
+  } catch (error) {
+    if (error instanceof ModelResourceManifestError) throw error;
+    return fail();
+  }
+}
+async function qualify(input) {
+  const started = performance.now();
+  const root = record(input);
+  if (Object.keys(root).some((key) => !["manifest", "packageManifest", "files", "signal", "timeoutMs"].includes(key))) fail();
+  const timeout = root.timeoutMs ?? 1e4;
+  if (typeof timeout !== "number" || !Number.isSafeInteger(timeout) || timeout < 1 || timeout > MODEL_RESOURCE_MANIFEST_LIMITS.timeoutMs) fail();
+  const signal = root.signal;
+  if (signal !== void 0 && !(signal instanceof AbortSignal)) fail();
+  const check = () => {
+    if (signal?.aborted) fail("aborted");
+    if (performance.now() - started >= timeout) fail("deadline-exceeded");
+  };
+  check();
+  const budget = { remaining: MODEL_RESOURCE_MANIFEST_LIMITS.metadataValues };
+  const rawManifest = snapshot(root.manifest, budget);
+  const inventory = record(snapshot(root.packageManifest, budget));
+  if (Object.keys(inventory).some((key) => !["format", "entries"].includes(key)) || !["zip", "tar", "directory-manifest", "inline"].includes(inventory.format)) fail();
+  let manifest;
+  try {
+    manifest = rawManifest.assetKind === "model" ? createModelAssetManifest(rawManifest) : createAssetManifest(rawManifest);
+  } catch {
+    return fail();
+  }
+  uniquePaths(manifest.files.map((file) => file.path));
+  if (!manifest.files.some((file) => file.path === path(manifest.entrypoint))) fail("inventory-mismatch");
+  const descriptors = new Map(manifest.files.map((file) => [file.path, file]));
+  let total = 0;
+  for (const file of manifest.files) {
+    if (!Number.isSafeInteger(file.byteLength)) fail();
+    if (file.byteLength > MODEL_RESOURCE_MANIFEST_LIMITS.fileBytes) fail("limit-exceeded");
+    total += file.byteLength;
+    if (total > MODEL_RESOURCE_MANIFEST_LIMITS.totalBytes) fail("limit-exceeded");
+    contentType(file.contentType);
+  }
+  const entries = list(inventory.entries).map(record);
+  uniquePaths(entries.map((entry) => path(entry.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);
+    if (!descriptor) fail("inventory-mismatch");
+    if (entry.contentType !== void 0 && contentType(entry.contentType) !== descriptor.contentType) fail("content-mismatch");
+  }
+  if (entries.length !== descriptors.size) fail("inventory-mismatch");
+  const payloads = list(root.files).map((value) => {
+    const file = record(value);
+    if (Object.keys(file).length !== 3 || Object.keys(file).some((key) => !["path", "bytes", "contentType"].includes(key))) fail();
+    const filePath = path(file.path);
+    if (!(file.bytes instanceof Uint8Array) || Object.getPrototypeOf(file.bytes) !== Uint8Array.prototype || !(bufferGetter.call(file.bytes) instanceof ArrayBuffer)) fail();
+    const descriptor = descriptors.get(filePath);
+    if (!descriptor) fail("inventory-mismatch");
+    if (byteLengthGetter.call(file.bytes) !== descriptor.byteLength || contentType(file.contentType) !== descriptor.contentType) fail("content-mismatch");
+    return { path: filePath, bytes: file.bytes, descriptor };
+  });
+  uniquePaths(payloads.map((file) => file.path));
+  if (payloads.length !== descriptors.size) fail("inventory-mismatch");
+  const copies = payloads.map((file) => ({ ...file, bytes: new Uint8Array(file.bytes) }));
+  for (const file of copies) {
+    check();
+    let hash;
+    try {
+      hash = await computeSha256(file.bytes);
+    } catch {
+      return fail("content-mismatch");
+    }
+    check();
+    if (hash !== file.descriptor.sha256) fail("content-mismatch");
+  }
+  return Object.freeze({ ...manifest, files: Object.freeze([...manifest.files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) });
+}
+
 // src/index.ts
 var ASSET_CONTRACTS_PACKAGE = "@plasius/asset-contracts";
 var UNIFIED_ASSET_PIPELINE_FEATURE_FLAG_ID = "asset.pipeline.unified-ai-assets.enabled";
@@ -7030,9 +7200,9 @@ async function validateGpuAssetFiles(input) {
   if (input.files.size !== manifest.files.length) {
     throw new Error("GPU asset validation requires exactly the declared file set.");
   }
-  for (const path of input.files.keys()) {
-    if (!manifest.files.some((file) => file.path === path)) {
-      throw new Error(`GPU asset validation received undeclared file ${path}.`);
+  for (const path2 of input.files.keys()) {
+    if (!manifest.files.some((file) => file.path === path2)) {
+      throw new Error(`GPU asset validation received undeclared file ${path2}.`);
     }
   }
   await Promise.all(manifest.files.map(async (file) => {
@@ -7043,7 +7213,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 computeSha256(bytes) !== file.sha256) {
+    if (await computeSha2562(bytes) !== file.sha256) {
       throw new Error(`GPU asset file ${file.path} digest differs from its descriptor.`);
     }
     if (file.contentType === ASSET_JSON_CONTENT_TYPE) {
@@ -7323,7 +7493,7 @@ async function bindDomainManifestBytes(bytes, manifest, fieldName) {
   if (canonicalizeGpuContract3(parsed) !== canonicalizeGpuContract3(manifest)) {
     throw new Error(`${fieldName} manifest bytes differ from the supplied manifest.`);
   }
-  return computeSha256(bytes);
+  return computeSha2562(bytes);
 }
 function assertRoleCount(manifest, role, expectedCount) {
   if (manifest.files.filter((file) => file.role === role).length !== expectedCount) {
@@ -7442,8 +7612,10 @@ export {
   MODEL_RESOLUTION_V2_CONTRACT_VERSION,
   MODEL_RESOLUTION_V2_JSON_SCHEMAS,
   MODEL_RESOLUTION_V2_STATES,
+  MODEL_RESOURCE_MANIFEST_LIMITS,
   MODEL_RIGHTS_STATUSES,
   MODEL_TEXT_ONLY_ASSURANCE_CEILING_REASON_CODE,
+  ModelResourceManifestError,
   PVOX_ASSEMBLY_CLOSURE_HASH_DOMAIN,
   PVOX_ASSET_MANIFEST_VERSION,
   PVOX_BINARY_CLOSURE_HASH_DOMAIN,
@@ -7634,6 +7806,7 @@ export {
   normalizeAssetId,
   normalizePvoxRootHeaderForHashV1,
   projectPvoxNamedJsonClosureV1,
+  qualifyModelResourceManifest,
   toLegacyModelResolutionState,
   validateGpuAssetFiles
 };