@plasius/gpu-model-core 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -21,8 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CANONICAL_GPU_MODEL_COORDINATE_SYSTEM: () => CANONICAL_GPU_MODEL_COORDINATE_SYSTEM,
+  GPU_MODEL_DIAGNOSTIC_LIMITS: () => GPU_MODEL_DIAGNOSTIC_LIMITS,
   GPU_MODEL_DOCUMENT_LIMITS: () => GPU_MODEL_DOCUMENT_LIMITS,
   GPU_MODEL_DOCUMENT_SCHEMA_VERSION: () => GPU_MODEL_DOCUMENT_SCHEMA_VERSION,
+  GPU_MODEL_REPAIR_RULES: () => GPU_MODEL_REPAIR_RULES,
+  GPU_MODEL_RESOURCE_GRAPH_LIMITS: () => GPU_MODEL_RESOURCE_GRAPH_LIMITS,
+  GPU_MODEL_RESOURCE_GRAPH_SCHEMA_VERSION: () => GPU_MODEL_RESOURCE_GRAPH_SCHEMA_VERSION,
   GPU_MODEL_RESOURCE_VERIFICATION_LIMITS: () => GPU_MODEL_RESOURCE_VERIFICATION_LIMITS,
   GPU_MODEL_STATIC_DEMO_FEATURE_FLAG: () => GPU_MODEL_STATIC_DEMO_FEATURE_FLAG,
   GPU_MODEL_STATIC_DEMO_LIMITS: () => GPU_MODEL_STATIC_DEMO_LIMITS,
