@plasius/asset-contracts 0.3.1 → 0.4.0

package/src/pvox-model-resolution-schema.ts

@@ -0,0 +1,1041 @@
+import {
+  CANONICAL_MODEL_COORDINATE_SYSTEM,
+  MODEL_ASSET_KINDS,
+  MODEL_CONFIRMATION_VIEW_KINDS,
+  MODEL_CONFIRMATION_VIEW_SIZE_PX,
+  MODEL_MATCH_ASSURANCE_BANDS,
+  MODEL_PROVENANCE_KINDS,
+  MODEL_RANKER_EVIDENCE_MODES,
+  MODEL_REQUEST_MAX_REVISION,
+  MODEL_RESOLUTION_CONTRACT_VERSION,
+  MODEL_RESOLUTION_STATES,
+  MODEL_RIGHTS_STATUSES,
+  STATIC_WORLD_V1_MODEL_POLICY,
+} from "./model-resolution.js";
+import {
+  MODEL_RESOLUTION_V2_CONTRACT_VERSION,
+  MODEL_RESOLUTION_V2_STATES,
+  PVOX_ASSET_MANIFEST_VERSION,
+  PVOX_BRICK_EDGE_VOXELS,
+  PVOX_CAPABILITIES,
+  PVOX_CONTENT_TYPE,
+  PVOX_DEFAULT_LIMITS,
+  PVOX_DEFAULT_SOURCE_INGESTION_LIMITS,
+  PVOX_EDIT_JOURNAL_VERSION,
+  PVOX_FIDELITY_PROFILE_IDS,
+  PVOX_FIDELITY_PROFILE_VERSION,
+  PVOX_FILE_EXTENSION,
+  PVOX_HASH_DOMAINS,
+  PVOX_HEADER_BYTE_LENGTH,
+  PVOX_DIRECTORY_ENTRY_BYTE_LENGTH,
+  PVOX_MAGIC,
+  PVOX_MAX_ABSOLUTE_COORDINATE_METRES,
+  PVOX_MAX_ENCODED_BRICK_PAYLOAD_BYTES,
+  PVOX_MAX_HIERARCHY_NODES,
+  PVOX_MAX_LOCAL_SAMPLES_PER_BRICK,
+  PVOX_MAX_RUNS_PER_BRICK,
+  PVOX_MAX_SECTIONS,
+  PVOX_MIN_STATIC_SECTION_COUNT,
+  PVOX_MAX_EDIT_PATCHES,
+  PVOX_MODEL_REQUEST_POLICY_ID,
+  PVOX_NATIVE_RENDERER_ID,
+  PVOX_NATIVE_REVIEW_SETTINGS_ID,
+  PVOX_NON_OVERRIDABLE_GATE_KINDS,
+  PVOX_PAGE_KINDS,
+  PVOX_PAGE_SIZE_BYTES,
+  PVOX_PHYSICAL_PROPERTIES,
+  PVOX_PHYSICAL_REGION_INVENTORY_VERSION,
+  PVOX_PHYSICAL_PROPERTY_POLICIES,
+  PVOX_PHYSICAL_PROPERTY_POLICY_ID,
+  PVOX_PHYSICAL_PROPERTY_POLICY_VERSION,
+  PVOX_RUNTIME_CAPABILITY_PROFILE_IDS,
+} from "./pvox-model-resolution.js";
+
+export type PvoxModelResolutionJsonSchema = Readonly<Record<string, unknown>> & {
+  readonly $id: string;
+  readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+  readonly type: "object";
+  readonly additionalProperties: false;
+  readonly $defs: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+};
+
+type Schema = Record<string, unknown>;
+
+function deepFreeze<T>(value: T, seen = new WeakSet<object>()): T {
+  if (value === null || typeof value !== "object") return value;
+  const object = value as object;
+  if (seen.has(object)) return value;
+  seen.add(object);
+  for (const child of Object.values(value as Record<string, unknown>)) deepFreeze(child, seen);
+  return Object.freeze(value);
+}
+
+function objectSchema(properties: Record<string, Schema>, required: readonly string[] = [], extra: Schema = {}): Schema {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    required,
+    ...extra,
+  };
+}
+
+function arraySchema(items: Schema, minimum = 0, maximum?: number): Schema {
+  return {
+    type: "array",
+    items,
+    minItems: minimum,
+    ...(maximum === undefined ? {} : { maxItems: maximum }),
+  };
+}
+
+function tupleSchema(items: readonly Schema[]): Schema {
+  return {
+    type: "array",
+    prefixItems: items,
+    items: false,
+    minItems: items.length,
+    maxItems: items.length,
+  };
+}
+
+function hashAttestationSchema(domain: Schema): Schema {
+  return objectSchema({
+    algorithm: { const: "sha256" },
+    domain,
+    digest: sha256,
+    attestationToken: attestation,
+  }, ["algorithm", "domain", "digest", "attestationToken"]);
+}
+
+const ref = (name: string): Schema => ({ $ref: `#/$defs/${name}` });
+const stringSchema = (maximum = 512): Schema => ({ type: "string", minLength: 1, maxLength: maximum });
+const numberSchema = (minimum?: number, maximum?: number): Schema => ({
+  type: "number",
+  ...(minimum === undefined ? {} : { minimum }),
+  ...(maximum === undefined ? {} : { maximum }),
+});
+const integerSchema = (minimum: number, maximum?: number): Schema => ({
+  type: "integer",
+  minimum,
+  ...(maximum === undefined ? {} : { maximum }),
+});
+
+const sha256 = { type: "string", pattern: "^[a-f0-9]{64}$" };
+const token = { type: "string", pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$" };
+const opaqueSourceAssetId = { type: "string", pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$" };
+const pathSegment = { type: "string", pattern: "^(?!\\.{1,2}$)[A-Za-z0-9][A-Za-z0-9._~-]{0,127}$" };
+const reasonCode = { type: "string", pattern: "^[a-z0-9][a-z0-9._:-]{0,127}$" };
+const attestation = { type: "string", pattern: "^[A-Za-z0-9_-]{32,256}$" };
+const timestamp = {
+  type: "string",
+  pattern: "^(?:[0-9]{4})-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])T(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]\\.[0-9]{3}Z$",
+};
+const immutableVersion = {
+  type: "string",
+  minLength: 1,
+  maxLength: 128,
+  pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$",
+  not: {
+    anyOf: [
+      { pattern: "^[Ll][Aa][Tt][Ee][Ss][Tt]$" },
+      { pattern: "^[Cc][Uu][Rr][Rr][Ee][Nn][Tt]$" },
+      { pattern: "^[Ss][Tt][Aa][Bb][Ll][Ee]$" },
+      { pattern: "^[Pp][Rr][Ee][Vv][Ii][Ee][Ww]$" },
+      { pattern: "^[Dd][Ee][Ff][Aa][Uu][Ll][Tt]$" },
+      { pattern: "^[Pp][Rr][Oo][Dd][Uu][Cc][Tt][Ii][Oo][Nn]$" },
+      { pattern: "^[Cc][Aa][Nn][Aa][Rr][Yy]$" },
+      { pattern: "^[Nn][Ee][Xx][Tt]$" },
+      { pattern: "^[Hh][Ee][Aa][Dd]$" },
+      { pattern: "^[Mm][Aa][Ii][Nn]$" },
+      { pattern: "(?:^|[._-])[xX](?:$|[._-])" },
+    ],
+  },
+};
+const reasonCodes = { ...arraySchema(reasonCode, 0, 32), uniqueItems: true };
+const releasedV1ReasonCodes = { ...arraySchema(token, 0, 32), uniqueItems: true };
+const mutableCatalogVersionPath = {
+  anyOf: [
+    { pattern: "/versions/[Ll][Aa][Tt][Ee][Ss][Tt]/" },
+    { pattern: "/versions/[Cc][Uu][Rr][Rr][Ee][Nn][Tt]/" },
+    { pattern: "/versions/[Ss][Tt][Aa][Bb][Ll][Ee]/" },
+    { pattern: "/versions/[Pp][Rr][Ee][Vv][Ii][Ee][Ww]/" },
+    { pattern: "/versions/[Dd][Ee][Ff][Aa][Uu][Ll][Tt]/" },
+    { pattern: "/versions/[Pp][Rr][Oo][Dd][Uu][Cc][Tt][Ii][Oo][Nn]/" },
+    { pattern: "/versions/[Cc][Aa][Nn][Aa][Rr][Yy]/" },
+    { pattern: "/versions/[Nn][Ee][Xx][Tt]/" },
+    { pattern: "/versions/[Hh][Ee][Aa][Dd]/" },
+    { pattern: "/versions/[Mm][Aa][Ii][Nn]/" },
+    { pattern: "/versions/(?:[vV])?[xX](?:[.-]|/)" },
+    { pattern: "/versions/[^/]*\\.[xX](?:[.-]|/)" },
+  ],
+};
+const shaTuple = tupleSchema([sha256, sha256, sha256, sha256]);
+const vector3 = tupleSchema([
+  numberSchema(-PVOX_MAX_ABSOLUTE_COORDINATE_METRES, PVOX_MAX_ABSOLUTE_COORDINATE_METRES),
+  numberSchema(-PVOX_MAX_ABSOLUTE_COORDINATE_METRES, PVOX_MAX_ABSOLUTE_COORDINATE_METRES),
+  numberSchema(-PVOX_MAX_ABSOLUTE_COORDINATE_METRES, PVOX_MAX_ABSOLUTE_COORDINATE_METRES),
+]);
+const positiveVector3 = tupleSchema([numberSchema(Number.EPSILON), numberSchema(Number.EPSILON), numberSchema(Number.EPSILON)]);
+const quaternion = tupleSchema([numberSchema(-1, 1), numberSchema(-1, 1), numberSchema(-1, 1), numberSchema(-1, 1)]);
+
+const definitions: Record<string, Schema> = {
+  coordinateSystem: objectSchema({
+    unit: { const: CANONICAL_MODEL_COORDINATE_SYSTEM.unit },
+    upAxis: { const: CANONICAL_MODEL_COORDINATE_SYSTEM.upAxis },
+    forwardAxis: { const: CANONICAL_MODEL_COORDINATE_SYSTEM.forwardAxis },
+    origin: { const: CANONICAL_MODEL_COORDINATE_SYSTEM.origin },
+    outwardFaceWinding: { const: CANONICAL_MODEL_COORDINATE_SYSTEM.outwardFaceWinding },
+  }, ["unit", "upAxis", "forwardAxis", "origin", "outwardFaceWinding"]),
+  pvoxFormatVersion: objectSchema({ major: { const: 1 }, minor: { const: 0 } }, ["major", "minor"]),
+  pvoxHashAttestation: hashAttestationSchema({ enum: Object.values(PVOX_HASH_DOMAINS) }),
+  pvoxAssemblyClosureHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.assemblyClosure }),
+  pvoxCapabilitySetHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.capabilitySet }),
+  pvoxConfirmationBindingHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.confirmationBinding }),
+  pvoxEditJournalHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.editJournal }),
+  pvoxEditOverlayRootHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.editOverlayRoot }),
+  pvoxEvaluationClosureHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.evaluationClosure }),
+  pvoxPhysicalEvidenceHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.physicalEvidence }),
+  pvoxPhysicalInventoryHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.physicalInventory }),
+  pvoxProcessingClosureHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.processingClosure }),
+  pvoxPublicationHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.publication }),
+  pvoxRenderEvidenceHashAttestation: hashAttestationSchema({ const: PVOX_HASH_DOMAINS.renderEvidence }),
+  bounds: objectSchema({ min: vector3, max: vector3 }, ["min", "max"]),
+  dimensions: objectSchema({
+    width: numberSchema(Number.EPSILON),
+    height: numberSchema(Number.EPSILON),
+    depth: numberSchema(Number.EPSILON),
+  }, ["width", "height", "depth"]),
+  hardConstraintsV2: objectSchema({
+    boundsMetres: ref("bounds"),
+    dimensionsMetres: ref("dimensions"),
+    collision: { enum: ["required", "optional", "forbidden"] },
+    partition: { enum: ["single", "allowed", "required"] },
+  }),
+  softPreferences: objectSchema({
+    category: stringSchema(80),
+    style: stringSchema(80),
+    materials: arraySchema(stringSchema(256), 0, 32),
+    colors: arraySchema(stringSchema(256), 0, 32),
+    era: stringSchema(80),
+    condition: stringSchema(80),
+    tags: arraySchema(stringSchema(256), 0, 32),
+  }),
+  sourceIngestionLimits: objectSchema({
+    maximumDownloadBytes: integerSchema(1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumDownloadBytes),
+    maximumExpandedBytes: integerSchema(1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumExpandedBytes),
+    maximumArchiveEntries: integerSchema(1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumArchiveEntries),
+    maximumSourceFiles: integerSchema(1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumSourceFiles),
+    maximumDecodedTextureBytes: integerSchema(1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumDecodedTextureBytes),
+    maximumTextureDimensionPx: integerSchema(1, PVOX_DEFAULT_SOURCE_INGESTION_LIMITS.maximumTextureDimensionPx),
+  }, ["maximumDownloadBytes", "maximumExpandedBytes", "maximumArchiveEntries", "maximumSourceFiles", "maximumDecodedTextureBytes", "maximumTextureDimensionPx"]),
+  pvoxRuntimeLimits: objectSchema({
+    maximumArtifactBytes: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumArtifactBytes),
+    maximumPages: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPages),
+    maximumHierarchyDepth: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth),
+    maximumHierarchyNodes: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumHierarchyNodes),
+    maximumBricks: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumBricks),
+    maximumLogicalVoxels: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels),
+    maximumEncodedSurfaceSamples: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples),
+    maximumSurfaceProperties: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumSurfaceProperties),
+    maximumPhysicalPaletteRecords: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties),
+    maximumPhysicalEvidenceEntries: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries),
+    maximumMaterialRegions: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions),
+    maximumInteriorLayers: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumInteriorLayers),
+    maximumMassPropertyRecords: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumMassPropertyRecords),
+    maximumBondRecords: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumBondRecords),
+    maximumPartitions: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPartitions),
+    maximumLodCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumLodCount),
+    maximumCpuResidentBytes: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumCpuResidentBytes),
+    maximumGpuResidentBytes: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumGpuResidentBytes),
+  }, ["maximumArtifactBytes", "maximumPages", "maximumHierarchyDepth", "maximumHierarchyNodes", "maximumBricks", "maximumLogicalVoxels", "maximumEncodedSurfaceSamples", "maximumSurfaceProperties", "maximumPhysicalPaletteRecords", "maximumPhysicalEvidenceEntries", "maximumMaterialRegions", "maximumInteriorLayers", "maximumMassPropertyRecords", "maximumBondRecords", "maximumPartitions", "maximumLodCount", "maximumCpuResidentBytes", "maximumGpuResidentBytes"]),
+  pvoxRuntimeProfile: objectSchema({
+    profileId: token,
+    fidelityProfileId: { enum: PVOX_FIDELITY_PROFILE_IDS },
+    capabilityProfileId: { enum: PVOX_RUNTIME_CAPABILITY_PROFILE_IDS },
+    geometryMode: { enum: ["solid", "shell", "mixed", "auto"] },
+    requiredCapabilities: { ...arraySchema({ enum: PVOX_CAPABILITIES }, 1, PVOX_CAPABILITIES.length), uniqueItems: true },
+    limits: ref("pvoxRuntimeLimits"),
+  }, ["profileId", "fidelityProfileId", "capabilityProfileId", "geometryMode", "requiredCapabilities", "limits"]),
+  modelRequestSpecV2: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_V2_CONTRACT_VERSION },
+    policyProfileId: { const: PVOX_MODEL_REQUEST_POLICY_ID },
+    requestSemanticProfileHash: sha256,
+    query: stringSchema(1_000),
+    revision: integerSchema(0, MODEL_REQUEST_MAX_REVISION),
+    locale: stringSchema(64),
+    rankerId: token,
+    hardConstraints: ref("hardConstraintsV2"),
+    softPreferences: ref("softPreferences"),
+    exclusions: arraySchema(stringSchema(256), 0, 32),
+    sourceIngestionLimits: ref("sourceIngestionLimits"),
+    pvoxRuntimeProfile: ref("pvoxRuntimeProfile"),
+  }, ["contractVersion", "policyProfileId", "requestSemanticProfileHash", "query", "revision", "hardConstraints", "softPreferences", "exclusions", "sourceIngestionLimits", "pvoxRuntimeProfile"]),
+  pvoxResource: objectSchema({
+    uri: {
+      type: "string",
+      maxLength: 512,
+      oneOf: [
+        { pattern: "^mcp://models/resolutions/[A-Za-z0-9._~-]+/candidates/[A-Za-z0-9._~-]+/artifacts/sha256/[a-f0-9]{64}\\.pvox$" },
+        {
+          pattern: "^mcp://models/catalog/[a-z0-9]+(?:-[a-z0-9]+)*/versions/[A-Za-z0-9][A-Za-z0-9._-]{0,127}/artifacts/sha256/[a-f0-9]{64}\\.pvox$",
+          not: mutableCatalogVersionPath,
+        },
+      ],
+    },
+    byteLength: { ...integerSchema(PVOX_PAGE_SIZE_BYTES, PVOX_DEFAULT_LIMITS.maximumArtifactBytes), multipleOf: PVOX_PAGE_SIZE_BYTES },
+    sha256,
+    contentType: { const: PVOX_CONTENT_TYPE },
+    authenticated: { const: true },
+  }, ["uri", "byteLength", "sha256", "contentType", "authenticated"]),
+  pvoxPageSpatialKey: objectSchema({
+    lodLevel: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumLodCount - 1),
+    partitionIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPartitions - 1),
+    hierarchyDepth: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth),
+    minimumMortonCode: { type: "string", pattern: "^[a-f0-9]{16}$" },
+    maximumMortonCode: { type: "string", pattern: "^[a-f0-9]{16}$" },
+  }, ["lodLevel", "partitionIndex", "hierarchyDepth", "minimumMortonCode", "maximumMortonCode"]),
+  pvoxPage: objectSchema({
+    pageIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPages - 1),
+    pageKind: { enum: PVOX_PAGE_KINDS },
+    byteOffset: { ...integerSchema(0, PVOX_DEFAULT_LIMITS.maximumArtifactBytes - 1), multipleOf: PVOX_PAGE_SIZE_BYTES },
+    byteLength: { const: PVOX_PAGE_SIZE_BYTES },
+    decodedByteLength: { const: PVOX_PAGE_SIZE_BYTES },
+    sha256,
+    spatialKey: ref("pvoxPageSpatialKey"),
+  }, ["pageIndex", "pageKind", "byteOffset", "byteLength", "decodedByteLength", "sha256"], {
+    allOf: [{
+      if: {
+        properties: { pageKind: { enum: ["render-field", "collision-field"] } },
+        required: ["pageKind"],
+      },
+      then: { properties: { spatialKey: ref("pvoxPageSpatialKey") }, required: ["spatialKey"] },
+      else: { not: { properties: { spatialKey: {} }, required: ["spatialKey"] } },
+    }],
+  }),
+  pvoxLod: objectSchema({
+    level: integerSchema(0, 3),
+    firstPageIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPages - 1),
+    pageCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPages),
+    brickCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumBricks),
+    cellSizeMetres: numberSchema(Number.EPSILON),
+    maximumSurfaceErrorMetres: numberSchema(0),
+    p99SurfaceErrorMetres: numberSchema(0),
+    silhouetteIou: numberSchema(0, 1),
+    maximumContourDisplacementPx: numberSchema(0),
+    renderedSsim: numberSchema(0, 1),
+    p95DeltaE2000: numberSchema(0, 100),
+    normalizedMaterialError: numberSchema(0, 1),
+  }, ["level", "firstPageIndex", "pageCount", "brickCount", "cellSizeMetres", "maximumSurfaceErrorMetres", "p99SurfaceErrorMetres", "silhouetteIou", "maximumContourDisplacementPx", "renderedSsim", "p95DeltaE2000", "normalizedMaterialError"]),
+  pvoxAssetManifest: objectSchema({
+    manifestVersion: { const: PVOX_ASSET_MANIFEST_VERSION },
+    representation: { const: "pvox" },
+    formatVersion: ref("pvoxFormatVersion"),
+    contentType: { const: PVOX_CONTENT_TYPE },
+    fileExtension: { const: PVOX_FILE_EXTENSION },
+    magic: { const: PVOX_MAGIC },
+    brickEdgeVoxels: { const: PVOX_BRICK_EDGE_VOXELS },
+    pageSizeBytes: { const: PVOX_PAGE_SIZE_BYTES },
+    geometryMode: { enum: ["solid", "shell", "mixed"] },
+    sourceContentHash: sha256,
+    canonicalDocumentHash: sha256,
+    rootHash: sha256,
+    directoryHash: sha256,
+    pageSetHash: sha256,
+    binaryClosureHash: sha256,
+    validationEvidenceHash: sha256,
+    compilationInputHash: sha256,
+    runtimeRequestProfileHash: sha256,
+    headerByteLength: { const: PVOX_HEADER_BYTE_LENGTH },
+    directoryEntryByteLength: { const: PVOX_DIRECTORY_ENTRY_BYTE_LENGTH },
+    sectionCount: integerSchema(PVOX_MIN_STATIC_SECTION_COUNT, PVOX_MAX_SECTIONS),
+    maximumRunsPerBrick: { const: PVOX_MAX_RUNS_PER_BRICK },
+    maximumLocalSamplesPerBrick: { const: PVOX_MAX_LOCAL_SAMPLES_PER_BRICK },
+    maximumEncodedBrickPayloadBytes: { const: PVOX_MAX_ENCODED_BRICK_PAYLOAD_BYTES },
+    coordinateSystem: ref("coordinateSystem"),
+    boundsMetres: ref("bounds"),
+    artifact: ref("pvoxResource"),
+    pages: arraySchema(ref("pvoxPage"), 1, PVOX_DEFAULT_LIMITS.maximumPages),
+    lods: arraySchema(ref("pvoxLod"), 1, PVOX_DEFAULT_LIMITS.maximumLodCount),
+  }, ["manifestVersion", "representation", "formatVersion", "contentType", "fileExtension", "magic", "brickEdgeVoxels", "pageSizeBytes", "geometryMode", "sourceContentHash", "canonicalDocumentHash", "rootHash", "directoryHash", "pageSetHash", "binaryClosureHash", "validationEvidenceHash", "compilationInputHash", "runtimeRequestProfileHash", "headerByteLength", "directoryEntryByteLength", "sectionCount", "maximumRunsPerBrick", "maximumLocalSamplesPerBrick", "maximumEncodedBrickPayloadBytes", "coordinateSystem", "boundsMetres", "artifact", "pages", "lods"]),
+  voxelTechnicalProfile: objectSchema({
+    boundsMetres: ref("bounds"),
+    dimensionsMetres: ref("dimensions"),
+    geometryMode: { enum: ["solid", "shell", "mixed"] },
+    artifactByteLength: { ...integerSchema(PVOX_PAGE_SIZE_BYTES, PVOX_DEFAULT_LIMITS.maximumArtifactBytes), multipleOf: PVOX_PAGE_SIZE_BYTES },
+    pageCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPages),
+    brickCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumBricks),
+    logicalVoxelCapacity: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels),
+    encodedSurfaceSampleCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples),
+    surfacePropertyCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumSurfaceProperties),
+    sectionCount: integerSchema(PVOX_MIN_STATIC_SECTION_COUNT, PVOX_MAX_SECTIONS),
+    levelSpanRecordCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPartitions * PVOX_DEFAULT_LIMITS.maximumLodCount * (PVOX_DEFAULT_LIMITS.maximumHierarchyDepth + 1)),
+    physicalPaletteRecordCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties),
+    physicalEvidenceRecordCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries),
+    materialRegionCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions),
+    interiorLayerRecordCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumInteriorLayers),
+    massPropertyRecordCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumMassPropertyRecords),
+    bondRecordCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumBondRecords),
+    hierarchyDepth: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth),
+    hierarchyNodeCount: integerSchema(1, PVOX_MAX_HIERARCHY_NODES),
+    lodCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumLodCount),
+    collisionHierarchyNodeCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumHierarchyNodes),
+    collisionBrickCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumBricks),
+    collisionLogicalVoxelCapacity: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumLogicalVoxels),
+    collisionEncodedSurfaceSampleCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumEncodedSurfaceSamples),
+    cpuResidentByteLength: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumCpuResidentBytes),
+    gpuResidentByteLength: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumGpuResidentBytes),
+    hasCollision: { type: "boolean" },
+    partitionCount: integerSchema(1, PVOX_DEFAULT_LIMITS.maximumPartitions),
+    maximumPartitionExtentMetres: numberSchema(Number.EPSILON, PVOX_MAX_ABSOLUTE_COORDINATE_METRES * 2),
+    maximumPartitionDiagonalMetres: numberSchema(Number.EPSILON, PVOX_MAX_ABSOLUTE_COORDINATE_METRES * Math.sqrt(12)),
+  }, ["boundsMetres", "dimensionsMetres", "geometryMode", "artifactByteLength", "pageCount", "brickCount", "logicalVoxelCapacity", "encodedSurfaceSampleCount", "surfacePropertyCount", "sectionCount", "levelSpanRecordCount", "physicalPaletteRecordCount", "physicalEvidenceRecordCount", "materialRegionCount", "interiorLayerRecordCount", "massPropertyRecordCount", "bondRecordCount", "hierarchyDepth", "hierarchyNodeCount", "lodCount", "collisionHierarchyNodeCount", "collisionBrickCount", "collisionLogicalVoxelCapacity", "collisionEncodedSurfaceSampleCount", "cpuResidentByteLength", "gpuResidentByteLength", "hasCollision", "partitionCount", "maximumPartitionExtentMetres", "maximumPartitionDiagonalMetres"]),
+  voxelCapabilityAssessment: objectSchema({
+    capability: { enum: PVOX_CAPABILITIES },
+    status: { enum: ["supported", "unsupported", "not-applicable"] },
+    evaluatorId: token,
+    evaluatorVersion: immutableVersion,
+    subjectContentHash: sha256,
+    evidenceHash: sha256,
+    reasonCodes,
+    evaluatedAt: timestamp,
+  }, ["capability", "status", "evaluatorId", "evaluatorVersion", "subjectContentHash", "evidenceHash", "reasonCodes", "evaluatedAt"], {
+    allOf: [
+      {
+        if: { properties: { status: { const: "supported" } }, required: ["status"] },
+        then: { properties: { reasonCodes: { ...reasonCodes, maxItems: 0 } } },
+        else: { properties: { reasonCodes: { ...reasonCodes, minItems: 1 } } },
+      },
+    ],
+  }),
+  physicalPropertyEvidence: objectSchema({
+    property: { enum: PVOX_PHYSICAL_PROPERTIES },
+    value: numberSchema(),
+    unit: stringSchema(32),
+    provenance: { enum: ["source", "authored", "derived", "inferred", "default"] },
+    confidence: numberSchema(0, 1),
+    subjectContentHash: sha256,
+    regionId: token,
+    materialId: token,
+    policyId: { const: PVOX_PHYSICAL_PROPERTY_POLICY_ID },
+    policyVersion: { const: PVOX_PHYSICAL_PROPERTY_POLICY_VERSION },
+    evidenceHash: sha256,
+    reviewedBy: token,
+    reviewedAt: timestamp,
+    reviewToken: attestation,
+  }, ["property", "value", "unit", "provenance", "confidence", "subjectContentHash", "regionId", "materialId", "policyId", "policyVersion", "evidenceHash"], {
+    dependentRequired: {
+      reviewedBy: ["reviewedAt", "reviewToken"],
+      reviewedAt: ["reviewedBy", "reviewToken"],
+      reviewToken: ["reviewedBy", "reviewedAt"],
+    },
+    allOf: [
+      {
+        if: { properties: { provenance: { const: "inferred" } }, required: ["provenance"] },
+        then: {
+          properties: { reviewedBy: token, reviewedAt: timestamp, reviewToken: attestation },
+          required: ["reviewedBy", "reviewedAt", "reviewToken"],
+        },
+      },
+      {
+        oneOf: Object.entries(PVOX_PHYSICAL_PROPERTY_POLICIES).map(([property, policy]) => ({
+          properties: {
+            property: { const: property },
+            unit: { const: policy.unit },
+            value: numberSchema(policy.minimum, policy.maximum),
+          },
+          required: ["property", "unit", "value"],
+        })),
+      },
+    ],
+  }),
+  pvoxFidelityEvidence: objectSchema({
+    profileId: { enum: PVOX_FIDELITY_PROFILE_IDS },
+    surfaceProfileId: { enum: ["precision-hero-v1", "props-furniture-v1", "rocks-organic-shells-v1", "buildings-v1"] },
+    profileVersion: { const: PVOX_FIDELITY_PROFILE_VERSION },
+    outcome: { enum: ["passed", "blocked"] },
+    canonicalDocumentHash: sha256,
+    pvoxBinaryClosureHash: sha256,
+    evaluatedDiagonalMetres: numberSchema(Number.EPSILON),
+    lod0CellSizeMetres: numberSchema(Number.EPSILON),
+    maximumAllowedSurfaceErrorMetres: numberSchema(0),
+    maximumSurfaceErrorMetres: numberSchema(0),
+    p99AllowedSurfaceErrorMetres: numberSchema(0),
+    p99SurfaceErrorMetres: numberSchema(0),
+    minimumSilhouetteIou: { const: 0.995 },
+    silhouetteIou: numberSchema(0, 1),
+    maximumAllowedContourDisplacementPx: { const: 0.5 },
+    maximumContourDisplacementPx: numberSchema(0),
+    minimumRenderedSsim: { const: 0.98 },
+    renderedSsim: numberSchema(0, 1),
+    maximumP95DeltaE2000: { const: 3 },
+    p95DeltaE2000: numberSchema(0, 100),
+    maximumNormalizedMaterialError: { const: 1 / 255 },
+    normalizedMaterialError: numberSchema(0, 1),
+    evidenceHash: sha256,
+    evaluatedAt: timestamp,
+    decisionToken: attestation,
+  }, ["profileId", "surfaceProfileId", "profileVersion", "outcome", "canonicalDocumentHash", "pvoxBinaryClosureHash", "evaluatedDiagonalMetres", "lod0CellSizeMetres", "maximumAllowedSurfaceErrorMetres", "maximumSurfaceErrorMetres", "p99AllowedSurfaceErrorMetres", "p99SurfaceErrorMetres", "minimumSilhouetteIou", "silhouetteIou", "maximumAllowedContourDisplacementPx", "maximumContourDisplacementPx", "minimumRenderedSsim", "renderedSsim", "maximumP95DeltaE2000", "p95DeltaE2000", "maximumNormalizedMaterialError", "normalizedMaterialError", "evidenceHash", "evaluatedAt", "decisionToken"]),
+  pvoxBrickPatch: objectSchema({
+    fieldKind: { enum: ["render-field", "collision-field"] },
+    lodLevel: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumLodCount - 1),
+    partitionIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPartitions - 1),
+    hierarchyDepth: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumHierarchyDepth),
+    mortonCode: { type: "string", pattern: "^[a-f0-9]{16}$" },
+    expectedPageIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPages - 1),
+    expectedPageHash: sha256,
+    operation: { enum: ["insert", "replace", "remove"] },
+    expectedBrickHash: sha256,
+    resultingBrickHash: sha256,
+    resultingPageHash: sha256,
+  }, ["fieldKind", "lodLevel", "partitionIndex", "hierarchyDepth", "mortonCode", "expectedPageIndex", "expectedPageHash", "operation", "expectedBrickHash", "resultingBrickHash", "resultingPageHash"]),
+  pvoxEditJournal: objectSchema({
+    journalVersion: { const: PVOX_EDIT_JOURNAL_VERSION },
+    baseContentHash: sha256,
+    basePageSetHash: sha256,
+    placementId: token,
+    gridVersion: token,
+    operationId: token,
+    expectedRevision: integerSchema(0),
+    resultingRevision: integerSchema(1),
+    previousJournalHash: sha256,
+    expectedRootHash: sha256,
+    resultingRootHash: sha256,
+    resultingRootHashAttestation: ref("pvoxEditOverlayRootHashAttestation"),
+    patches: arraySchema(ref("pvoxBrickPatch"), 1, PVOX_MAX_EDIT_PATCHES),
+    dirtyBoundsMetres: ref("bounds"),
+    massDeltaKg: numberSchema(),
+    journalHash: sha256,
+    journalHashAttestation: ref("pvoxEditJournalHashAttestation"),
+    recordedAt: timestamp,
+  }, ["journalVersion", "baseContentHash", "basePageSetHash", "placementId", "gridVersion", "operationId", "expectedRevision", "resultingRevision", "previousJournalHash", "expectedRootHash", "resultingRootHash", "resultingRootHashAttestation", "patches", "dirtyBoundsMetres", "massDeltaKg", "journalHash", "journalHashAttestation", "recordedAt"]),
+  pvoxGateEvidence: objectSchema({
+    kind: { enum: PVOX_NON_OVERRIDABLE_GATE_KINDS },
+    outcome: { enum: ["passed", "blocked"] },
+    validatorId: token,
+    validatorVersion: immutableVersion,
+    subjectContentHash: sha256,
+    evidenceHash: sha256,
+    reasonCodes,
+    evaluatedAt: timestamp,
+    attestationToken: attestation,
+  }, ["kind", "outcome", "validatorId", "validatorVersion", "subjectContentHash", "evidenceHash", "reasonCodes", "evaluatedAt", "attestationToken"]),
+  compilerEvidence: objectSchema({
+    compilerId: token,
+    compilerVersion: immutableVersion,
+    sourceFormat: token,
+    sourceContentHash: sha256,
+    canonicalDocumentHash: sha256,
+    compilationInputHash: sha256,
+    runtimeRequestProfileHash: sha256,
+    outputContentHash: sha256,
+    evidenceHash: sha256,
+    compiledAt: timestamp,
+  }, ["compilerId", "compilerVersion", "sourceFormat", "sourceContentHash", "canonicalDocumentHash", "compilationInputHash", "runtimeRequestProfileHash", "outputContentHash", "evidenceHash", "compiledAt"]),
+  physicalRegionInventoryEntry: objectSchema({
+    regionIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumMaterialRegions - 1),
+    physicalPaletteIndex: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumPhysicalProperties - 1),
+    regionId: token,
+    materialId: token,
+  }, ["regionIndex", "physicalPaletteIndex", "regionId", "materialId"]),
+  physicalRegionInventory: objectSchema({
+    inventoryVersion: { const: PVOX_PHYSICAL_REGION_INVENTORY_VERSION },
+    subjectContentHash: sha256,
+    inventoryHash: sha256,
+    inventoryHashAttestation: ref("pvoxPhysicalInventoryHashAttestation"),
+    validationEvidenceHash: sha256,
+    entries: arraySchema(ref("physicalRegionInventoryEntry"), 1, PVOX_DEFAULT_LIMITS.maximumMaterialRegions),
+  }, ["inventoryVersion", "subjectContentHash", "inventoryHash", "inventoryHashAttestation", "validationEvidenceHash", "entries"]),
+  reviewedStructuralEvidence: objectSchema({
+    kind: { enum: ["mass-properties", "bond-graph", "interior-layers"] },
+    subjectContentHash: sha256,
+    physicalInventoryHash: sha256,
+    recordCount: integerSchema(0, PVOX_DEFAULT_LIMITS.maximumBondRecords),
+    evidenceHash: sha256,
+    reviewerId: token,
+    reviewedAt: timestamp,
+    reviewToken: attestation,
+  }, ["kind", "subjectContentHash", "physicalInventoryHash", "recordCount", "evidenceHash", "reviewerId", "reviewedAt", "reviewToken"]),
+  transform: objectSchema({ translationMetres: vector3, rotationQuaternion: quaternion, scale: positiveVector3 }, ["translationMetres", "rotationQuaternion", "scale"]),
+  modelAssetRef: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_CONTRACT_VERSION },
+    assetId: { type: "string", pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+    version: immutableVersion,
+    kind: { enum: MODEL_ASSET_KINDS },
+    contentHash: sha256,
+    runtimeManifestUri: { type: "string", pattern: "^mcp://models/catalog/[a-z0-9]+(?:-[a-z0-9]+)*/versions/[A-Za-z0-9][A-Za-z0-9._-]*/manifest$" },
+  }, ["contractVersion", "assetId", "version", "kind", "contentHash", "runtimeManifestUri"]),
+  existingAssemblyChildRef: objectSchema({
+    disposition: { const: "existing" },
+    representation: { const: "pvox" },
+    asset: ref("modelAssetRef"),
+    processingManifestId: token,
+    binaryClosureHash: sha256,
+    processingClosureHash: sha256,
+    processingManifestUri: { type: "string", pattern: "^mcp://models/catalog/.+/processing-manifest$" },
+  }, ["disposition", "representation", "asset", "processingManifestId", "binaryClosureHash", "processingClosureHash", "processingManifestUri"]),
+  stagedAssemblyChildRef: objectSchema({
+    disposition: { const: "staged-derived" },
+    representation: { const: "pvox" },
+    derivedId: pathSegment,
+    kind: { const: "leaf" },
+    contentHash: sha256,
+    binaryClosureHash: sha256,
+    processingClosureHash: sha256,
+    processingManifestId: token,
+    processingManifestUri: { type: "string", pattern: "^mcp://models/resolutions/.+/processing-manifest$" },
+  }, ["disposition", "representation", "derivedId", "kind", "contentHash", "binaryClosureHash", "processingClosureHash", "processingManifestId", "processingManifestUri"]),
+  assemblyChild: objectSchema({
+    instanceId: token,
+    parentInstanceId: token,
+    assetRef: { oneOf: [ref("existingAssemblyChildRef"), ref("stagedAssemblyChildRef")] },
+    transform: ref("transform"),
+  }, ["instanceId", "assetRef", "transform"]),
+  modelProcessingManifest: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_V2_CONTRACT_VERSION },
+    representation: { const: "pvox" },
+    manifestId: token,
+    resolutionId: pathSegment,
+    candidateId: pathSegment,
+    kind: { enum: MODEL_ASSET_KINDS },
+    requestProfileId: token,
+    requestSemanticProfileHash: sha256,
+    capabilityProfileId: { enum: PVOX_RUNTIME_CAPABILITY_PROFILE_IDS },
+    contentHash: sha256,
+    binaryClosureHash: sha256,
+    processingClosureHash: sha256,
+    processingClosureAttestation: ref("pvoxProcessingClosureHashAttestation"),
+    assemblyClosureHash: sha256,
+    assemblyClosureAttestation: ref("pvoxAssemblyClosureHashAttestation"),
+    compilationInputHash: sha256,
+    runtimeRequestProfileHash: sha256,
+    coordinateSystem: ref("coordinateSystem"),
+    pvox: ref("pvoxAssetManifest"),
+    technicalProfile: ref("voxelTechnicalProfile"),
+    requiredCapabilities: { ...arraySchema({ enum: PVOX_CAPABILITIES }, 1, PVOX_CAPABILITIES.length), uniqueItems: true },
+    capabilities: { ...arraySchema(ref("voxelCapabilityAssessment"), PVOX_CAPABILITIES.length, PVOX_CAPABILITIES.length), uniqueItems: true },
+    capabilityEvidenceSetHash: sha256,
+    capabilityEvidenceSetAttestation: ref("pvoxCapabilitySetHashAttestation"),
+    physicalRegionInventory: ref("physicalRegionInventory"),
+    physicalProperties: arraySchema(ref("physicalPropertyEvidence"), 0, PVOX_DEFAULT_LIMITS.maximumPhysicalEvidenceEntries),
+    physicalEvidenceHash: sha256,
+    physicalEvidenceAttestation: ref("pvoxPhysicalEvidenceHashAttestation"),
+    massPropertiesEvidence: ref("reviewedStructuralEvidence"),
+    bondGraphEvidence: ref("reviewedStructuralEvidence"),
+    interiorLayerEvidence: ref("reviewedStructuralEvidence"),
+    converter: ref("compilerEvidence"),
+    fidelity: ref("pvoxFidelityEvidence"),
+    children: arraySchema(ref("assemblyChild"), 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren),
+    processedAt: timestamp,
+  }, ["contractVersion", "representation", "manifestId", "resolutionId", "candidateId", "kind", "requestProfileId", "requestSemanticProfileHash", "capabilityProfileId", "contentHash", "binaryClosureHash", "processingClosureHash", "processingClosureAttestation", "assemblyClosureHash", "assemblyClosureAttestation", "compilationInputHash", "runtimeRequestProfileHash", "coordinateSystem", "pvox", "technicalProfile", "requiredCapabilities", "capabilities", "capabilityEvidenceSetHash", "capabilityEvidenceSetAttestation", "physicalRegionInventory", "physicalProperties", "physicalEvidenceHash", "physicalEvidenceAttestation", "massPropertiesEvidence", "bondGraphEvidence", "interiorLayerEvidence", "converter", "fidelity", "children", "processedAt"]),
+  hardConstraintsV1: objectSchema({
+    boundsMetres: ref("bounds"),
+    dimensionsMetres: ref("dimensions"),
+    maxTriangles: integerSchema(1, STATIC_WORLD_V1_MODEL_POLICY.maxTriangles),
+    maxBytes: integerSchema(1, STATIC_WORLD_V1_MODEL_POLICY.maxBytes),
+    maxTextureBytes: integerSchema(1, STATIC_WORLD_V1_MODEL_POLICY.maxTextureBytes),
+    maxTextureDimensionPx: integerSchema(1, STATIC_WORLD_V1_MODEL_POLICY.maxTextureDimensionPx),
+    maxPartitionCellMetres: numberSchema(Number.EPSILON, STATIC_WORLD_V1_MODEL_POLICY.maxPartitionCellMetres),
+    lod: { enum: ["required", "optional", "forbidden"] },
+    collision: { enum: ["required", "optional", "forbidden"] },
+    partition: { enum: ["single", "allowed", "required"] },
+  }, ["maxTriangles", "maxBytes", "maxTextureBytes", "maxTextureDimensionPx", "maxPartitionCellMetres", "lod", "collision", "partition"]),
+  modelRequestSpecV1: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_CONTRACT_VERSION },
+    policyProfileId: { const: STATIC_WORLD_V1_MODEL_POLICY.id },
+    query: stringSchema(1_000),
+    revision: integerSchema(0, MODEL_REQUEST_MAX_REVISION),
+    locale: stringSchema(64),
+    rankerId: token,
+    hardConstraints: ref("hardConstraintsV1"),
+    softPreferences: ref("softPreferences"),
+    exclusions: arraySchema(stringSchema(256), 0, 32),
+  }, ["contractVersion", "policyProfileId", "query", "revision", "hardConstraints", "softPreferences", "exclusions"]),
+  rankerRef: objectSchema({
+    id: token,
+    version: immutableVersion,
+    calibrationId: token,
+    calibrationVersion: immutableVersion,
+    evidenceMode: { enum: MODEL_RANKER_EVIDENCE_MODES },
+    assuranceCeiling: { enum: MODEL_MATCH_ASSURANCE_BANDS },
+  }, ["id", "version", "calibrationId", "calibrationVersion", "evidenceMode", "assuranceCeiling"]),
+  modelMatchAssessment: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_CONTRACT_VERSION },
+    score: numberSchema(0, 1),
+    assurance: { enum: MODEL_MATCH_ASSURANCE_BANDS },
+    hardConstraintPass: { type: "boolean" },
+    exactMatch: { type: "boolean" },
+    reasonCodes: releasedV1ReasonCodes,
+    ranker: ref("rankerRef"),
+    fidelityWarnings: arraySchema(stringSchema(256), 0, 32),
+    request: ref("modelRequestSpecV1"),
+    candidateId: pathSegment,
+    candidateContentHash: sha256,
+    requestSemanticProfileHash: sha256,
+    requestSemanticProfileCanonical: stringSchema(65_536),
+    evidenceHash: sha256,
+  }, ["contractVersion", "score", "assurance", "hardConstraintPass", "exactMatch", "reasonCodes", "ranker", "fidelityWarnings", "request", "candidateId", "candidateContentHash", "requestSemanticProfileHash", "requestSemanticProfileCanonical", "evidenceHash"]),
+  provenance: objectSchema({
+    kind: { enum: MODEL_PROVENANCE_KINDS },
+    sourceId: token,
+    sourceAssetId: opaqueSourceAssetId,
+    sourcePageUri: { type: "string", pattern: "^https://", maxLength: 2_048 },
+    contentHash: sha256,
+    capturedAt: timestamp,
+  }, ["kind", "sourceId", "sourceAssetId", "contentHash", "capturedAt"]),
+  attribution: objectSchema({
+    title: stringSchema(256),
+    creator: stringSchema(256),
+    notice: stringSchema(512),
+    sourcePageUri: { type: "string", pattern: "^https://", maxLength: 2_048 },
+  }, ["title", "creator", "notice"]),
+  rights: objectSchema({
+    decisionId: token,
+    decisionToken: attestation,
+    policyId: token,
+    policyVersion: immutableVersion,
+    sourceId: token,
+    sourceAssetId: opaqueSourceAssetId,
+    sourceContentHash: sha256,
+    status: { enum: MODEL_RIGHTS_STATUSES },
+    licenseId: token,
+    evidencePageUri: { type: "string", pattern: "^https://", maxLength: 2_048 },
+    attribution: ref("attribution"),
+    reviewedAt: timestamp,
+  }, ["decisionId", "decisionToken", "policyId", "policyVersion", "sourceId", "sourceAssetId", "sourceContentHash", "status", "licenseId", "evidencePageUri", "reviewedAt"]),
+  existingCandidateAssetRef: objectSchema({ disposition: { const: "existing" }, kind: { enum: MODEL_ASSET_KINDS }, contentHash: sha256, asset: ref("modelAssetRef") }, ["disposition", "kind", "contentHash", "asset"]),
+  proposedCandidateAssetRef: objectSchema({ disposition: { const: "proposed" }, proposalId: token, kind: { enum: MODEL_ASSET_KINDS }, contentHash: sha256 }, ["disposition", "proposalId", "kind", "contentHash"]),
+  confirmationView: objectSchema({
+    kind: { enum: MODEL_CONFIRMATION_VIEW_KINDS },
+    imageUri: { type: "string", pattern: "^mcp://models/resolutions/.+\\.png$", maxLength: 512 },
+    sha256,
+    contentType: { const: "image/png" },
+    width: { const: MODEL_CONFIRMATION_VIEW_SIZE_PX },
+    height: { const: MODEL_CONFIRMATION_VIEW_SIZE_PX },
+  }, ["kind", "imageUri", "sha256", "contentType", "width", "height"]),
+  renderEvidence: objectSchema({
+    renderId: token,
+    representation: { const: "pvox" },
+    lodLevel: { const: 0 },
+    traversalBackend: { const: "native-pvox" },
+    rendererId: { const: PVOX_NATIVE_RENDERER_ID },
+    rendererVersion: immutableVersion,
+    rendererQualificationHash: sha256,
+    settingsId: { const: PVOX_NATIVE_REVIEW_SETTINGS_ID },
+    settingsVersion: immutableVersion,
+    cameraQualificationHash: sha256,
+    processingManifestId: token,
+    processingClosureHash: sha256,
+    pvoxContentHash: sha256,
+    pvoxRootHash: sha256,
+    pvoxDirectoryHash: sha256,
+    pvoxPageSetHash: sha256,
+    viewSha256s: shaTuple,
+    renderedAt: timestamp,
+    evidenceHash: sha256,
+    evidenceHashAttestation: ref("pvoxRenderEvidenceHashAttestation"),
+  }, ["renderId", "representation", "lodLevel", "traversalBackend", "rendererId", "rendererVersion", "rendererQualificationHash", "settingsId", "settingsVersion", "cameraQualificationHash", "processingManifestId", "processingClosureHash", "pvoxContentHash", "pvoxRootHash", "pvoxDirectoryHash", "pvoxPageSetHash", "viewSha256s", "renderedAt", "evidenceHash", "evidenceHashAttestation"]),
+  confirmationBinding: objectSchema({
+    bindingHash: sha256,
+    bindingHashAttestation: ref("pvoxConfirmationBindingHashAttestation"),
+    resolutionId: pathSegment,
+    requesterId: token,
+    request: ref("modelRequestSpecV2"),
+    requestSemanticProfileHash: sha256,
+    requestRevision: integerSchema(0, MODEL_REQUEST_MAX_REVISION),
+    candidateId: pathSegment,
+    candidateContentHash: sha256,
+    candidateAssetRef: { oneOf: [ref("existingCandidateAssetRef"), ref("proposedCandidateAssetRef")] },
+    match: ref("modelMatchAssessment"),
+    provenance: ref("provenance"),
+    rights: ref("rights"),
+    sourceContentHash: sha256,
+    binaryClosureHash: sha256,
+    pvoxRootHash: sha256,
+    pvoxDirectoryHash: sha256,
+    pvoxPageSetHash: sha256,
+    compilationInputHash: sha256,
+    runtimeRequestProfileHash: sha256,
+    processingClosureHash: sha256,
+    assemblyClosureHash: sha256,
+    evaluationClosureHash: sha256,
+    capabilityEvidenceSetHash: sha256,
+    hardGates: { ...arraySchema(ref("pvoxGateEvidence"), PVOX_NON_OVERRIDABLE_GATE_KINDS.length, PVOX_NON_OVERRIDABLE_GATE_KINDS.length), uniqueItems: true },
+    viewSha256s: shaTuple,
+    rightsDecisionId: token,
+    fidelityEvidenceHash: sha256,
+    physicalEvidenceHash: sha256,
+    rendererId: { const: PVOX_NATIVE_RENDERER_ID },
+    rendererVersion: immutableVersion,
+    rendererEvidenceHash: sha256,
+    renderEvidence: ref("renderEvidence"),
+  }, ["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"]),
+  modelCandidate: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_V2_CONTRACT_VERSION },
+    resolutionId: pathSegment,
+    requesterId: token,
+    candidateId: pathSegment,
+    request: ref("modelRequestSpecV2"),
+    admissionStatus: { enum: ["confirmable", "diagnostic"] },
+    assetRef: { oneOf: [ref("existingCandidateAssetRef"), ref("proposedCandidateAssetRef")] },
+    match: ref("modelMatchAssessment"),
+    provenance: ref("provenance"),
+    rights: ref("rights"),
+    processingManifest: ref("modelProcessingManifest"),
+    views: arraySchema(ref("confirmationView"), 4, 4),
+    renderEvidence: ref("renderEvidence"),
+    evaluationClosureHash: sha256,
+    evaluationClosureAttestation: ref("pvoxEvaluationClosureHashAttestation"),
+    hardGates: { ...arraySchema(ref("pvoxGateEvidence"), PVOX_NON_OVERRIDABLE_GATE_KINDS.length, PVOX_NON_OVERRIDABLE_GATE_KINDS.length), uniqueItems: true },
+    confirmationBinding: ref("confirmationBinding"),
+    confirmationToken: attestation,
+    blockingReasonCodes: arraySchema(reasonCode, 1, 256),
+    confirmationRequired: { type: "boolean" },
+  }, ["contractVersion", "resolutionId", "requesterId", "candidateId", "request", "admissionStatus", "assetRef", "match", "provenance", "rights", "processingManifest", "views", "renderEvidence", "evaluationClosureHash", "evaluationClosureAttestation", "hardGates", "confirmationRequired"], {
+    oneOf: [
+      {
+        properties: {
+          admissionStatus: { const: "confirmable" },
+          confirmationRequired: { const: true },
+          confirmationBinding: ref("confirmationBinding"),
+          confirmationToken: attestation,
+          blockingReasonCodes: arraySchema(reasonCode, 1, 256),
+        },
+        required: ["admissionStatus", "confirmationRequired", "confirmationBinding", "confirmationToken"],
+        not: { required: ["blockingReasonCodes"], properties: { blockingReasonCodes: {} } },
+      },
+      {
+        properties: {
+          admissionStatus: { const: "diagnostic" },
+          confirmationRequired: { const: false },
+          blockingReasonCodes: arraySchema(reasonCode, 1, 256),
+          confirmationBinding: ref("confirmationBinding"),
+          confirmationToken: attestation,
+        },
+        required: ["admissionStatus", "confirmationRequired", "blockingReasonCodes"],
+        not: {
+          anyOf: [
+            { required: ["confirmationBinding"], properties: { confirmationBinding: {} } },
+            { required: ["confirmationToken"], properties: { confirmationToken: {} } },
+          ],
+        },
+      },
+    ],
+  }),
+  modelCandidateConfirmation: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_V2_CONTRACT_VERSION },
+    confirmationId: token,
+    resolutionId: pathSegment,
+    requesterId: token,
+    candidateId: pathSegment,
+    confirmationToken: attestation,
+    confirmationBindingHash: sha256,
+    viewSha256s: shaTuple,
+    confirmedBy: stringSchema(256),
+    confirmedAt: timestamp,
+    semanticRiskAccepted: { type: "boolean" },
+  }, ["contractVersion", "confirmationId", "resolutionId", "requesterId", "candidateId", "confirmationToken", "confirmationBindingHash", "viewSha256s", "confirmedBy", "confirmedAt", "semanticRiskAccepted"]),
+  modelPromotionReceipt: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_V2_CONTRACT_VERSION },
+    promotionId: token,
+    resolutionId: pathSegment,
+    requesterId: token,
+    candidateId: pathSegment,
+    proposalId: token,
+    candidateAssetRef: ref("proposedCandidateAssetRef"),
+    confirmationId: token,
+    confirmationBindingHash: sha256,
+    processingManifestId: token,
+    processingContentHash: sha256,
+    processingClosureHash: sha256,
+    assemblyClosureHash: sha256,
+    assemblyChildClosureHashes: arraySchema(sha256, 0, PVOX_DEFAULT_LIMITS.maximumAssemblyChildren),
+    finalAssetRef: ref("modelAssetRef"),
+    creditsRecordHash: sha256,
+    catalogRowHash: sha256,
+    indexSnapshotHash: sha256,
+    catalogPointerEtag: token,
+    indexPointerEtag: token,
+    publicationState: { const: "pointer-last-complete" },
+    creditsWrittenAt: timestamp,
+    catalogRowWrittenAt: timestamp,
+    indexSnapshotWrittenAt: timestamp,
+    pointerPublishedAt: timestamp,
+    publicationHash: sha256,
+    publicationHashAttestation: ref("pvoxPublicationHashAttestation"),
+    promotedAt: timestamp,
+    publicationToken: attestation,
+  }, ["contractVersion", "promotionId", "resolutionId", "requesterId", "candidateId", "proposalId", "candidateAssetRef", "confirmationId", "confirmationBindingHash", "processingManifestId", "processingContentHash", "processingClosureHash", "assemblyClosureHash", "assemblyChildClosureHashes", "finalAssetRef", "creditsRecordHash", "catalogRowHash", "indexSnapshotHash", "catalogPointerEtag", "indexPointerEtag", "publicationState", "creditsWrittenAt", "catalogRowWrittenAt", "indexSnapshotWrittenAt", "pointerPublishedAt", "publicationHash", "publicationHashAttestation", "promotedAt", "publicationToken"]),
+  modelRefinementQuestion: objectSchema({ questionId: token, prompt: stringSchema(500), reasonCodes }, ["questionId", "prompt", "reasonCodes"]),
+  modelResolution: objectSchema({
+    contractVersion: { const: MODEL_RESOLUTION_V2_CONTRACT_VERSION },
+    resolutionId: pathSegment,
+    requesterId: token,
+    request: ref("modelRequestSpecV2"),
+    attempts: integerSchema(1, 12),
+    state: { enum: MODEL_RESOLUTION_V2_STATES },
+    compatibilityState: { enum: MODEL_RESOLUTION_STATES },
+    candidates: arraySchema(ref("modelCandidate"), 0, 20),
+    bestCandidate: ref("modelCandidate"),
+    confirmation: ref("modelCandidateConfirmation"),
+    promotionReceipt: ref("modelPromotionReceipt"),
+    refinementQuestions: arraySchema(ref("modelRefinementQuestion"), 0, 3),
+    finalAssetRef: ref("modelAssetRef"),
+    stateReasonCode: reasonCode,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+  }, ["contractVersion", "resolutionId", "requesterId", "request", "attempts", "state", "compatibilityState", "candidates", "refinementQuestions", "createdAt", "updatedAt"], {
+    allOf: [
+      {
+        if: { properties: { state: { const: "awaiting-confirmation" } }, required: ["state"] },
+        then: {
+          properties: {
+            bestCandidate: {
+              type: "object",
+              properties: { admissionStatus: { const: "confirmable" } },
+              required: ["admissionStatus"],
+            },
+          },
+          required: ["bestCandidate"],
+        },
+      },
+      {
+        if: {
+          properties: {
+            state: { const: "awaiting-confirmation" },
+            bestCandidate: {
+              type: "object",
+              properties: {
+                match: {
+                  type: "object",
+                  properties: { assurance: { const: "low" } },
+                  required: ["assurance"],
+                },
+              },
+              required: ["match"],
+            },
+          },
+          required: ["state", "bestCandidate"],
+        },
+        then: {
+          properties: { refinementQuestions: arraySchema(ref("modelRefinementQuestion"), 1, 3) },
+          required: ["refinementQuestions"],
+        },
+      },
+      {
+        if: { properties: { state: { enum: ["promoting", "completed"] } }, required: ["state"] },
+        then: {
+          properties: {
+            bestCandidate: {
+              type: "object",
+              properties: { admissionStatus: { const: "confirmable" } },
+              required: ["admissionStatus"],
+            },
+            confirmation: ref("modelCandidateConfirmation"),
+          },
+          required: ["bestCandidate", "confirmation"],
+        },
+        else: {
+          not: {
+            properties: { confirmation: {} },
+            required: ["confirmation"],
+          },
+        },
+      },
+      {
+        if: { properties: { state: { const: "completed" } }, required: ["state"] },
+        then: {
+          properties: { finalAssetRef: ref("modelAssetRef") },
+          required: ["finalAssetRef"],
+        },
+        else: {
+          not: {
+            properties: { finalAssetRef: {} },
+            required: ["finalAssetRef"],
+          },
+        },
+      },
+      {
+        if: {
+          properties: {
+            state: { const: "completed" },
+            bestCandidate: {
+              type: "object",
+              properties: {
+                assetRef: {
+                  type: "object",
+                  properties: { disposition: { const: "proposed" } },
+                  required: ["disposition"],
+                },
+              },
+              required: ["assetRef"],
+            },
+          },
+          required: ["state", "bestCandidate"],
+        },
+        then: {
+          properties: { promotionReceipt: ref("modelPromotionReceipt") },
+          required: ["promotionReceipt"],
+        },
+        else: {
+          not: {
+            properties: { promotionReceipt: {} },
+            required: ["promotionReceipt"],
+          },
+        },
+      },
+      {
+        if: {
+          properties: { state: { enum: ["unresolved", "failed", "cancelled"] } },
+          required: ["state"],
+        },
+        then: {
+          properties: { stateReasonCode: reasonCode },
+          required: ["stateReasonCode"],
+        },
+        else: {
+          not: {
+            properties: { stateReasonCode: {} },
+            required: ["stateReasonCode"],
+          },
+        },
+      },
+    ],
+  }),
+};
+
+const frozenDefinitions = deepFreeze(definitions);
+
+function standaloneSchema(definitionName: string, title: string): PvoxModelResolutionJsonSchema {
+  const definition = frozenDefinitions[definitionName];
+  if (definition === undefined || definition.type !== "object" || definition.additionalProperties !== false) {
+    throw new Error("PVOX standalone schema requires a closed object definition.");
+  }
+  return deepFreeze({
+    $id: `https://schemas.plasius.com/asset-contracts/model-resolution/${MODEL_RESOLUTION_V2_CONTRACT_VERSION}/${definitionName}.schema.json`,
+    $schema: "https://json-schema.org/draft/2020-12/schema" as const,
+    title,
+    ...definition,
+    type: "object" as const,
+    additionalProperties: false as const,
+    $defs: frozenDefinitions,
+  });
+}
+
+/** Complete closed JSON Schema 2020-12 descriptors for MCP/admin consumers. */
+export const MODEL_RESOLUTION_V2_JSON_SCHEMAS = deepFreeze({
+  modelRequestSpec: standaloneSchema("modelRequestSpecV2", "ModelRequestSpecV2"),
+  pvoxAssetManifest: standaloneSchema("pvoxAssetManifest", "PvoxAssetManifestV1"),
+  voxelTechnicalProfile: standaloneSchema("voxelTechnicalProfile", "VoxelTechnicalProfile"),
+  voxelCapabilityAssessment: standaloneSchema("voxelCapabilityAssessment", "VoxelCapabilityAssessment"),
+  physicalPropertyEvidence: standaloneSchema("physicalPropertyEvidence", "PhysicalPropertyEvidence"),
+  pvoxEditJournal: standaloneSchema("pvoxEditJournal", "PvoxEditJournal"),
+  pvoxFidelityEvidence: standaloneSchema("pvoxFidelityEvidence", "PvoxFidelityEvidence"),
+  pvoxGateEvidence: standaloneSchema("pvoxGateEvidence", "PvoxGateEvidence"),
+  modelProcessingManifest: standaloneSchema("modelProcessingManifest", "ModelProcessingManifestV2"),
+  modelCandidate: standaloneSchema("modelCandidate", "ModelCandidateV2"),
+  modelCandidateConfirmation: standaloneSchema("modelCandidateConfirmation", "ModelCandidateConfirmationV2"),
+  modelPromotionReceipt: standaloneSchema("modelPromotionReceipt", "ModelPromotionReceiptV2"),
+  modelRefinementQuestion: standaloneSchema("modelRefinementQuestion", "ModelRefinementQuestionV2"),
+  modelResolution: standaloneSchema("modelResolution", "ModelResolutionV2"),
+});