@pixel-point/toolcraft 0.0.15 → 0.0.17

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

@@ -0,0 +1,93 @@
+import { GLB_BUFFER, type JSONDocument } from "@gltf-transform/core";
+
+import {
+  gltfDecodeCheckpoint,
+  gltfDecodeFailure,
+} from "./gltf-decode-safety";
+
+const GLB_MAGIC = 0x46546c67;
+const GLB_VERSION = 2;
+const JSON_CHUNK = 0x4e4f534a;
+const BIN_CHUNK = 0x004e4942;
+const HEADER_BYTES = 12;
+const CHUNK_HEADER_BYTES = 8;
+
+export type ExtractedGlb = Readonly<{
+  jsonBytes: Uint8Array<ArrayBuffer>;
+  resources: JSONDocument["resources"];
+}>;
+
+function malformedGlb(message: string): never {
+  return gltfDecodeFailure("format", "malformed-glb", message);
+}
+
+export function extractGlbDocument(
+  bytes: Uint8Array<ArrayBuffer>,
+  signal: AbortSignal,
+): ExtractedGlb {
+  if (bytes.byteLength < HEADER_BYTES + CHUNK_HEADER_BYTES) {
+    return malformedGlb("The GLB is too short to contain its JSON chunk.");
+  }
+  const view = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength,
+  );
+  if (view.getUint32(0, true) !== GLB_MAGIC) {
+    return malformedGlb("The GLB magic header is invalid.");
+  }
+  if (view.getUint32(4, true) !== GLB_VERSION) {
+    return malformedGlb("Only GLB version 2 is supported.");
+  }
+  const declaredLength = view.getUint32(8, true);
+  if (declaredLength !== bytes.byteLength || declaredLength % 4 !== 0) {
+    return malformedGlb("The GLB declared length does not match its bytes.");
+  }
+
+  let offset = HEADER_BYTES;
+  let jsonBytes: Uint8Array<ArrayBuffer> | undefined;
+  let binBytes: Uint8Array<ArrayBuffer> | undefined;
+  let chunkIndex = 0;
+  while (offset < declaredLength) {
+    gltfDecodeCheckpoint(signal, chunkIndex);
+    if (offset > declaredLength - CHUNK_HEADER_BYTES) {
+      return malformedGlb("A GLB chunk header exceeds the declared length.");
+    }
+    const chunkLength = view.getUint32(offset, true);
+    const chunkType = view.getUint32(offset + 4, true);
+    const contentOffset = offset + CHUNK_HEADER_BYTES;
+    if (
+      chunkLength === 0 ||
+      chunkLength % 4 !== 0 ||
+      contentOffset > declaredLength - chunkLength
+    ) {
+      return malformedGlb("A GLB chunk has invalid or overflowing bounds.");
+    }
+    const chunk = new Uint8Array(
+      bytes.buffer,
+      bytes.byteOffset + contentOffset,
+      chunkLength,
+    );
+    if (chunkIndex === 0) {
+      if (chunkType !== JSON_CHUNK) {
+        return malformedGlb("The first GLB chunk must contain JSON.");
+      }
+      jsonBytes = chunk;
+    } else if (chunkType === JSON_CHUNK) {
+      return malformedGlb("A GLB may contain only one JSON chunk.");
+    } else if (chunkType === BIN_CHUNK) {
+      if (binBytes) {
+        return malformedGlb("A GLB may contain only one binary chunk.");
+      }
+      binBytes = chunk;
+    }
+    offset = contentOffset + chunkLength;
+    chunkIndex += 1;
+  }
+  if (!jsonBytes || offset !== declaredLength) {
+    return malformedGlb("The GLB JSON chunk is missing or truncated.");
+  }
+  const resources = Object.create(null) as JSONDocument["resources"];
+  if (binBytes) resources[GLB_BUFFER] = binBytes;
+  return Object.freeze({ jsonBytes, resources });
+}

package/templates/runtime/model-import/formats/gltf-json-inspection.ts

