@plasius/gpu-model-core 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -38,12 +38,16 @@ __export(index_exports, {
   GpuModelDiagnosticsError: () => GpuModelDiagnosticsError,
   GpuModelDocumentError: () => GpuModelDocumentError,
   GpuModelResourceGraphError: () => GpuModelResourceGraphError,
+  MODEL_REGISTRY_LIMITS: () => MODEL_REGISTRY_LIMITS,
+  ModelRegistryError: () => ModelRegistryError,
   assertGpuModelStaticDemoNormalization: () => assertGpuModelStaticDemoNormalization,
   canCreateGpuModelDocument: () => canCreateGpuModelDocument,
   createAndVerifyGpuModelDocument: () => createAndVerifyGpuModelDocument,
   createGpuModelDocument: () => createGpuModelDocument,
   createGpuModelResourceGraph: () => createGpuModelResourceGraph,
   createGpuModelStaticDemoCompilerInput: () => createGpuModelStaticDemoCompilerInput,
+  createModelConversionRegistry: () => createModelConversionRegistry,
+  createModelResultBase: () => createModelResultBase,
   encodeGpuModelDocumentCanonical: () => encodeGpuModelDocumentCanonical,
   evaluateGpuModelDiagnostics: () => evaluateGpuModelDiagnostics,
   gpuModelResourceKey: () => gpuModelResourceKey,
@@ -230,9 +234,9 @@ function readRecord(value, path, allowedKeys) {
   }
   return value;
 }
-function requireKey(record3, key, path) {
-  if (!Object.hasOwn(record3, key)) return fail("invalid-value", `${path}.${key}`, "required key is missing");
-  return record3[key];
+function requireKey(record4, key, path) {
+  if (!Object.hasOwn(record4, key)) return fail("invalid-value", `${path}.${key}`, "required key is missing");
+  return record4[key];
 }
 function readArray(value, path, maximum, minimum = 0) {
   if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
@@ -311,9 +315,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(record3, key, parser, path) {
-  if (!Object.hasOwn(record3, key)) return void 0;
-  return parser(record3[key], `${path}.${key}`);
+function readOptional(record4, key, parser, path) {
+  if (!Object.hasOwn(record4, key)) return void 0;
+  return parser(record4[key], `${path}.${key}`);
 }
 function assignOptional(target, key, value) {
   if (value !== void 0) Object.assign(target, { [key]: value });
@@ -335,17 +339,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 record3 = value;
-  const prototype = Object.getPrototypeOf(record3);
+  const record4 = value;
+  const prototype = Object.getPrototypeOf(record4);
   if (prototype !== Object.prototype && prototype !== null) return fail("invalid-type", path, "metadata objects must be plain objects");
-  const keys = Reflect.ownKeys(record3);
+  const keys = Reflect.ownKeys(record4);
   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(record3, key);
+    const descriptor = Object.getOwnPropertyDescriptor(record4, 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);
   }
@@ -358,9 +362,9 @@ function readMetadata(value, path, budget) {
 }
 function parseCoordinateSystem(value) {
   const path = "$.coordinateSystem";
-  const record3 = readRecord(value, path, ["unit", "upAxis", "forwardAxis", "handedness", "winding", "origin"]);
+  const record4 = readRecord(value, path, ["unit", "upAxis", "forwardAxis", "handedness", "winding", "origin"]);
   for (const [key, expected] of Object.entries(CANONICAL_GPU_MODEL_COORDINATE_SYSTEM)) {
-    if (requireKey(record3, key, path) !== expected) return fail("invalid-value", `${path}.${key}`, "coordinate system is not canonical");
+    if (requireKey(record4, key, path) !== expected) return fail("invalid-value", `${path}.${key}`, "coordinate system is not canonical");
   }
   return CANONICAL_GPU_MODEL_COORDINATE_SYSTEM;
 }
@@ -372,19 +376,19 @@ function parseMatrix(value, path, requireAffine = true) {
   return matrix;
 }
 function parseBounds(value, path) {
-  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);
+  const record4 = readRecord(value, path, ["min", "max"]);
+  const min = readNumberTuple(requireKey(record4, "min", path), `${path}.min`, 3);
+  const max = readNumberTuple(requireKey(record4, "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 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 record4 = readRecord(value, path, ["translation", "rotation", "scale"]);
+  const translation = readNumberTuple(requireKey(record4, "translation", path), `${path}.translation`, 3);
+  const rotation = readNumberTuple(requireKey(record4, "rotation", path), `${path}.rotation`, 4);
+  const scale = readNumberTuple(requireKey(record4, "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 };
@@ -406,25 +410,25 @@ function intrinsicBlobArrayBuffer(blob) {
   return Reflect.apply(blobArrayBuffer, blob, []);
 }
 function parseResourceHeader(value, path) {
-  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();
+  const record4 = readRecord(value, path, ["id", "kind", "contentHash", "byteLength", "mimeType", "payload"]);
+  const kind = readEnum(requireKey(record4, "kind", path), `${path}.kind`, ["buffer", "image"]);
+  const mimeType = readString(requireKey(record4, "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(record3, "payload", path);
+  const payload = requireKey(record4, "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(record3, "byteLength", path), `${path}.byteLength`, 1);
+  const byteLength = readSafeInteger(requireKey(record4, "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(record3, "id", path), `${path}.id`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
     kind,
-    contentHash: readSha256(requireKey(record3, "contentHash", path), `${path}.contentHash`),
+    contentHash: readSha256(requireKey(record4, "contentHash", path), `${path}.contentHash`),
     byteLength,
     mimeType,
     payload
@@ -433,11 +437,11 @@ function parseResourceHeader(value, path) {
 function resolveVerificationLimits(options) {
   const overrides = options?.limits;
   if (overrides === void 0) return GPU_MODEL_RESOURCE_VERIFICATION_LIMITS;
-  const record3 = readRecord(overrides, "$.verification.limits", Object.keys(GPU_MODEL_RESOURCE_VERIFICATION_LIMITS));
+  const record4 = 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(record3, key)) continue;
-    const value = readSafeInteger(record3[key], `$.verification.limits.${key}`, 1, ceiling);
+    if (!Object.hasOwn(record4, key)) continue;
+    const value = readSafeInteger(record4[key], `$.verification.limits.${key}`, 1, ceiling);
     Object.assign(output, { [key]: value });
   }
   if (output.maxImageBytes > output.maxResourceBytes) output.maxImageBytes = output.maxResourceBytes;
@@ -549,13 +553,13 @@ function createVerificationDeadline(timeoutMs, callerSignal, path) {
   };
 }
 function parseInspection(value, path) {
-  const record3 = readRecord(value, path, ["valid", "detectedMimeType", "width", "height"]);
+  const record4 = readRecord(value, path, ["valid", "detectedMimeType", "width", "height"]);
   const output = {
-    valid: readBoolean(requireKey(record3, "valid", path), `${path}.valid`),
-    detectedMimeType: readString(requireKey(record3, "detectedMimeType", path), `${path}.detectedMimeType`, 128, MIME_TYPE).toLowerCase()
+    valid: readBoolean(requireKey(record4, "valid", path), `${path}.valid`),
+    detectedMimeType: readString(requireKey(record4, "detectedMimeType", path), `${path}.detectedMimeType`, 128, MIME_TYPE).toLowerCase()
   };
-  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));
+  assignOptional(output, "width", readOptional(record4, "width", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
+  assignOptional(output, "height", readOptional(record4, "height", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
   return output;
 }
 function bytesStartWith(bytes, signature) {
@@ -670,62 +674,62 @@ async function verifyGpuModelResource(value, port, options) {
   }
 }
 function parseNode(value, path, budget) {
-  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}]`)));
+  const record4 = readRecord(value, path, ["id", "name", "children", "meshId", "skinId", "localMatrix", "metadata"]);
+  const children = Object.freeze(readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
     children,
-    localMatrix: parseMatrix(requireKey(record3, "localMatrix", path), `${path}.localMatrix`)
+    localMatrix: parseMatrix(requireKey(record4, "localMatrix", path), `${path}.localMatrix`)
   };
-  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));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "meshId", readOptional(record4, "meshId", readId, path));
+  assignOptional(output, "skinId", readOptional(record4, "skinId", readId, path));
+  assignOptional(output, "metadata", readOptional(record4, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseAccessor(value, path, budget) {
-  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);
+  const record4 = readRecord(value, path, ["id", "resourceId", "byteOffset", "byteStride", "count", "componentType", "elementType", "normalized", "min", "max"]);
+  const componentType = readEnum(requireKey(record4, "componentType", path), `${path}.componentType`, ["i8", "u8", "i16", "u16", "u32", "f32"]);
+  const elementType = readEnum(requireKey(record4, "elementType", path), `${path}.elementType`, ["scalar", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4"]);
+  const normalized = readOptional(record4, "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(record3, "min", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
-  const max = readOptional(record3, "max", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
+  const min = readOptional(record4, "min", (entry, entryPath) => readNumberTuple(entry, entryPath, expectedComponents), path);
+  const max = readOptional(record4, "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];
+    const [componentMinimum, componentMaximum, integer2] = COMPONENT_RANGES[componentType];
     for (let index = 0; index < expectedComponents; index += 1) {
       const minimum = min[index];
       const maximum = max[index];
       if (minimum > maximum) return fail("invalid-value", path, "accessor min cannot exceed max");
-      if (minimum < componentMinimum || maximum > componentMaximum || integer && (!Number.isInteger(minimum) || !Number.isInteger(maximum))) {
+      if (minimum < componentMinimum || maximum > componentMaximum || integer2 && (!Number.isInteger(minimum) || !Number.isInteger(maximum))) {
         return fail("invalid-value", path, "accessor bounds are outside the component representation");
       }
     }
   }
-  const count = readSafeInteger(requireKey(record3, "count", path), `${path}.count`, 1, GPU_MODEL_DOCUMENT_LIMITS.weightVertices);
+  const count = readSafeInteger(requireKey(record4, "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(record3, "id", path), `${path}.id`),
-    resourceId: readId(requireKey(record3, "resourceId", path), `${path}.resourceId`),
-    byteOffset: readSafeInteger(requireKey(record3, "byteOffset", path), `${path}.byteOffset`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    resourceId: readId(requireKey(record4, "resourceId", path), `${path}.resourceId`),
+    byteOffset: readSafeInteger(requireKey(record4, "byteOffset", path), `${path}.byteOffset`),
     count,
     componentType,
     elementType
   };
-  assignOptional(output, "byteStride", readOptional(record3, "byteStride", (entry, entryPath) => readSafeInteger(entry, entryPath, 1, 2048), path));
+  assignOptional(output, "byteStride", readOptional(record4, "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 record3 = readRecord(value, path, ["id", "topology", "attributes", "indicesAccessorId", "materialId", "metadata"]);
-  const attributesInput = readArray(requireKey(record3, "attributes", path), `${path}.attributes`, 64, 1);
+  const record4 = readRecord(value, path, ["id", "topology", "attributes", "indicesAccessorId", "materialId", "metadata"]);
+  const attributesInput = readArray(requireKey(record4, "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}]`;
@@ -738,53 +742,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(record3, "id", path), `${path}.id`),
-    topology: readEnum(requireKey(record3, "topology", path), `${path}.topology`, ["points", "lines", "line-strip", "triangles", "triangle-strip"]),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    topology: readEnum(requireKey(record4, "topology", path), `${path}.topology`, ["points", "lines", "line-strip", "triangles", "triangle-strip"]),
     attributes
   };
-  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));
+  assignOptional(output, "indicesAccessorId", readOptional(record4, "indicesAccessorId", readId, path));
+  assignOptional(output, "materialId", readOptional(record4, "materialId", readId, path));
+  assignOptional(output, "metadata", readOptional(record4, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseMesh(value, path, budget) {
-  const record3 = readRecord(value, path, ["id", "name", "primitives", "metadata"]);
-  const input = readArray(requireKey(record3, "primitives", path), `${path}.primitives`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
+  const record4 = readRecord(value, path, ["id", "name", "primitives", "metadata"]);
+  const input = readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
     primitives: Object.freeze(input.map((entry, index) => parsePrimitive(entry, `${path}.primitives[${index}]`, budget)))
   };
-  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));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "metadata", readOptional(record4, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseTextureTransform(value, path) {
-  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 record4 = readRecord(value, path, ["offset", "rotationRadians", "scale"]);
+  if (Reflect.ownKeys(record4).length === 0) return fail("invalid-value", path, "texture transform cannot be empty");
   const output = {};
-  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));
+  assignOptional(output, "offset", readOptional(record4, "offset", (entry, entryPath) => readNumberTuple(entry, entryPath, 2), path));
+  assignOptional(output, "rotationRadians", readOptional(record4, "rotationRadians", readFinite, path));
+  assignOptional(output, "scale", readOptional(record4, "scale", (entry, entryPath) => readNumberTuple(entry, entryPath, 2), path));
   return output;
 }
 function parseTextureBinding(value, path) {
-  const record3 = readRecord(value, path, ["textureId", "samplerId", "texCoordSet", "transform", "colorSpace", "intendedUsage"]);
+  const record4 = readRecord(value, path, ["textureId", "samplerId", "texCoordSet", "transform", "colorSpace", "intendedUsage"]);
   const output = {
-    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)
+    textureId: readId(requireKey(record4, "textureId", path), `${path}.textureId`),
+    colorSpace: readEnum(requireKey(record4, "colorSpace", path), `${path}.colorSpace`, ["srgb", "linear", "normal-map", "data"]),
+    intendedUsage: readEnum(requireKey(record4, "intendedUsage", path), `${path}.intendedUsage`, TEXTURE_USAGES)
   };
-  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));
+  assignOptional(output, "samplerId", readOptional(record4, "samplerId", readId, path));
+  assignOptional(output, "texCoordSet", readOptional(record4, "texCoordSet", (entry, entryPath) => readSafeInteger(entry, entryPath, 0, 7), path));
+  assignOptional(output, "transform", readOptional(record4, "transform", parseTextureTransform, path));
   return output;
 }
 function parseMaterialTextures(value, path) {
   const slots = Object.keys(MATERIAL_TEXTURE_SLOTS);
-  const record3 = readRecord(value, path, slots);
+  const record4 = readRecord(value, path, slots);
   const output = {};
-  for (const slot of slots) assignOptional(output, slot, readOptional(record3, slot, parseTextureBinding, path));
+  for (const slot of slots) assignOptional(output, slot, readOptional(record4, slot, parseTextureBinding, path));
   return output;
 }
 function parseMaterial(value, path, budget) {
@@ -810,138 +814,138 @@ function parseMaterial(value, path, budget) {
     "extensions",
     "sourceMetadata"
   ];
-  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);
+  const record4 = readRecord(value, path, keys);
+  const alphaMode = readEnum(requireKey(record4, "alphaMode", path), `${path}.alphaMode`, ["opaque", "mask", "blend"]);
+  const alphaCutoff = readOptional(record4, "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(record3, "id", path), `${path}.id`),
-    workflow: readEnum(requireKey(record3, "workflow", path), `${path}.workflow`, ["metallic-roughness", "specular-glossiness", "unlit", "custom"]),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    workflow: readEnum(requireKey(record4, "workflow", path), `${path}.workflow`, ["metallic-roughness", "specular-glossiness", "unlit", "custom"]),
     alphaMode,
-    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)
+    baseColorFactor: readNumberTuple(requireKey(record4, "baseColorFactor", path), `${path}.baseColorFactor`, 4, 0, 1),
+    textures: parseMaterialTextures(requireKey(record4, "textures", path), `${path}.textures`),
+    extensions: readMetadata(requireKey(record4, "extensions", path), `${path}.extensions`, budget),
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
   assignOptional(output, "alphaCutoff", alphaCutoff);
-  assignOptional(output, "doubleSided", readOptional(record3, "doubleSided", readBoolean, path));
+  assignOptional(output, "doubleSided", readOptional(record4, "doubleSided", readBoolean, path));
   for (const key of ["metallicFactor", "roughnessFactor", "transmissionFactor", "clearcoatFactor", "clearcoatRoughnessFactor", "sheenRoughnessFactor", "occlusionStrength"]) {
-    assignOptional(output, key, readOptional(record3, key, (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path));
+    assignOptional(output, key, readOptional(record4, key, (entry, entryPath) => readFinite(entry, entryPath, 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));
+  assignOptional(output, "normalScale", readOptional(record4, "normalScale", readFinite, path));
+  assignOptional(output, "emissiveFactor", readOptional(record4, "emissiveFactor", (entry, entryPath) => readNumberTuple(entry, entryPath, 3, 0), path));
+  assignOptional(output, "sheenColorFactor", readOptional(record4, "sheenColorFactor", (entry, entryPath) => readNumberTuple(entry, entryPath, 3, 0, 1), path));
   return output;
 }
 function parseTextureSampler(value, 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));
+  const record4 = readRecord(value, path, ["id", "wrapS", "wrapT", "minFilter", "magFilter", "mipFilter"]);
+  const output = { id: readId(requireKey(record4, "id", path), `${path}.id`) };
+  assignOptional(output, "wrapS", readOptional(record4, "wrapS", (entry, entryPath) => readEnum(entry, entryPath, ["repeat", "mirrored-repeat", "clamp-to-edge"]), path));
+  assignOptional(output, "wrapT", readOptional(record4, "wrapT", (entry, entryPath) => readEnum(entry, entryPath, ["repeat", "mirrored-repeat", "clamp-to-edge"]), path));
+  assignOptional(output, "minFilter", readOptional(record4, "minFilter", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
+  assignOptional(output, "magFilter", readOptional(record4, "magFilter", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
+  assignOptional(output, "mipFilter", readOptional(record4, "mipFilter", (entry, entryPath) => readEnum(entry, entryPath, ["nearest", "linear"]), path));
   return output;
 }
 function parseTexture(value, path, budget) {
-  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)));
+  const record4 = readRecord(value, path, ["id", "fileName", "relativePath", "mimeType", "contentHash", "imageResourceId", "byteLength", "intendedUsage", "colorSpace", "sampler", "exportEmbeddingPolicy", "sourceMetadata"]);
+  const usages = Object.freeze(readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
-    contentHash: readSha256(requireKey(record3, "contentHash", path), `${path}.contentHash`),
-    imageResourceId: readId(requireKey(record3, "imageResourceId", path), `${path}.imageResourceId`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    contentHash: readSha256(requireKey(record4, "contentHash", path), `${path}.contentHash`),
+    imageResourceId: readId(requireKey(record4, "imageResourceId", path), `${path}.imageResourceId`),
     intendedUsage: usages,
-    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)
+    colorSpace: readEnum(requireKey(record4, "colorSpace", path), `${path}.colorSpace`, ["srgb", "linear", "normal-map", "data"]),
+    exportEmbeddingPolicy: readEnum(requireKey(record4, "exportEmbeddingPolicy", path), `${path}.exportEmbeddingPolicy`, ["inherit-source", "prefer-embedded", "prefer-external", "forbid-embedding"]),
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  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));
+  assignOptional(output, "fileName", readOptional(record4, "fileName", (entry, entryPath) => readString(entry, entryPath, 512, FILE_NAME), path));
+  assignOptional(output, "relativePath", readOptional(record4, "relativePath", (entry, entryPath) => readString(entry, entryPath, 2048, RELATIVE_PATH), path));
+  assignOptional(output, "mimeType", readOptional(record4, "mimeType", (entry, entryPath) => readString(entry, entryPath, 128, MIME_TYPE).toLowerCase(), path));
+  assignOptional(output, "byteLength", readOptional(record4, "byteLength", (entry, entryPath) => readSafeInteger(entry, entryPath, 1), path));
+  assignOptional(output, "sampler", readOptional(record4, "sampler", parseTextureSampler, path));
   return output;
 }
 function parseSkeleton(value, path, budget) {
-  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}]`)));
+  const record4 = readRecord(value, path, ["id", "name", "jointIds", "rootJointIds", "sourceMetadata"]);
+  const jointIds = Object.freeze(readArray(requireKey(record4, "jointIds", path), `${path}.jointIds`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, 1).map((entry, index) => readId(entry, `${path}.jointIds[${index}]`)));
+  const rootJointIds = Object.freeze(readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
     jointIds,
     rootJointIds,
-    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
   return output;
 }
 function parseJoint(value, path, budget) {
-  const record3 = readRecord(value, path, ["id", "name", "nodeId", "parentJointId", "restLocalTransform", "inverseBindMatrix", "sourceMetadata"]);
+  const record4 = readRecord(value, path, ["id", "name", "nodeId", "parentJointId", "restLocalTransform", "inverseBindMatrix", "sourceMetadata"]);
   const output = {
-    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)
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    nodeId: readId(requireKey(record4, "nodeId", path), `${path}.nodeId`),
+    restLocalTransform: parseTransformTrs(requireKey(record4, "restLocalTransform", path), `${path}.restLocalTransform`),
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  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));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "parentJointId", readOptional(record4, "parentJointId", readId, path));
+  assignOptional(output, "inverseBindMatrix", readOptional(record4, "inverseBindMatrix", parseMatrix, path));
   return output;
 }
-function parseWeightRows(value, path, rows, columns, integer, budget) {
+function parseWeightRows(value, path, rows, columns, integer2, budget) {
   const input = readArray(value, path, rows, rows);
   consumeBudget(budget, "weightVertices", input.length, GPU_MODEL_DOCUMENT_LIMITS.weightVertices, path, "weight vertex");
   consumeBudget(budget, "weightInfluences", input.length * columns, GPU_MODEL_DOCUMENT_LIMITS.weightInfluences, path, "weight influence");
   return Object.freeze(input.map((row, rowIndex) => {
-    const parsed = readNumberTuple(row, `${path}[${rowIndex}]`, columns, 0, integer ? Number.MAX_SAFE_INTEGER : 1);
-    if (integer && parsed.some((entry) => !Number.isSafeInteger(entry))) return fail("invalid-value", `${path}[${rowIndex}]`, "joint indices must be safe integers");
+    const parsed = readNumberTuple(row, `${path}[${rowIndex}]`, columns, 0, integer2 ? Number.MAX_SAFE_INTEGER : 1);
+    if (integer2 && parsed.some((entry) => !Number.isSafeInteger(entry))) return fail("invalid-value", `${path}[${rowIndex}]`, "joint indices must be safe integers");
     return parsed;
   }));
 }
 function parseVertexWeightSet(value, path, budget) {
-  const record3 = readRecord(value, path, ["primitiveId", "influencesPerVertex", "joints", "weights"]);
-  const influences = readSafeInteger(requireKey(record3, "influencesPerVertex", path), `${path}.influencesPerVertex`, 1, 32);
+  const record4 = readRecord(value, path, ["primitiveId", "influencesPerVertex", "joints", "weights"]);
+  const influences = readSafeInteger(requireKey(record4, "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(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);
+  const jointRows = readArray(requireKey(record4, "joints", path), `${path}.joints`, GPU_MODEL_DOCUMENT_LIMITS.weightVertices, 1);
+  const weightRows = readArray(requireKey(record4, "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(record3, "primitiveId", path), `${path}.primitiveId`),
+    primitiveId: readId(requireKey(record4, "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 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}]`)));
+  const record4 = readRecord(value, path, ["id", "skeletonId", "jointIds", "inverseBindMatrices", "weightSets", "sourceMetadata"]);
+  const jointIds = Object.freeze(readArray(requireKey(record4, "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(record3, "inverseBindMatrices", path), `${path}.inverseBindMatrices`, GPU_MODEL_DOCUMENT_LIMITS.skinJoints, jointIds.length);
+  const inverseInput = readArray(requireKey(record4, "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(record3, "weightSets", path), `${path}.weightSets`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
+  const weightInput = readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
-    skeletonId: readId(requireKey(record3, "skeletonId", path), `${path}.skeletonId`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    skeletonId: readId(requireKey(record4, "skeletonId", path), `${path}.skeletonId`),
     jointIds,
     inverseBindMatrices: Object.freeze(inverseInput.map((entry, index) => parseMatrix(entry, `${path}.inverseBindMatrices[${index}]`))),
     weightSets,
-    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
 }
 function parseBlendShapeDelta(value, path) {
-  const record3 = readRecord(value, path, ["primitiveId", "positionAccessorId", "normalAccessorId", "tangentAccessorId"]);
-  const output = { primitiveId: readId(requireKey(record3, "primitiveId", path), `${path}.primitiveId`) };
+  const record4 = readRecord(value, path, ["primitiveId", "positionAccessorId", "normalAccessorId", "tangentAccessorId"]);
+  const output = { primitiveId: readId(requireKey(record4, "primitiveId", path), `${path}.primitiveId`) };
   for (const key of ["positionAccessorId", "normalAccessorId", "tangentAccessorId"]) {
-    assignOptional(output, key, readOptional(record3, key, readId, path));
+    assignOptional(output, key, readOptional(record4, key, readId, path));
   }
   if (!output.positionAccessorId && !output.normalAccessorId && !output.tangentAccessorId) {
     return fail("invalid-value", path, "blend-shape delta requires at least one accessor");
@@ -949,8 +953,8 @@ function parseBlendShapeDelta(value, path) {
   return output;
 }
 function parseBlendShape(value, path, budget) {
-  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);
+  const record4 = readRecord(value, path, ["id", "meshId", "name", "defaultWeight", "deltas", "sourceMetadata"]);
+  const deltaInput = readArray(requireKey(record4, "deltas", path), `${path}.deltas`, GPU_MODEL_DOCUMENT_LIMITS.primitives, 1);
   consumeBudget(
     budget,
     "blendShapeDeltas",
@@ -962,96 +966,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(record3, "id", path), `${path}.id`),
-    meshId: readId(requireKey(record3, "meshId", path), `${path}.meshId`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    meshId: readId(requireKey(record4, "meshId", path), `${path}.meshId`),
     deltas,
-    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  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));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "defaultWeight", readOptional(record4, "defaultWeight", (entry, entryPath) => readFinite(entry, entryPath, 0, 1), path));
   return output;
 }
 function parseAnimationSampler(value, path, budget) {
-  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);
+  const record4 = readRecord(value, path, ["id", "inputAccessorId", "outputAccessorId", "inputTimesSeconds", "outputValues", "interpolation", "sourceMetadata"]);
+  const timesInput = readArray(requireKey(record4, "inputTimesSeconds", path), `${path}.inputTimesSeconds`, GPU_MODEL_DOCUMENT_LIMITS.animationValues, 1);
+  const valuesInput = readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
-    inputAccessorId: readId(requireKey(record3, "inputAccessorId", path), `${path}.inputAccessorId`),
-    outputAccessorId: readId(requireKey(record3, "outputAccessorId", path), `${path}.outputAccessorId`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    inputAccessorId: readId(requireKey(record4, "inputAccessorId", path), `${path}.inputAccessorId`),
+    outputAccessorId: readId(requireKey(record4, "outputAccessorId", path), `${path}.outputAccessorId`),
     inputTimesSeconds: times,
     outputValues: Object.freeze(valuesInput.map((entry, index) => readFinite(entry, `${path}.outputValues[${index}]`))),
-    interpolation: readEnum(requireKey(record3, "interpolation", path), `${path}.interpolation`, ["step", "linear", "cubic-spline"]),
-    sourceMetadata: readMetadata(requireKey(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    interpolation: readEnum(requireKey(record4, "interpolation", path), `${path}.interpolation`, ["step", "linear", "cubic-spline"]),
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
 }
 function parseAnimationChannel(value, path, budget) {
-  const record3 = readRecord(value, path, ["id", "samplerId", "targetType", "targetId", "sourceMetadata"]);
+  const record4 = readRecord(value, path, ["id", "samplerId", "targetType", "targetId", "sourceMetadata"]);
   return {
-    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)
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    samplerId: readId(requireKey(record4, "samplerId", path), `${path}.samplerId`),
+    targetType: readEnum(requireKey(record4, "targetType", path), `${path}.targetType`, ["node-translation", "node-rotation", "node-scale", "weights"]),
+    targetId: readId(requireKey(record4, "targetId", path), `${path}.targetId`),
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
 }
 function parseAnimation(value, path, budget) {
-  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);
+  const record4 = readRecord(value, path, ["id", "name", "durationSeconds", "samplers", "channels", "sourceMetadata"]);
+  const samplerInput = readArray(requireKey(record4, "samplers", path), `${path}.samplers`, GPU_MODEL_DOCUMENT_LIMITS.animationSamplers, 1);
+  const channelInput = readArray(requireKey(record4, "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(record3, "id", path), `${path}.id`),
-    durationSeconds: readFinite(requireKey(record3, "durationSeconds", path), `${path}.durationSeconds`, 0),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
+    durationSeconds: readFinite(requireKey(record4, "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(record3, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
+    sourceMetadata: readMetadata(requireKey(record4, "sourceMetadata", path), `${path}.sourceMetadata`, budget)
   };
-  assignOptional(output, "name", readOptional(record3, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
+  assignOptional(output, "name", readOptional(record4, "name", (entry, entryPath) => readString(entry, entryPath, GPU_MODEL_DOCUMENT_LIMITS.nameLength), path));
   return output;
 }
 function parseAnalyticGeometry(value, path, budget) {
-  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 record4 = readRecord(value, path, ["id", "kind", "sourceResourceId", "sourceUnit", "tessellatedMeshId", "metadata"]);
+  if (requireKey(record4, "kind", path) !== "brep-placeholder") return fail("invalid-value", `${path}.kind`, "unsupported analytic geometry kind");
   const output = {
-    id: readId(requireKey(record3, "id", path), `${path}.id`),
+    id: readId(requireKey(record4, "id", path), `${path}.id`),
     kind: "brep-placeholder",
-    sourceResourceId: readId(requireKey(record3, "sourceResourceId", path), `${path}.sourceResourceId`),
-    sourceUnit: readEnum(requireKey(record3, "sourceUnit", path), `${path}.sourceUnit`, ["metre", "millimetre", "centimetre", "inch", "foot", "unitless"])
+    sourceResourceId: readId(requireKey(record4, "sourceResourceId", path), `${path}.sourceResourceId`),
+    sourceUnit: readEnum(requireKey(record4, "sourceUnit", path), `${path}.sourceUnit`, ["metre", "millimetre", "centimetre", "inch", "foot", "unitless"])
   };
-  assignOptional(output, "tessellatedMeshId", readOptional(record3, "tessellatedMeshId", readId, path));
-  assignOptional(output, "metadata", readOptional(record3, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
+  assignOptional(output, "tessellatedMeshId", readOptional(record4, "tessellatedMeshId", readId, path));
+  assignOptional(output, "metadata", readOptional(record4, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseProvenance(value, budget) {
   const path = "$.provenance";
-  const record3 = readRecord(value, path, ["sourceFormat", "sourceContentHash", "converterId", "converterVersion", "provider", "sourceIdentifier", "metadata"]);
+  const record4 = readRecord(value, path, ["sourceFormat", "sourceContentHash", "converterId", "converterVersion", "provider", "sourceIdentifier", "metadata"]);
   const output = {
-    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)
+    sourceFormat: readString(requireKey(record4, "sourceFormat", path), `${path}.sourceFormat`, 128, TOKEN),
+    sourceContentHash: readSha256(requireKey(record4, "sourceContentHash", path), `${path}.sourceContentHash`),
+    converterId: readString(requireKey(record4, "converterId", path), `${path}.converterId`, 128, TOKEN),
+    converterVersion: readString(requireKey(record4, "converterVersion", path), `${path}.converterVersion`, 128, TOKEN)
   };
-  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));
+  assignOptional(output, "provider", readOptional(record4, "provider", (entry, entryPath) => readString(entry, entryPath, 128, TOKEN), path));
+  assignOptional(output, "sourceIdentifier", readOptional(record4, "sourceIdentifier", (entry, entryPath) => readString(entry, entryPath, 2048), path));
+  assignOptional(output, "metadata", readOptional(record4, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function parseDiagnostic(value, path, budget) {
-  const record3 = readRecord(value, path, ["severity", "code", "message", "path", "metadata"]);
+  const record4 = readRecord(value, path, ["severity", "code", "message", "path", "metadata"]);
   const output = {
-    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)
+    severity: readEnum(requireKey(record4, "severity", path), `${path}.severity`, ["info", "warning", "error"]),
+    code: readString(requireKey(record4, "code", path), `${path}.code`, 128, TOKEN),
+    message: readString(requireKey(record4, "message", path), `${path}.message`, GPU_MODEL_DOCUMENT_LIMITS.diagnosticMessageLength)
   };
-  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));
+  assignOptional(output, "path", readOptional(record4, "path", (entry, entryPath) => readString(entry, entryPath, 512), path));
+  assignOptional(output, "metadata", readOptional(record4, "metadata", (entry, entryPath) => readMetadata(entry, entryPath, budget), path));
   return output;
 }
 function ensureUnique(values, path, detail = "duplicate identity") {
@@ -1692,11 +1696,11 @@ var DOCUMENT_KEYS = Object.freeze([
 ]);
 function parseGpuModelDocument(value) {
   const path = "$";
-  const record3 = readRecord(value, path, DOCUMENT_KEYS);
-  const schemaVersion = requireKey(record3, "schemaVersion", path);
+  const record4 = readRecord(value, path, DOCUMENT_KEYS);
+  const schemaVersion = requireKey(record4, "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(record3, key, path), `$.${key}`, maximum, minimum);
+    const input = readArray(requireKey(record4, key, path), `$.${key}`, maximum, minimum);
     return Object.freeze(input.map((entry, index) => parser(entry, `$.${key}[${index}]`)));
   };
   const budget = {
@@ -1717,10 +1721,10 @@ function parseGpuModelDocument(value) {
     geometryWorldAccessorInstances: 0,
     geometryWorldVertices: 0
   };
-  const roots = Object.freeze(readArray(requireKey(record3, "roots", path), "$.roots", GPU_MODEL_DOCUMENT_LIMITS.roots, 1).map((entry, index) => readId(entry, `$.roots[${index}]`)));
+  const roots = Object.freeze(readArray(requireKey(record4, "roots", path), "$.roots", GPU_MODEL_DOCUMENT_LIMITS.roots, 1).map((entry, index) => readId(entry, `$.roots[${index}]`)));
   const document = {
     schemaVersion,
-    coordinateSystem: parseCoordinateSystem(requireKey(record3, "coordinateSystem", path)),
+    coordinateSystem: parseCoordinateSystem(requireKey(record4, "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),
@@ -1734,10 +1738,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(record3, "bounds", path), "$.bounds"),
-    provenance: parseProvenance(requireKey(record3, "provenance", path), budget),
+    bounds: parseBounds(requireKey(record4, "bounds", path), "$.bounds"),
+    provenance: parseProvenance(requireKey(record4, "provenance", path), budget),
     diagnostics: parseCollection("diagnostics", GPU_MODEL_DOCUMENT_LIMITS.diagnostics, (entry, entryPath) => parseDiagnostic(entry, entryPath, budget)),
-    metadata: readMetadata(requireKey(record3, "metadata", path), "$.metadata", budget)
+    metadata: readMetadata(requireKey(record4, "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);
@@ -1774,8 +1778,8 @@ async function createAndVerifyGpuModelDocument(value, port, options) {
       value.resources.forEach((resource, index) => assertVerifiedResourceEvidence(resource, limits, `$.resources[${index}]`));
       return value;
     }
-    const record3 = readRecord(value, "$", DOCUMENT_KEYS);
-    const resourceInput = readArray(requireKey(record3, "resources", "$"), "$.resources", GPU_MODEL_DOCUMENT_LIMITS.resources, 1);
+    const record4 = readRecord(value, "$", DOCUMENT_KEYS);
+    const resourceInput = readArray(requireKey(record4, "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}]`);
@@ -1788,7 +1792,7 @@ async function createAndVerifyGpuModelDocument(value, port, options) {
     }
     const candidate = {};
     for (const key of DOCUMENT_KEYS) {
-      if (Object.hasOwn(record3, key)) candidate[key] = record3[key];
+      if (Object.hasOwn(record4, key)) candidate[key] = record4[key];
     }
     candidate.resources = verified;
     return createGpuModelDocument(candidate);
@@ -1853,11 +1857,11 @@ async function hashGpuModelDocumentCanonical(document) {
   return Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("");
 }
 function resolveStaticDemoLimits(options) {
-  const record3 = readRecord(options, "$.options", ["pvoxModelsEnabled", "limits"]);
-  const enabled = readBoolean(requireKey(record3, "pvoxModelsEnabled", "$.options"), "$.options.pvoxModelsEnabled");
+  const record4 = readRecord(options, "$.options", ["pvoxModelsEnabled", "limits"]);
+  const enabled = readBoolean(requireKey(record4, "pvoxModelsEnabled", "$.options"), "$.options.pvoxModelsEnabled");
   if (!enabled) return fail("feature-disabled", "$.options.pvoxModelsEnabled", `${GPU_MODEL_STATIC_DEMO_FEATURE_FLAG} is disabled`);
-  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));
+  if (!Object.hasOwn(record4, "limits")) return GPU_MODEL_STATIC_DEMO_LIMITS;
+  const overrides = readRecord(record4.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);
@@ -2319,7 +2323,7 @@ function evaluateGpuModelDiagnostics(value) {
   const diagnostics = [];
   const repairs = [];
   const losses = [];
-  let accepted = true;
+  let accepted2 = true;
   for (const issue of issues) {
     const base = { code: issue.code, path: issue.path, message: issue.message };
     if (issue.kind === "violation") {
@@ -2330,20 +2334,20 @@ function evaluateGpuModelDiagnostics(value) {
         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;
+        accepted2 = false;
         diagnostics.push(Object.freeze({ ...base, kind: "blocking-error", severity: "error", ruleId: issue.ruleId }));
       }
     } else if (issue.kind === "unsupported") {
-      accepted = false;
+      accepted2 = false;
       diagnostics.push(Object.freeze({ ...issue, severity: "error" }));
     } else if (issue.kind === "loss") {
-      if (!allowLoss) accepted = false;
+      if (!allowLoss) accepted2 = 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 } : {} });
+  return Object.freeze({ mode, standard, accepted: accepted2, diagnostics: Object.freeze(diagnostics), repairs: Object.freeze(repairs), losses: Object.freeze(losses), ...mode === "forensic" ? { rawSource: args.rawSource } : {} });
 }
 
 // src/resource-graph.ts
@@ -2537,6 +2541,360 @@ function validateDag(nodes) {
   if (queue.length !== nodes.size) fail3("graph-cycle");
 }
 
+// src/adapter-registry.ts
+var MODEL_REGISTRY_LIMITS = Object.freeze({ adapters: 128, concurrent: 8, timeoutMs: 3e4, maxTimeoutMs: 3e5, string: 4096, mapEntries: 64, manifestEntries: 4096, memoryBytes: 64 * 1024 * 1024 });
+var ModelRegistryError = class extends TypeError {
+  constructor(code) {
+    super(`GPU model registry: ${code}`);
+    this.code = code;
+    this.name = "ModelRegistryError";
+  }
+  code;
+};
+function fail4(code = "invalid-input") {
+  throw new ModelRegistryError(code);
+}
+var sourceKinds = ["file-path", "url", "blob-storage-url", "blob", "array-buffer", "uint8-array", "stream"];
+var targetKinds = ["file-path", "blob-storage-url", "blob", "array-buffer", "uint8-array", "stream", "package"];
+var bases = /* @__PURE__ */ new WeakMap();
+function createModelResultBase(input) {
+  const report = evaluateGpuModelDiagnostics(input);
+  const value = Object.freeze({ report, diagnostics: report.diagnostics, warnings: Object.freeze(report.diagnostics.filter((d) => d.severity === "warning")), repairs: report.repairs, lossReports: report.losses });
+  bases.set(report, value);
+  return value;
+}
+function record3(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail4();
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > MODEL_REGISTRY_LIMITS.mapEntries) fail4();
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string" || allowed && !allowed.includes(key)) fail4();
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor)) fail4();
+    output[key] = descriptor.value;
+  }
+  return output;
+}
+function text2(value) {
+  if (typeof value !== "string" || !value.length || value.length > MODEL_REGISTRY_LIMITS.string || Array.from(value).some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) fail4();
+  return value;
+}
+function format(value) {
+  if (typeof value !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(value)) fail4();
+  return value;
+}
+function enumeration(value, values) {
+  if (!values.includes(value)) fail4();
+  return value;
+}
+function boolean2(value) {
+  if (typeof value !== "boolean") fail4();
+  return value;
+}
+function integer(value, max, min = 0) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) fail4();
+  return value;
+}
+function list(value, max) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || value.length > max || Reflect.ownKeys(value).length !== value.length + 1) fail4();
+  return Array.from({ length: value.length }, (_, i) => {
+    const d = Object.getOwnPropertyDescriptor(value, String(i));
+    if (!d || !("value" in d)) fail4();
+    return d.value;
+  });
+}
+function strings(value) {
+  const input = record3(value);
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [key, entry] of Object.entries(input)) out[text2(key)] = text2(entry);
+  return Object.freeze(out);
+}
+function metadata(value) {
+  const v = record3(value, ["formatId", "displayName", "supportedSourceKinds", "supportedTargetKinds", "supportsAnimations", "supportsSkins", "supportsAnalyticGeometry"]);
+  const kinds = (input, allowed) => {
+    const values = list(input, allowed.length).map((k) => enumeration(k, allowed));
+    if (new Set(values).size !== values.length) fail4();
+    return Object.freeze(values);
+  };
+  return Object.freeze({ formatId: format(v.formatId), displayName: text2(v.displayName), supportedSourceKinds: kinds(v.supportedSourceKinds, sourceKinds), supportedTargetKinds: kinds(v.supportedTargetKinds, targetKinds), supportsAnimations: boolean2(v.supportsAnimations), supportsSkins: boolean2(v.supportsSkins), supportsAnalyticGeometry: boolean2(v.supportsAnalyticGeometry) });
+}
+function snapshotIO(input, source) {
+  const v = record3(input);
+  const kind = enumeration(v.kind, source ? sourceKinds : targetKinds);
+  const common = source ? ["kind", "fileNameHint", "mimeTypeHint", "provenance"] : ["kind"];
+  const specific = source ? {
+    "file-path": ["path"],
+    url: ["url", "headers"],
+    "blob-storage-url": ["url", "credentialMode"],
+    blob: ["blob"],
+    "array-buffer": ["bytes"],
+    "uint8-array": ["bytes"],
+    stream: ["stream", "byteLengthHint"]
+  } : {
+    "file-path": ["path", "overwrite"],
+    "blob-storage-url": ["url", "overwrite", "contentType", "metadata"],
+    blob: ["mimeType", "fileName"],
+    "array-buffer": [],
+    "uint8-array": [],
+    stream: ["stream", "contentType"],
+    package: ["packageFormat", "destinationHint", "includeSourcePayload"]
+  };
+  if (Object.keys(v).some((k) => ![...common, ...specific[kind]].includes(k))) fail4();
+  const out = { kind };
+  for (const key of ["fileNameHint", "mimeTypeHint", "mimeType", "fileName", "contentType", "destinationHint"]) if (v[key] !== void 0) out[key] = text2(v[key]);
+  for (const key of ["overwrite", "includeSourcePayload"]) if (v[key] !== void 0) out[key] = boolean2(v[key]);
+  for (const key of ["headers", "metadata"]) if (v[key] !== void 0) out[key] = strings(v[key]);
+  if (v.provenance !== void 0) out.provenance = strings(record3(v.provenance, ["sourceId", "sourceSystem", "acquiredAt", "licenseHint"]));
+  if (v.credentialMode !== void 0) out.credentialMode = enumeration(v.credentialMode, ["anonymous", "signed", "runtime-resolved"]);
+  if (v.byteLengthHint !== void 0) out.byteLengthHint = integer(v.byteLengthHint, Number.MAX_SAFE_INTEGER);
+  if (kind === "file-path") out.path = text2(v.path);
+  if (kind === "url" || kind === "blob-storage-url") {
+    const url = text2(v.url);
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return fail4();
+    }
+    if (!["https:", "http:"].includes(parsed.protocol) || parsed.username || parsed.password) fail4();
+    out.url = url;
+  }
+  if (source && kind === "blob") {
+    if (!(v.blob instanceof Blob)) fail4();
+    integer(v.blob.size, MODEL_REGISTRY_LIMITS.memoryBytes);
+    out.blob = v.blob;
+  }
+  if (source && (kind === "array-buffer" || kind === "uint8-array")) {
+    if (kind === "array-buffer") {
+      if (!(v.bytes instanceof ArrayBuffer)) fail4();
+      integer(v.bytes.byteLength, MODEL_REGISTRY_LIMITS.memoryBytes);
+      out.bytes = v.bytes.slice(0);
+    } else {
+      if (!(v.bytes instanceof Uint8Array) || !(v.bytes.buffer instanceof ArrayBuffer)) fail4();
+      integer(v.bytes.byteLength, MODEL_REGISTRY_LIMITS.memoryBytes);
+      out.bytes = new Uint8Array(v.bytes);
+    }
+  }
+  if (kind === "stream") {
+    const stream = v.stream;
+    if (!stream || typeof stream !== "object") fail4();
+    if (source ? !(stream instanceof ReadableStream) && typeof stream[Symbol.asyncIterator] !== "function" : !(stream instanceof WritableStream) && !("write" in stream && typeof stream.write === "function" && typeof stream.end === "function")) fail4();
+    out.stream = stream;
+  }
+  if (kind === "package") out.packageFormat = enumeration(v.packageFormat, ["zip", "tar", "directory-manifest"]);
+  return Object.freeze(out);
+}
+function manifest(input) {
+  const v = record3(input, ["format", "entries"]);
+  const ids = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const entries = list(v.entries, MODEL_REGISTRY_LIMITS.manifestEntries).map((entry) => {
+    const e = record3(entry, ["id", "role", "path", "contentType"]);
+    const id = text2(e.id);
+    const path = text2(e.path);
+    if (ids.has(id) || paths.has(path.toLowerCase()) || path.split("/").some((s) => !/^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/.test(s) || /[.]$/.test(s) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:[.]|$)/i.test(s))) fail4();
+    ids.add(id);
+    paths.add(path.toLowerCase());
+    return Object.freeze({ id, path, role: enumeration(e.role, ["mesh", "material", "texture", "animation", "auxiliary"]), ...e.contentType !== void 0 ? { contentType: text2(e.contentType) } : {} });
+  });
+  return Object.freeze({ format: enumeration(v.format, ["zip", "tar", "directory-manifest", "inline"]), entries: Object.freeze(entries) });
+}
+function reportBase(value, context) {
+  const base = bases.get(value.report);
+  if (!base || base.report.mode !== context.options.mode || ["diagnostics", "warnings", "repairs", "lossReports"].some((k) => value[k] !== base[k])) fail4("invalid-result");
+  return base;
+}
+function accepted(report, context) {
+  return report.accepted && (context.options.allowLoss || report.losses.length === 0);
+}
+function ledger(stages, ok, payload = {}) {
+  return Object.freeze({ ...payload, accepted: ok, stages: Object.freeze([...stages]), diagnostics: Object.freeze(stages.flatMap((s) => s.report.diagnostics)), warnings: Object.freeze(stages.flatMap((s) => s.report.diagnostics.filter((d) => d.severity === "warning"))), repairs: Object.freeze(stages.flatMap((s) => s.report.repairs)), lossReports: Object.freeze(stages.flatMap((s) => s.report.losses)) });
+}
+function createModelConversionRegistry(adapters, limits = {}) {
+  const registry = /* @__PURE__ */ new Map();
+  const maxConcurrent = integer(record3(limits, ["maxConcurrent"]).maxConcurrent ?? MODEL_REGISTRY_LIMITS.concurrent, MODEL_REGISTRY_LIMITS.concurrent, 1);
+  for (const input of list(adapters, MODEL_REGISTRY_LIMITS.adapters)) {
+    let a;
+    try {
+      const v = record3(input, ["metadata", "inspect", "load", "export", "validate"]);
+      const m = metadata(v.metadata);
+      for (const name of ["inspect", "load", "export", "validate"]) if (typeof v[name] !== "function") fail4();
+      const raw = input;
+      a = Object.freeze({ metadata: m, inspect: raw.inspect.bind(raw), load: raw.load.bind(raw), export: raw.export.bind(raw), validate: raw.validate.bind(raw) });
+    } catch {
+      return fail4("invalid-adapter");
+    }
+    if (registry.has(a.metadata.formatId)) fail4("duplicate-format");
+    registry.set(a.metadata.formatId, a);
+  }
+  let active = 0;
+  function lookup(id) {
+    const a = registry.get(format(id));
+    if (!a) fail4("unsupported-format");
+    return a;
+  }
+  function sourceFor(a, input) {
+    const source = snapshotIO(input, true);
+    if (!a.metadata.supportedSourceKinds.includes(source.kind)) fail4("unsupported-source");
+    return source;
+  }
+  function targetFor(a, input) {
+    const target = snapshotIO(input, false);
+    if (!a.metadata.supportedTargetKinds.includes(target.kind)) fail4("unsupported-target");
+    return target;
+  }
+  function check(context) {
+    if (context.options.signal.aborted) fail4("aborted");
+    if (Date.now() >= context.deadline) fail4("deadline-exceeded");
+  }
+  async function run(options, work) {
+    const v = record3(options ?? {}, ["mode", "allowLoss", "signal", "timeoutMs"]);
+    const mode = enumeration(v.mode ?? "strict", ["strict", "tolerant", "forensic"]);
+    const allowLoss = v.allowLoss === void 0 ? false : boolean2(v.allowLoss);
+    const timeoutMs = integer(v.timeoutMs ?? MODEL_REGISTRY_LIMITS.timeoutMs, MODEL_REGISTRY_LIMITS.maxTimeoutMs, 1);
+    if (v.signal !== void 0 && !(v.signal instanceof AbortSignal)) fail4();
+    const parent = v.signal;
+    if (parent?.aborted) fail4("aborted");
+    if (active >= maxConcurrent) fail4("capacity-exceeded");
+    const controller = new AbortController();
+    const context = { options: Object.freeze({ mode, allowLoss, timeoutMs, signal: controller.signal }), deadline: Date.now() + timeoutMs };
+    active++;
+    let timer;
+    let abort;
+    const pending = Promise.resolve().then(() => {
+      check(context);
+      return work(context);
+    }).finally(() => {
+      active--;
+    });
+    const stopped = new Promise((_, reject) => {
+      abort = () => {
+        controller.abort();
+        reject(new ModelRegistryError("aborted"));
+      };
+      parent?.addEventListener("abort", abort, { once: true });
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(new ModelRegistryError("deadline-exceeded"));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([pending, stopped]);
+    } catch (error) {
+      if (error instanceof ModelRegistryError) throw error;
+      return fail4();
+    } finally {
+      clearTimeout(timer);
+      if (abort) parent?.removeEventListener("abort", abort);
+    }
+  }
+  async function invoke(a, operation, context, call, stages) {
+    check(context);
+    let raw;
+    try {
+      raw = await call();
+    } catch {
+      return fail4("adapter-failed");
+    }
+    check(context);
+    try {
+      const v = record3(raw, ["report", "diagnostics", "warnings", "repairs", "lossReports", ...{ inspect: ["detectedFormat", "capabilities"], load: ["document", "resourcePackage"], validate: ["valid"], export: ["target", "resourcePackage", "output"] }[operation]]);
+      const base = reportBase(v, context);
+      const result = { ...v, ...base };
+      if (v.resourcePackage !== void 0) result.resourcePackage = manifest(v.resourcePackage);
+      stages.push(Object.freeze({ formatId: a.metadata.formatId, operation, report: base.report }));
+      return result;
+    } catch {
+      return fail4("invalid-result");
+    }
+  }
+  async function load(a, source, c, stages) {
+    const v = await invoke(a, "load", c, () => a.load(source, c.options), stages);
+    if (v.document !== void 0 && !isGpuModelDocument(v.document)) fail4("invalid-result");
+    if (accepted(v.report, c) && !isGpuModelDocument(v.document)) fail4("invalid-result");
+    return Object.freeze(v);
+  }
+  async function validate(a, input, c, stages) {
+    const v = await invoke(a, "validate", c, () => a.validate(input, c.options), stages);
+    if (typeof v.valid !== "boolean") fail4("invalid-result");
+    return v.valid && accepted(v.report, c);
+  }
+  async function exportDocument(a, document, target, c, stages) {
+    const issues = [];
+    for (const [supported, present, path] of [[a.metadata.supportsAnimations, document.animations.length, "/animations"], [a.metadata.supportsSkins, document.skins.length + document.skeletons.length + document.joints.length, "/skins"], [a.metadata.supportsAnalyticGeometry, document.analyticGeometry.length, "/analyticGeometry"]]) {
+      if (!supported && present) issues.push({ kind: "loss", code: "TARGET_CAPABILITY_LOSS", path, message: "Target cannot preserve canonical semantics", effect: "dropped" });
+    }
+    const report = evaluateGpuModelDiagnostics({ standard: "gltf-glb", mode: c.options.mode, allowLoss: c.options.allowLoss, issues, ...c.options.mode === "forensic" ? { rawSource: null } : {} });
+    stages.push(Object.freeze({ formatId: a.metadata.formatId, operation: "capabilities", report }));
+    if (!accepted(report, c) || !await validate(a, document, c, stages)) return ledger(stages, false, { document });
+    const v = await invoke(a, "export", c, () => a.export(document, target, c.options), stages);
+    if (v.target !== target.kind) fail4("invalid-result");
+    try {
+      if (v.output !== void 0) {
+        const output = v.output;
+        if (target.kind === "blob" && output instanceof Blob) {
+          integer(output.size, MODEL_REGISTRY_LIMITS.memoryBytes);
+        } else if (target.kind === "array-buffer" && output instanceof ArrayBuffer) {
+          integer(output.byteLength, MODEL_REGISTRY_LIMITS.memoryBytes);
+          v.output = output.slice(0);
+        } else if (target.kind === "uint8-array" && output instanceof Uint8Array && output.buffer instanceof ArrayBuffer) {
+          integer(output.byteLength, MODEL_REGISTRY_LIMITS.memoryBytes);
+          v.output = new Uint8Array(output);
+        } else fail4();
+      }
+    } catch {
+      return fail4("invalid-result");
+    }
+    const exported = Object.freeze(v);
+    return ledger(stages, accepted(exported.report, c), { document, exported, ...exported.resourcePackage ? { resourcePackage: exported.resourcePackage } : {} });
+  }
+  const api = {
+    capabilities: Object.freeze([...registry.values()].map((a) => a.metadata)),
+    inspect: (id, input, options) => run(options, async (c) => {
+      const a = lookup(id);
+      const source = sourceFor(a, input);
+      const stages = [];
+      const v = await invoke(a, "inspect", c, () => a.inspect(source, c.options), stages);
+      try {
+        if (v.detectedFormat !== void 0 && format(v.detectedFormat) !== a.metadata.formatId) fail4();
+        if (JSON.stringify(metadata(v.capabilities)) !== JSON.stringify(a.metadata)) fail4();
+      } catch {
+        return fail4("invalid-result");
+      }
+      return ledger(stages, accepted(v.report, c), { inspection: Object.freeze({ ...v, capabilities: a.metadata }) });
+    }),
+    load: (id, input, options) => run(options, async (c) => {
+      const a = lookup(id);
+      const stages = [];
+      const result = await load(a, sourceFor(a, input), c, stages);
+      return ledger(stages, accepted(result.report, c), { ...result.document ? { document: result.document } : {}, ...result.resourcePackage ? { resourcePackage: result.resourcePackage } : {} });
+    }),
+    validate: (id, input, options) => run(options, async (c) => {
+      const a = lookup(id);
+      const stages = [];
+      return ledger(stages, await validate(a, isGpuModelDocument(input) ? input : sourceFor(a, input), c, stages));
+    }),
+    export: (id, document, input, options) => run(options, async (c) => {
+      const a = lookup(id);
+      if (!isGpuModelDocument(document)) fail4();
+      return exportDocument(a, document, targetFor(a, input), c, []);
+    }),
+    convert: (request, options) => run(options, async (c) => {
+      const v = record3(request, ["sourceFormat", "targetFormat", "source", "target"]);
+      const from = lookup(v.sourceFormat);
+      const to = lookup(v.targetFormat);
+      const source = sourceFor(from, v.source);
+      const target = targetFor(to, v.target);
+      const stages = [];
+      const result = await load(from, source, c, stages);
+      if (!accepted(result.report, c)) return ledger(stages, false, { ...result.resourcePackage ? { resourcePackage: result.resourcePackage } : {} });
+      return exportDocument(to, result.document, target, c, stages);
+    })
+  };
+  return Object.freeze(api);
+}
+
 // src/index.ts
 var packageName = "@plasius/gpu-model-core";
 var packageBootstrap = Object.freeze({
@@ -2564,12 +2922,16 @@ var packageBootstrap = Object.freeze({
   GpuModelDiagnosticsError,
   GpuModelDocumentError,
   GpuModelResourceGraphError,
+  MODEL_REGISTRY_LIMITS,
+  ModelRegistryError,
   assertGpuModelStaticDemoNormalization,
   canCreateGpuModelDocument,
   createAndVerifyGpuModelDocument,
   createGpuModelDocument,
   createGpuModelResourceGraph,
   createGpuModelStaticDemoCompilerInput,
+  createModelConversionRegistry,
+  createModelResultBase,
   encodeGpuModelDocumentCanonical,
   evaluateGpuModelDiagnostics,
   gpuModelResourceKey,