@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/runtime/model-import/formats/gltf-primitive-preflight.ts

@@ -0,0 +1,295 @@
+import type { GLTF } from "@gltf-transform/core";
+
+import type { ToolcraftModelImportLimits } from "../../schema/types";
+import {
+  validateGltfNormalEncoding,
+  validateGltfPositionEncoding,
+} from "./gltf-attribute-encoding";
+import {
+  checkedGltfScale,
+  checkedGltfTotal,
+  gltfDecodeCheckpoint,
+  gltfDecodeFailure,
+} from "./gltf-decode-safety";
+import {
+  type GltfAccessorInfo,
+  type GltfBufferViewInfo,
+  type GltfJsonRecord,
+  gltfJsonArray,
+  gltfJsonIndexed,
+  gltfJsonInteger,
+  gltfJsonRecord,
+} from "./gltf-json-inspection";
+
+export type GltfPrimitivePreflight = Readonly<{
+  canonicalBytes: number;
+  decodedCountExpectations: GltfDecodedCountExpectation[];
+  dracoScratchBytes: number;
+  meshCount: number;
+  primitiveCount: number;
+}>;
+
+export type GltfDecodedCountExpectation = Readonly<{
+  indexCount?: number;
+  meshIndex: number;
+  normalCount?: number;
+  positionCount: number;
+  primitiveIndex: number;
+}>;
+
+function triangleCountForMode(mode: number, count: number): number {
+  if (mode === 4 && count >= 3 && count % 3 === 0) return count / 3;
+  if ((mode === 5 || mode === 6) && count >= 3) return count - 2;
+  if (mode >= 0 && mode <= 3) {
+    return gltfDecodeFailure(
+      "format",
+      "unsupported-primitive-mode",
+      `glTF primitive mode ${mode} is not triangle geometry.`,
+    );
+  }
+  return gltfDecodeFailure(
+    "geometry",
+    "malformed-triangle-primitive",
+    "A triangle primitive has malformed cardinality or mode.",
+  );
+}
+
+function inspectDraco(
+  primitive: GltfJsonRecord,
+  views: readonly GltfBufferViewInfo[],
+  position: GltfAccessorInfo,
+  normal: GltfAccessorInfo | undefined,
+  indices: GltfAccessorInfo | undefined,
+): number {
+  const extensions = primitive.extensions;
+  const value =
+    typeof extensions === "object" && extensions !== null
+      ? (extensions as GltfJsonRecord).KHR_draco_mesh_compression
+      : undefined;
+  if (value === undefined) {
+    if (
+      position.record.bufferView === undefined &&
+      position.record.sparse === undefined
+    ) {
+      return gltfDecodeFailure(
+        "geometry",
+        "invalid-position-accessor",
+        "POSITION has no bufferView, sparse values, or Draco payload.",
+      );
+    }
+    return 0;
+  }
+  const extension = gltfJsonRecord(
+    value,
+    "invalid-draco-extension",
+    "KHR_draco_mesh_compression",
+  );
+  gltfJsonIndexed(
+    views,
+    extension.bufferView,
+    "invalid-draco-extension",
+    "Draco bufferView",
+  );
+  const attributes = gltfJsonRecord(
+    extension.attributes,
+    "invalid-draco-extension",
+    "Draco attributes",
+  );
+  for (const [semantic, attributeId] of Object.entries(attributes)) {
+    gltfJsonInteger(
+      attributeId,
+      "invalid-draco-extension",
+      `Draco attribute ${semantic}`,
+    );
+  }
+  if (attributes.POSITION === undefined) {
+    return gltfDecodeFailure(
+      "geometry",
+      "invalid-draco-extension",
+      "Draco geometry must declare its POSITION attribute.",
+    );
+  }
+  const vertexBytes = checkedGltfScale(
+    position.count,
+    normal ? 24 : 12,
+    "estimated-worker-memory-limit-exceeded",
+  );
+  const indexBytes = checkedGltfScale(
+    indices?.count ?? position.count,
+    Uint32Array.BYTES_PER_ELEMENT,
+    "estimated-worker-memory-limit-exceeded",
+  );
+  return checkedGltfTotal(
+    vertexBytes,
+    indexBytes,
+    Number.MAX_SAFE_INTEGER,
+    "estimated-worker-memory-limit-exceeded",
+    "Draco declared expansion",
+  );
+}
+
+export function preflightGltfPrimitives(
+  json: GLTF.IGLTF,
+  accessors: readonly GltfAccessorInfo[],
+  views: readonly GltfBufferViewInfo[],
+  limits: ToolcraftModelImportLimits,
+  signal: AbortSignal,
+): GltfPrimitivePreflight {
+  const requiredExtensions = new Set(json.extensionsRequired ?? []);
+  const meshes = gltfJsonArray(
+    json.meshes,
+    "invalid-gltf-meshes",
+    "glTF meshes",
+  );
+  let canonicalBytes = 0;
+  const decodedCountExpectations: GltfDecodedCountExpectation[] = [];
+  let dracoScratchBytes = 0;
+  let primitiveCount = 0;
+  let triangles = 0;
+  let vertices = 0;
+  meshes.forEach((meshValue, meshIndex) => {
+    const mesh = gltfJsonRecord(
+      meshValue,
+      "invalid-gltf-mesh",
+      `mesh ${meshIndex}`,
+    );
+    const primitives = gltfJsonArray(
+      mesh.primitives,
+      "invalid-gltf-primitives",
+      `mesh ${meshIndex}.primitives`,
+    );
+    primitives.forEach((primitiveValue, primitiveIndex) => {
+      gltfDecodeCheckpoint(signal, primitiveCount);
+      primitiveCount += 1;
+      if (primitiveCount > limits.maxPrimitives) {
+        return gltfDecodeFailure(
+          "resource-limit",
+          "max-primitives-exceeded",
+          `glTF exceeds maxPrimitives ${limits.maxPrimitives}.`,
+        );
+      }
+      const primitive = gltfJsonRecord(
+        primitiveValue,
+        "invalid-gltf-primitive",
+        `mesh ${meshIndex} primitive ${primitiveIndex}`,
+      );
+      const attributes = gltfJsonRecord(
+        primitive.attributes,
+        "invalid-gltf-primitive",
+        "Primitive attributes",
+      );
+      const position = gltfJsonIndexed(
+        accessors,
+        attributes.POSITION,
+        "invalid-position-accessor",
+        "POSITION accessor",
+      );
+      validateGltfPositionEncoding(position, requiredExtensions);
+      const normal =
+        attributes.NORMAL === undefined
+          ? undefined
+          : gltfJsonIndexed(
+              accessors,
+              attributes.NORMAL,
+              "invalid-normal-accessor",
+              "NORMAL accessor",
+            );
+      if (normal) {
+        validateGltfNormalEncoding(normal, position.count, requiredExtensions);
+      }
+      const indices =
+        primitive.indices === undefined
+          ? undefined
+          : gltfJsonIndexed(
+              accessors,
+              primitive.indices,
+              "invalid-index-accessor",
+              "Index accessor",
+            );
+      if (
+        indices &&
+        (indices.type !== "SCALAR" ||
+          ![5121, 5123, 5125].includes(indices.componentType) ||
+          indices.normalized)
+      ) {
+        return gltfDecodeFailure(
+          "geometry",
+          "invalid-index-accessor",
+          "Indices must be non-normalized unsigned scalar accessors.",
+        );
+      }
+      const mode =
+        primitive.mode === undefined
+          ? 4
+          : gltfJsonInteger(
+              primitive.mode,
+              "invalid-gltf-primitive",
+              "Primitive mode",
+            );
+      decodedCountExpectations.push({
+        ...(indices ? { indexCount: indices.count } : {}),
+        meshIndex,
+        ...(normal ? { normalCount: normal.count } : {}),
+        positionCount: position.count,
+        primitiveIndex,
+      });
+      const primitiveTriangles = triangleCountForMode(
+        mode,
+        indices?.count ?? position.count,
+      );
+      if (vertices > limits.maxVertices - position.count) {
+        return gltfDecodeFailure(
+          "resource-limit",
+          "max-vertices-exceeded",
+          `glTF exceeds maxVertices ${limits.maxVertices}.`,
+        );
+      }
+      if (triangles > limits.maxTriangles - primitiveTriangles) {
+        return gltfDecodeFailure(
+          "resource-limit",
+          "max-triangles-exceeded",
+          `glTF exceeds maxTriangles ${limits.maxTriangles}.`,
+        );
+      }
+      vertices += position.count;
+      triangles += primitiveTriangles;
+      const vertexBytes = checkedGltfScale(
+        position.count,
+        normal ? 24 : 12,
+        "decoded-byte-limit-exceeded",
+      );
+      const indexBytes = checkedGltfScale(
+        primitiveTriangles,
+        3 * Uint32Array.BYTES_PER_ELEMENT,
+        "decoded-byte-limit-exceeded",
+      );
+      canonicalBytes = checkedGltfTotal(
+        canonicalBytes,
+        checkedGltfTotal(
+          vertexBytes,
+          indexBytes,
+          limits.maxDecodedBytes,
+          "decoded-byte-limit-exceeded",
+          "Canonical glTF primitive",
+        ),
+        limits.maxDecodedBytes,
+        "decoded-byte-limit-exceeded",
+        "Canonical glTF geometry",
+      );
+      dracoScratchBytes = checkedGltfTotal(
+        dracoScratchBytes,
+        inspectDraco(primitive, views, position, normal, indices),
+        limits.maxEstimatedWorkerBytes,
+        "estimated-worker-memory-limit-exceeded",
+        "Draco declared expansion",
+      );
+    });
+  });
+  return {
+    canonicalBytes,
+    decodedCountExpectations,
+    dracoScratchBytes,
+    meshCount: meshes.length,
+    primitiveCount,
+  };
+}