@@ -0,0 +1,152 @@
+import {
+  checkedGltfScale,
+  checkedGltfTotal,
+  gltfDecodeFailure,
+} from "./gltf-decode-safety";
+
+export type GltfJsonRecord = Record<string, unknown>;
+
+export type GltfAccessorInfo = Readonly<{
+  byteLength: number;
+  componentType: number;
+  count: number;
+  normalized: boolean;
+  record: GltfJsonRecord;
+  type: string;
+}>;
+
+export type GltfBufferViewInfo = Readonly<{
+  byteLength: number;
+  byteOffset: number;
+  byteStride?: number;
+  meshoptCompressed: boolean;
+  readBytes: () => Uint8Array;
+}>;
+
+export const GLTF_COMPONENT_BYTES: Readonly<Record<number, number>> = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4,
+  5130: 8,
+  5131: 2,
+};
+
+const ELEMENT_COMPONENTS: Readonly<Record<string, number>> = {
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16,
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+};
+
+export function gltfJsonRecord(
+  value: unknown,
+  code: string,
+  label: string,
+): GltfJsonRecord {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return gltfDecodeFailure("format", code, `${label} must be an object.`);
+  }
+  return value as GltfJsonRecord;
+}
+
+export function gltfJsonArray(
+  value: unknown,
+  code: string,
+  label: string,
+): unknown[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) {
+    return gltfDecodeFailure("format", code, `${label} must be an array.`);
+  }
+  return value;
+}
+
+export function gltfJsonInteger(
+  value: unknown,
+  code: string,
+  label: string,
+  minimum = 0,
+): number {
+  if (!Number.isSafeInteger(value) || (value as number) < minimum) {
+    return gltfDecodeFailure(
+      "format",
+      code,
+      `${label} must be a safe integer of at least ${minimum}.`,
+    );
+  }
+  return value as number;
+}
+
+export function gltfJsonOptionalInteger(
+  value: unknown,
+  code: string,
+  label: string,
+): number {
+  return value === undefined ? 0 : gltfJsonInteger(value, code, label);
+}
+
+export function gltfJsonIndexed<T>(
+  values: readonly T[],
+  value: unknown,
+  code: string,
+  label: string,
+): T {
+  const index = gltfJsonInteger(value, code, label);
+  if (index >= values.length) {
+    return gltfDecodeFailure("format", code, `${label} is out of range.`);
+  }
+  return values[index]!;
+}
+
+export function assertGltfByteRange(
+  offset: number,
+  byteLength: number,
+  containerLength: number,
+  code: string,
+  label: string,
+): void {
+  if (byteLength < 0 || offset > containerLength - byteLength) {
+    gltfDecodeFailure("format", code, `${label} exceeds its declared buffer.`);
+  }
+}
+
+export function getGltfElementByteLength(
+  componentType: number,
+  type: string,
+): number | undefined {
+  const componentBytes = GLTF_COMPONENT_BYTES[componentType];
+  const components = ELEMENT_COMPONENTS[type];
+  if (!componentBytes || !components) return undefined;
+
+  if (type === "MAT2" || type === "MAT3" || type === "MAT4") {
+    const columns = Number(type.at(-1));
+    const columnBytes = checkedGltfScale(
+      columns,
+      componentBytes,
+      "decoded-byte-limit-exceeded",
+    );
+    const alignedColumnBytes = checkedGltfTotal(
+      columnBytes,
+      (4 - (columnBytes % 4)) % 4,
+      Number.MAX_SAFE_INTEGER,
+      "decoded-byte-limit-exceeded",
+      "glTF matrix element",
+    );
+    return checkedGltfScale(
+      columns,
+      alignedColumnBytes,
+      "decoded-byte-limit-exceeded",
+    );
+  }
+  return checkedGltfScale(
+    componentBytes,
+    components,
+    "decoded-byte-limit-exceeded",
+  );
+}

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