@@ -31,15 +35,21 @@ __export(index_exports, {
   GPU_MODEL_STATIC_DEMO_MAX_EXTENT_METRES: () => GPU_MODEL_STATIC_DEMO_MAX_EXTENT_METRES,
   GPU_MODEL_STATIC_DEMO_NORMALIZATION_CONTRACT: () => GPU_MODEL_STATIC_DEMO_NORMALIZATION_CONTRACT,
   GPU_MODEL_STATIC_DEMO_PROFILE_VERSION: () => GPU_MODEL_STATIC_DEMO_PROFILE_VERSION,
+  GpuModelDiagnosticsError: () => GpuModelDiagnosticsError,
   GpuModelDocumentError: () => GpuModelDocumentError,
+  GpuModelResourceGraphError: () => GpuModelResourceGraphError,
   assertGpuModelStaticDemoNormalization: () => assertGpuModelStaticDemoNormalization,
   canCreateGpuModelDocument: () => canCreateGpuModelDocument,
   createAndVerifyGpuModelDocument: () => createAndVerifyGpuModelDocument,
   createGpuModelDocument: () => createGpuModelDocument,
+  createGpuModelResourceGraph: () => createGpuModelResourceGraph,
   createGpuModelStaticDemoCompilerInput: () => createGpuModelStaticDemoCompilerInput,
   encodeGpuModelDocumentCanonical: () => encodeGpuModelDocumentCanonical,
+  evaluateGpuModelDiagnostics: () => evaluateGpuModelDiagnostics,
+  gpuModelResourceKey: () => gpuModelResourceKey,
   hashGpuModelDocumentCanonical: () => hashGpuModelDocumentCanonical,
   isGpuModelDocument: () => isGpuModelDocument,
+  isGpuModelResourceGraph: () => isGpuModelResourceGraph,
   packageBootstrap: () => packageBootstrap,
   packageName: () => packageName,
   verifyGpuModelResource: () => verifyGpuModelResource
@@ -220,9 +230,9 @@ function readRecord(value, path, allowedKeys) {
   }
   return value;
 }
-function requireKey(record, key, path) {
-  if (!Object.hasOwn(record, key)) return fail("invalid-value", `${path}.${key}`, "required key is missing");
-  return record[key];
+function requireKey(record3, key, path) {
+  if (!Object.hasOwn(record3, key)) return fail("invalid-value", `${path}.${key}`, "required key is missing");
+  return record3[key];
 }
 function readArray(value, path, maximum, minimum = 0) {
   if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
@@ -301,9 +311,9 @@ function readNumberTuple(value, path, length, minimum, maximum) {
   const input = readArray(value, path, length, length);
   return Object.freeze(input.map((entry, index) => readFinite(entry, `${path}[${index}]`, minimum, maximum)));
 }
-function readOptional(record, key, parser, path) {
-  if (!Object.hasOwn(record, key)) return void 0;
-  return parser(record[key], `${path}.${key}`);
+function readOptional(record3, key, parser, path) {
+  if (!Object.hasOwn(record3, key)) return void 0;
+  return parser(record3[key], `${path}.${key}`);
 }
 function assignOptional(target, key, value) {
   if (value !== void 0) Object.assign(target, { [key]: value });
@@ -325,17 +335,17 @@ function readMetadataValue(value, path, depth, budget) {
     return Object.freeze(input.map((entry, index) => readMetadataValue(entry, `${path}[${index}]`, depth + 1, budget)));
   }
   if (typeof value !== "object" || value === null) return fail("invalid-type", path, "metadata value is not JSON-compatible");
-  const record = value;
-  const prototype = Object.getPrototypeOf(record);
+  const record3 = value;
+  const prototype = Object.getPrototypeOf(record3);
   if (prototype !== Object.prototype && prototype !== null) return fail("invalid-type", path, "metadata objects must be plain objects");
-  const keys = Reflect.ownKeys(record);
+  const keys = Reflect.ownKeys(record3);
   if (keys.length > GPU_MODEL_DOCUMENT_LIMITS.metadataObjectKeys) return fail("limit-exceeded", path, "metadata object has too many keys");
   const output = {};
   for (const key of keys) {
     if (typeof key !== "string") return fail("unknown-key", path, "metadata symbol keys are not permitted");
     if (PROHIBITED_KEYS.has(key)) return fail("unknown-key", `${path}.${key}`, "prohibited metadata key");
     readString(key, `${path}.[key]`, GPU_MODEL_DOCUMENT_LIMITS.metadataKeyLength, METADATA_KEY);
-    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    const descriptor = Object.getOwnPropertyDescriptor(record3, key);
     if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) return fail("invalid-type", `${path}.${key}`, "metadata properties must be enumerable data properties");
     output[key] = readMetadataValue(descriptor.value, `${path}.${key}`, depth + 1, budget);
   }
@@ -348,9 +358,9 @@ function readMetadata(value, path, budget) {
 }
 function parseCoordinateSystem(value) {
   const path = "$.coordinateSystem";
-  const record = readRecord(value, path, ["unit", "upAxis", "forwardAxis", "handedness", "winding", "origin"]);
+  const record3 = readRecord(value, path, ["unit", "upAxis", "forwardAxis", "handedness", "winding", "origin"]);
   for (const [key, expected] of Object.entries(CANONICAL_GPU_MODEL_COORDINATE_SYSTEM)) {
-    if (requireKey(record, key, path) !== expected) return fail("invalid-value", `${path}.${key}`, "coordinate system is not canonical");
+    if (requireKey(record3, key, path) !== expected) return fail("invalid-value", `${path}.${key}`, "coordinate system is not canonical");
   }
   return CANONICAL_GPU_MODEL_COORDINATE_SYSTEM;
 }
@@ -362,19 +372,19 @@ function parseMatrix(value, path, requireAffine = true) {
   return matrix;
 }
 function parseBounds(value, path) {
-  const record = readRecord(value, path, ["min", "max"]);
-  const min = readNumberTuple(requireKey(record, "min", path), `${path}.min`, 3);
-  const max = readNumberTuple(requireKey(record, "max", path), `${path}.max`, 3);
+  const record3 = readRecord(value, path, ["min", "max"]);
+  const min = readNumberTuple(requireKey(record3, "min", path), `${path}.min`, 3);
+  const max = readNumberTuple(requireKey(record3, "max", path), `${path}.max`, 3);
   for (let index = 0; index < 3; index += 1) {
     if (min[index] > max[index]) return fail("invalid-value", path, "bounds min cannot exceed max");
   }
   return { min, max };
 }
 function parseTransformTrs(value, path) {
-  const record = readRecord(value, path, ["translation", "rotation", "scale"]);
-  const translation = readNumberTuple(requireKey(record, "translation", path), `${path}.translation`, 3);
-  const rotation = readNumberTuple(requireKey(record, "rotation", path), `${path}.rotation`, 4);
-  const scale = readNumberTuple(requireKey(record, "scale", path), `${path}.scale`, 3);
+  const record3 = readRecord(value, path, ["translation", "rotation", "scale"]);
+  const translation = readNumberTuple(requireKey(record3, "translation", path), `${path}.translation`, 3);
+  const rotation = readNumberTuple(requireKey(record3, "rotation", path), `${path}.rotation`, 4);
+  const scale = readNumberTuple(requireKey(record3, "scale", path), `${path}.scale`, 3);
   const magnitude = Math.hypot(...rotation);
   if (!almostEqual(magnitude, 1, 1e-4)) return fail("invalid-value", `${path}.rotation`, "rotation quaternion must be normalized");
   return { translation, rotation, scale };
@@ -396,25 +406,25 @@ function intrinsicBlobArrayBuffer(blob) {
   return Reflect.apply(blobArrayBuffer, blob, []);
 }
 function parseResourceHeader(value, path) {
-  const record = readRecord(value, path, ["id", "kind", "contentHash", "byteLength", "mimeType", "payload"]);
-  const kind = readEnum(requireKey(record, "kind", path), `${path}.kind`, ["buffer", "image"]);
-  const mimeType = readString(requireKey(record, "mimeType", path), `${path}.mimeType`, 128, MIME_TYPE).toLowerCase();
+  const record3 = readRecord(value, path, ["id", "kind", "contentHash", "byteLength", "mimeType", "payload"]);
+  const kind = readEnum(requireKey(record3, "kind", path), `${path}.kind`, ["buffer", "image"]);
+  const mimeType = readString(requireKey(record3, "mimeType", path), `${path}.mimeType`, 128, MIME_TYPE).toLowerCase();
   if (kind === "image" ? !IMAGE_MIME_TYPES.has(mimeType) : !BUFFER_MIME_TYPES.has(mimeType)) {
     return fail("invalid-value", `${path}.mimeType`, `unsupported ${kind} MIME type`);
   }
-  const payload = requireKey(record, "payload", path);
+  const payload = requireKey(record3, "payload", path);
   if (!(payload instanceof Blob)) return fail("invalid-type", `${path}.payload`, "expected an immutable Blob payload");
   if (Object.getPrototypeOf(payload) !== Blob.prototype || Reflect.ownKeys(payload).some((key) => typeof key === "string")) {
     return fail("invalid-type", `${path}.payload`, "expected a native Blob without caller-defined properties");
   }
-  const byteLength = readSafeInteger(requireKey(record, "byteLength", path), `${path}.byteLength`, 1);
+  const byteLength = readSafeInteger(requireKey(record3, "byteLength", path), `${path}.byteLength`, 1);
   if (intrinsicBlobSize(payload) !== byteLength) return fail("payload-length-mismatch", `${path}.payload`, "payload byte length does not match byteLength");
   const payloadType = intrinsicBlobType(payload);
   if (payloadType && payloadType.toLowerCase() !== mimeType) return fail("invalid-value", `${path}.payload`, "payload MIME type does not match mimeType");
   return {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
     kind,
-    contentHash: readSha256(requireKey(record, "contentHash", path), `${path}.contentHash`),
+    contentHash: readSha256(requireKey(record3, "contentHash", path), `${path}.contentHash`),
     byteLength,
     mimeType,
     payload
@@ -423,11 +433,11 @@ function parseResourceHeader(value, path) {
 function resolveVerificationLimits(options) {
   const overrides = options?.limits;
   if (overrides === void 0) return GPU_MODEL_RESOURCE_VERIFICATION_LIMITS;
-  const record = readRecord(overrides, "$.verification.limits", Object.keys(GPU_MODEL_RESOURCE_VERIFICATION_LIMITS));
+  const record3 = readRecord(overrides, "$.verification.limits", Object.keys(GPU_MODEL_RESOURCE_VERIFICATION_LIMITS));
   const output = { ...GPU_MODEL_RESOURCE_VERIFICATION_LIMITS };
   for (const [key, ceiling] of Object.entries(GPU_MODEL_RESOURCE_VERIFICATION_LIMITS)) {
-    if (!Object.hasOwn(record, key)) continue;
-    const value = readSafeInteger(record[key], `$.verification.limits.${key}`, 1, ceiling);
+    if (!Object.hasOwn(record3, key)) continue;
+    const value = readSafeInteger(record3[key], `$.verification.limits.${key}`, 1, ceiling);
     Object.assign(output, { [key]: value });
   }
   if (output.maxImageBytes > output.maxResourceBytes) output.maxImageBytes = output.maxResourceBytes;
@@ -480,7 +490,7 @@ function verificationAbortError(signal, path) {
 function throwIfVerificationAborted(signal, path) {
   if (signal.aborted) throw verificationAbortError(signal, path);
 }
-function createBlobChunks(blob, chunkBytes, observed, signal, path, snapshot) {
+function createBlobChunks(blob, chunkBytes, observed, signal, path, snapshot2) {
   return {
     async *[Symbol.asyncIterator]() {
       const size = intrinsicBlobSize(blob);
@@ -490,7 +500,7 @@ function createBlobChunks(blob, chunkBytes, observed, signal, path, snapshot) {
         const chunk = new Uint8Array(await intrinsicBlobArrayBuffer(intrinsicBlobSlice(blob, offset, end)));
         throwIfVerificationAborted(signal, path);
         observed.bytes += chunk.byteLength;
-        if (snapshot) snapshot.set(chunk, offset);
+        if (snapshot2) snapshot2.set(chunk, offset);
         yield chunk;
       }
       throwIfVerificationAborted(signal, path);
@@ -539,13 +549,13 @@ function createVerificationDeadline(timeoutMs, callerSignal, path) {
   };
 }
 function parseInspection(value, path) {
-  const record = readRecord(value, path, ["valid", "detectedMimeType", "width", "height"]);
+  const record3 = readRecord(value, path, ["valid", "detectedMimeType", "width", "height"]);
   const output = {
-    valid: readBoolean(requireKey(record, "valid", path), `${path}.valid`),
-    detectedMimeType: readString(requireKey(record, "detectedMimeType", path), `${path}.detectedMimeType`, 128, MIME_TYPE).toLowerCase()
+    valid: readBoolean(requireKey(record3, "valid", path), `${path}.valid`),
+    detectedMimeType: readString(requireKey(record3, "detectedMimeType", path), `${path}.detectedMimeType`, 128, MIME_TYPE).toLowerCase()
   };
-  assignOptional(output, "width", readOptional(record, "width", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
-  assignOptional(output, "height", readOptional(record, "height", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
+  assignOptional(output, "width", readOptional(record3, "width", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
+  assignOptional(output, "height", readOptional(record3, "height", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
   return output;
 }
 function bytesStartWith(bytes, signature) {
@@ -618,12 +628,12 @@ async function verifyParsedResource(resource, port, limits, options, path = "$.r
     } else if (inspection.width !== void 0 || inspection.height !== void 0) {
       return fail("resource-verification-failed", path, "buffer inspection must not report image dimensions");
     }
-    const snapshot = new Uint8Array(resource.byteLength);
+    const snapshot2 = new Uint8Array(resource.byteLength);
     const digestObserved = { bytes: 0 };
     let digest;
     try {
       digest = await deadline.race(() => port.digestSha256(
-        createBlobChunks(resource.payload, limits.chunkBytes, digestObserved, deadline.signal, path, snapshot),
+        createBlobChunks(resource.payload, limits.chunkBytes, digestObserved, deadline.signal, path, snapshot2),
         context
       ));
     } catch (error) {
@@ -636,13 +646,13 @@ async function verifyParsedResource(resource, port, limits, options, path = "$.r
     if (typeof digest !== "string" || !SHA_256.test(digest) || digest !== resource.contentHash) {
       return fail("resource-verification-failed", path, "resource digest does not match contentHash");
     }
-    if (resource.kind === "image") validateImageMagic(resource, snapshot, inspection, path);
+    if (resource.kind === "image") validateImageMagic(resource, snapshot2, inspection, path);
     const verified = Object.freeze({
       ...resource,
-      payload: new Blob([snapshot], { type: resource.mimeType })
+      payload: new Blob([snapshot2], { type: resource.mimeType })
     });
     verifiedResources.add(verified);
-    verifiedResourceBytes.set(verified, snapshot);
+    verifiedResourceBytes.set(verified, snapshot2);
     verifiedResourceEvidence.set(verified, Object.freeze({ ...inspection }));
     return verified;
   } finally {
@@ -660,31 +670,31 @@ async function verifyGpuModelResource(value, port, options) {
   }
 }
 function parseNode(value, path, budget) {
-  const record = readRecord(value, path, ["id", "name", "children", "meshId", "skinId", "localMatrix", "metadata"]);
-  const children = Object.freeze(readArray(requireKey(record, "children", path), `${path}.children`, GPU_MODEL_DOCUMENT_LIMITS.nodes).map((entry, index) => readId(entry, `${path}.children[${index}]`)));
+  const record3 = readRecord(value, path, ["id", "name", "children", "meshId", "skinId", "localMatrix", "metadata"]);
+  const children = Object.freeze(readArray(requireKey(record3, "children", path), `${path}.children`, GPU_MODEL_DOCUMENT_LIMITS.nodes).map((entry, index) => readId(entry, `${path}.children[${index}]`)));
   consumeBudget(budget, "sceneEdges", children.length, GPU_MODEL_DOCUMENT_LIMITS.sceneEdges, path, "scene edge");
   ensureUnique(children, `${path}.children`, "duplicate child node");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
     children,
-    localMatrix: parseMatrix(requireKey(record, "localMatrix", path), `${path}.localMatrix`)
+    localMatrix: parseMatrix(requireKey(record3, "localMatrix", path), `${path}.localMatrix`)
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
-  assignOptional(output, "meshId", readOptional(record, "meshId", readId, path));
-  assignOptional(output, "skinId", readOptional(record, "skinId", readId, path));
-  assignOptional(output, "metadata", readOptional(record, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "meshId", readOptional(record3, "meshId", readId, path));
+  assignOptional(output, "skinId", readOptional(record3, "skinId", readId, path));
+  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseAccessor(value, path, budget) {
-  const record = readRecord(value, path, ["id", "resourceId", "byteOffset", "byteStride", "count", "componentType", "elementType", "normalized", "min", "max"]);
-  const componentType = readEnum(requireKey(record, "componentType", path), `${path}.componentType`, ["i8", "u8", "i16", "u16", "u32", "f32"]);
-  const elementType = readEnum(requireKey(record, "elementType", path), `${path}.elementType`, ["scalar", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4"]);
-  const normalized = readOptional(record, "normalized", readBoolean, path);
+  const record3 = readRecord(value, path, ["id", "resourceId", "byteOffset", "byteStride", "count", "componentType", "elementType", "normalized", "min", "max"]);
+  const componentType = readEnum(requireKey(record3, "componentType", path), `${path}.componentType`, ["i8", "u8", "i16", "u16", "u32", "f32"]);
+  const elementType = readEnum(requireKey(record3, "elementType", path), `${path}.elementType`, ["scalar", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4"]);
+  const normalized = readOptional(record3, "normalized", readBoolean, path);
   if (normalized === true && componentType === "f32") return fail("invalid-value", `${path}.normalized`, "floating-point accessors cannot be normalized");
   if (elementType.startsWith("mat") && componentType !== "f32") return fail("invalid-value", `${path}.componentType`, "matrix accessors must use f32 components");
   const expectedComponents = ELEMENT_COMPONENTS[elementType];
-  const min = readOptional(record, "min", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
-  const max = readOptional(record, "max", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
+  const min = readOptional(record3, "min", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
+  const max = readOptional(record3, "max", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
   if (min === void 0 !== (max === void 0)) return fail("invalid-value", path, "accessor min and max must be supplied together");
   if (min && max) {
     const [componentMinimum, componentMaximum, integer] = COMPONENT_RANGES[componentType];
@@ -697,25 +707,25 @@ function parseAccessor(value, path, budget) {
       }
     }
   }
-  const count = readSafeInteger(requireKey(record, "count", path), `${path}.count`, 1, GPU_MODEL_DOCUMENT_LIMITS.weightVertices);
+  const count = readSafeInteger(requireKey(record3, "count", path), `${path}.count`, 1, GPU_MODEL_DOCUMENT_LIMITS.weightVertices);
   consumeBudget(budget, "accessorElements", count * expectedComponents, GPU_MODEL_DOCUMENT_LIMITS.accessorElements, path, "accessor element component");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    resourceId: readId(requireKey(record, "resourceId", path), `${path}.resourceId`),
-    byteOffset: readSafeInteger(requireKey(record, "byteOffset", path), `${path}.byteOffset`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    resourceId: readId(requireKey(record3, "resourceId", path), `${path}.resourceId`),
+    byteOffset: readSafeInteger(requireKey(record3, "byteOffset", path), `${path}.byteOffset`),
     count,
     componentType,
     elementType
   };
-  assignOptional(output, "byteStride", readOptional(record, "byteStride", (entry, entryPath) => readSafeInteger(entry, entryPath, 1, 2048), path));
+  assignOptional(output, "byteStride", readOptional(record3, "byteStride", (entry, entryPath) => readSafeInteger(entry, entryPath, 1, 2048), path));
   assignOptional(output, "normalized", normalized);
   assignOptional(output, "min", min);
   assignOptional(output, "max", max);
   return output;
 }
 function parsePrimitive(value, path, budget) {
-  const record = readRecord(value, path, ["id", "topology", "attributes", "indicesAccessorId", "materialId", "metadata"]);
-  const attributesInput = readArray(requireKey(record, "attributes", path), `${path}.attributes`, 64, 1);
+  const record3 = readRecord(value, path, ["id", "topology", "attributes", "indicesAccessorId", "materialId", "metadata"]);
+  const attributesInput = readArray(requireKey(record3, "attributes", path), `${path}.attributes`, 64, 1);
   consumeBudget(budget, "primitiveAttributes", attributesInput.length, GPU_MODEL_DOCUMENT_LIMITS.primitiveAttributes, path, "primitive attribute");
   const attributes = Object.freeze(attributesInput.map((entry, index) => {
     const entryPath = `${path}.attributes[${index}]`;
@@ -728,53 +738,53 @@ function parsePrimitive(value, path, budget) {
   ensureUnique(attributes.map(({ semantic }) => semantic), `${path}.attributes`, "duplicate attribute semantic");
   if (!attributes.some(({ semantic }) => semantic === "POSITION")) return fail("invalid-value", `${path}.attributes`, "primitive requires POSITION");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    topology: readEnum(requireKey(record, "topology", path), `${path}.topology`, ["points", "lines", "line-strip", "triangles", "triangle-strip"]),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    topology: readEnum(requireKey(record3, "topology", path), `${path}.topology`, ["points", "lines", "line-strip", "triangles", "triangle-strip"]),
     attributes
   };
-  assignOptional(output, "indicesAccessorId", readOptional(record, "indicesAccessorId", readId, path));
-  assignOptional(output, "materialId", readOptional(record, "materialId", readId, path));
-  assignOptional(output, "metadata", readOptional(record, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "indicesAccessorId", readOptional(record3, "indicesAccessorId", readId, path));
+  assignOptional(output, "materialId", readOptional(record3, "materialId", readId, path));
+  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseMesh(value, path, budget) {
-  const record = readRecord(value, path, ["id", "name", "primitives", "metadata"]);
-  const input = readArray(requireKey(record, "primitives", path), `${path}.primitives`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
+  const record3 = readRecord(value, path, ["id", "name", "primitives", "metadata"]);
+  const input = readArray(requireKey(record3, "primitives", path), `${path}.primitives`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
   consumeBudget(budget, "primitives", input.length, GPU_MODEL_DOCUMENT_LIMITS.primitives, path, "primitive");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
     primitives: Object.freeze(input.map((entry, index) => parsePrimitive(entry, `${path}.primitives[${index}]`, budget)))
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
-  assignOptional(output, "metadata", readOptional(record, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseTextureTransform(value, path) {
-  const record = readRecord(value, path, ["offset", "rotationRadians", "scale"]);
-  if (Reflect.ownKeys(record).length === 0) return fail("invalid-value", path, "texture transform cannot be empty");
+  const record3 = readRecord(value, path, ["offset", "rotationRadians", "scale"]);
+  if (Reflect.ownKeys(record3).length === 0) return fail("invalid-value", path, "texture transform cannot be empty");
   const output = {};
-  assignOptional(output, "offset", readOptional(record, "offset", (entry, entryPath) => readNumberTuple(entry, entryPath, 2), path));
-  assignOptional(output, "rotationRadians", readOptional(record, "rotationRadians", readFinite, path));
-  assignOptional(output, "scale", readOptional(record, "scale", (entry, entryPath) => readNumberTuple(entry, entryPath, 2), path));
+  assignOptional(output, "offset", readOptional(record3, "offset", (entry, entryPath) => readNumberTuple(entry, entryPath, 2), path));
+  assignOptional(output, "rotationRadians", readOptional(record3, "rotationRadians", readFinite, path));
+  assignOptional(output, "scale", readOptional(record3, "scale", (entry, entryPath) => readNumberTuple(entry, entryPath, 2), path));
   return output;
 }
 function parseTextureBinding(value, path) {
-  const record = readRecord(value, path, ["textureId", "samplerId", "texCoordSet", "transform", "colorSpace", "intendedUsage"]);
+  const record3 = readRecord(value, path, ["textureId", "samplerId", "texCoordSet", "transform", "colorSpace", "intendedUsage"]);
   const output = {
-    textureId: readId(requireKey(record, "textureId", path), `${path}.textureId`),
-    colorSpace: readEnum(requireKey(record, "colorSpace", path), `${path}.colorSpace`, ["srgb", "linear", "normal-map", "data"]),
-    intendedUsage: readEnum(requireKey(record, "intendedUsage", path), `${path}.intendedUsage`, TEXTURE_USAGES)
+    textureId: readId(requireKey(record3, "textureId", path), `${path}.textureId`),
+    colorSpace: readEnum(requireKey(record3, "colorSpace", path), `${path}.colorSpace`, ["srgb", "linear", "normal-map", "data"]),
+    intendedUsage: readEnum(requireKey(record3, "intendedUsage", path), `${path}.intendedUsage`, TEXTURE_USAGES)
   };
-  assignOptional(output, "samplerId", readOptional(record, "samplerId", readId, path));
-  assignOptional(output, "texCoordSet", readOptional(record, "texCoordSet", (entry, entryPath) => readSafeInteger(entry, entryPath, 0, 7), path));
-  assignOptional(output, "transform", readOptional(record, "transform", parseTextureTransform, path));
+  assignOptional(output, "samplerId", readOptional(record3, "samplerId", readId, path));
+  assignOptional(output, "texCoordSet", readOptional(record3, "texCoordSet", (entry, entryPath) => readSafeInteger(entry, entryPath, 0, 7), path));
+  assignOptional(output, "transform", readOptional(record3, "transform", parseTextureTransform, path));
   return output;
 }
 function parseMaterialTextures(value, path) {
   const slots = Object.keys(MATERIAL_TEXTURE_SLOTS);
-  const record = readRecord(value, path, slots);
+  const record3 = readRecord(value, path, slots);
   const output = {};
-  for (const slot of slots) assignOptional(output, slot, readOptional(record, slot, parseTextureBinding, path));
+  for (const slot of slots) assignOptional(output, slot, readOptional(record3, slot, parseTextureBinding, path));
   return output;
 }
 function parseMaterial(value, path, budget) {
@@ -800,88 +810,88 @@ function parseMaterial(value, path, budget) {
     "extensions",
     "sourceMetadata"
   ];
-  const record = readRecord(value, path, keys);
-  const alphaMode = readEnum(requireKey(record, "alphaMode", path), `${path}.alphaMode`, ["opaque", "mask", "blend"]);
-  const alphaCutoff = readOptional(record, "alphaCutoff", (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path);
+  const record3 = readRecord(value, path, keys);
+  const alphaMode = readEnum(requireKey(record3, "alphaMode", path), `${path}.alphaMode`, ["opaque", "mask", "blend"]);
+  const alphaCutoff = readOptional(record3, "alphaCutoff", (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path);
   if (alphaMode === "mask" && alphaCutoff === void 0) return fail("invalid-value", `${path}.alphaCutoff`, "mask materials require alphaCutoff");
   if (alphaMode !== "mask" && alphaCutoff !== void 0) return fail("invalid-value", `${path}.alphaCutoff`, "alphaCutoff is only valid for mask materials");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    workflow: readEnum(requireKey(record, "workflow", path), `${path}.workflow`, ["metallic-roughness", "specular-glossiness", "unlit", "custom"]),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    workflow: readEnum(requireKey(record3, "workflow", path), `${path}.workflow`, ["metallic-roughness", "specular-glossiness", "unlit", "custom"]),
     alphaMode,
-    baseColorFactor: readNumberTuple(requireKey(record, "baseColorFactor", path), `${path}.baseColorFactor`, 4, 0, 1),
-    textures: parseMaterialTextures(requireKey(record, "textures", path), `${path}.textures`),
-    extensions: readMetadata(requireKey(record, "extensions", path), `${path}.extensions`, budget),
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    baseColorFactor: readNumberTuple(requireKey(record3, "baseColorFactor", path), `${path}.baseColorFactor`, 4, 0, 1),
+    textures: parseMaterialTextures(requireKey(record3, "textures", path), `${path}.textures`),
+    extensions: readMetadata(requireKey(record3, "extensions", path), `${path}.extensions`, budget),
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
   assignOptional(output, "alphaCutoff", alphaCutoff);
-  assignOptional(output, "doubleSided", readOptional(record, "doubleSided", readBoolean, path));
+  assignOptional(output, "doubleSided", readOptional(record3, "doubleSided", readBoolean, path));
   for (const key of ["metallicFactor", "roughnessFactor", "transmissionFactor", "clearcoatFactor", "clearcoatRoughnessFactor", "sheenRoughnessFactor", "occlusionStrength"]) {
-    assignOptional(output, key, readOptional(record, key, (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path));
+    assignOptional(output, key, readOptional(record3, key, (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path));
   }
-  assignOptional(output, "normalScale", readOptional(record, "normalScale", readFinite, path));
-  assignOptional(output, "emissiveFactor", readOptional(record, "emissiveFactor", (entry, entryPath) => readNumberTuple(entry, entryPath, 3, 0), path));
-  assignOptional(output, "sheenColorFactor", readOptional(record, "sheenColorFactor", (entry, entryPath) => readNumberTuple(entry, entryPath, 3, 0, 1), path));
+  assignOptional(output, "normalScale", readOptional(record3, "normalScale", readFinite, path));
+  assignOptional(output, "emissiveFactor", readOptional(record3, "emissiveFactor", (entry, entryPath) => readNumberTuple(entry, entryPath, 3, 0), path));
+  assignOptional(output, "sheenColorFactor", readOptional(record3, "sheenColorFactor", (entry, entryPath) => readNumberTuple(entry, entryPath, 3, 0, 1), path));
   return output;
 }
 function parseTextureSampler(value, path) {
-  const record = readRecord(value, path, ["id", "wrapS", "wrapT", "minFilter", "magFilter", "mipFilter"]);
-  const output = { id: readId(requireKey(record, "id", path), `${path}.id`) };
-  assignOptional(output, "wrapS", readOptional(record, "wrapS", (entry, entryPath) => readEnum(entry, entryPath, ["repeat", "mirrored-repeat", "clamp-to-edge"]), path));
-  assignOptional(output, "wrapT", readOptional(record, "wrapT", (entry, entryPath) => readEnum(entry, entryPath, ["repeat", "mirrored-repeat", "clamp-to-edge"]), path));
-  assignOptional(output, "minFilter", readOptional(record, "minFilter", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
-  assignOptional(output, "magFilter", readOptional(record, "magFilter", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
-  assignOptional(output, "mipFilter", readOptional(record, "mipFilter", (entry, entryPath) => readEnum(entry, entryPath, ["nearest", "linear"]), path));
+  const record3 = readRecord(value, path, ["id", "wrapS", "wrapT", "minFilter", "magFilter", "mipFilter"]);
+  const output = { id: readId(requireKey(record3, "id", path), `${path}.id`) };
+  assignOptional(output, "wrapS", readOptional(record3, "wrapS", (entry, entryPath) => readEnum(entry, entryPath, ["repeat", "mirrored-repeat", "clamp-to-edge"]), path));
+  assignOptional(output, "wrapT", readOptional(record3, "wrapT", (entry, entryPath) => readEnum(entry, entryPath, ["repeat", "mirrored-repeat", "clamp-to-edge"]), path));
+  assignOptional(output, "minFilter", readOptional(record3, "minFilter", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
+  assignOptional(output, "magFilter", readOptional(record3, "magFilter", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
+  assignOptional(output, "mipFilter", readOptional(record3, "mipFilter", (entry, entryPath) => readEnum(entry, entryPath, ["nearest", "linear"]), path));
   return output;
 }
 function parseTexture(value, path, budget) {
-  const record = readRecord(value, path, ["id", "fileName", "relativePath", "mimeType", "contentHash", "imageResourceId", "byteLength", "intendedUsage", "colorSpace", "sampler", "exportEmbeddingPolicy", "sourceMetadata"]);
-  const usages = Object.freeze(readArray(requireKey(record, "intendedUsage", path), `${path}.intendedUsage`, TEXTURE_USAGES.length, 1).map((entry, index) => readEnum(entry, `${path}.intendedUsage[${index}]`, TEXTURE_USAGES)));
+  const record3 = readRecord(value, path, ["id", "fileName", "relativePath", "mimeType", "contentHash", "imageResourceId", "byteLength", "intendedUsage", "colorSpace", "sampler", "exportEmbeddingPolicy", "sourceMetadata"]);
+  const usages = Object.freeze(readArray(requireKey(record3, "intendedUsage", path), `${path}.intendedUsage`, TEXTURE_USAGES.length, 1).map((entry, index) => readEnum(entry, `${path}.intendedUsage[${index}]`, TEXTURE_USAGES)));
   ensureUnique(usages, `${path}.intendedUsage`, "duplicate intended texture usage");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    contentHash: readSha256(requireKey(record, "contentHash", path), `${path}.contentHash`),
-    imageResourceId: readId(requireKey(record, "imageResourceId", path), `${path}.imageResourceId`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    contentHash: readSha256(requireKey(record3, "contentHash", path), `${path}.contentHash`),
+    imageResourceId: readId(requireKey(record3, "imageResourceId", path), `${path}.imageResourceId`),
     intendedUsage: usages,
-    colorSpace: readEnum(requireKey(record, "colorSpace", path), `${path}.colorSpace`, ["srgb", "linear", "normal-map", "data"]),
-    exportEmbeddingPolicy: readEnum(requireKey(record, "exportEmbeddingPolicy", path), `${path}.exportEmbeddingPolicy`, ["inherit-source", "prefer-embedded", "prefer-external", "forbid-embedding"]),
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    colorSpace: readEnum(requireKey(record3, "colorSpace", path), `${path}.colorSpace`, ["srgb", "linear", "normal-map", "data"]),
+    exportEmbeddingPolicy: readEnum(requireKey(record3, "exportEmbeddingPolicy", path), `${path}.exportEmbeddingPolicy`, ["inherit-source", "prefer-embedded", "prefer-external", "forbid-embedding"]),
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "fileName", readOptional(record, "fileName", (entry, entryPath) => readString(entry, entryPath, 512, FILE_NAME), path));
-  assignOptional(output, "relativePath", readOptional(record, "relativePath", (entry, entryPath) => readString(entry, entryPath, 2048, RELATIVE_PATH), path));
-  assignOptional(output, "mimeType", readOptional(record, "mimeType", (entry, entryPath) => readString(entry, entryPath, 128, MIME_TYPE).toLowerCase(), path));
-  assignOptional(output, "byteLength", readOptional(record, "byteLength", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
-  assignOptional(output, "sampler", readOptional(record, "sampler", parseTextureSampler, path));
+  assignOptional(output, "fileName", readOptional(record3, "fileName", (entry, entryPath) => readString(entry, entryPath, 512, FILE_NAME), path));
+  assignOptional(output, "relativePath", readOptional(record3, "relativePath", (entry, entryPath) => readString(entry, entryPath, 2048, RELATIVE_PATH), path));
+  assignOptional(output, "mimeType", readOptional(record3, "mimeType", (entry, entryPath) => readString(entry, entryPath, 128, MIME_TYPE).toLowerCase(), path));
+  assignOptional(output, "byteLength", readOptional(record3, "byteLength", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
+  assignOptional(output, "sampler", readOptional(record3, "sampler", parseTextureSampler, path));
   return output;
 }
 function parseSkeleton(value, path, budget) {
-  const record = readRecord(value, path, ["id", "name", "jointIds", "rootJointIds", "sourceMetadata"]);
-  const jointIds = Object.freeze(readArray(requireKey(record, "jointIds", path), `${path}.jointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.jointIds[${index}]`)));
-  const rootJointIds = Object.freeze(readArray(requireKey(record, "rootJointIds", path), `${path}.rootJointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.rootJointIds[${index}]`)));
+  const record3 = readRecord(value, path, ["id", "name", "jointIds", "rootJointIds", "sourceMetadata"]);
+  const jointIds = Object.freeze(readArray(requireKey(record3, "jointIds", path), `${path}.jointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.jointIds[${index}]`)));
+  const rootJointIds = Object.freeze(readArray(requireKey(record3, "rootJointIds", path), `${path}.rootJointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.rootJointIds[${index}]`)));
   consumeBudget(budget, "skinJoints", jointIds.length + rootJointIds.length, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, path, "rig joint");
   ensureUnique(jointIds, `${path}.jointIds`, "duplicate skeleton joint");
   ensureUnique(rootJointIds, `${path}.rootJointIds`, "duplicate root joint");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
     jointIds,
     rootJointIds,
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
   return output;
 }
 function parseJoint(value, path, budget) {
-  const record = readRecord(value, path, ["id", "name", "nodeId", "parentJointId", "restLocalTransform", "inverseBindMatrix", "sourceMetadata"]);
+  const record3 = readRecord(value, path, ["id", "name", "nodeId", "parentJointId", "restLocalTransform", "inverseBindMatrix", "sourceMetadata"]);
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    nodeId: readId(requireKey(record, "nodeId", path), `${path}.nodeId`),
-    restLocalTransform: parseTransformTrs(requireKey(record, "restLocalTransform", path), `${path}.restLocalTransform`),
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    nodeId: readId(requireKey(record3, "nodeId", path), `${path}.nodeId`),
+    restLocalTransform: parseTransformTrs(requireKey(record3, "restLocalTransform", path), `${path}.restLocalTransform`),
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
-  assignOptional(output, "parentJointId", readOptional(record, "parentJointId", readId, path));
-  assignOptional(output, "inverseBindMatrix", readOptional(record, "inverseBindMatrix", parseMatrix, path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "parentJointId", readOptional(record3, "parentJointId", readId, path));
+  assignOptional(output, "inverseBindMatrix", readOptional(record3, "inverseBindMatrix", parseMatrix, path));
   return output;
 }
 function parseWeightRows(value, path, rows, columns, integer, budget) {
@@ -895,43 +905,43 @@ function parseWeightRows(value, path, rows, columns, integer, budget) {
   }));
 }
 function parseVertexWeightSet(value, path, budget) {
-  const record = readRecord(value, path, ["primitiveId", "influencesPerVertex", "joints", "weights"]);
-  const influences = readSafeInteger(requireKey(record, "influencesPerVertex", path), `${path}.influencesPerVertex`, 1, 32);
+  const record3 = readRecord(value, path, ["primitiveId", "influencesPerVertex", "joints", "weights"]);
+  const influences = readSafeInteger(requireKey(record3, "influencesPerVertex", path), `${path}.influencesPerVertex`, 1, 32);
   if (influences % 4 !== 0) return fail("invalid-value", `${path}.influencesPerVertex`, "influencesPerVertex must be a multiple of four");
-  const jointRows = readArray(requireKey(record, "joints", path), `${path}.joints`, GPU_MODEL_DOCUMENT_LIMITS.weightVertices, 1);
-  const weightRows = readArray(requireKey(record, "weights", path), `${path}.weights`, GPU_MODEL_DOCUMENT_LIMITS.weightVertices, 1);
+  const jointRows = readArray(requireKey(record3, "joints", path), `${path}.joints`, GPU_MODEL_DOCUMENT_LIMITS.weightVertices, 1);
+  const weightRows = readArray(requireKey(record3, "weights", path), `${path}.weights`, GPU_MODEL_DOCUMENT_LIMITS.weightVertices, 1);
   if (jointRows.length !== weightRows.length) return fail("invalid-value", path, "joint and weight row counts must match");
   return {
-    primitiveId: readId(requireKey(record, "primitiveId", path), `${path}.primitiveId`),
+    primitiveId: readId(requireKey(record3, "primitiveId", path), `${path}.primitiveId`),
     influencesPerVertex: influences,
     joints: parseWeightRows(jointRows, `${path}.joints`, jointRows.length, influences, true, budget),
     weights: parseWeightRows(weightRows, `${path}.weights`, weightRows.length, influences, false, budget)
   };
 }
 function parseSkin(value, path, budget) {
-  const record = readRecord(value, path, ["id", "skeletonId", "jointIds", "inverseBindMatrices", "weightSets", "sourceMetadata"]);
-  const jointIds = Object.freeze(readArray(requireKey(record, "jointIds", path), `${path}.jointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.jointIds[${index}]`)));
+  const record3 = readRecord(value, path, ["id", "skeletonId", "jointIds", "inverseBindMatrices", "weightSets", "sourceMetadata"]);
+  const jointIds = Object.freeze(readArray(requireKey(record3, "jointIds", path), `${path}.jointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.jointIds[${index}]`)));
   consumeBudget(budget, "skinJoints", jointIds.length, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, path, "skin joint");
   ensureUnique(jointIds, `${path}.jointIds`, "duplicate skin joint");
-  const inverseInput = readArray(requireKey(record, "inverseBindMatrices", path), `${path}.inverseBindMatrices`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, jointIds.length);
+  const inverseInput = readArray(requireKey(record3, "inverseBindMatrices", path), `${path}.inverseBindMatrices`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, jointIds.length);
   if (inverseInput.length !== jointIds.length) return fail("invalid-value", `${path}.inverseBindMatrices`, "one inverse bind matrix is required per skin joint");
-  const weightInput = readArray(requireKey(record, "weightSets", path), `${path}.weightSets`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
+  const weightInput = readArray(requireKey(record3, "weightSets", path), `${path}.weightSets`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
   const weightSets = Object.freeze(weightInput.map((entry, index) => parseVertexWeightSet(entry, `${path}.weightSets[${index}]`, budget)));
   ensureUnique(weightSets.map(({ primitiveId }) => primitiveId), `${path}.weightSets`, "duplicate primitive weight set");
   return {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    skeletonId: readId(requireKey(record, "skeletonId", path), `${path}.skeletonId`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    skeletonId: readId(requireKey(record3, "skeletonId", path), `${path}.skeletonId`),
     jointIds,
     inverseBindMatrices: Object.freeze(inverseInput.map((entry, index) => parseMatrix(entry, `${path}.inverseBindMatrices[${index}]`))),
     weightSets,
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
 }
 function parseBlendShapeDelta(value, path) {
-  const record = readRecord(value, path, ["primitiveId", "positionAccessorId", "normalAccessorId", "tangentAccessorId"]);
-  const output = { primitiveId: readId(requireKey(record, "primitiveId", path), `${path}.primitiveId`) };
+  const record3 = readRecord(value, path, ["primitiveId", "positionAccessorId", "normalAccessorId", "tangentAccessorId"]);
+  const output = { primitiveId: readId(requireKey(record3, "primitiveId", path), `${path}.primitiveId`) };
   for (const key of ["positionAccessorId", "normalAccessorId", "tangentAccessorId"]) {
-    assignOptional(output, key, readOptional(record, key, readId, path));
+    assignOptional(output, key, readOptional(record3, key, readId, path));
   }
   if (!output.positionAccessorId && !output.normalAccessorId && !output.tangentAccessorId) {
     return fail("invalid-value", path, "blend-shape delta requires at least one accessor");
@@ -939,8 +949,8 @@ function parseBlendShapeDelta(value, path) {
   return output;
 }
 function parseBlendShape(value, path, budget) {
-  const record = readRecord(value, path, ["id", "meshId", "name", "defaultWeight", "deltas", "sourceMetadata"]);
-  const deltaInput = readArray(requireKey(record, "deltas", path), `${path}.deltas`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
+  const record3 = readRecord(value, path, ["id", "meshId", "name", "defaultWeight", "deltas", "sourceMetadata"]);
+  const deltaInput = readArray(requireKey(record3, "deltas", path), `${path}.deltas`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
   consumeBudget(
     budget,
     "blendShapeDeltas",
@@ -952,96 +962,96 @@ function parseBlendShape(value, path, budget) {
   const deltas = Object.freeze(deltaInput.map((entry, index) => parseBlendShapeDelta(entry, `${path}.deltas[${index}]`)));
   ensureUnique(deltas.map(({ primitiveId }) => primitiveId), `${path}.deltas`, "duplicate blend-shape primitive delta");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    meshId: readId(requireKey(record, "meshId", path), `${path}.meshId`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    meshId: readId(requireKey(record3, "meshId", path), `${path}.meshId`),
     deltas,
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
-  assignOptional(output, "defaultWeight", readOptional(record, "defaultWeight", (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "defaultWeight", readOptional(record3, "defaultWeight", (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path));
   return output;
 }
 function parseAnimationSampler(value, path, budget) {
-  const record = readRecord(value, path, ["id", "inputAccessorId", "outputAccessorId", "inputTimesSeconds", "outputValues", "interpolation", "sourceMetadata"]);
-  const timesInput = readArray(requireKey(record, "inputTimesSeconds", path), `${path}.inputTimesSeconds`, GPU_MODEL_DOCUMENT_LIMITS.animationValues, 1);
-  const valuesInput = readArray(requireKey(record, "outputValues", path), `${path}.outputValues`, GPU_MODEL_DOCUMENT_LIMITS.animationValues, 1);
+  const record3 = readRecord(value, path, ["id", "inputAccessorId", "outputAccessorId", "inputTimesSeconds", "outputValues", "interpolation", "sourceMetadata"]);
+  const timesInput = readArray(requireKey(record3, "inputTimesSeconds", path), `${path}.inputTimesSeconds`, GPU_MODEL_DOCUMENT_LIMITS.animationValues, 1);
+  const valuesInput = readArray(requireKey(record3, "outputValues", path), `${path}.outputValues`, GPU_MODEL_DOCUMENT_LIMITS.animationValues, 1);
   consumeBudget(budget, "animationValues", timesInput.length + valuesInput.length, GPU_MODEL_DOCUMENT_LIMITS.animationValues, path, "animation value");
   const times = Object.freeze(timesInput.map((entry, index) => readFinite(entry, `${path}.inputTimesSeconds[${index}]`, 0)));
   for (let index = 1; index < times.length; index += 1) {
     if (times[index] <= times[index - 1]) return fail("invalid-value", `${path}.inputTimesSeconds`, "animation input times must be strictly increasing");
   }
   return {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    inputAccessorId: readId(requireKey(record, "inputAccessorId", path), `${path}.inputAccessorId`),
-    outputAccessorId: readId(requireKey(record, "outputAccessorId", path), `${path}.outputAccessorId`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    inputAccessorId: readId(requireKey(record3, "inputAccessorId", path), `${path}.inputAccessorId`),
+    outputAccessorId: readId(requireKey(record3, "outputAccessorId", path), `${path}.outputAccessorId`),
     inputTimesSeconds: times,
     outputValues: Object.freeze(valuesInput.map((entry, index) => readFinite(entry, `${path}.outputValues[${index}]`))),
-    interpolation: readEnum(requireKey(record, "interpolation", path), `${path}.interpolation`, ["step", "linear", "cubic-spline"]),
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    interpolation: readEnum(requireKey(record3, "interpolation", path), `${path}.interpolation`, ["step", "linear", "cubic-spline"]),
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
 }
 function parseAnimationChannel(value, path, budget) {
-  const record = readRecord(value, path, ["id", "samplerId", "targetType", "targetId", "sourceMetadata"]);
+  const record3 = readRecord(value, path, ["id", "samplerId", "targetType", "targetId", "sourceMetadata"]);
   return {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    samplerId: readId(requireKey(record, "samplerId", path), `${path}.samplerId`),
-    targetType: readEnum(requireKey(record, "targetType", path), `${path}.targetType`, ["node-translation", "node-rotation", "node-scale", "weights"]),
-    targetId: readId(requireKey(record, "targetId", path), `${path}.targetId`),
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    samplerId: readId(requireKey(record3, "samplerId", path), `${path}.samplerId`),
+    targetType: readEnum(requireKey(record3, "targetType", path), `${path}.targetType`, ["node-translation", "node-rotation", "node-scale", "weights"]),
+    targetId: readId(requireKey(record3, "targetId", path), `${path}.targetId`),
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
 }
 function parseAnimation(value, path, budget) {
-  const record = readRecord(value, path, ["id", "name", "durationSeconds", "samplers", "channels", "sourceMetadata"]);
-  const samplerInput = readArray(requireKey(record, "samplers", path), `${path}.samplers`, GPU_MODEL_DOCUMENT_LIMITS.animationSamplers, 1);
-  const channelInput = readArray(requireKey(record, "channels", path), `${path}.channels`, GPU_MODEL_DOCUMENT_LIMITS.animationChannels, 1);
+  const record3 = readRecord(value, path, ["id", "name", "durationSeconds", "samplers", "channels", "sourceMetadata"]);
+  const samplerInput = readArray(requireKey(record3, "samplers", path), `${path}.samplers`, GPU_MODEL_DOCUMENT_LIMITS.animationSamplers, 1);
+  const channelInput = readArray(requireKey(record3, "channels", path), `${path}.channels`, GPU_MODEL_DOCUMENT_LIMITS.animationChannels, 1);
   consumeBudget(budget, "animationSamplers", samplerInput.length, GPU_MODEL_DOCUMENT_LIMITS.animationSamplers, path, "animation sampler");
   consumeBudget(budget, "animationChannels", channelInput.length, GPU_MODEL_DOCUMENT_LIMITS.animationChannels, path, "animation channel");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
-    durationSeconds: readFinite(requireKey(record, "durationSeconds", path), `${path}.durationSeconds`, 0),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    durationSeconds: readFinite(requireKey(record3, "durationSeconds", path), `${path}.durationSeconds`, 0),
     samplers: Object.freeze(samplerInput.map((entry, index) => parseAnimationSampler(entry, `${path}.samplers[${index}]`, budget))),
     channels: Object.freeze(channelInput.map((entry, index) => parseAnimationChannel(entry, `${path}.channels[${index}]`, budget))),
-    sourceMetadata: readMetadata(requireKey(record, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
   return output;
 }
 function parseAnalyticGeometry(value, path, budget) {
-  const record = readRecord(value, path, ["id", "kind", "sourceResourceId", "sourceUnit", "tessellatedMeshId", "metadata"]);
-  if (requireKey(record, "kind", path) !== "brep-placeholder") return fail("invalid-value", `${path}.kind`, "unsupported analytic geometry kind");
+  const record3 = readRecord(value, path, ["id", "kind", "sourceResourceId", "sourceUnit", "tessellatedMeshId", "metadata"]);
+  if (requireKey(record3, "kind", path) !== "brep-placeholder") return fail("invalid-value", `${path}.kind`, "unsupported analytic geometry kind");
   const output = {
-    id: readId(requireKey(record, "id", path), `${path}.id`),
+    id: readId(requireKey(record3, "id", path), `${path}.id`),
     kind: "brep-placeholder",
-    sourceResourceId: readId(requireKey(record, "sourceResourceId", path), `${path}.sourceResourceId`),
-    sourceUnit: readEnum(requireKey(record, "sourceUnit", path), `${path}.sourceUnit`, ["metre", "millimetre", "centimetre", "inch", "foot", "unitless"])
+    sourceResourceId: readId(requireKey(record3, "sourceResourceId", path), `${path}.sourceResourceId`),
+    sourceUnit: readEnum(requireKey(record3, "sourceUnit", path), `${path}.sourceUnit`, ["metre", "millimetre", "centimetre", "inch", "foot", "unitless"])
   };
-  assignOptional(output, "tessellatedMeshId", readOptional(record, "tessellatedMeshId", readId, path));
-  assignOptional(output, "metadata", readOptional(record, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "tessellatedMeshId", readOptional(record3, "tessellatedMeshId", readId, path));
+  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseProvenance(value, budget) {
   const path = "$.provenance";
-  const record = readRecord(value, path, ["sourceFormat", "sourceContentHash", "converterId", "converterVersion", "provider", "sourceIdentifier", "metadata"]);
+  const record3 = readRecord(value, path, ["sourceFormat", "sourceContentHash", "converterId", "converterVersion", "provider", "sourceIdentifier", "metadata"]);
   const output = {
-    sourceFormat: readString(requireKey(record, "sourceFormat", path), `${path}.sourceFormat`, 128, TOKEN),
-    sourceContentHash: readSha256(requireKey(record, "sourceContentHash", path), `${path}.sourceContentHash`),
-    converterId: readString(requireKey(record, "converterId", path), `${path}.converterId`, 128, TOKEN),
-    converterVersion: readString(requireKey(record, "converterVersion", path), `${path}.converterVersion`, 128, TOKEN)
+    sourceFormat: readString(requireKey(record3, "sourceFormat", path), `${path}.sourceFormat`, 128, TOKEN),
+    sourceContentHash: readSha256(requireKey(record3, "sourceContentHash", path), `${path}.sourceContentHash`),
+    converterId: readString(requireKey(record3, "converterId", path), `${path}.converterId`, 128, TOKEN),
+    converterVersion: readString(requireKey(record3, "converterVersion", path), `${path}.converterVersion`, 128, TOKEN)
   };
-  assignOptional(output, "provider", readOptional(record, "provider", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
-  assignOptional(output, "sourceIdentifier", readOptional(record, "sourceIdentifier", (entry, entryPath) => readString(entry, entryPath, 2048), path));
-  assignOptional(output, "metadata", readOptional(record, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "provider", readOptional(record3, "provider", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
+  assignOptional(output, "sourceIdentifier", readOptional(record3, "sourceIdentifier", (entry, entryPath) => readString(entry, entryPath, 2048), path));
+  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseDiagnostic(value, path, budget) {
-  const record = readRecord(value, path, ["severity", "code", "message", "path", "metadata"]);
+  const record3 = readRecord(value, path, ["severity", "code", "message", "path", "metadata"]);
   const output = {
-    severity: readEnum(requireKey(record, "severity", path), `${path}.severity`, ["info", "warning", "error"]),
-    code: readString(requireKey(record, "code", path), `${path}.code`, 128, TOKEN),
-    message: readString(requireKey(record, "message", path), `${path}.message`, GPU_MODEL_DOCUMENT_LIMITS.diagnosticMessageLength)
+    severity: readEnum(requireKey(record3, "severity", path), `${path}.severity`, ["info", "warning", "error"]),
+    code: readString(requireKey(record3, "code", path), `${path}.code`, 128, TOKEN),
+    message: readString(requireKey(record3, "message", path), `${path}.message`, GPU_MODEL_DOCUMENT_LIMITS.diagnosticMessageLength)
   };
-  assignOptional(output, "path", readOptional(record, "path", (entry, entryPath) => readString(entry, entryPath, 512), path));
-  assignOptional(output, "metadata", readOptional(record, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "path", readOptional(record3, "path", (entry, entryPath) => readString(entry, entryPath, 512), path));
+  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function ensureUnique(values, path, detail = "duplicate identity") {
@@ -1682,11 +1692,11 @@ var DOCUMENT_KEYS = Object.freeze([
 ]);
 function parseGpuModelDocument(value) {
   const path = "$";
-  const record = readRecord(value, path, DOCUMENT_KEYS);
-  const schemaVersion = requireKey(record, "schemaVersion", path);
+  const record3 = readRecord(value, path, DOCUMENT_KEYS);
+  const schemaVersion = requireKey(record3, "schemaVersion", path);
   if (schemaVersion !== GPU_MODEL_DOCUMENT_SCHEMA_VERSION) return fail("invalid-value", "$.schemaVersion", "unsupported schema version");
   const parseCollection = (key, maximum, parser, minimum = 0) => {
-    const input = readArray(requireKey(record, key, path), `$.${key}`, maximum, minimum);
+    const input = readArray(requireKey(record3, key, path), `$.${key}`, maximum, minimum);
     return Object.freeze(input.map((entry, index) => parser(entry, `$.${key}[${index}]`)));
   };
   const budget = {
@@ -1707,10 +1717,10 @@ function parseGpuModelDocument(value) {
     geometryWorldAccessorInstances: 0,
     geometryWorldVertices: 0
   };
-  const roots = Object.freeze(readArray(requireKey(record, "roots", path), "$.roots", GPU_MODEL_DOCUMENT_LIMITS.roots, 1).map((entry, index) => readId(entry, `$.roots[${index}]`)));
+  const roots = Object.freeze(readArray(requireKey(record3, "roots", path), "$.roots", GPU_MODEL_DOCUMENT_LIMITS.roots, 1).map((entry, index) => readId(entry, `$.roots[${index}]`)));
   const document = {
     schemaVersion,
-    coordinateSystem: parseCoordinateSystem(requireKey(record, "coordinateSystem", path)),
+    coordinateSystem: parseCoordinateSystem(requireKey(record3, "coordinateSystem", path)),
     roots,
     nodes: parseCollection("nodes", GPU_MODEL_DOCUMENT_LIMITS.nodes, (entry, entryPath) => parseNode(entry, entryPath, budget), 1),
     resources: parseCollection("resources", GPU_MODEL_DOCUMENT_LIMITS.resources, parseVerifiedResource, 1),
@@ -1724,10 +1734,10 @@ function parseGpuModelDocument(value) {
     blendShapes: parseCollection("blendShapes", GPU_MODEL_DOCUMENT_LIMITS.blendShapes, (entry, entryPath) => parseBlendShape(entry, entryPath, budget)),
     animations: parseCollection("animations", GPU_MODEL_DOCUMENT_LIMITS.animations, (entry, entryPath) => parseAnimation(entry, entryPath, budget)),
     analyticGeometry: parseCollection("analyticGeometry", GPU_MODEL_DOCUMENT_LIMITS.analyticGeometry, (entry, entryPath) => parseAnalyticGeometry(entry, entryPath, budget)),
-    bounds: parseBounds(requireKey(record, "bounds", path), "$.bounds"),
-    provenance: parseProvenance(requireKey(record, "provenance", path), budget),
+    bounds: parseBounds(requireKey(record3, "bounds", path), "$.bounds"),
+    provenance: parseProvenance(requireKey(record3, "provenance", path), budget),
     diagnostics: parseCollection("diagnostics", GPU_MODEL_DOCUMENT_LIMITS.diagnostics, (entry, entryPath) => parseDiagnostic(entry, entryPath, budget)),
-    metadata: readMetadata(requireKey(record, "metadata", path), "$.metadata", budget)
+    metadata: readMetadata(requireKey(record3, "metadata", path), "$.metadata", budget)
   };
   if (document.meshes.length === 0) return fail("invalid-value", "$.meshes", "v1 document bounds require at least one canonical mesh");
   validateReferences(document, budget);
@@ -1764,8 +1774,8 @@ async function createAndVerifyGpuModelDocument(value, port, options) {
       value.resources.forEach((resource, index) => assertVerifiedResourceEvidence(resource, limits, `$.resources[${index}]`));
       return value;
     }
-    const record = readRecord(value, "$", DOCUMENT_KEYS);
-    const resourceInput = readArray(requireKey(record, "resources", "$"), "$.resources", GPU_MODEL_DOCUMENT_LIMITS.resources, 1);
+    const record3 = readRecord(value, "$", DOCUMENT_KEYS);
+    const resourceInput = readArray(requireKey(record3, "resources", "$"), "$.resources", GPU_MODEL_DOCUMENT_LIMITS.resources, 1);
     const parsed = resourceInput.map((entry, index) => {
       if (typeof entry === "object" && entry !== null && verifiedResources.has(entry) && verifiedResourceBytes.has(entry)) return entry;
       return parseResourceHeader(entry, `$.resources[${index}]`);
@@ -1778,7 +1788,7 @@ async function createAndVerifyGpuModelDocument(value, port, options) {
     }
     const candidate = {};
     for (const key of DOCUMENT_KEYS) {
-      if (Object.hasOwn(record, key)) candidate[key] = record[key];
+      if (Object.hasOwn(record3, key)) candidate[key] = record3[key];
     }
     candidate.resources = verified;
     return createGpuModelDocument(candidate);
@@ -1843,11 +1853,11 @@ async function hashGpuModelDocumentCanonical(document) {
   return Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("");
 }
 function resolveStaticDemoLimits(options) {
-  const record = readRecord(options, "$.options", ["pvoxModelsEnabled", "limits"]);
-  const enabled = readBoolean(requireKey(record, "pvoxModelsEnabled", "$.options"), "$.options.pvoxModelsEnabled");
+  const record3 = readRecord(options, "$.options", ["pvoxModelsEnabled", "limits"]);
+  const enabled = readBoolean(requireKey(record3, "pvoxModelsEnabled", "$.options"), "$.options.pvoxModelsEnabled");
   if (!enabled) return fail("feature-disabled", "$.options.pvoxModelsEnabled", `${GPU_MODEL_STATIC_DEMO_FEATURE_FLAG} is disabled`);
-  if (!Object.hasOwn(record, "limits")) return GPU_MODEL_STATIC_DEMO_LIMITS;
-  const overrides = readRecord(record.limits, "$.options.limits", Object.keys(GPU_MODEL_STATIC_DEMO_LIMITS));
+  if (!Object.hasOwn(record3, "limits")) return GPU_MODEL_STATIC_DEMO_LIMITS;
+  const overrides = readRecord(record3.limits, "$.options.limits", Object.keys(GPU_MODEL_STATIC_DEMO_LIMITS));
   const limits = { ...GPU_MODEL_STATIC_DEMO_LIMITS };
   for (const [key, ceiling] of Object.entries(GPU_MODEL_STATIC_DEMO_LIMITS)) {
     if (Object.hasOwn(overrides, key)) limits[key] = readSafeInteger(overrides[key], `$.options.limits.${key}`, 1, ceiling);
@@ -2082,6 +2092,451 @@ async function createGpuModelStaticDemoCompilerInput(document, options) {
   });
 }
 
+// src/diagnostics.ts
+var GPU_MODEL_REPAIR_RULES = Object.freeze([
+  {
+    "id": "missing-normals",
+    "action": "Generate deterministic vertex normals from validated triangle geometry.",
+    "severity": "warning",
+    "confidence": "high",
+    "standardIds": [
+      "gltf-glb",
+      "obj-mtl",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Generate deterministic vertex normals from validated triangle geometry and record the generation basis."
+  },
+  {
+    "id": "bad-winding",
+    "action": "Normalize winding to the adapter coordinate convention.",
+    "severity": "warning",
+    "confidence": "medium",
+    "standardIds": [
+      "gltf-glb",
+      "obj-mtl",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Normalize winding to the adapter coordinate convention and record the inferred orientation."
+  },
+  {
+    "id": "invalid-indices",
+    "action": "Drop the invalid primitive.",
+    "severity": "error",
+    "confidence": "medium",
+    "standardIds": [
+      "gltf-glb",
+      "obj-mtl",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Reject the invalid primitive or clamp only when the fixture and adapter policy explicitly prove a safe repair; retain the original index in the record."
+  },
+  {
+    "id": "nan-transforms",
+    "action": "Replace non-finite transform components with identity components.",
+    "severity": "error",
+    "confidence": "high",
+    "standardIds": [
+      "gltf-glb",
+      "obj-mtl",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Replace the non-finite component with the identity transform component and record the source value and fallback."
+  },
+  {
+    "id": "non-normalized-weights",
+    "action": "Normalize finite non-negative skin weights.",
+    "severity": "warning",
+    "confidence": "high",
+    "standardIds": [
+      "gltf-glb",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Normalize finite, non-negative influences and record the pre-normalization weights and discarded influence policy."
+  },
+  {
+    "id": "missing-texture-path",
+    "action": "Leave the missing or unsafe texture slot unresolved.",
+    "severity": "warning",
+    "confidence": "low",
+    "standardIds": [
+      "gltf-glb",
+      "obj-mtl",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Resolve only an explicitly bounded package-relative fallback; otherwise keep the material slot unresolved and emit a visible warning."
+  },
+  {
+    "id": "malformed-material-reference",
+    "action": "Attach the canonical default material.",
+    "severity": "error",
+    "confidence": "medium",
+    "standardIds": [
+      "gltf-glb",
+      "obj-mtl",
+      "fbx",
+      "cad-bim"
+    ],
+    "policy": "Attach the canonical default material only when the target policy permits it and preserve the unresolved source reference."
+  }
+].map((rule) => Object.freeze({ ...rule, standardIds: Object.freeze(rule.standardIds) })));
+var GPU_MODEL_DIAGNOSTIC_LIMITS = Object.freeze({
+  issues: 4096,
+  values: 16384,
+  depth: 12,
+  members: 1024,
+  string: 65536,
+  bytes: 1048576
+});
+var GpuModelDiagnosticsError = class extends TypeError {
+  constructor() {
+    super("Invalid or over-budget GPU model diagnostics report");
+    this.name = "GpuModelDiagnosticsError";
+  }
+};
+function fail2() {
+  throw new GpuModelDiagnosticsError();
+}
+function charge(budget, bytes) {
+  budget.bytes += bytes;
+  if (budget.bytes > GPU_MODEL_DIAGNOSTIC_LIMITS.bytes) fail2();
+}
+function textBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function snapshot(value, depth, budget, ancestors, memberLimit = GPU_MODEL_DIAGNOSTIC_LIMITS.members) {
+  if (++budget.values > GPU_MODEL_DIAGNOSTIC_LIMITS.values || depth > GPU_MODEL_DIAGNOSTIC_LIMITS.depth) fail2();
+  if (value === null || typeof value === "boolean") {
+    charge(budget, value === null ? 4 : value ? 4 : 5);
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) fail2();
+    charge(budget, JSON.stringify(value).length);
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (typeof value === "string") {
+    if (value.length > GPU_MODEL_DIAGNOSTIC_LIMITS.string) fail2();
+    charge(budget, textBytes(value));
+    return value;
+  }
+  if (typeof value !== "object" || ancestors.has(value)) fail2();
+  const array2 = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array2 ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) fail2();
+  const keys = Reflect.ownKeys(value);
+  const maxMembers = memberLimit;
+  if (keys.length > maxMembers + (array2 ? 1 : 0)) fail2();
+  ancestors.add(value);
+  charge(budget, 2);
+  if (array2) {
+    const length = Object.getOwnPropertyDescriptor(value, "length").value;
+    if (length > maxMembers || keys.length !== length + 1) fail2();
+    const result2 = [];
+    for (let i = 0; i < length; i++) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) fail2();
+      if (i > 0) charge(budget, 1);
+      result2.push(snapshot(descriptor.value, depth + 1, budget, ancestors));
+    }
+    ancestors.delete(value);
+    return Object.freeze(result2);
+  }
+  const result = {};
+  let count = 0;
+  for (const key of keys) {
+    if (typeof key !== "string" || key.length > 256 || ["__proto__", "constructor", "prototype"].includes(key)) fail2();
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor) || !descriptor.enumerable) fail2();
+    if (count++ > 0) charge(budget, 1);
+    charge(budget, textBytes(key) + 1);
+    result[key] = snapshot(descriptor.value, depth + 1, budget, ancestors, depth === 0 && key === "issues" ? GPU_MODEL_DIAGNOSTIC_LIMITS.issues : GPU_MODEL_DIAGNOSTIC_LIMITS.members);
+  }
+  ancestors.delete(value);
+  return Object.freeze(result);
+}
+function record(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return fail2();
+  return value;
+}
+function keysOnly(value, allowed) {
+  if (Object.keys(value).some((key) => !allowed.includes(key))) fail2();
+}
+function enumValue(value, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) return fail2();
+  return value;
+}
+function hasUnsafeText(value) {
+  for (const character of value) {
+    const point = character.codePointAt(0);
+    if (point < 32 || point >= 127 && point <= 159 || point >= 8232 && point <= 8238 || point >= 8294 && point <= 8297 || point >= 55296 && point <= 57343) return true;
+  }
+  return false;
+}
+function text(value, max) {
+  if (typeof value !== "string" || value.length === 0 || value.length > max || hasUnsafeText(value)) return fail2();
+  return value;
+}
+function boolean(value) {
+  if (typeof value !== "boolean") return fail2();
+  return value;
+}
+function parseIssue(value) {
+  const issue = record(value);
+  const kind = enumValue(issue.kind, ["violation", "unsupported", "warning", "loss"]);
+  const base = { code: text(issue.code, 128), path: text(issue.path, 1024), message: text(issue.message, 2048) };
+  if (!base.path.startsWith("/")) fail2();
+  const common = ["kind", "code", "path", "message"];
+  if (kind === "violation") {
+    keysOnly(issue, [...common, "ruleId", "originalValue", "repairApplied"]);
+    if (!Object.hasOwn(issue, "originalValue")) fail2();
+    return { ...base, kind, ruleId: text(issue.ruleId, 128), originalValue: issue.originalValue, repairApplied: boolean(issue.repairApplied) };
+  }
+  if (kind === "loss") {
+    keysOnly(issue, [...common, "effect"]);
+    return { ...base, kind, effect: enumValue(issue.effect, ["dropped", "approximated"]) };
+  }
+  keysOnly(issue, common);
+  return { ...base, kind };
+}
+function evaluateGpuModelDiagnostics(value) {
+  const budget = { values: 0, bytes: 0 };
+  const args = record(snapshot(value, 0, budget, /* @__PURE__ */ new Set()));
+  keysOnly(args, ["standard", "mode", "allowLoss", "issues", "rawSource", "maxEvidenceBytes"]);
+  const standard = enumValue(args.standard, ["gltf-glb", "obj-mtl", "fbx", "cad-bim"]);
+  const mode = args.mode === void 0 ? "strict" : enumValue(args.mode, ["strict", "tolerant", "forensic"]);
+  const allowLoss = args.allowLoss === void 0 ? false : boolean(args.allowLoss);
+  if (args.maxEvidenceBytes !== void 0 && (typeof args.maxEvidenceBytes !== "number" || !Number.isSafeInteger(args.maxEvidenceBytes) || args.maxEvidenceBytes < 1 || args.maxEvidenceBytes > GPU_MODEL_DIAGNOSTIC_LIMITS.bytes || budget.bytes > args.maxEvidenceBytes)) fail2();
+  if (mode === "forensic" ? !Object.hasOwn(args, "rawSource") : Object.hasOwn(args, "rawSource")) fail2();
+  if (!Array.isArray(args.issues) || args.issues.length > GPU_MODEL_DIAGNOSTIC_LIMITS.issues) fail2();
+  const issues = args.issues.map(parseIssue);
+  const lossPaths = new Set(issues.filter((issue) => issue.kind === "loss").map((issue) => issue.path));
+  const diagnostics = [];
+  const repairs = [];
+  const losses = [];
+  let accepted = true;
+  for (const issue of issues) {
+    const base = { code: issue.code, path: issue.path, message: issue.message };
+    if (issue.kind === "violation") {
+      const rule = GPU_MODEL_REPAIR_RULES.find((rule2) => rule2.id === issue.ruleId);
+      const requiresLoss = ["invalid-indices", "missing-texture-path", "malformed-material-reference"].includes(issue.ruleId);
+      const repaired = mode !== "strict" && issue.repairApplied && rule && rule.standardIds.includes(standard) && (!requiresLoss || lossPaths.has(issue.path));
+      if (repaired) {
+        repairs.push(Object.freeze({ ruleId: rule.id, originalValue: issue.originalValue, action: rule.action, severity: rule.severity, affectedPath: issue.path, confidence: rule.confidence }));
+        diagnostics.push(Object.freeze({ ...base, kind: "repair", severity: rule.severity, ruleId: rule.id }));
+      } else {
+        accepted = false;
+        diagnostics.push(Object.freeze({ ...base, kind: "blocking-error", severity: "error", ruleId: issue.ruleId }));
+      }
+    } else if (issue.kind === "unsupported") {
+      accepted = false;
+      diagnostics.push(Object.freeze({ ...issue, severity: "error" }));
+    } else if (issue.kind === "loss") {
+      if (!allowLoss) accepted = false;
+      const loss = Object.freeze({ ...issue, severity: "warning" });
+      losses.push(loss);
+      diagnostics.push(loss);
+    } else diagnostics.push(Object.freeze({ ...issue, severity: "warning" }));
+  }
+  return Object.freeze({ mode, standard, accepted, diagnostics: Object.freeze(diagnostics), repairs: Object.freeze(repairs), losses: Object.freeze(losses), ...mode === "forensic" ? { rawSource: args.rawSource } : {} });
+}
+
+// src/resource-graph.ts
+var GPU_MODEL_RESOURCE_GRAPH_LIMITS = Object.freeze({
+  nodes: 65536,
+  edges: 262144,
+  packages: 256,
+  pathLength: 1024
+});
+var GPU_MODEL_RESOURCE_GRAPH_SCHEMA_VERSION = "plasius.gpu-model-resource-graph/1";
+var KINDS = ["resource", "accessor", "texture", "material", "skeleton", "skin", "animation", "provenance", "package"];
+var GpuModelResourceGraphError = class extends TypeError {
+  constructor(code) {
+    super(`Invalid GPU model resource graph: ${code}`);
+    this.code = code;
+    this.name = "GpuModelResourceGraphError";
+  }
+  code;
+};
+function fail3(code = "invalid-value") {
+  throw new GpuModelResourceGraphError(code);
+}
+function identifier(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value)) fail3();
+  return value;
+}
+function choice(value, choices) {
+  if (typeof value !== "string" || !choices.includes(value)) fail3();
+  return value;
+}
+function gpuModelResourceKey(kind, id) {
+  return JSON.stringify([choice(kind, KINDS), identifier(id)]);
+}
+function record2(value, keys) {
+  if (typeof value !== "object" || value === null || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail3();
+  const names = Reflect.ownKeys(value);
+  if (names.length !== keys.length || names.some((key) => typeof key !== "string" || !keys.includes(key))) fail3();
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) fail3();
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+function array(value, maximum) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) fail3();
+  if (value.length > maximum) fail3("limit-exceeded");
+  if (Reflect.ownKeys(value).length !== value.length + 1) fail3();
+  const output = [];
+  for (let index = 0; index < value.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) fail3();
+    output.push(descriptor.value);
+  }
+  return output;
+}
+function relativePath(value) {
+  if (typeof value !== "string" || value.length > GPU_MODEL_RESOURCE_GRAPH_LIMITS.pathLength || !/^[A-Za-z0-9._/-]+$/u.test(value)) fail3();
+  for (const part of value.split("/")) {
+    if (!part || part.length > 255 || part === "." || part === ".." || part.endsWith(".") || /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\.|$)/iu.test(part)) fail3();
+  }
+  return value;
+}
+function parseLocation(value) {
+  if (typeof value !== "object" || value === null) fail3();
+  const kind = Object.getOwnPropertyDescriptor(value, "kind");
+  if (!kind || !("value" in kind)) fail3();
+  if (kind.value === "embedded") {
+    record2(value, ["kind"]);
+    return Object.freeze({ kind: "embedded" });
+  }
+  const location = record2(value, ["kind", "relativePath"]);
+  if (location.kind !== "external") fail3();
+  return Object.freeze({ kind: "external", relativePath: relativePath(location.relativePath) });
+}
+var graphs = /* @__PURE__ */ new WeakSet();
+function isGpuModelResourceGraph(value) {
+  return typeof value === "object" && value !== null && graphs.has(value);
+}
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function createGpuModelResourceGraph(document, input) {
+  try {
+    return buildGraph(document, input);
+  } catch (error) {
+    if (error instanceof GpuModelResourceGraphError) throw error;
+    fail3();
+  }
+}
+function buildGraph(document, input) {
+  if (!isGpuModelDocument(document)) fail3("unverified-document");
+  const raw = record2(input, ["resources", "packages"]);
+  const resourceInputs = array(raw.resources, GPU_MODEL_RESOURCE_GRAPH_LIMITS.nodes);
+  const packageInputs = array(raw.packages, GPU_MODEL_RESOURCE_GRAPH_LIMITS.packages);
+  const nodes = /* @__PURE__ */ new Map();
+  let edgeCount = 0;
+  const add = (kind, id, value, dependencies) => {
+    const key = gpuModelResourceKey(kind, id);
+    if (nodes.has(key)) fail3("duplicate-reference");
+    if (nodes.size >= GPU_MODEL_RESOURCE_GRAPH_LIMITS.nodes) fail3("limit-exceeded");
+    edgeCount += dependencies.length;
+    if (edgeCount > GPU_MODEL_RESOURCE_GRAPH_LIMITS.edges) fail3("limit-exceeded");
+    nodes.set(key, Object.freeze({ kind, id, key, value, dependencies: Object.freeze([...new Set(dependencies)].sort(compare)) }));
+  };
+  const resources = new Map(document.resources.map((resource) => [resource.id, resource]));
+  const paths = /* @__PURE__ */ new Set();
+  for (const entry of resourceInputs) {
+    const binding = record2(entry, ["resourceId", "location", "exportEmbeddingPolicy"]);
+    const id = identifier(binding.resourceId);
+    const resource = resources.get(id);
+    if (!resource) fail3("missing-reference");
+    const location = parseLocation(binding.location);
+    const exportEmbeddingPolicy = choice(binding.exportEmbeddingPolicy, ["inherit-source", "prefer-embedded", "prefer-external", "forbid-embedding"]);
+    if (location.kind === "embedded" && exportEmbeddingPolicy === "forbid-embedding") fail3();
+    if (location.kind === "external") {
+      const path = location.relativePath.toLowerCase();
+      if (paths.has(path)) fail3("duplicate-reference");
+      paths.add(path);
+    }
+    add("resource", id, Object.freeze({ resource, location, exportEmbeddingPolicy }), []);
+  }
+  for (const path of paths) {
+    for (let index = path.indexOf("/"); index !== -1; index = path.indexOf("/", index + 1)) {
+      if (paths.has(path.slice(0, index))) fail3("duplicate-reference");
+    }
+  }
+  if (nodes.size !== resources.size) fail3("missing-reference");
+  addDocumentNodes(document, add);
+  for (const entry of packageInputs) {
+    const pkg = record2(entry, ["id", "members"]);
+    const id = identifier(pkg.id);
+    const members = [];
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const entry2 of array(pkg.members, GPU_MODEL_RESOURCE_GRAPH_LIMITS.edges - edgeCount)) {
+      const reference = record2(entry2, ["kind", "id"]);
+      const member = Object.freeze({ kind: choice(reference.kind, KINDS), id: identifier(reference.id) });
+      const key = gpuModelResourceKey(member.kind, member.id);
+      if (dependencies.has(key)) fail3("duplicate-reference");
+      dependencies.add(key);
+      members.push(member);
+    }
+    members.sort((a, b) => compare(gpuModelResourceKey(a.kind, a.id), gpuModelResourceKey(b.kind, b.id)));
+    add("package", id, Object.freeze({ id, members: Object.freeze(members) }), [...dependencies]);
+  }
+  validateDag(nodes);
+  const result = Object.freeze({ schemaVersion: GPU_MODEL_RESOURCE_GRAPH_SCHEMA_VERSION, nodes: Object.freeze([...nodes.values()].sort((a, b) => compare(a.key, b.key))) });
+  graphs.add(result);
+  return result;
+}
+function addDocumentNodes(document, add) {
+  const key = gpuModelResourceKey;
+  for (const value of document.accessors) add("accessor", value.id, value, [key("resource", value.resourceId)]);
+  for (const value of document.textures) add("texture", value.id, value, [key("resource", value.imageResourceId)]);
+  for (const value of document.materials) add("material", value.id, value, Object.values(value.textures).map((binding) => key("texture", binding.textureId)));
+  const joints = new Map(document.joints.map((joint) => [joint.id, joint]));
+  for (const skeleton of document.skeletons) add("skeleton", skeleton.id, Object.freeze({ skeleton, joints: Object.freeze(skeleton.jointIds.map((id) => joints.get(id))) }), []);
+  const primitives = new Map(document.meshes.flatMap((mesh) => mesh.primitives.map((primitive) => [primitive.id, primitive])));
+  for (const value of document.skins) {
+    const dependencies = [key("skeleton", value.skeletonId)];
+    for (const weightSet of value.weightSets) {
+      for (const attribute of primitives.get(weightSet.primitiveId).attributes) {
+        if (/^(JOINTS|WEIGHTS)_/u.test(attribute.semantic)) dependencies.push(key("accessor", attribute.accessorId));
+      }
+    }
+    add("skin", value.id, value, dependencies);
+  }
+  for (const value of document.animations) add("animation", value.id, value, value.samplers.flatMap((sampler) => [key("accessor", sampler.inputAccessorId), key("accessor", sampler.outputAccessorId)]));
+  add("provenance", "source", document.provenance, []);
+}
+function validateDag(nodes) {
+  const remaining = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const node of nodes.values()) {
+    remaining.set(node.key, node.dependencies.length);
+    if (!node.dependencies.length) queue.push(node.key);
+    for (const dependency of node.dependencies) {
+      if (!nodes.has(dependency)) fail3("missing-reference");
+      const users = dependents.get(dependency) ?? [];
+      users.push(node.key);
+      dependents.set(dependency, users);
+    }
+  }
+  for (let index = 0; index < queue.length; index++) {
+    for (const dependent of dependents.get(queue[index]) ?? []) {
+      const count = remaining.get(dependent) - 1;
+      remaining.set(dependent, count);
+      if (!count) queue.push(dependent);
+    }
+  }
+  if (queue.length !== nodes.size) fail3("graph-cycle");
+}
+
 // src/index.ts
 var packageName = "@plasius/gpu-model-core";
 var packageBootstrap = Object.freeze({
@@ -2092,8 +2547,12 @@ var packageBootstrap = Object.freeze({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CANONICAL_GPU_MODEL_COORDINATE_SYSTEM,
+  GPU_MODEL_DIAGNOSTIC_LIMITS,
   GPU_MODEL_DOCUMENT_LIMITS,
   GPU_MODEL_DOCUMENT_SCHEMA_VERSION,
+  GPU_MODEL_REPAIR_RULES,
+  GPU_MODEL_RESOURCE_GRAPH_LIMITS,
+  GPU_MODEL_RESOURCE_GRAPH_SCHEMA_VERSION,
   GPU_MODEL_RESOURCE_VERIFICATION_LIMITS,
   GPU_MODEL_STATIC_DEMO_FEATURE_FLAG,
   GPU_MODEL_STATIC_DEMO_LIMITS,
@@ -2102,15 +2561,21 @@ var packageBootstrap = Object.freeze({
   GPU_MODEL_STATIC_DEMO_MAX_EXTENT_METRES,
   GPU_MODEL_STATIC_DEMO_NORMALIZATION_CONTRACT,
   GPU_MODEL_STATIC_DEMO_PROFILE_VERSION,
+  GpuModelDiagnosticsError,
   GpuModelDocumentError,
+  GpuModelResourceGraphError,
   assertGpuModelStaticDemoNormalization,
   canCreateGpuModelDocument,
   createAndVerifyGpuModelDocument,
   createGpuModelDocument,
+  createGpuModelResourceGraph,
   createGpuModelStaticDemoCompilerInput,
   encodeGpuModelDocumentCanonical,
+  evaluateGpuModelDiagnostics,
+  gpuModelResourceKey,
   hashGpuModelDocumentCanonical,
   isGpuModelDocument,
+  isGpuModelResourceGraph,
   packageBootstrap,
   packageName,
   verifyGpuModelResource