package/templates/runtime/model-import/formats/gltf-source-document.ts

@@ -0,0 +1,234 @@
+import { type GLTF, type JSONDocument } from "@gltf-transform/core";
+
+import type {
+  ToolcraftModelFormat,
+  ToolcraftModelImportLimits,
+} from "../../schema/types";
+import { inspectBufferDataUri } from "../model-source-data-uri";
+import { isToolcraftModelAppearanceSidecarPath } from "../model-package-path";
+import { preflightAndParseGltfJson } from "../model-source-json-preflight";
+import { normalizeLocalBufferUri } from "../model-source-path";
+import type { GltfFeatureInventory } from "./gltf-canonical-metadata";
+import {
+  checkedGltfTotal,
+  gltfDecodeCheckpoint,
+  gltfDecodeFailure,
+  throwIfGltfDecodeAborted,
+} from "./gltf-decode-safety";
+import { validateAndSanitizeGltfJson } from "./gltf-document-sanitizer";
+import { extractGlbDocument } from "./gltf-glb-document";
+import { preflightGltfJsonDocument } from "./gltf-json-preflight";
+import {
+  removeMissingGltfAppearance,
+  type GltfMissingAppearanceBinding,
+  type GltfMissingImage,
+  type GltfMissingTexture,
+} from "./gltf-missing-appearance";
+import type { GltfDecodedCountExpectation } from "./gltf-primitive-preflight";
+import type { GltfSourceSnapshot } from "./gltf-source-snapshot";
+import { decodeGltfImageDataUri } from "./gltf-texture-resource";
+
+const REMOTE_URI_PATTERN = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/iu;
+
+type JsonRecord = Record<string, unknown>;
+
+export type PreparedGltfSourceDocument = Readonly<{
+  decodedCountExpectations: readonly GltfDecodedCountExpectation[];
+  features: GltfFeatureInventory;
+  jsonDocument: JSONDocument;
+  missingAppearanceBindings: readonly GltfMissingAppearanceBinding[];
+  retainedWorkerBytes: number;
+}>;
+
+function parseRootJson(
+  bytes: Uint8Array<ArrayBuffer>,
+  sourceWorkerBytes: number,
+  maxWorkerBytes: number,
+  signal: AbortSignal,
+): { json: GLTF.IGLTF; workerBytes: number } {
+  throwIfGltfDecodeAborted(signal);
+  const remaining = maxWorkerBytes - sourceWorkerBytes;
+  if (remaining <= 0) {
+    return gltfDecodeFailure(
+      "resource-limit",
+      "estimated-worker-memory-limit-exceeded",
+      "The source snapshot leaves no bounded memory for glTF JSON parsing.",
+    );
+  }
+  const parsed = preflightAndParseGltfJson(bytes, remaining);
+  throwIfGltfDecodeAborted(signal);
+  if (
+    typeof parsed.value !== "object" ||
+    parsed.value === null ||
+    Array.isArray(parsed.value)
+  ) {
+    return gltfDecodeFailure(
+      "format",
+      "malformed-gltf-json",
+      "The glTF root must contain a JSON object.",
+    );
+  }
+  const workerBytes = checkedGltfTotal(
+    sourceWorkerBytes,
+    parsed.preflight.estimatedWorkerBytes,
+    maxWorkerBytes,
+    "estimated-worker-memory-limit-exceeded",
+    "glTF source and JSON memory",
+  );
+  return { json: parsed.value as GLTF.IGLTF, workerBytes };
+}
+
+function mapGltfResources(
+  json: GLTF.IGLTF,
+  snapshot: GltfSourceSnapshot,
+  format: Extract<ToolcraftModelFormat, "glb" | "gltf">,
+  initialResources: JSONDocument["resources"] | undefined,
+  limits: ToolcraftModelImportLimits,
+  signal: AbortSignal,
+): Readonly<{
+  missingAppearanceBindings: readonly GltfMissingAppearanceBinding[];
+  resources: JSONDocument["resources"];
+}> {
+  const resources = Object.create(null) as JSONDocument["resources"];
+  if (initialResources) Object.assign(resources, initialResources);
+  const usedPaths = new Set([snapshot.root.path]);
+  const rootDirectory = snapshot.root.path.split("/").slice(0, -1);
+  const buffers = Array.isArray(json.buffers) ? json.buffers : [];
+  buffers.forEach((bufferValue, index) => {
+    gltfDecodeCheckpoint(signal, index);
+    if (typeof bufferValue !== "object" || bufferValue === null) return;
+    const uri = (bufferValue as unknown as JsonRecord).uri;
+    if (typeof uri !== "string") return;
+    if (inspectBufferDataUri(uri, limits.maxDecodedBytes) !== undefined) return;
+    if (format === "glb" || REMOTE_URI_PATTERN.test(uri)) {
+      return gltfDecodeFailure(
+        "bundle",
+        "remote-buffer-uri",
+        "Geometry buffer URIs must resolve to selected local glTF files.",
+      );
+    }
+    const path = [...rootDirectory, ...normalizeLocalBufferUri(uri)].join("/");
+    const source = snapshot.filesByPath.get(path);
+    if (!source) {
+      return gltfDecodeFailure(
+        "bundle",
+        "missing-buffer-file",
+        `Selected source file ${path} is required by buffer URI ${uri}.`,
+      );
+    }
+    resources[uri] = source.bytes;
+    usedPaths.add(path);
+  });
+  const missingImages: GltfMissingImage[] = [];
+  const images = Array.isArray(json.images) ? json.images : [];
+  images.forEach((imageValue, index) => {
+    gltfDecodeCheckpoint(signal, buffers.length + index);
+    if (typeof imageValue !== "object" || imageValue === null) return;
+    const image = imageValue as unknown as JsonRecord;
+    const uri = image.uri;
+    if (typeof uri !== "string") return;
+    const embedded = decodeGltfImageDataUri(uri, limits.maxTextureBytes);
+    if (embedded) {
+      resources[uri] = embedded.bytes;
+      image.mimeType ??= embedded.mimeType;
+      return;
+    }
+    if (REMOTE_URI_PATTERN.test(uri)) {
+      missingImages.push({ imageIndex: index, reason: "remote-uri", uri });
+      return;
+    }
+    const path = [...rootDirectory, ...normalizeLocalBufferUri(uri)].join("/");
+    const source = snapshot.filesByPath.get(path);
+    if (!source) {
+      missingImages.push({
+        imageIndex: index,
+        reason: "missing-local-file",
+        uri,
+      });
+      return;
+    }
+    resources[uri] = source.bytes;
+    usedPaths.add(path);
+  });
+  const missingTextures: GltfMissingTexture[] = [];
+  const textures = Array.isArray(json.textures) ? json.textures : [];
+  textures.forEach((textureValue, index) => {
+    gltfDecodeCheckpoint(signal, buffers.length + images.length + index);
+    if (typeof textureValue !== "object" || textureValue === null) return;
+    const texture = textureValue as unknown as JsonRecord;
+    if (texture.source !== undefined) return;
+    missingTextures.push({
+      reason: "unsupported-image-source",
+      textureIndex: index,
+      uri: `texture:${index}`,
+    });
+  });
+  const missingAppearanceBindings = removeMissingGltfAppearance(
+    json,
+    missingImages,
+    missingTextures,
+    signal,
+  );
+  const unexpected = snapshot.files.find(
+    (file) =>
+      !usedPaths.has(file.path) &&
+      !isToolcraftModelAppearanceSidecarPath(file.path),
+  );
+  if (unexpected) {
+    return gltfDecodeFailure(
+      "bundle",
+      "unexpected-source-file",
+      `Selected source file ${unexpected.path} is not an exact glTF dependency.`,
+    );
+  }
+  return Object.freeze({
+    missingAppearanceBindings,
+    resources,
+  });
+}
+
+export function prepareGltfSourceDocument(
+  snapshot: GltfSourceSnapshot,
+  format: Extract<ToolcraftModelFormat, "glb" | "gltf">,
+  supportedExtensions: ReadonlySet<string>,
+  limits: ToolcraftModelImportLimits,
+  signal: AbortSignal,
+): PreparedGltfSourceDocument {
+  const extracted =
+    format === "glb"
+      ? extractGlbDocument(snapshot.root.bytes, signal)
+      : { jsonBytes: snapshot.root.bytes, resources: undefined };
+  const parsed = parseRootJson(
+    extracted.jsonBytes,
+    snapshot.sourceWorkerBytes,
+    limits.maxEstimatedWorkerBytes,
+    signal,
+  );
+  const features = validateAndSanitizeGltfJson(
+    parsed.json,
+    supportedExtensions,
+    signal,
+  );
+  const mapped = mapGltfResources(
+    parsed.json,
+    snapshot,
+    format,
+    extracted.resources,
+    limits,
+    signal,
+  );
+  const preflight = preflightGltfJsonDocument(
+    parsed.json,
+    mapped.resources,
+    parsed.workerBytes,
+    limits,
+    signal,
+  );
+  return Object.freeze({
+    decodedCountExpectations: Object.freeze(preflight.decodedCountExpectations),
+    features,
+    jsonDocument: { json: parsed.json, resources: mapped.resources },
+    missingAppearanceBindings: mapped.missingAppearanceBindings,
+    retainedWorkerBytes: preflight.retainedWorkerBytes,
+  });
+}