@@ -0,0 +1,128 @@
+import type { GLTF, JSONDocument } from "@gltf-transform/core";
+
+import type { ToolcraftModelImportLimits } from "../../schema/types";
+import { preflightGltfAccessors } from "./gltf-accessor-preflight";
+import { preflightGltfBuffers } from "./gltf-buffer-preflight";
+import {
+  checkedGltfScale,
+  checkedGltfTotal,
+  throwIfGltfDecodeAborted,
+} from "./gltf-decode-safety";
+import { preflightGltfNodes } from "./gltf-node-preflight";
+import { preflightGltfPrimitives } from "./gltf-primitive-preflight";
+import type { GltfDecodedCountExpectation } from "./gltf-primitive-preflight";
+import { preflightGltfAppearanceResources } from "./gltf-texture-resource";
+
+function totalWithin(
+  values: readonly number[],
+  maximum: number,
+  code: string,
+  label: string,
+  initial = 0,
+): number {
+  return values.reduce(
+    (total, value) =>
+      checkedGltfTotal(total, value, maximum, code, label),
+    initial,
+  );
+}
+
+export function preflightGltfJsonDocument(
+  json: GLTF.IGLTF,
+  resources: JSONDocument["resources"],
+  sourceWorkerBytes: number,
+  limits: ToolcraftModelImportLimits,
+  signal: AbortSignal,
+): {
+  decodedCountExpectations: GltfDecodedCountExpectation[];
+  retainedWorkerBytes: number;
+} {
+  throwIfGltfDecodeAborted(signal);
+  const retainedWorkerBytes = totalWithin(
+    [sourceWorkerBytes],
+    limits.maxEstimatedWorkerBytes,
+    "estimated-worker-memory-limit-exceeded",
+    "glTF source snapshot memory",
+  );
+  const buffers = preflightGltfBuffers(
+    json,
+    resources,
+    retainedWorkerBytes,
+    limits,
+    signal,
+  );
+  const accessors = preflightGltfAccessors(
+    json,
+    buffers.bufferViews,
+    limits,
+    signal,
+  );
+  const primitives = preflightGltfPrimitives(
+    json,
+    accessors.accessors,
+    buffers.bufferViews,
+    limits,
+    signal,
+  );
+  const hierarchy = preflightGltfNodes(
+    json,
+    primitives.meshCount,
+    limits,
+    signal,
+  );
+  const appearance = preflightGltfAppearanceResources(
+    json,
+    resources,
+    buffers.bufferViews,
+    limits,
+    signal,
+  );
+
+  totalWithin(
+    [
+      buffers.embeddedBytes,
+      buffers.meshoptBytes,
+      accessors.decodedBytes,
+      primitives.canonicalBytes,
+      appearance.imageBytes,
+    ],
+    limits.maxDecodedBytes,
+    "decoded-byte-limit-exceeded",
+    "Decoded glTF geometry",
+  );
+  totalWithin(
+    [
+      buffers.embeddedBytes,
+      buffers.meshoptBytes,
+      accessors.decodedBytes,
+      appearance.imageBytes,
+      primitives.dracoScratchBytes,
+      checkedGltfScale(
+        totalWithin(
+          [
+            hierarchy.metadataBytes,
+            checkedGltfScale(
+              primitives.primitiveCount,
+              256,
+              "estimated-worker-memory-limit-exceeded",
+            ),
+          ],
+          Number.MAX_SAFE_INTEGER,
+          "estimated-worker-memory-limit-exceeded",
+          "glTF canonical snapshot metadata",
+          primitives.canonicalBytes,
+        ),
+        2,
+        "estimated-worker-memory-limit-exceeded",
+      ),
+    ],
+    limits.maxEstimatedWorkerBytes,
+    "estimated-worker-memory-limit-exceeded",
+    "glTF worker memory",
+    retainedWorkerBytes,
+  );
+  return {
+    decodedCountExpectations: primitives.decodedCountExpectations,
+    retainedWorkerBytes,
+  };
+}

package/templates/runtime/model-import/formats/gltf-missing-appearance.ts

