three-vat 4.1.0 → 4.2.0

package/dist/index.js

@@ -1,984 +1,158 @@
-import { LoopMode, MAX_TEXTURE_SIZE, vertexLayoutFor, makeVATNormalTexture, makeVATTexture, RIG_TEXELS_PER_SLOT, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS, HALF_FLOAT_MAX, RIG_TEXELS } from './chunk-OEKKEHRQ.js';
-export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-OEKKEHRQ.js';
-import { LoopRepeat, LoopOnce, LoopPingPong, DataUtils, Quaternion, Matrix4, Box3, Vector4, Vector3, Sphere, HalfFloatType, BufferGeometry, BufferAttribute, AdditiveAnimationBlendMode, AnimationMixer, PropertyBinding, FloatType, Material, InterleavedBuffer, SkinnedMesh, Mesh, Bone, Object3D, Skeleton, AnimationClip, Color, InterleavedBufferAttribute, VectorKeyframeTrack, StringKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, ColorKeyframeTrack, BooleanKeyframeTrack, Float16BufferAttribute, Interpolant } from 'three';
+import { BAKED_FILE_EXTENSION, BAKED_FILE_VERSION, BAKED_LAYER_FORMATS, positionDigest, bakeVATWith, flatFacts, mergedFlatMaterial, keepRestSlots, restSlotsOf } from './chunk-P6AFXEBT.js';
+export { bakeVAT, decodeOctahedral, encodeOctahedral } from './chunk-P6AFXEBT.js';
+import { makeVATTexture, makeVATNormalTexture } from './chunk-4IKOXUSX.js';
+export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance, turnVATInstance } from './chunk-4IKOXUSX.js';
+import { Quaternion, Box3, Vector3, Sphere, BufferAttribute, BufferGeometry, FloatType, HalfFloatType, Material, InterleavedBuffer, SkinnedMesh, Mesh, Bone, Object3D, Skeleton, Matrix4, AnimationClip, AnimationMixer, VectorKeyframeTrack, StringKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, ColorKeyframeTrack, BooleanKeyframeTrack, InterleavedBufferAttribute, Float16BufferAttribute, PropertyBinding, Interpolant } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 
-var IGNORED = ["uuid", "name", "color", "userData", "metadata"];
-function flatFacts(material) {
-  const m = material;
-  if (!m.color?.isColor || m.vertexColors || m.isShadowMaterial) return null;
-  const own = (key) => Object.prototype.hasOwnProperty.call(m, key);
-  if (own("onBeforeCompile") || own("customProgramCacheKey")) return null;
-  for (const value of Object.values(m)) {
-    const v = value;
-    if (v?.isTexture || v?.isNode) return null;
+async function loadVAT(url, { loader = new GLTFLoader(), materials } = {}) {
+  if (!withPlugin.has(loader)) {
+    loader.register((parser) => new VATPlugin(parser));
+    withPlugin.add(loader);
   }
-  const json = m.toJSON();
-  for (const key of IGNORED) delete json[key];
-  return { key: JSON.stringify(json), color: [m.color.r, m.color.g, m.color.b] };
-}
-function mergedFlatMaterial(members) {
-  const merged = members[0].clone();
-  merged.color.setRGB(1, 1, 1);
-  merged.vertexColors = true;
-  merged.name = members.map((m) => m.name).filter(Boolean).join(" + ");
-  return merged;
-}
-var FLAT_MERGE = { facts: flatFacts, merge: mergedFlatMaterial };
-function planFlatMerge(materials, hooks) {
-  const facts = /* @__PURE__ */ new Map();
-  const groups = /* @__PURE__ */ new Map();
-  for (const material of materials) {
-    if (facts.has(material)) continue;
-    const f = hooks.facts(material);
-    if (!f) continue;
-    facts.set(material, f);
-    groups.set(f.key, [...groups.get(f.key) ?? [], material]);
-  }
-  const targets = /* @__PURE__ */ new Map();
-  for (const members of groups.values()) {
-    if (members.length < 2) continue;
-    const merged = hooks.merge(members);
-    for (const m of members) targets.set(m, { material: merged, tint: new Color().fromArray(facts.get(m).color) });
-  }
-  return { targetOf: (material) => targets.get(material) };
-}
-
-// src/octahedral.ts
-var signNotZero = (v) => v >= 0 ? 1 : -1;
-var toByte = (v) => Math.max(0, Math.min(255, Math.round((v * 0.5 + 0.5) * 255)));
-function encodeOctahedral(x, y, z, out, offset) {
-  const l1 = Math.abs(x) + Math.abs(y) + Math.abs(z);
-  if (l1 === 0) {
-    out[offset] = toByte(0);
-    out[offset + 1] = toByte(0);
-    return;
-  }
-  const px = x / l1;
-  const py = y / l1;
-  const fold = z <= 0;
-  out[offset] = toByte(fold ? (1 - Math.abs(py)) * signNotZero(px) : px);
-  out[offset + 1] = toByte(fold ? (1 - Math.abs(px)) * signNotZero(py) : py);
-}
-function decodeOctahedral(u, v, out = { x: 0, y: 0, z: 0 }) {
-  const ex = u / 255 * 2 - 1;
-  const ey = v / 255 * 2 - 1;
-  const z = 1 - Math.abs(ex) - Math.abs(ey);
-  const t = Math.max(-z, 0);
-  const x = ex - signNotZero(ex) * t;
-  const y = ey - signNotZero(ey) * t;
-  const length = Math.hypot(x, y, z) || 1;
-  out.x = x / length;
-  out.y = y / length;
-  out.z = z / length;
-  return out;
-}
-
-// src/bake.ts
-var LOOP_MODES = /* @__PURE__ */ new Map([
-  [LoopRepeat, LoopMode.Repeat],
-  [LoopOnce, LoopMode.Once],
-  [LoopPingPong, LoopMode.PingPong]
-]);
-function isAction(input) {
-  return typeof input.getClip === "function";
-}
-function resolveAnimation(input) {
-  if (!isAction(input)) return { clip: input, defaults: { ...LIBRARY_PLAYBACK_DEFAULTS } };
-  const clip = input.getClip();
-  const name = clip.name || "(unnamed)";
-  const cannotBlend = (field, value) => new Error(
-    `three-vat: action for clip "${name}" has ${field} ${value}; that blends several actions at once, which a single baked band cannot represent \u2014 bake the clips separately and crossfade between them (three-vat#30), or reset the action before baking`
-  );
-  if (input.weight !== 1) throw cannotBlend("weight", String(input.weight));
-  if (input.blendMode === AdditiveAnimationBlendMode) throw cannotBlend("blendMode", "additive");
-  if (input.timeScale < 0) {
-    throw new Error(
-      `three-vat: action for clip "${name}" has timeScale ${input.timeScale}; ${FORWARD_ONLY_REASON}.`
-    );
-  }
-  const loopMode = LOOP_MODES.get(input.loop);
-  if (loopMode === void 0) {
-    throw new Error(
-      `three-vat: action for clip "${name}" has an unrecognised loop mode ${input.loop}; expected THREE.LoopRepeat, LoopOnce or LoopPingPong`
-    );
-  }
-  return {
-    clip,
-    defaults: {
-      loopMode,
-      // three's `repetitions` defaults to Infinity and `LoopOnce` ignores it
-      // outright — so a one-shot is one play whatever the field says, and an
-      // endless count becomes the sentinel a Float32Array can carry.
-      repetitions: loopMode === LoopMode.Once ? 1 : Number.isFinite(input.repetitions) ? input.repetitions : INFINITE_REPETITIONS,
-      // Not read off the action (see the rule above), so a bake clamps whichever
-      // input it was handed. Uniform across loop modes on purpose: an instance
-      // may override a repeating clip's `loopMode` to `Once` and inherit this
-      // field, so there is no mode whose end mode is safely unreachable and
-      // could hold a different answer. Rewind is per instance:
-      // `{ ..., endMode: EndMode.Rewind }` (#43, ADR-0017).
-      endMode: LIBRARY_PLAYBACK_DEFAULTS.endMode,
-      speed: input.timeScale
-    }
-  };
-}
-function morphCountOf({ mesh, morphPos, morphNrm }) {
-  const influences = mesh.morphTargetInfluences;
-  return influences ? Math.min(influences.length, Math.max(morphPos?.length ?? 0, morphNrm?.length ?? 0)) : 0;
-}
-var _mt = /* @__PURE__ */ new Vector3();
-var _mb = /* @__PURE__ */ new Vector3();
-var _mbn = /* @__PURE__ */ new Vector3();
-function morphVertex(part, v, weights, count, p, n) {
-  const { basePos, baseNrm, morphPos, morphNrm, morphRelative } = part;
-  if (!morphRelative) {
-    _mb.fromBufferAttribute(basePos, v);
-    if (n) _mbn.fromBufferAttribute(baseNrm, v);
-  }
-  for (let t = 0; t < count; t++) {
-    const w = weights[t];
-    if (w === 0) continue;
-    const targetPos = morphPos?.[t];
-    if (targetPos) {
-      _mt.fromBufferAttribute(targetPos, v);
-      if (!morphRelative) _mt.sub(_mb);
-      p.addScaledVector(_mt, w);
-    }
-    const targetNrm = n ? morphNrm?.[t] : void 0;
-    if (n && targetNrm) {
-      _mt.fromBufferAttribute(targetNrm, v);
-      if (!morphRelative) _mt.sub(_mbn);
-      n.addScaledVector(_mt, w);
-    }
-  }
-}
-function asAttribute(value, mesh, name) {
-  if (!(value instanceof BufferAttribute)) {
-    throw new Error(
-      `three-vat: mesh "${mesh.name || "(unnamed)"}" has an interleaved or unsupported "${name}" attribute; VAT bakes plain BufferAttributes`
-    );
-  }
-  return value;
-}
-function deriveNormals(position, index) {
-  const scratch = new BufferGeometry();
-  scratch.setAttribute("position", position);
-  scratch.setIndex(index);
-  scratch.computeVertexNormals();
-  return scratch.attributes.normal;
-}
-function collectParts(root, hooks) {
-  const found = [];
-  root.traverse((o) => {
-    const mesh = o;
-    if (mesh.isMesh && mesh.geometry) found.push(mesh);
-  });
-  if (found.length === 0) {
-    throw new Error("three-vat: no Mesh found under root; nothing to bake");
-  }
-  const flat = hooks ? planFlatMerge(
-    found.flatMap((mesh) => Array.isArray(mesh.material) ? [] : [mesh.material]),
-    hooks
-  ) : null;
-  const materials = [];
-  const parts = [];
-  for (const mesh of found) {
-    if (Array.isArray(mesh.material)) {
-      throw new Error(
-        `three-vat: mesh "${mesh.name || "(unnamed)"}" uses a material array; split it into one mesh per material before baking`
-      );
-    }
-    const geometry = mesh.geometry;
-    const source = mesh.material;
-    const merged = flat?.targetOf(source);
-    const material = merged?.material ?? source;
-    let materialIndex = materials.indexOf(material);
-    if (materialIndex === -1) materialIndex = materials.push(material) - 1;
-    const skinned = mesh;
-    const basePos = asAttribute(geometry.attributes.position, mesh, "position");
-    parts.push({
-      mesh,
-      material,
-      materialIndex,
-      vertexStart: 0,
-      // assigned below, after material sorting
-      vertexCount: geometry.attributes.position.count,
-      basePos,
-      baseNrm: geometry.attributes.normal ? asAttribute(geometry.attributes.normal, mesh, "normal") : deriveNormals(basePos, geometry.index),
-      isSkinned: !!geometry.attributes.skinWeight && !!skinned.skeleton,
-      skeleton: skinned.skeleton,
-      pose: void 0,
-      // assigned below, once the distinct rigs are known
-      skinIndex: geometry.attributes.skinIndex,
-      skinWeight: geometry.attributes.skinWeight,
-      morphPos: geometry.morphAttributes.position,
-      morphNrm: geometry.morphAttributes.normal,
-      morphRelative: geometry.morphTargetsRelative,
-      tint: merged?.tint ?? null
-    });
-  }
-  parts.sort((a, b) => a.materialIndex - b.materialIndex);
-  let offset = 0;
-  for (const part of parts) {
-    part.vertexStart = offset;
-    offset += part.vertexCount;
-  }
-  return parts;
-}
-function mergeGeometry(parts, restMatrices, total) {
-  const position = new Float32Array(total * 3);
-  const normal = new Float32Array(total * 3);
-  const _v = new Vector3();
-  const _n = new Vector3();
-  parts.forEach((part, pi) => {
-    const m = restMatrices[pi];
-    for (let v = 0; v < part.vertexCount; v++) {
-      _v.fromBufferAttribute(part.basePos, v).applyMatrix4(m);
-      _n.fromBufferAttribute(part.baseNrm, v).transformDirection(m);
-      _v.toArray(position, (part.vertexStart + v) * 3);
-      _n.toArray(normal, (part.vertexStart + v) * 3);
-    }
-  });
-  const merged = new BufferGeometry();
-  merged.setAttribute("position", new BufferAttribute(position, 3));
-  merged.setAttribute("normal", new BufferAttribute(normal, 3));
-  mergeSurface(merged, parts, total, restMatrices);
-  return merged;
-}
-function mergeSurface(merged, parts, total, restMatrices) {
-  const merging = parts.some((p) => p.tint);
-  const want = optionalAttributes(parts, merging);
-  const uv = want.uv ? new Float32Array(total * 2) : null;
-  const color = want.color ? new Float32Array(total * 3) : null;
-  const tangent = want.tangent ? new Float32Array(total * 4) : null;
-  const _t = new Vector3();
-  parts.forEach((part, pi) => {
-    const geometry = part.mesh.geometry;
-    const start = part.vertexStart;
-    const srcUV = uv ? asAttribute(geometry.attributes.uv, part.mesh, "uv") : null;
-    const srcColor = color ? colorSource(part, merging) : null;
-    const srcTangent = tangent ? geometry.attributes.tangent : null;
-    const m = restMatrices?.[pi];
-    for (let v = 0; v < part.vertexCount; v++) {
-      const vi = start + v;
-      if (uv && srcUV) {
-        uv[vi * 2] = srcUV.getX(v);
-        uv[vi * 2 + 1] = srcUV.getY(v);
-      }
-      if (color) writeColor(color, vi * 3, part, srcColor, v);
-      if (tangent && srcTangent) {
-        _t.fromBufferAttribute(srcTangent, v);
-        if (m) _t.transformDirection(m);
-        const o4 = vi * 4;
-        tangent[o4] = _t.x;
-        tangent[o4 + 1] = _t.y;
-        tangent[o4 + 2] = _t.z;
-        tangent[o4 + 3] = srcTangent.getW(v);
-      }
-    }
-  });
-  if (uv) merged.setAttribute("uv", new BufferAttribute(uv, 2));
-  if (color) merged.setAttribute("color", new BufferAttribute(color, 3));
-  if (tangent) merged.setAttribute("tangent", new BufferAttribute(tangent, 4));
-  indexParts(merged, parts);
-}
-function colorSource(part, merging) {
-  const source = part.mesh.geometry.attributes.color;
-  if (part.tint || !source) return null;
-  if (merging && source instanceof InterleavedBufferAttribute) return source;
-  return asAttribute(source, part.mesh, "color");
-}
-function writeColor(out, o3, part, source, v) {
-  if (part.tint) {
-    out[o3] = part.tint.r;
-    out[o3 + 1] = part.tint.g;
-    out[o3 + 2] = part.tint.b;
-  } else if (source) {
-    out[o3] = source.getX(v);
-    out[o3 + 1] = source.getY(v);
-    out[o3 + 2] = source.getZ(v);
-  } else {
-    out[o3] = out[o3 + 1] = out[o3 + 2] = 1;
-  }
-}
-function optionalAttributes(parts, merging) {
-  return {
-    uv: parts.every((p) => !!p.mesh.geometry.attributes.uv),
-    // A merge writes a colour for every part it touched, so the attribute is
-    // there whenever one happened; a part it did not touch keeps its own, or
-    // white, which leaves an untinted material's shading as it was.
-    color: merging || parts.every((p) => !!p.mesh.geometry.attributes.color),
-    tangent: parts.every((p) => {
-      const t = p.mesh.geometry.attributes.tangent;
-      return t instanceof BufferAttribute && t.itemSize === 4;
-    })
-  };
-}
-function indexParts(merged, parts) {
-  const indices = [];
-  const groups = [];
-  for (const part of parts) {
-    const start = part.vertexStart;
-    const groupStart = indices.length;
-    const index = part.mesh.geometry.index;
-    if (index) {
-      for (let i = 0; i < index.count; i++) indices.push(start + index.getX(i));
-    } else {
-      for (let v = 0; v < part.vertexCount; v++) indices.push(start + v);
-    }
-    const last = groups[groups.length - 1];
-    if (last && last.materialIndex === part.materialIndex) {
-      last.count += indices.length - groupStart;
-    } else {
-      groups.push({
-        start: groupStart,
-        count: indices.length - groupStart,
-        materialIndex: part.materialIndex
-      });
-    }
-  }
-  merged.setIndex(indices);
-  for (const g of groups) merged.addGroup(g.start, g.count, g.materialIndex);
-}
-function frameCountsFor(clips, fps, maxTextureSize) {
-  const frameCounts = clips.map((c) => Math.max(2, Math.round(c.duration * fps)));
-  const totalFrames = frameCounts.reduce((a, b) => a + b, 0);
-  if (totalFrames > maxTextureSize) {
-    throw new Error(
-      `three-vat: totalFrames ${totalFrames} exceeds maxTextureSize ${maxTextureSize}; lower fps or bake fewer clips`
-    );
-  }
-  return { frameCounts, totalFrames };
-}
-function bakeVAT(root, animations, options = {}) {
-  return bakeVATWith(root, animations, options, FLAT_MERGE);
-}
-function bakeVATWith(root, animations, options, hooks) {
-  const {
-    fps = 30,
-    maxTextureSize = MAX_TEXTURE_SIZE,
-    bakeNormals = true,
-    encoding = "auto",
-    mergeFlatMaterials = false
-  } = options;
-  const resolved = animations.map(resolveAnimation);
-  root.updateMatrixWorld(true);
-  const parts = collectParts(root, mergeFlatMaterials ? hooks : null);
-  if (encoding === "rig") return bakeRig(root, parts, resolved, { fps, maxTextureSize });
-  if (encoding === "delta") {
-    return { ...bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals }), fallback: null };
-  }
-  let refusal;
+  let gltf;
   try {
-    return bakeRig(root, parts, resolved, { fps, maxTextureSize });
+    gltf = await loader.loadAsync(url);
   } catch (error) {
-    if (!(error instanceof RigRefusal)) throw error;
-    refusal = error;
+    if (error instanceof Refusal) throw new Error(`three-vat: ${url} ${error.message}`);
+    throw error;
   }
-  try {
-    return { ...bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals }), fallback: refusal.message };
-  } catch (error) {
-    if (!(error instanceof Error)) throw error;
+  const vat = loaded.get(gltf);
+  if (vat === void 0) {
     throw new Error(
-      `three-vat: neither encoding can bake this subtree. The vertex encoding: ${unprefixed(error)}. The rig encoding, tried first: ${unprefixed(refusal)}`,
-      { cause: refusal }
+      `three-vat: ${url} is not a baked file: it carries no ${BAKED_FILE_EXTENSION} extension. Write one with \`npx three-vat bake <input> --out <file>\``
     );
   }
-}
-function unprefixed(error) {
-  return error.message.replace(/^three-vat: /, "");
-}
-function sampleClips(root, resolved, frameCounts, poses, writeFrame) {
-  const mixer = new AnimationMixer(root);
-  const clipTable = [];
-  let rowOffset = 0;
-  try {
-    for (let ci = 0; ci < resolved.length; ci++) {
-      const { clip, defaults } = resolved[ci];
-      const frames = frameCounts[ci];
-      const action = mixer.clipAction(clip);
-      action.play();
-      let maxDeltaSq = 0;
-      for (let f = 0; f < frames; f++) {
-        mixer.setTime(f / frames * clip.duration);
-        root.updateMatrixWorld(true);
-        poseSkeletons(poses);
-        maxDeltaSq = Math.max(maxDeltaSq, writeFrame(clip, f, rowOffset + f));
-      }
-      action.stop();
-      clipTable.push({
-        name: clip.name,
-        startFrame: rowOffset,
-        frames,
-        fps: frames / clip.duration,
-        duration: clip.duration,
-        maxDelta: Math.sqrt(maxDeltaSq),
-        // Declared once, here, rather than repeated at every instance that plays
-        // this band. An instance overrides any of them, field by field.
-        ...defaults
-      });
-      rowOffset += frames;
-    }
-  } finally {
-    mixer.stopAllAction();
-    mixer.setTime(0);
-    root.updateMatrixWorld(true);
-  }
-  return clipTable;
-}
-function bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals }) {
-  const clips = resolved.map((a) => a.clip);
-  const vertexCount = parts.reduce((n, p) => n + p.vertexCount, 0);
-  const { frameCounts, totalFrames } = frameCountsFor(clips, fps, maxTextureSize);
-  const { rowsPerFrame, width, height, frameStride } = vertexLayoutFor(vertexCount, totalFrames, maxTextureSize);
-  const rootInverse = root.matrixWorld.clone().invert();
-  const restMatrices = parts.map(
-    (p) => new Matrix4().multiplyMatrices(rootInverse, p.mesh.matrixWorld)
-  );
-  const geometry = mergeGeometry(parts, restMatrices, vertexCount);
-  const mergedBase = geometry.attributes.position;
-  const posData = new Uint16Array(frameStride * totalFrames * 4);
-  const nrmData = bakeNormals ? new Uint8Array(frameStride * totalFrames * 2) : null;
-  const bakeNormal = nrmData !== null;
-  const bounds = new Box3();
-  const _si = new Vector4();
-  const _sw = new Vector4();
-  const _acc = new Matrix4();
-  const _skin = new Matrix4();
-  const _partMatrix = new Matrix4();
-  const _p = new Vector3();
-  const _bp = new Vector3();
-  const _n = new Vector3();
-  const poses = attachPoseBuffers(parts);
-  const influencers = bakeNormals ? parts.filter((p) => p.pose).map(influencedBones) : [];
-  let warnedNonUniformScale = false;
-  const writeFrame = (clip, f, row) => {
-    let maxDeltaSq = 0;
-    if (!warnedNonUniformScale) {
-      warnedNonUniformScale = warnOnNonUniformBoneScale(influencers);
-    }
-    for (const part of parts) {
-      _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
-      const influences = part.mesh.morphTargetInfluences;
-      const { isSkinned, skinIndex, skinWeight } = part;
-      const boneMatrices = part.pose?.matrices;
-      const morphCount = morphCountOf(part);
-      for (let v = 0; v < part.vertexCount; v++) {
-        const vi = part.vertexStart + v;
-        _p.fromBufferAttribute(part.basePos, v);
-        if (bakeNormal) _n.fromBufferAttribute(part.baseNrm, v);
-        if (influences && morphCount > 0) morphVertex(part, v, influences, morphCount, _p, bakeNormal ? _n : null);
-        if (isSkinned && boneMatrices) {
-          const skinned = part.mesh;
-          _si.fromBufferAttribute(skinIndex, v);
-          _sw.fromBufferAttribute(skinWeight, v);
-          const ae = _acc.elements;
-          for (let e = 0; e < 16; e++) ae[e] = 0;
-          for (let i = 0; i < 4; i++) {
-            const w = _sw.getComponent(i);
-            if (w === 0) continue;
-            const b = _si.getComponent(i) * BONE_STRIDE;
-            for (let e = 0; e < 16; e++) ae[e] += boneMatrices[b + e] * w;
-          }
-          _skin.multiplyMatrices(_acc, skinned.bindMatrix).premultiply(skinned.bindMatrixInverse);
-          _p.applyMatrix4(_skin);
-          if (bakeNormal) _n.transformDirection(_skin);
-        }
-        _p.applyMatrix4(_partMatrix);
-        if (bakeNormal) _n.transformDirection(_partMatrix);
-        bounds.expandByPoint(_p);
-        _bp.fromBufferAttribute(mergedBase, vi);
-        const texel = row * frameStride + vi;
-        const o = texel * 4;
-        const dx = _p.x - _bp.x;
-        const dy = _p.y - _bp.y;
-        const dz = _p.z - _bp.z;
-        maxDeltaSq = Math.max(maxDeltaSq, dx * dx + dy * dy + dz * dz);
-        const largest = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
-        if (largest > HALF_FLOAT_MAX) {
-          throw new Error(
-            `three-vat: position delta component ${largest} (clip "${clip.name}", frame ${f}, vertex ${vi}) exceeds the half-float limit of ${HALF_FLOAT_MAX} the position texture stores; a unit smaller than the metre is the usual cause`
-          );
-        }
-        posData[o] = toHalfFloat(dx);
-        posData[o + 1] = toHalfFloat(dy);
-        posData[o + 2] = toHalfFloat(dz);
-        posData[o + 3] = HALF_ONE;
-        if (bakeNormal) encodeOctahedral(_n.x, _n.y, _n.z, nrmData, texel * 2);
-      }
-    }
-    return maxDeltaSq;
-  };
-  const clipTable = sampleClips(root, resolved, frameCounts, poses, writeFrame);
-  geometry.boundingBox = bounds.clone();
-  geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
-  const materials = [];
-  for (const part of parts) materials[part.materialIndex] = part.material;
-  return {
-    positionTexture: makeVATTexture(posData, width, height, HalfFloatType),
-    normalTexture: nrmData ? makeVATNormalTexture(nrmData, width, height) : null,
-    clips: clipTable,
-    bounds,
-    vertexCount,
-    totalFrames,
-    rowsPerFrame,
-    encoding: "delta",
-    geometry,
-    materials
-  };
-}
-var toHalfFloat = DataUtils.toHalfFloat;
-var HALF_ONE = /* @__PURE__ */ toHalfFloat(1);
-var BONE_STRIDE = 16;
-var IDENTITY = /* @__PURE__ */ new Matrix4();
-function attachPoseBuffers(parts) {
-  const byRig = /* @__PURE__ */ new Map();
-  for (const part of parts) {
-    if (!part.isSkinned || !part.skeleton) continue;
-    let pose = byRig.get(part.skeleton);
-    if (!pose) {
-      const matrices = new Float64Array(part.skeleton.bones.length * BONE_STRIDE);
-      pose = { skeleton: part.skeleton, matrices };
-      byRig.set(part.skeleton, pose);
-    }
-    part.pose = pose;
-  }
-  return [...byRig.values()];
-}
-function poseSkeletons(poses) {
-  const scratch = new Matrix4();
-  for (const { skeleton, matrices } of poses) {
-    const { bones, boneInverses } = skeleton;
-    for (let b = 0; b < bones.length; b++) {
-      scratch.multiplyMatrices(bones[b]?.matrixWorld ?? IDENTITY, boneInverses[b]);
-      matrices.set(scratch.elements, b * BONE_STRIDE);
-    }
-  }
-}
-function influencedBones(part) {
-  const used = /* @__PURE__ */ new Set();
-  const index = part.skinIndex;
-  const weight = part.skinWeight;
-  for (let v = 0; v < part.vertexCount; v++) {
-    for (let i = 0; i < 4; i++) {
-      if (weight.getComponent(v, i) !== 0) used.add(index.getComponent(v, i));
-    }
-  }
-  return { pose: part.pose, bones: [...used] };
-}
-var SCALE_UNIFORMITY_EPSILON = 1e-4;
-var MATRIX_BASIS = [0, 1, 2, 4, 5, 6, 8, 9, 10];
-function hasNonUniformScale(matrices, b) {
-  const o = b * BONE_STRIDE;
-  return unevenSquares(
-    matrices[o] ** 2 + matrices[o + 1] ** 2 + matrices[o + 2] ** 2,
-    matrices[o + 4] ** 2 + matrices[o + 5] ** 2 + matrices[o + 6] ** 2,
-    matrices[o + 8] ** 2 + matrices[o + 9] ** 2 + matrices[o + 10] ** 2
-  );
-}
-function hasShear(matrices, b) {
-  const m = (i) => matrices[b * BONE_STRIDE + i];
-  const lengthSq = (a) => m(a) ** 2 + m(a + 1) ** 2 + m(a + 2) ** 2;
-  const dot = (a, c) => m(a) * m(c) + m(a + 1) * m(c + 1) + m(a + 2) * m(c + 2);
-  const square = (a, c) => dot(a, c) ** 2 <= SCALE_UNIFORMITY_EPSILON ** 2 * lengthSq(a) * lengthSq(c);
-  return !(square(0, 4) && square(0, 8) && square(4, 8));
-}
-function unevenSquares(x, y, z) {
-  const max = Math.max(x, y, z);
-  return max - Math.min(x, y, z) > SCALE_UNIFORMITY_EPSILON * max;
-}
-function warnOnNonUniformBoneScale(influencers) {
-  for (const { pose, bones } of influencers) {
-    for (const b of bones) {
-      if (!hasNonUniformScale(pose.matrices, b)) continue;
-      console.warn(
-        `three-vat: bone "${pose.skeleton.bones[b].name || "(unnamed)"}" animates with non-uniform scale; baked normals under it are approximate, because linear-blend skinning transforms a normal by the skin matrix rather than its inverse-transpose \u2014 the same shortcut three's own skinning shader takes. Positions are exact.`
+  if (materials !== void 0) {
+    const plural = (n) => `${n} material${n === 1 ? "" : "s"}`;
+    if (materials.length !== vat.materials.length) {
+      throw new Error(
+        `three-vat: loadVAT's \`materials\` holds ${plural(materials.length)}, and ${url} has ${plural(vat.materials.length)}, one for each materialIndex; pass one for each, in that order`
       );
-      return true;
     }
+    vat.materials = [...materials];
   }
-  return false;
+  return vat;
 }
-var VERTEX_ENCODING_STORES_IT = "the vertex encoding (`encoding: 'delta'`) stores what a rig cannot";
-var RigRefusal = class extends Error {
+var withPlugin = /* @__PURE__ */ new WeakSet();
+var loaded = /* @__PURE__ */ new WeakMap();
+var Refusal = class extends Error {
 };
-function placementOf(part, rootInverse, out) {
-  out.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
-  if (part.pose) out.multiply(part.mesh.bindMatrixInverse);
-  return out;
-}
-var MATRIX_EPSILON = 1e-6;
-function matricesClose(a, b) {
-  const ae = a.elements;
-  const be = b.elements;
-  for (let e = 0; e < 16; e++) if (Math.abs(ae[e] - be[e]) > MATRIX_EPSILON) return false;
-  return true;
-}
-function slotLabel(slot) {
-  const parts = slot.parts.map(partName).join(", ");
-  if (!slot.rig) return `rigid part ${parts}`;
-  const { pose, bone } = slot.rig;
-  return `bone "${pose.skeleton.bones[bone]?.name || `bone ${bone}`}" of ${parts}`;
-}
-function partName(part) {
-  return `"${part.mesh.name || "(unnamed)"}"`;
-}
-function slotReads(slot, bone, boneInverse, bindMatrix, placement) {
-  const { rig } = slot;
-  return rig !== void 0 && rig.pose.skeleton.bones[rig.bone] === bone && matricesClose(rig.pose.skeleton.boneInverses[rig.bone], boneInverse) && matricesClose(rig.bindMatrix, bindMatrix) && matricesClose(slot.restPlacement, placement);
-}
-function layoutSlots(parts, rootInverse) {
-  const slots = [];
-  const slotMaps = /* @__PURE__ */ new Map();
-  for (const part of parts) {
-    const restPlacement = placementOf(part, rootInverse, new Matrix4());
-    if (part.pose) {
-      const { pose } = part;
-      const { bones, boneInverses } = pose.skeleton;
-      const bindMatrix = part.mesh.bindMatrix.clone();
-      const map = [];
-      for (let b = 0; b < bones.length; b++) {
-        const bone = bones[b];
-        const shared = bone ? slots.findIndex((s) => slotReads(s, bone, boneInverses[b], bindMatrix, restPlacement)) : -1;
-        if (shared >= 0) {
-          const slot = slots[shared];
-          if (!slot.parts.includes(part)) slot.parts.push(part);
-          map.push(shared);
-        } else {
-          map.push(slots.length);
-          slots.push({ rig: { pose, bone: b, bindMatrix }, parts: [part], restPlacement });
-        }
-      }
-      slotMaps.set(part, map);
-    } else {
-      slotMaps.set(part, [slots.length]);
-      slots.push({ rig: void 0, parts: [part], restPlacement });
+var VATPlugin = class {
+  constructor(parser) {
+    this.parser = parser;
+    this.name = BAKED_FILE_EXTENSION;
+  }
+  get extension() {
+    return this.parser.json.extensions?.[BAKED_FILE_EXTENSION];
+  }
+  beforeRoot() {
+    const extension = this.extension;
+    if (extension !== void 0 && extension.version !== BAKED_FILE_VERSION) {
+      throw new Refusal(
+        `is a baked file of format version ${extension.version}, and this three-vat reads version ${BAKED_FILE_VERSION} only; bake it again with this version of \`three-vat bake\``
+      );
     }
-  }
-  return { slots, slotMaps };
-}
-function morphTracksOn(mesh, clip, root) {
-  const driven = /* @__PURE__ */ new Map();
-  for (const track of clip.tracks) {
-    const parsed = PropertyBinding.parseTrackName(track.name);
-    if (parsed.propertyName !== "morphTargetInfluences") continue;
-    if (PropertyBinding.findNode(root, parsed.nodeName) !== mesh) continue;
-    const size = track.getValueSize();
-    const keys = track.times.length;
-    const values = track.values;
-    const add = (t, read) => {
-      const list = driven.get(t) ?? [];
-      for (let k = 0; k < keys; k++) list.push(read(k));
-      driven.set(t, list);
+    return null;
+  }
+  async afterRoot(result) {
+    const extension = this.extension;
+    if (extension !== void 0) loaded.set(result, await this.build(extension));
+  }
+  async build(extension) {
+    const node = await this.parser.getDependency("mesh", extension.mesh);
+    const primitives = node.isMesh ? [node] : node.children;
+    const geometry = mergedGeometry(primitives, extension);
+    const materials = [];
+    extension.groups.forEach((group, i) => materials[group.materialIndex] = primitives[i].material);
+    const bounds = new Box3(new Vector3().fromArray(extension.bounds.min), new Vector3().fromArray(extension.bounds.max));
+    geometry.boundingBox = bounds.clone();
+    geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
+    const shared = {
+      geometry,
+      materials,
+      clips: extension.clips.map((clip) => ({ ...clip })),
+      bounds,
+      vertexCount: extension.vertexCount,
+      totalFrames: extension.totalFrames
     };
-    if (parsed.propertyIndex === void 0) {
-      for (let t = 0; t < size; t++) add(t, (k) => values[k * size + t]);
-    } else {
-      const byIndex = Number(parsed.propertyIndex);
-      const t = Number.isInteger(byIndex) ? byIndex : mesh.morphTargetDictionary?.[parsed.propertyIndex];
-      if (t !== void 0) add(t, (k) => values[k]);
-    }
-  }
-  return driven;
-}
-function morphInfluences(part, clips, root) {
-  const { mesh } = part;
-  const influences = mesh.morphTargetInfluences;
-  const count = morphCountOf(part);
-  if (!influences || count === 0) return { statics: [], animated: [] };
-  const driven = clips.map((clip) => morphTracksOn(mesh, clip, root));
-  const statics = [];
-  const animated = [];
-  for (let t = 0; t < count; t++) {
-    const seen = /* @__PURE__ */ new Set();
-    const offending = [];
-    driven.forEach((tracks, ci) => {
-      const values = tracks.get(t);
-      if (!values) {
-        seen.add(influences[t]);
-        return;
-      }
-      offending.push(`"${clips[ci].name}"`);
-      for (const value of values) seen.add(value);
-    });
-    if (seen.size > 1) {
-      const name = Object.entries(mesh.morphTargetDictionary ?? {}).find(([, i]) => i === t)?.[0];
-      animated.push({ part, target: name ? `"${name}"` : String(t), clips: offending });
+    if (extension.encoding === "rig") {
+      geometry.setAttribute("skinWeight", await this.writtenWeights(extension.mesh));
+      return {
+        encoding: "rig",
+        rigTexture: await this.texture(extension.layers.rig),
+        slotCount: extension.slotCount,
+        ...shared
+      };
     }
-    statics.push(seen.values().next().value);
+    const { position, normal } = extension.layers;
+    return {
+      encoding: "delta",
+      positionTexture: await this.texture(position),
+      normalTexture: normal ? await this.texture(normal) : null,
+      rowsPerFrame: extension.rowsPerFrame,
+      fallback: extension.fallback,
+      ...shared
+    };
   }
-  return { statics, animated };
-}
-function refuseAnimatedMorphs(animated) {
-  const byDriver = /* @__PURE__ */ new Map();
-  for (const { part, target, clips } of animated) {
-    const key = `${target}
-${clips.join("\n")}`;
-    const entry = byDriver.get(key) ?? { target, clips, parts: [] };
-    if (!entry.parts.includes(part)) entry.parts.push(part);
-    byDriver.set(key, entry);
+  /**
+   * The skin weights of the mesh's primitives as the file holds them, four
+   * floats a vertex, read from the file rather than taken from the geometry:
+   * `GLTFLoader` normalizes a skinned primitive's weights in place, and the
+   * bake's are the source's, unrounded. That geometry is a view over the loaded buffer view,
+   * so the bytes are read from the buffer beneath it, which nothing writes to.
+   * The primitives share the attribute, so the first one's is read.
+   */
+  async writtenWeights(mesh) {
+    const json = this.parser.json;
+    const accessor = json.accessors[json.meshes[mesh].primitives[0].attributes["WEIGHTS_0"]];
+    const view = json.bufferViews[accessor.bufferView];
+    if (accessor.componentType !== 5126 || (view.byteStride ?? 16) !== 16) {
+      throw rewritten("its skin weights are no longer the floats the bake wrote");
+    }
+    const buffer = await this.parser.getDependency("buffer", view.buffer);
+    const start = (view.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+    return new BufferAttribute(new Float32Array(buffer.slice(start, start + accessor.count * 16)), 4);
+  }
+  /** A layer's texels, handed to the builder the bake used for that layer. */
+  async texture({ bufferView, width, height, format }) {
+    if (!Object.prototype.hasOwnProperty.call(BAKED_LAYER_FORMATS, format)) {
+      throw new Refusal(`holds a texture layer of unknown format "${format}"`);
+    }
+    const { bytesPerTexel, build } = BAKED_LAYER_FORMATS[format];
+    const buffer = await this.parser.getDependency("bufferView", bufferView);
+    return build(buffer.slice(0, width * height * bytesPerTexel), width, height);
   }
-  const offences = [...byDriver.values()].map(({ target, clips, parts }) => {
-    const one = clips.length === 1;
-    const its = parts.length === 1 ? "its" : "their";
-    return `clip${one ? "" : "s"} ${clips.join(", ")} animate${one ? "s" : ""} morph target ${target} of part${parts.length === 1 ? "" : "s"} ${parts.map(partName).join(", ")}, ${its} vertices moving where no bone does`;
-  });
-  return new RigRefusal(
-    `three-vat: the rig encoding cannot bake this subtree: ${offences.join("; ")}. A slot stores a rotation, a translation and one scale, not a per-vertex delta, and ${VERTEX_ENCODING_STORES_IT}`
-  );
-}
-function foldMorphs(part, statics) {
-  const { vertexCount, basePos, baseNrm } = part;
-  const position = new Float32Array(vertexCount * 3);
-  const normal = new Float32Array(vertexCount * 3);
-  const active = statics.some((w) => w !== 0);
-  const _p = new Vector3();
-  const _n = new Vector3();
-  for (let v = 0; v < vertexCount; v++) {
-    _p.fromBufferAttribute(basePos, v);
-    _n.fromBufferAttribute(baseNrm, v);
-    if (active) {
-      morphVertex(part, v, statics, statics.length, _p, _n);
-      _n.normalize();
-    }
-    _p.toArray(position, v * 3);
-    _n.toArray(normal, v * 3);
-  }
-  return { position, normal };
-}
-function scaleSensitiveNodes(slots, root, influenced) {
-  const sensitive = /* @__PURE__ */ new Map();
-  slots.forEach((slot, i) => {
-    if (!influenced[i]) return;
-    if (slot.rig) {
-      const { bones } = slot.rig.pose.skeleton;
-      for (let node = bones[slot.rig.bone] ?? null; node && bones.includes(node); node = node.parent) {
-        sensitive.set(node, slot);
-      }
-    } else {
-      for (let node = slot.parts[0].mesh; node && node !== root; node = node.parent) {
-        sensitive.set(node, slot);
-      }
-    }
+};
+var rewritten = (what) => new Refusal(
+  `holds a geometry rewritten after the bake: ${what}. Its texels are addressed by the vertex order the bake wrote, so an optimizer that reorders, welds or simplifies vertices (a gltfpack or gltf-transform pass) is the likely cause; bake it again, and keep the baked file out of that step`
+);
+function mergedGeometry(primitives, extension) {
+  if (primitives.length !== extension.groups.length) {
+    throw rewritten(`${primitives.length} primitives where ${extension.groups.length} were written`);
+  }
+  const shared = primitives[0].geometry;
+  const position = shared.attributes.position;
+  if (position.count !== extension.vertexCount) {
+    throw rewritten(`${position.count} vertices where ${extension.vertexCount} were written`);
+  }
+  if (positionDigest(position) !== extension.digest) throw rewritten("its rest positions no longer match");
+  const geometry = new BufferGeometry();
+  for (const [name, attribute] of Object.entries(shared.attributes)) geometry.setAttribute(name, attribute);
+  const runs = primitives.map((mesh, i) => {
+    const index = mesh.geometry.index;
+    const group = extension.groups[i];
+    if (mesh.geometry.attributes.position !== position || index === null || index.count !== group.count) {
+      throw rewritten(`primitive ${i} no longer draws the run of vertices it was written with`);
+    }
+    return index.array;
   });
-  return sensitive;
-}
-function refuseAnimatedNonUniformScale(slots, clips, root, influenced) {
-  const sensitive = scaleSensitiveNodes(slots, root, influenced);
-  for (const clip of clips) {
-    for (const track of clip.tracks) {
-      const parsed = PropertyBinding.parseTrackName(track.name);
-      if (parsed.propertyName !== "scale" || track.getValueSize() !== 3) continue;
-      const node = PropertyBinding.findNode(root, parsed.nodeName);
-      const reached = node && sensitive.get(node);
-      if (!reached) continue;
-      const values = track.values;
-      for (let k = 0; k < track.times.length; k++) {
-        const o = k * 3;
-        if (unevenSquares(values[o] ** 2, values[o + 1] ** 2, values[o + 2] ** 2)) {
-          throw nonUniformScale(slotLabel(reached), clip);
-        }
-      }
-    }
-  }
-}
-function nonUniformScale(label, clip) {
-  return new RigRefusal(
-    `three-vat: ${label} animates with non-uniform scale in clip "${clip.name}", which the rig encoding cannot store \u2014 a slot is a rotation, a translation and one scale, and ${VERTEX_ENCODING_STORES_IT}. Authored with a uniform scale, it bakes as a rig`
-  );
-}
-function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
-  const clips = resolved.map((a) => a.clip);
-  const rootInverse = root.matrixWorld.clone().invert();
-  const poses = attachPoseBuffers(parts);
-  const { slots, slotMaps } = layoutSlots(parts, rootInverse);
-  const slotCount = slots.length;
-  const morphs = parts.map((part) => morphInfluences(part, clips, root));
-  const animated = morphs.flatMap((m) => m.animated);
-  if (animated.length > 0) throw refuseAnimatedMorphs(animated);
-  const rigParts = parts.map((part, i) => ({
-    part,
-    slotOf: slotMaps.get(part),
-    ...foldMorphs(part, morphs[i].statics)
-  }));
-  const width = slotCount * RIG_TEXELS_PER_SLOT;
-  if (width > maxTextureSize) {
-    throw new RigRefusal(
-      `three-vat: rig texture width ${width} (${slotCount} slots \xD7 ${RIG_TEXELS_PER_SLOT} texels) exceeds maxTextureSize ${maxTextureSize}`
-    );
-  }
-  const { frameCounts, totalFrames } = frameCountsFor(clips, fps, maxTextureSize);
-  const vertexCount = parts.reduce((n, p) => n + p.vertexCount, 0);
-  const geometry = mergeRigGeometry(rigParts, vertexCount);
-  const localPosition = geometry.attributes.position.array;
-  const skinIndex = geometry.attributes.skinIndex.array;
-  const skinWeight = geometry.attributes.skinWeight.array;
-  const influenced = new Uint8Array(slotCount);
-  for (let i = 0; i < skinWeight.length; i++) {
-    if (skinWeight[i] !== 0) influenced[skinIndex[i]] = 1;
-  }
-  refuseAnimatedNonUniformScale(slots, clips, root, influenced);
-  const _p = new Vector3();
-  const _slot = new Matrix4();
-  const _partMatrix = new Matrix4();
-  const placements = new Map(parts.map((part) => [part, new Matrix4()]));
-  const _q2 = new Quaternion();
-  const _t = new Vector3();
-  const _s = new Vector3();
-  const restRoot = new Float64Array(vertexCount * 3);
-  for (const part of parts) {
-    _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
-    for (let v = 0; v < part.vertexCount; v++) {
-      _p.fromBufferAttribute(part.basePos, v).applyMatrix4(_partMatrix);
-      _p.toArray(restRoot, (part.vertexStart + v) * 3);
-    }
-  }
-  const data = new Float32Array(width * totalFrames * 4);
-  const slotMatrices = new Float64Array(slotCount * BONE_STRIDE);
-  const previous = new Float64Array(slotCount * 4);
-  const bounds = new Box3();
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  const writeFrame = (clip, _f, row) => {
-    let maxDeltaSq = 0;
-    for (const [part, placement] of placements) placementOf(part, rootInverse, placement);
-    for (let slot = 0; slot < slotCount; slot++) {
-      const { rig, parts: readers } = slots[slot];
-      const lead = readers[0];
-      const placement = placements.get(lead);
-      for (let pi = 1; pi < readers.length; pi++) {
-        const other = readers[pi];
-        if (!matricesClose(placement, placements.get(other))) {
-          throw new RigRefusal(
-            `three-vat: parts ${partName(lead)} and ${partName(other)} read the same slots but move apart in clip "${clip.name}"; the rig encoding gives them one set of slots, which cannot place them differently, and ${VERTEX_ENCODING_STORES_IT}`
-          );
-        }
-      }
-      if (rig) {
-        _slot.fromArray(rig.pose.matrices, rig.bone * BONE_STRIDE).multiply(rig.bindMatrix).premultiply(placement);
-      } else {
-        _slot.copy(placement);
-      }
-      slotMatrices.set(_slot.elements, slot * BONE_STRIDE);
-      if (influenced[slot] && (hasNonUniformScale(slotMatrices, slot) || hasShear(slotMatrices, slot))) {
-        throw nonUniformScale(slotLabel(slots[slot]), clip);
-      }
-      const p4 = slot * 4;
-      const det = _slot.determinant();
-      let scale;
-      if (det === 0) {
-        _t.setFromMatrixPosition(_slot);
-        _q2.fromArray(previous, p4);
-        if (_q2.lengthSq() === 0) _q2.identity();
-        scale = 0;
-      } else {
-        if (det < 0) for (const e of MATRIX_BASIS) _slot.elements[e] = -_slot.elements[e];
-        _slot.decompose(_t, _q2, _s);
-        scale = det < 0 ? -_s.x : _s.x;
-      }
-      if (previous[p4] * _q2.x + previous[p4 + 1] * _q2.y + previous[p4 + 2] * _q2.z + previous[p4 + 3] * _q2.w < 0) {
-        _q2.set(-_q2.x, -_q2.y, -_q2.z, -_q2.w);
-      }
-      previous[p4] = _q2.x;
-      previous[p4 + 1] = _q2.y;
-      previous[p4 + 2] = _q2.z;
-      previous[p4 + 3] = _q2.w;
-      const o = (row * width + slot * RIG_TEXELS_PER_SLOT) * 4;
-      const rotation = o + RIG_TEXELS.rotation * 4;
-      data[rotation] = _q2.x;
-      data[rotation + 1] = _q2.y;
-      data[rotation + 2] = _q2.z;
-      data[rotation + 3] = _q2.w;
-      const placementTexel = o + RIG_TEXELS.placement * 4;
-      data[placementTexel] = _t.x;
-      data[placementTexel + 1] = _t.y;
-      data[placementTexel + 2] = _t.z;
-      data[placementTexel + 3] = scale;
-    }
-    for (let v = 0; v < vertexCount; v++) {
-      const o3 = v * 3;
-      const o4 = v * 4;
-      const x = localPosition[o3];
-      const y = localPosition[o3 + 1];
-      const z = localPosition[o3 + 2];
-      let px = 0;
-      let py = 0;
-      let pz = 0;
-      for (let i = 0; i < 4; i++) {
-        const w = skinWeight[o4 + i];
-        if (w === 0) continue;
-        const m = skinIndex[o4 + i] * BONE_STRIDE;
-        px += w * (slotMatrices[m] * x + slotMatrices[m + 4] * y + slotMatrices[m + 8] * z + slotMatrices[m + 12]);
-        py += w * (slotMatrices[m + 1] * x + slotMatrices[m + 5] * y + slotMatrices[m + 9] * z + slotMatrices[m + 13]);
-        pz += w * (slotMatrices[m + 2] * x + slotMatrices[m + 6] * y + slotMatrices[m + 10] * z + slotMatrices[m + 14]);
-      }
-      if (px < minX) minX = px;
-      if (px > maxX) maxX = px;
-      if (py < minY) minY = py;
-      if (py > maxY) maxY = py;
-      if (pz < minZ) minZ = pz;
-      if (pz > maxZ) maxZ = pz;
-      const dx = px - restRoot[o3];
-      const dy = py - restRoot[o3 + 1];
-      const dz = pz - restRoot[o3 + 2];
-      const deltaSq = dx * dx + dy * dy + dz * dz;
-      if (deltaSq > maxDeltaSq) maxDeltaSq = deltaSq;
-    }
-    return maxDeltaSq;
-  };
-  const clipTable = sampleClips(root, resolved, frameCounts, poses, writeFrame);
-  bounds.min.set(minX, minY, minZ);
-  bounds.max.set(maxX, maxY, maxZ);
-  geometry.boundingBox = bounds.clone();
-  geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
-  const materials = [];
-  for (const part of parts) materials[part.materialIndex] = part.material;
-  return {
-    encoding: "rig",
-    rigTexture: makeVATTexture(data, width, totalFrames),
-    slotCount,
-    clips: clipTable,
-    bounds,
-    vertexCount,
-    totalFrames,
-    geometry,
-    materials
-  };
-}
-function mergeRigGeometry(rigParts, total) {
-  const position = new Float32Array(total * 3);
-  const normal = new Float32Array(total * 3);
-  const slotIndex = new Uint16Array(total * 4);
-  const slotWeight = new Float32Array(total * 4);
-  for (const { part, slotOf, position: restPos, normal: restNrm } of rigParts) {
-    const start = part.vertexStart;
-    const srcIndex = part.pose ? part.skinIndex : null;
-    const srcWeight = part.pose ? part.skinWeight : null;
-    position.set(restPos, start * 3);
-    normal.set(restNrm, start * 3);
-    for (let v = 0; v < part.vertexCount; v++) {
-      const o4 = (start + v) * 4;
-      if (srcIndex && srcWeight) {
-        for (let i = 0; i < 4; i++) {
-          slotIndex[o4 + i] = slotOf[srcIndex.getComponent(v, i)];
-          slotWeight[o4 + i] = srcWeight.getComponent(v, i);
-        }
-      } else {
-        slotIndex[o4] = slotOf[0];
-        slotWeight[o4] = 1;
-      }
-    }
-  }
-  const merged = new BufferGeometry();
-  merged.setAttribute("position", new BufferAttribute(position, 3));
-  merged.setAttribute("normal", new BufferAttribute(normal, 3));
-  merged.setAttribute("skinIndex", new BufferAttribute(slotIndex, 4));
-  merged.setAttribute("skinWeight", new BufferAttribute(slotWeight, 4));
-  mergeSurface(merged, rigParts.map((r) => r.part), total, null);
-  return merged;
+  const IndexArray = runs[0].constructor;
+  const indices = new IndexArray(runs.reduce((n, run) => n + run.length, 0));
+  extension.groups.forEach((group, i) => indices.set(runs[i], group.start));
+  geometry.setIndex(new BufferAttribute(indices, 1));
+  for (const { start, count, materialIndex } of extension.groups) geometry.addGroup(start, count, materialIndex);
+  return geometry;
 }
 var REQUEST = "three-vat:bake";
 var RESPONSE = "three-vat:baked";
@@ -1137,7 +311,7 @@ function rebuildTrack(record) {
   if (record.settings) Object.assign(track, { settings: record.settings });
   return track;
 }
-function isAction2(input) {
+function isAction(input) {
   return typeof input.getClip === "function";
 }
 function recordScene(root, animations, mergeFlat) {
@@ -1230,7 +404,7 @@ function recordScene(root, animations, mergeFlat) {
     return clips.push(clip) - 1;
   };
   const inputs = animations.map(
-    (input) => isAction2(input) ? {
+    (input) => isAction(input) ? {
       clip: clipOf(input.getClip()),
       action: {
         weight: input.weight,
@@ -1343,6 +517,8 @@ function recordVAT(vat, stand) {
     height: texture.image.height,
     normals: normals ? transferable(normals, true, transfer) : null,
     slotCount: vat.encoding === "rig" ? vat.slotCount : 0,
+    // Transferred, so detached here: the worker's VAT is dropped once it is sent.
+    restSlots: vat.encoding === "rig" ? transferable(restSlotsOf(vat), true, transfer) : null,
     fallback: vat.encoding === "delta" ? vat.fallback : null,
     rowsPerFrame: vat.encoding === "delta" ? vat.rowsPerFrame : 1,
     geometry: recordGeometry(vat.geometry, true, transfer, /* @__PURE__ */ new Map(), []),
@@ -1376,6 +552,7 @@ function rebuildVAT(record, materials) {
       slotCount: record.slotCount,
       ...base
     };
+    keepRestSlots(vat2, record.restSlots);
     return vat2;
   }
   const vat = {
@@ -1445,4 +622,4 @@ function serveVATBakes(scope = globalThis) {
   return () => scope.removeEventListener("message", onMessage);
 }
 
-export { bakeVAT, bakeVATInWorker, decodeOctahedral, encodeOctahedral, serveVATBakes };
+export { bakeVATInWorker, loadVAT, serveVATBakes };