package/templates/runtime/model-import/formats/gltf-source-snapshot.ts

@@ -0,0 +1,187 @@
+import type { ToolcraftModelFormat } from "../../schema/types";
+import { TOOLCRAFT_MODEL_IMPORT_LIMIT_CEILINGS } from "../model-import-limit-values";
+import type { ToolcraftModelDecodeContext } from "../model-import-types";
+import { sourceExtension } from "../model-source-path";
+import {
+  checkedGltfScale,
+  checkedGltfTotal,
+  gltfDecodeCheckpoint,
+  gltfDecodeFailure,
+  throwIfGltfDecodeAborted,
+} from "./gltf-decode-safety";
+
+export type GltfSourceFileSnapshot = Readonly<{
+  bytes: Uint8Array<ArrayBuffer>;
+  path: string;
+}>;
+
+export type GltfSourceSnapshot = Readonly<{
+  files: readonly GltfSourceFileSnapshot[];
+  filesByPath: ReadonlyMap<string, GltfSourceFileSnapshot>;
+  root: GltfSourceFileSnapshot;
+  sourceWorkerBytes: number;
+}>;
+
+const arrayBufferByteLength = Object.getOwnPropertyDescriptor(
+  ArrayBuffer.prototype,
+  "byteLength",
+)!.get!;
+const DRIVE_PATH_PATTERN = /^[a-z]:/iu;
+
+function getArrayBufferByteLength(value: unknown): number | undefined {
+  try {
+    return arrayBufferByteLength.call(value) as number;
+  } catch {
+    return undefined;
+  }
+}
+
+function validateLimits(context: ToolcraftModelDecodeContext): void {
+  for (const key of Object.keys(
+    TOOLCRAFT_MODEL_IMPORT_LIMIT_CEILINGS,
+  ) as Array<keyof ToolcraftModelDecodeContext["limits"]>) {
+    const value = context.limits[key];
+    if (
+      !Number.isSafeInteger(value) ||
+      value <= 0 ||
+      value > TOOLCRAFT_MODEL_IMPORT_LIMIT_CEILINGS[key]
+    ) {
+      gltfDecodeFailure(
+        "resource-limit",
+        "invalid-import-limits",
+        `Model import limit ${key} is outside its protected integer range.`,
+      );
+    }
+  }
+}
+
+function validateSelectedPath(path: unknown): asserts path is string {
+  if (
+    typeof path !== "string" ||
+    path.length === 0 ||
+    path.startsWith("/") ||
+    path.includes("\\") ||
+    path.includes("\0") ||
+    path.includes("?") ||
+    path.includes("#") ||
+    path.normalize("NFC") !== path ||
+    DRIVE_PATH_PATTERN.test(path.split("/", 1)[0] ?? "") ||
+    path.split("/").some((segment) => !segment || segment === "." || segment === "..")
+  ) {
+    gltfDecodeFailure(
+      "bundle",
+      "unsafe-source-path",
+      "The model transfer contains an unsafe selected path.",
+    );
+  }
+}
+
+export function snapshotGltfDecodeSource(
+  context: ToolcraftModelDecodeContext,
+  format: Extract<ToolcraftModelFormat, "glb" | "gltf">,
+): GltfSourceSnapshot {
+  throwIfGltfDecodeAborted(context.signal);
+  validateLimits(context);
+  const sourceFiles = context.bundle?.sourceFiles;
+  if (!Array.isArray(sourceFiles) || sourceFiles.length === 0) {
+    return gltfDecodeFailure(
+      "bundle",
+      "empty-model-bundle",
+      "The model transfer contains no source files.",
+    );
+  }
+  if (sourceFiles.length > context.limits.maxBundleFiles) {
+    return gltfDecodeFailure(
+      "resource-limit",
+      "bundle-file-limit-exceeded",
+      `The model transfer exceeds maxBundleFiles ${context.limits.maxBundleFiles}.`,
+    );
+  }
+  validateSelectedPath(context.bundle.rootPath);
+  if (sourceExtension(context.bundle.rootPath) !== `.${format}`) {
+    return gltfDecodeFailure(
+      "format",
+      "adapter-root-format-mismatch",
+      `The ${format} adapter requires a .${format} root.`,
+    );
+  }
+
+  const admitted: Array<{ bytes: ArrayBuffer; path: string }> = [];
+  const paths = new Set<string>();
+  let sourceBytes = 0;
+  for (let index = 0; index < sourceFiles.length; index += 1) {
+    gltfDecodeCheckpoint(context.signal, index);
+    if (!Object.prototype.hasOwnProperty.call(sourceFiles, index)) {
+      return gltfDecodeFailure(
+        "bundle",
+        "invalid-source-file",
+        "The model transfer contains a sparse source-file entry.",
+      );
+    }
+    const file = sourceFiles[index];
+    validateSelectedPath(file?.path);
+    const byteLength = getArrayBufferByteLength(file?.bytes);
+    if (byteLength === undefined) {
+      return gltfDecodeFailure(
+        "bundle",
+        "invalid-source-file",
+        "The model transfer source bytes must be an ArrayBuffer.",
+      );
+    }
+    if (paths.has(file.path)) {
+      return gltfDecodeFailure(
+        "bundle",
+        "duplicate-source-path",
+        "The model transfer contains a duplicate selected path.",
+      );
+    }
+    paths.add(file.path);
+    sourceBytes = checkedGltfTotal(
+      sourceBytes,
+      byteLength,
+      context.limits.maxSourceBytes,
+      "source-byte-limit-exceeded",
+      "Model source bytes",
+    );
+    if (sourceBytes > context.limits.maxDecodedBytes) {
+      return gltfDecodeFailure(
+        "resource-limit",
+        "decoded-byte-limit-exceeded",
+        `Model source bytes exceed maxDecodedBytes ${context.limits.maxDecodedBytes}.`,
+      );
+    }
+    admitted.push({ bytes: file.bytes, path: file.path });
+  }
+  const sourceWorkerBytes = checkedGltfScale(
+    sourceBytes,
+    2,
+    "estimated-worker-memory-limit-exceeded",
+  );
+  checkedGltfTotal(
+    0,
+    sourceWorkerBytes,
+    context.limits.maxEstimatedWorkerBytes,
+    "estimated-worker-memory-limit-exceeded",
+    "Model source snapshot memory",
+  );
+  if (!paths.has(context.bundle.rootPath)) {
+    return gltfDecodeFailure(
+      "bundle",
+      "missing-model-root",
+      "The model transfer does not contain its declared root file.",
+    );
+  }
+
+  const files = Object.freeze(
+    admitted.map(({ bytes, path }) =>
+      Object.freeze({
+        bytes: new Uint8Array(bytes).slice(),
+        path,
+      }),
+    ),
+  );
+  const filesByPath = new Map(files.map((file) => [file.path, file]));
+  const root = filesByPath.get(context.bundle.rootPath);
+  if (!root) throw new Error("Validated glTF root snapshot is missing.");
+  return Object.freeze({ files, filesByPath, root, sourceWorkerBytes });
+}