@@ -0,0 +1,158 @@
+import type { GLTF } from "@gltf-transform/core";
+
+import { gltfDecodeCheckpoint } from "./gltf-decode-safety";
+
+type JsonRecord = Record<string, unknown>;
+
+export type GltfMissingAppearanceReason =
+  | "missing-local-file"
+  | "remote-uri"
+  | "unsupported-image-source";
+
+export type GltfMissingImage = Readonly<{
+  imageIndex: number;
+  reason: GltfMissingAppearanceReason;
+  uri: string;
+}>;
+
+export type GltfMissingTexture = Readonly<{
+  reason: GltfMissingAppearanceReason;
+  textureIndex: number;
+  uri: string;
+}>;
+
+export type GltfMissingAppearanceBinding = Readonly<{
+  materialIndex: number;
+  reason: GltfMissingAppearanceReason;
+  slotName:
+    | "baseColorTexture"
+    | "emissiveTexture"
+    | "metallicRoughnessTexture"
+    | "normalTexture"
+    | "occlusionTexture";
+  textureIndex: number;
+  uri: string;
+}>;
+
+type TextureBinding = Readonly<{
+  owner: JsonRecord;
+  slotName: GltfMissingAppearanceBinding["slotName"];
+}>;
+
+function materialTextureBindings(material: JsonRecord): TextureBinding[] {
+  const bindings: TextureBinding[] = [
+    { owner: material, slotName: "emissiveTexture" },
+    { owner: material, slotName: "normalTexture" },
+    { owner: material, slotName: "occlusionTexture" },
+  ];
+  const pbr = material.pbrMetallicRoughness;
+  if (typeof pbr === "object" && pbr !== null && !Array.isArray(pbr)) {
+    bindings.push(
+      { owner: pbr as JsonRecord, slotName: "baseColorTexture" },
+      { owner: pbr as JsonRecord, slotName: "metallicRoughnessTexture" },
+    );
+  }
+  return bindings;
+}
+
+function textureInfoIndex(binding: TextureBinding): number | undefined {
+  const value = binding.owner[binding.slotName];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const index = (value as JsonRecord).index;
+  return Number.isSafeInteger(index) && (index as number) >= 0
+    ? index as number
+    : undefined;
+}
+
+export function removeMissingGltfAppearance(
+  json: GLTF.IGLTF,
+  missingImages: readonly GltfMissingImage[],
+  missingTextures: readonly GltfMissingTexture[],
+  signal: AbortSignal,
+): readonly GltfMissingAppearanceBinding[] {
+  if (missingImages.length === 0 && missingTextures.length === 0) return [];
+  const images = Array.isArray(json.images) ? json.images : [];
+  const textures = Array.isArray(json.textures) ? json.textures : [];
+  const missingImageByIndex = new Map(
+    missingImages.map((missing) => [missing.imageIndex, missing]),
+  );
+  const missingTextureByIndex = new Map(
+    missingTextures.map((missing) => [missing.textureIndex, missing]),
+  );
+  textures.forEach((textureValue, textureIndex) => {
+    gltfDecodeCheckpoint(signal, textureIndex);
+    if (typeof textureValue !== "object" || textureValue === null) return;
+    const source = (textureValue as unknown as JsonRecord).source;
+    if (!Number.isSafeInteger(source)) return;
+    const missing = missingImageByIndex.get(source as number);
+    if (missing) {
+      missingTextureByIndex.set(textureIndex, {
+        reason: missing.reason,
+        textureIndex,
+        uri: missing.uri,
+      });
+    }
+  });
+
+  const bindings: GltfMissingAppearanceBinding[] = [];
+  const materials = Array.isArray(json.materials) ? json.materials : [];
+  materials.forEach((materialValue, materialIndex) => {
+    gltfDecodeCheckpoint(signal, textures.length + materialIndex);
+    if (typeof materialValue !== "object" || materialValue === null) return;
+    for (const binding of materialTextureBindings(
+      materialValue as unknown as JsonRecord,
+    )) {
+      const textureIndex = textureInfoIndex(binding);
+      const missing = textureIndex === undefined
+        ? undefined
+        : missingTextureByIndex.get(textureIndex);
+      if (!missing) continue;
+      bindings.push({
+        materialIndex,
+        reason: missing.reason,
+        slotName: binding.slotName,
+        textureIndex: missing.textureIndex,
+        uri: missing.uri,
+      });
+      delete binding.owner[binding.slotName];
+    }
+  });
+
+  const textureRemap = new Map<number, number>();
+  const retainedTextures = textures.filter((_texture, index) => {
+    if (missingTextureByIndex.has(index)) return false;
+    textureRemap.set(index, textureRemap.size);
+    return true;
+  });
+  for (const materialValue of materials) {
+    if (typeof materialValue !== "object" || materialValue === null) continue;
+    for (const binding of materialTextureBindings(
+      materialValue as unknown as JsonRecord,
+    )) {
+      const oldIndex = textureInfoIndex(binding);
+      if (oldIndex === undefined) continue;
+      const newIndex = textureRemap.get(oldIndex);
+      const value = binding.owner[binding.slotName] as JsonRecord;
+      if (newIndex !== undefined) value.index = newIndex;
+    }
+  }
+
+  const imageRemap = new Map<number, number>();
+  const retainedImages = images.filter((_image, index) => {
+    if (missingImageByIndex.has(index)) return false;
+    imageRemap.set(index, imageRemap.size);
+    return true;
+  });
+  for (const textureValue of retainedTextures) {
+    if (typeof textureValue !== "object" || textureValue === null) continue;
+    const texture = textureValue as unknown as JsonRecord;
+    if (!Number.isSafeInteger(texture.source)) continue;
+    const newSource = imageRemap.get(texture.source as number);
+    if (newSource !== undefined) texture.source = newSource;
+  }
+  json.images = retainedImages;
+  json.textures = retainedTextures;
+  return Object.freeze(bindings);
+}

package/templates/runtime/model-import/formats/gltf-model-format-adapter-appearance.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  contextFor,
+  createGlbTransfer,
+  createGltfTransfer,
+} from "../test-fixtures/model-fixtures";
+import {
+  GLTF_APPEARANCE_JPEG,
+  GLTF_APPEARANCE_PNG,
+  createEmbeddedGltfPbrFixture,
+  createLocalImageGltfTransfer,
+} from "../test-fixtures/gltf-appearance-fixtures";
+import {
+  toolcraftGlbModelFormatAdapter,
+  toolcraftGltfModelFormatAdapter,
+} from "./gltf-model-format-adapter";
+
+function imageDataUri(bytes: Uint8Array, mimeType: string): string {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return `data:${mimeType};base64,${btoa(binary)}`;
+}
+
+describe("glTF canonical appearance", () => {
+  it("preserves embedded PNG/JPEG PBR, UV sets, RGBA colors, and samplers", async () => {
+    const result = await toolcraftGlbModelFormatAdapter.decode(
+      contextFor(createGlbTransfer(createEmbeddedGltfPbrFixture())),
+    );
+    expect(result.document.version).toBe(2);
+    if (result.document.version !== 2) throw new Error("Expected v2 document.");
+
+    expect(result.document.materials).toHaveLength(1);
+    expect(result.document.materials[0]).toMatchObject({
+      alphaCutoff: 0.4,
+      alphaMode: "mask",
+      baseColor: [0.25, 0.5, 0.75],
+      doubleSided: true,
+      emissive: [0.1, 0.2, 0.3],
+      metallic: 0.7,
+      opacity: 0.6,
+      roughness: 0.2,
+      usesVertexColor: true,
+    });
+    expect(result.document.materials[0]!.normalTexture).toMatchObject({
+      scale: 0.35,
+      texCoord: 0,
+    });
+    expect(result.document.materials[0]!.occlusionTexture).toMatchObject({
+      strength: 0.45,
+      texCoord: 1,
+    });
+    expect(result.document.textures).toHaveLength(4);
+    expect(result.document.textures.map((texture) => [
+      texture.colorSpace,
+      texture.mimeType,
+      texture.width,
+      texture.height,
+    ])).toEqual([
+      ["srgb", "image/png", 2, 3],
+      ["srgb", "image/jpeg", 5, 4],
+      ["linear", "image/jpeg", 5, 4],
+      ["linear", "image/png", 2, 3],
+    ]);
+    expect(result.document.textures[0]!.sampler).toEqual({
+      magFilter: "nearest",
+      minFilter: "nearest-mipmap-nearest",
+      wrapS: "clamp-to-edge",
+      wrapT: "mirrored-repeat",
+    });
+    expect(result.appearanceResources.map(({ mimeType }) => mimeType).sort())
+      .toEqual(["image/jpeg", "image/png"]);
+    const primitive = result.document.primitives[0]!;
+    expect(primitive.materialId).toBe("material:0");
+    expect(primitive.textureCoordinates?.map(({ set }) => set)).toEqual([0, 1]);
+    expect(primitive.colors).toMatchObject({ components: 4 });
+    expect(primitive.colors?.values).toEqual(new Float32Array([
+      1, 0, 0, 1,
+      0, 1, 0, 128 / 255,
+      0, 0, 1, 64 / 255,
+    ]));
+  });
+
+  it("resolves exact local image dependencies without network access", async () => {
+    const result = await toolcraftGltfModelFormatAdapter.decode(
+      contextFor(createLocalImageGltfTransfer()),
+    );
+    expect(result.appearanceResources).toHaveLength(2);
+    expect(result.diagnostics).not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ code: "missing-appearance-resource" }),
+      ]),
+    );
+  });
+
+  it("tolerates unreferenced appearance sidecars in a selected package", async () => {
+    const transfer = createLocalImageGltfTransfer();
+    const result = await toolcraftGltfModelFormatAdapter.decode(
+      contextFor({
+        ...transfer,
+        sourceFiles: [
+          ...transfer.sourceFiles,
+          {
+            bytes: GLTF_APPEARANCE_PNG.slice().buffer,
+            contentDigest: "fixture-unused-sidecar",
+            mimeType: "image/png",
+            path: "models/textures/unused.png",
+          },
+        ],
+      }),
+    );
+    expect(result.appearanceResources).toHaveLength(2);
+  });
+
+  it("omits only slots backed by a missing local image", async () => {
+    const result = await toolcraftGltfModelFormatAdapter.decode(
+      contextFor(createLocalImageGltfTransfer("jpeg")),
+    );
+    if (result.document.version !== 2) throw new Error("Expected v2 document.");
+    const material = result.document.materials[0]!;
+    expect(material.baseColorTexture).toBeDefined();
+    expect(material.normalTexture).toBeDefined();
+    expect(material.emissiveTexture).toBeUndefined();
+    expect(material.metallicRoughnessTexture).toBeUndefined();
+    expect(material.occlusionTexture).toBeUndefined();
+    expect(material).toMatchObject({
+      baseColor: [0.25, 0.5, 0.75],
+      emissive: [0.1, 0.2, 0.3],
+      metallic: 0.7,
+      roughness: 0.2,
+    });
+    expect(result.appearanceResources).toHaveLength(1);
+    expect(result.diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: "missing-appearance-resource",
+          explanation: expect.stringContaining("textures/packed.jpg"),
+          severity: "warning",
+        }),
+      ]),
+    );
+  });
+
+  it("preserves RGB vertex colors and blend semantics", async () => {
+    const fixture = createEmbeddedGltfPbrFixture();
+    fixture.json.accessors![3]!.type = "VEC3";
+    fixture.json.bufferViews![3]!.byteLength = 9;
+    fixture.json.materials![0]!.alphaMode = "BLEND";
+    const result = await toolcraftGlbModelFormatAdapter.decode(
+      contextFor(createGlbTransfer(fixture)),
+    );
+    if (result.document.version !== 2) throw new Error("Expected v2 document.");
+    expect(result.document.materials[0]!.alphaMode).toBe("blend");
+    expect(result.document.primitives[0]!.colors).toMatchObject({ components: 3 });
+  });
+
+  it("accepts bounded embedded PNG/JPEG data URIs without fetch", async () => {
+    const fixture = createEmbeddedGltfPbrFixture();
+    fixture.json.images = [
+      { uri: imageDataUri(GLTF_APPEARANCE_PNG, "image/png") },
+      { uri: imageDataUri(GLTF_APPEARANCE_JPEG, "image/jpeg") },
+    ];
+    const result = await toolcraftGltfModelFormatAdapter.decode(
+      contextFor(createGltfTransfer(fixture)),
+    );
+    expect(result.appearanceResources).toHaveLength(2);
+  });
+
+  it.each([
+    ["bytes", { maxTextureBytes: 30 }, "max-texture-bytes-exceeded"],
+    ["count", { maxTextureCount: 1 }, "max-textures-exceeded"],
+    ["dimension", { maxTextureDimension: 2 }, "max-texture-dimension-exceeded"],
+    ["pixels", { maxTexturePixels: 10 }, "max-texture-pixels-exceeded"],
+  ] as const)("preflights texture %s limits", async (_name, limits, code) => {
+    await expect(
+      toolcraftGlbModelFormatAdapter.decode(
+        contextFor(createGlbTransfer(createEmbeddedGltfPbrFixture()), { limits }),
+      ),
+    ).rejects.toMatchObject({ category: "resource-limit", code });
+  });
+});