three-vat 2.1.0 → 4.0.0

package/dist/chunk-BSAJL5PG.js

@@ -0,0 +1,249 @@
+import { FloatType, DataTexture, RGBAFormat, RGFormat, UnsignedByteType, HalfFloatType, NearestFilter } from 'three';
+
+// src/vat-texture.ts
+var MAX_TEXTURE_SIZE = 16384;
+var HALF_FLOAT_MAX = 65504;
+function sampledExactly(tex) {
+  tex.minFilter = NearestFilter;
+  tex.magFilter = NearestFilter;
+  tex.generateMipmaps = false;
+  tex.needsUpdate = true;
+  return tex;
+}
+function makeVATTexture(data, width, height, type = FloatType) {
+  const half = type === HalfFloatType;
+  const wanted = half ? Uint16Array : Float32Array;
+  if (!(data instanceof wanted)) {
+    throw new Error(
+      `three-vat: a ${half ? "HalfFloatType" : "FloatType"} texture is built from a ${wanted.name}, not a ${data.constructor.name} \u2014 the array and the type describe the same texels and have to agree`
+    );
+  }
+  return sampledExactly(new DataTexture(data, width, height, RGBAFormat, type));
+}
+function makeVATNormalTexture(data, width, height) {
+  const tex = new DataTexture(data, width, height, RGFormat, UnsignedByteType);
+  tex.unpackAlignment = 1;
+  return sampledExactly(tex);
+}
+
+// src/instance-playback.ts
+var PACK_TEXELS = {
+  clip: 0,
+  playback: 1,
+  crossfade: 2,
+  outgoingClip: 3,
+  outgoingPlayback: 4
+};
+var PACK_WIDTH = 5;
+var PACK_STRIDE = PACK_WIDTH * 4;
+var LoopMode = {
+  /** Play the clip end to end, forever (or `repetitions` times). */
+  Repeat: 0,
+  /** Play the clip through once. */
+  Once: 1,
+  /** Play forward, then backward, without baking the reversed frames. */
+  PingPong: 2
+};
+var EndMode = {
+  /** Hold the last frame. */
+  Clamp: 0,
+  /** Return to the first frame. */
+  Rewind: 1
+};
+var INFINITE_REPETITIONS = -1;
+function defaultRepetitions(loopMode) {
+  return loopMode === LoopMode.Repeat ? INFINITE_REPETITIONS : 1;
+}
+var LIBRARY_PLAYBACK_DEFAULTS = {
+  loopMode: LoopMode.Repeat,
+  repetitions: defaultRepetitions(LoopMode.Repeat),
+  endMode: EndMode.Clamp,
+  speed: 1
+};
+function resolvedPlaybackOf(instance) {
+  const { clip } = instance;
+  const clipLoopMode = clip.loopMode ?? LIBRARY_PLAYBACK_DEFAULTS.loopMode;
+  const loopMode = instance.loopMode ?? clipLoopMode;
+  const clipRepetitions = loopMode === clipLoopMode ? clip.repetitions : void 0;
+  return {
+    loopMode,
+    repetitions: instance.repetitions ?? clipRepetitions ?? defaultRepetitions(loopMode),
+    endMode: instance.endMode ?? clip.endMode ?? LIBRARY_PLAYBACK_DEFAULTS.endMode,
+    speed: instance.speed ?? clip.speed ?? LIBRARY_PLAYBACK_DEFAULTS.speed
+  };
+}
+function crossfadeOf(instance) {
+  const from = instance.from;
+  if (!from || !asksToBlend(instance)) return null;
+  return { from, duration: instance.fadeDuration };
+}
+var asksToBlend = (instance) => (instance.fadeDuration ?? 0) > 0;
+function resolveVATFrame(instance, time) {
+  const { clip } = instance;
+  const frames = clip.frames;
+  const last = frames - 1;
+  const duration = frames / clip.fps;
+  const { loopMode, repetitions, endMode, speed } = resolvedPlaybackOf(instance);
+  const local = (time - instance.startTime) * speed;
+  const loops = local / duration;
+  const started = local >= 0;
+  const finished = started && repetitions !== INFINITE_REPETITIONS && loops >= repetitions;
+  let phase;
+  let looping;
+  if (!started) {
+    phase = 0;
+    looping = false;
+  } else if (finished) {
+    phase = endMode === EndMode.Clamp ? 1 : 0;
+    looping = false;
+  } else if (loopMode === LoopMode.PingPong) {
+    const m = loops - 2 * Math.floor(loops * 0.5);
+    phase = m < 1 ? m : 2 - m;
+    looping = false;
+  } else {
+    phase = loops % 1;
+    looping = true;
+  }
+  const holds = looping && endMode === EndMode.Clamp && repetitions !== INFINITE_REPETITIONS && Math.floor(loops) + 1 >= repetitions;
+  const wraps = looping && !holds;
+  const f = phase * (looping ? frames : last);
+  const f0 = Math.min(Math.floor(f), last);
+  const next = f0 + 1;
+  const f1 = wraps ? next >= frames ? 0 : next : Math.min(next, last);
+  const row = clip.startFrame + f0;
+  const crossfade = crossfadeOf(instance);
+  const elapsed = crossfade ? (time - instance.startTime) / crossfade.duration : 0;
+  return {
+    row,
+    rowNext: clip.startFrame + f1,
+    mix: f - f0,
+    wraps,
+    finished,
+    phase,
+    outgoing: crossfade ? { ...resolveVATFrame(crossfade.from, time), weight: 1 - Math.min(Math.max(elapsed, 0), 1) } : null
+  };
+}
+var RESERVED_ROW = {
+  clip: { startFrame: 0, frames: 1, fps: 1 },
+  startTime: 0,
+  speed: 0
+};
+function createVATPlaybackTexture(instances, options = {}) {
+  const live = instances.length;
+  const count = options.capacity ?? live;
+  if (count < live) {
+    throw new Error(
+      `three-vat: a capacity of ${count} cannot hold the ${live} instances it was given \u2014 capacity is the crowd ceiling, so it is at least the crowd you start with.`
+    );
+  }
+  if (count < 1) {
+    throw new Error(
+      "three-vat: a crowd needs at least one instance \u2014 a playback texture is one row per instance, and there is no zero-row texture to carry none. Pass a capacity to reserve rows for a crowd that has not spawned yet"
+    );
+  }
+  const ceiling = options.maxTextureSize ?? MAX_TEXTURE_SIZE;
+  if (count > ceiling) {
+    const [source, hint] = options.maxTextureSize === void 0 ? [
+      "MAX_TEXTURE_SIZE, the default when no maxTextureSize option is given",
+      " Pass getMaxTextureSize(renderer) as maxTextureSize to check against this GPU's own limit."
+    ] : ["the maxTextureSize option", ""];
+    throw new Error(
+      `three-vat: ${count} rows of playback texture is past the ${ceiling}-row ceiling of ${source} \u2014 the playback texture holds one row per instance, so the texture ceiling is the instance ceiling.` + hint
+    );
+  }
+  const data = new Float32Array(count * PACK_STRIDE);
+  for (let i = 0; i < count; i++) writePack(data, i, instances[i] ?? RESERVED_ROW);
+  return { texture: makeVATTexture(data, PACK_WIDTH, count), count };
+}
+var FORWARD_ONLY_REASON = "a baked band plays forward from its own first row, so a negative speed would freeze it on that row rather than run it backwards \u2014 bake a reversed clip instead. A speed of 0 is a held first row, and is fine";
+var rowStart = (index) => index * PACK_STRIDE;
+var texelStart = (index, field) => rowStart(index) + field * 4;
+function checkedPolicyOf(state, index, what) {
+  const policy = resolvedPlaybackOf(state);
+  if (policy.speed < 0) {
+    throw new Error(`three-vat: ${what} ${index} has speed ${policy.speed}; ${FORWARD_ONLY_REASON}.`);
+  }
+  return policy;
+}
+function putBand(data, index, at, state, policy) {
+  const clip = texelStart(index, at.clip);
+  const playback = texelStart(index, at.playback);
+  data[clip] = state.clip.startFrame;
+  data[clip + 1] = state.clip.frames;
+  data[clip + 2] = state.clip.fps;
+  data[clip + 3] = policy.speed;
+  data[playback] = state.startTime;
+  data[playback + 1] = policy.loopMode;
+  data[playback + 2] = policy.repetitions;
+  data[playback + 3] = policy.endMode;
+}
+var LIVE_PAIR = { clip: PACK_TEXELS.clip, playback: PACK_TEXELS.playback };
+var OUTGOING_PAIR = { clip: PACK_TEXELS.outgoingClip, playback: PACK_TEXELS.outgoingPlayback };
+function checkedCrossfadeOf(instance, index) {
+  const duration = instance.fadeDuration;
+  if (duration !== void 0 && !(Number.isFinite(duration) && duration >= 0)) {
+    throw new Error(
+      `three-vat: instance ${index} has fadeDuration ${duration}; a transition lasts a finite number of seconds, and 0 (or no fadeDuration at all) is the cut.`
+    );
+  }
+  return crossfadeOf(instance);
+}
+function writePack(data, index, instance) {
+  const crossfade = checkedCrossfadeOf(instance, index);
+  const live = checkedPolicyOf(instance, index, "instance");
+  const outgoing = crossfade ? { state: crossfade.from, policy: checkedPolicyOf(crossfade.from, index, "the outgoing band of instance") } : null;
+  const crossfadeTexel = texelStart(index, PACK_TEXELS.crossfade);
+  putBand(data, index, LIVE_PAIR, instance, live);
+  if (outgoing) putBand(data, index, OUTGOING_PAIR, outgoing.state, outgoing.policy);
+  else clearTexels(data, index, OUTGOING_PAIR);
+  data[crossfadeTexel] = crossfade ? crossfade.duration : 0;
+  data[crossfadeTexel + 1] = 0;
+  data[crossfadeTexel + 2] = 0;
+  data[crossfadeTexel + 3] = 0;
+}
+function clearTexels(data, index, at) {
+  data.fill(0, texelStart(index, at.clip), texelStart(index, at.clip) + 4);
+  data.fill(0, texelStart(index, at.playback), texelStart(index, at.playback) + 4);
+}
+function readPack(data, index) {
+  const clip = texelStart(index, PACK_TEXELS.clip);
+  const playback = texelStart(index, PACK_TEXELS.playback);
+  return {
+    clip: { startFrame: data[clip], frames: data[clip + 1], fps: data[clip + 2] },
+    startTime: data[playback],
+    speed: data[clip + 3],
+    loopMode: data[playback + 1],
+    repetitions: data[playback + 2],
+    endMode: data[playback + 3]
+  };
+}
+function assertInstance(playback, index) {
+  if (!Number.isInteger(index) || index < 0 || index >= playback.count) {
+    throw new Error(`three-vat: instance ${index} is outside this crowd's ${playback.count} rows`);
+  }
+}
+function setVATInstance(playback, index, instance) {
+  assertInstance(playback, index);
+  const data = playback.texture.image.data;
+  const transitioning = instance.from === void 0 && asksToBlend(instance) ? { ...instance, from: readPack(data, index) } : instance;
+  writePack(data, index, transitioning);
+  playback.texture.addUpdateRange(rowStart(index), PACK_STRIDE);
+  playback.texture.needsUpdate = true;
+}
+function endsAt(instance) {
+  const { repetitions, speed } = resolvedPlaybackOf(instance);
+  if (repetitions === INFINITE_REPETITIONS || speed <= 0) return null;
+  const duration = instance.clip.frames / instance.clip.fps;
+  return instance.startTime + duration * repetitions / speed;
+}
+
+// src/rig-texture.ts
+var RIG_TEXELS = {
+  /** `(qx, qy, qz, qw)` — the slot's rotation, on one hemisphere with its neighbouring rows. */
+  rotation: 0,
+  /** `(tx, ty, tz, s)` — where the slot puts the origin, and its uniform scale in the spare component. */
+  placement: 1
+};
+var RIG_TEXELS_PER_SLOT = 2;
+
+export { EndMode, FORWARD_ONLY_REASON, HALF_FLOAT_MAX, INFINITE_REPETITIONS, LIBRARY_PLAYBACK_DEFAULTS, LoopMode, MAX_TEXTURE_SIZE, PACK_TEXELS, RIG_TEXELS, RIG_TEXELS_PER_SLOT, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { AnimationClip, AnimationAction, Object3D, TypedArray, TextureDataType, DataTexture } from 'three';
-import { D as DeltaVAT, R as RigVAT, V as VAT } from './carrier-BXaLAPRO.js';
-export { E as EndMode, I as INFINITE_REPETITIONS, L as LoopMode, M as MAX_FADE_DURATION, a as VATBase, b as VATCarrier, c as VATClip, d as VATClipDefaults, e as VATClock, f as VATCrowd, g as VATFadeFrom, h as VATFrame, i as VATInstance, j as VATPlaybackTexture, k as createVATPlaybackTexture, l as endsAt, r as resolveVATFrame, s as setVATInstance } from './carrier-BXaLAPRO.js';
+import { AnimationClip, AnimationAction, Object3D, DataTexture, FloatType, HalfFloatType } from 'three';
+import { D as DeltaVAT, R as RigVAT, V as VAT } from './carrier-D4pkftSk.js';
+export { E as EndMode, I as INFINITE_REPETITIONS, L as LoopMode, a as VATBase, b as VATCarrier, c as VATClip, d as VATClipDefaults, e as VATClock, f as VATCrowd, g as VATFrame, h as VATInstance, i as VATOutgoingFrame, j as VATPlaybackState, k as VATPlaybackTexture, l as VATPlaybackTextureOptions, m as createVATPlaybackTexture, n as endsAt, r as resolveVATFrame, s as setVATInstance } from './carrier-D4pkftSk.js';
 
 /**
  * What {@link bakeVAT} takes for each animation: the clip itself, or an
@@ -24,8 +24,8 @@ interface BakeOptions {
     /**
      * Bake the normal texture. Default `true`.
      *
-     * Turning it off halves the VAT — `verts x frames x 16 B x 2` becomes `x 1` —
-     * and is correct for exactly two material setups:
+     * Turning it off drops the normal layer — `verts x frames x (8 B + 2 B)`
+     * becomes `x 8 B` — and is correct for exactly two material setups:
      *
      * - **Unlit** (`MeshBasicMaterial`, and its node twin), which never reads a
      *   normal, so the texture was pure waste.
@@ -44,11 +44,16 @@ interface BakeOptions {
      */
     bakeNormals?: boolean;
     /**
-     * What a frame row holds (ADR-0018). Default `'delta'`.
+     * What a frame row holds (ADR-0018). Default `'auto'` (ADR-0027).
      *
+     * - **`'auto'`** — the rig encoding where the asset allows it, and the
+     *   vertex encoding where the rig encoding refuses it. Read `vat.encoding` to
+     *   learn which one a bake chose. The default since 4.0: the rig texture is
+     *   two orders of magnitude smaller, bakes in milliseconds, and decodes
+     *   faster where memory bandwidth is scarce, as on a phone.
      * - **`'delta'`** — the vertex encoding: where every vertex ended up, as a
      *   position delta and a normal. Source-agnostic — skinning, morph targets
-     *   and node animation alike — and the default.
+     *   and node animation alike.
      * - **`'rig'`** — the rig encoding: the posed rig, one **slot** per bone as a
      *   rotation, a translation and a uniform scale, skinned in the vertex shader
      *   from the rest-pose geometry. Two orders of magnitude smaller, no vertex
@@ -59,7 +64,24 @@ interface BakeOptions {
      *   node-animated part is one slot of weight one; parts reading the same
      *   bones through the same bind matrix share slots.
      */
-    encoding?: 'delta' | 'rig';
+    encoding?: 'auto' | 'delta' | 'rig';
+    /**
+     * Collapse materials that differ only in their flat colour into one, so the
+     * crowd draws once instead of once per material (ADR-0028). Default `false`.
+     *
+     * A material is **flat** when it has a `color`, no texture map of any kind,
+     * and `vertexColors` off. Two or more flat materials that agree on every
+     * other property — type, roughness, metalness, emissive, side, opacity and
+     * the rest — become one clone of the first, white, with `vertexColors` on,
+     * and each part's colour moves into the merged geometry's `color` attribute.
+     * A material that is not flat, or is the only one of its kind, is left
+     * exactly as it was. `vat.materials` therefore holds a material you did not
+     * create wherever a merge happened.
+     *
+     * Off by default because it is only ever right for flat-shaded assets: a
+     * textured character has nothing to collapse, and merging never guesses.
+     */
+    mergeFlatMaterials?: boolean;
 }
 /**
  * Bake animations into a VAT by sampling the posed subtree frame by frame on
@@ -111,16 +133,17 @@ interface BakeOptions {
  * Renderer-agnostic — touches no WebGL/WebGPU context — so it runs identically
  * at runtime, in a Web Worker, and in Node.
  *
- * All of that is the **vertex encoding**, the default. `encoding: 'rig'`
- * stores the posed rig instead — one slot per bone, two texels, skinned in the
- * vertex shader from the rest-pose geometry (ADR-0018) — under the same clip
- * table and the same playback contract, at a fraction of the memory; see
- * {@link BakeOptions.encoding} for what it refuses. Overloaded on the option's
- * literal, so a call that names no encoding, or the vertex encoding, still
- * holds the narrow {@link DeltaVAT} it always did.
+ * All of that is the **vertex encoding**. `encoding: 'rig'` stores the posed
+ * rig instead — one slot per bone, two texels, skinned in the vertex shader
+ * from the rest-pose geometry (ADR-0018) — under the same clip table and the
+ * same playback contract, at a fraction of the memory; see
+ * {@link BakeOptions.encoding} for what it refuses. The default is the rig
+ * where the asset allows it and the vertices where it does not (ADR-0027), so
+ * a bake that names no encoding returns the {@link VAT} union: narrow on
+ * `vat.encoding`, or name the encoding and get the narrow member back.
  */
-declare function bakeVAT(root: Object3D, animations: BakeInput[], options?: BakeOptions & {
-    encoding?: 'delta';
+declare function bakeVAT(root: Object3D, animations: BakeInput[], options: BakeOptions & {
+    encoding: 'delta';
 }): DeltaVAT;
 declare function bakeVAT(root: Object3D, animations: BakeInput[], options: BakeOptions & {
     encoding: 'rig';
@@ -135,21 +158,159 @@ declare function bakeVAT(root: Object3D, animations: BakeInput[], options?: Bake
  *   Node, and in a Web Worker) so it cannot query the real limit itself: pass
  *   `getMaxTextureSize(renderer)` from `three-vat/webgl` or `three-vat/tsl`
  *   whenever a renderer exists.
- * - **The instance ceiling**, because the playback texture is one row per
- *   instance (`createVATPlaybackTexture`, ADR-0016). That one takes no
- *   override, the crowd being built long after the bake was sized.
- *
- * Not a guarantee either way: plenty of mobile GPUs report 4096 or 8192, and
- * a crowd between that and this number is refused by the driver at upload
- * rather than here. The bake is where the real limit is worth passing, because
- * it is where the numbers get large.
+ * - **The instance ceiling's fallback**, because the playback texture is one
+ *   row per instance (`createVATPlaybackTexture`, ADR-0016), used when the
+ *   caller does not pass `maxTextureSize` to it or to `createVATMesh`. The
+ *   crowd is built beside the renderer, so the real limit is to hand there
+ *   (ADR-0022's amendment).
+ *
+ * Not a guarantee either way: plenty of mobile GPUs report 4096 or 8192. The
+ * playback texture names this number as its source when it falls back to it,
+ * so a crowd refused against it says where the real limit belongs.
  */
 declare const MAX_TEXTURE_SIZE = 16384;
 /**
- * Build a VAT `DataTexture` with the fixed sampling flags every path relies on:
- * RGBA, nearest filtering, no mipmaps. Frame interpolation is done manually in
- * the shader, so linear filtering must stay off.
+ * Build an RGBA VAT `DataTexture` — the position texture, the rig texture and
+ * the playback texture, which is every layer whose texel is four numbers that
+ * have to stay numbers.
+ *
+ * `type` says which kind of number, and the two callers that pass it disagree
+ * deliberately (ADR-0002's amendment):
+ *
+ * - **`HalfFloatType`, with a `Uint16Array`** — the position layer (#73). It
+ *   stores *deltas*, and half-float's error is proportional to what it holds:
+ *   0.061% of the delta, zero at the rest pose. Eight bytes a texel instead of
+ *   sixteen. Half-float tops out at 65 504, which is the one thing a delta can
+ *   exceed, so `bakeVAT` range-checks before it writes.
+ * - **`FloatType`, with a `Float32Array`** — the rig texture, whose texels are
+ *   a quaternion and an *absolute* translation, and the playback texture, whose
+ *   `startTime` in seconds does not survive half precision.
+ *
+ * `data` is one of those two arrays and not a `TypedArray`, deliberately: the
+ * normal texture is two unsigned bytes a texel ({@link makeVATNormalTexture}),
+ * and handing its buffer to this function would upload byte pairs as float32
+ * bits — a crowd rendering garbage rather than a call that failed. The narrow
+ * parameter turns that into a compile error, which is what a stale copy of the
+ * Web Worker recipe in `docs/usage.md` deserves. Pairing either array with the
+ * *other's* `type` is the same fault wearing a legal signature — half a texel
+ * read as a whole one — so that pairing is checked here and refused, rather
+ * than left to the driver.
+ */
+declare function makeVATTexture(data: Float32Array | Uint16Array, width: number, height: number, type?: typeof FloatType | typeof HalfFloatType): DataTexture;
+/**
+ * Build the normal texture: two unsigned bytes a texel, an octahedral unit
+ * vector (`src/octahedral.ts`, #29). `RG8` where the position layer is
+ * `RGBA16F`, because a normal is a direction and eight bits of each of two
+ * channels carry one to under a degree.
+ *
+ * `unpackAlignment` is the one thing this needs that the float builder does
+ * not: a row of `RG8` is `2 × width` bytes, so an odd vertex count makes every
+ * row an odd multiple of two, and the default alignment of 4 would have the
+ * driver start each row at the wrong offset. An RGBA half-float row is `8 ×
+ * width` bytes and an RGBA float row `16 × width` — a multiple of 4 at any
+ * width either way, which is why this never came up on those.
+ */
+declare function makeVATNormalTexture(data: Uint8Array, width: number, height: number): DataTexture;
+
+/** A vector the decode can write into — `THREE.Vector3` is one. */
+interface Vec3Out {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Write a normal into two bytes of a VAT normal texture's buffer, at `offset`
+ * and `offset + 1` — `(row * vertexCount + vertex) * 2` for the texel of one
+ * vertex at one frame.
+ *
+ * Takes a direction, not a unit vector: the first step is a division by the L1
+ * norm, so the encoding is scale-invariant and an unnormalised normal encodes
+ * to the same texel its normalised twin does. A zero-length normal has no
+ * direction to divide out, and is written as the texel +Z lands on rather than
+ * as NaN — a degenerate vertex then shades like a flat one instead of turning
+ * the mesh black.
+ */
+declare function encodeOctahedral(x: number, y: number, z: number, out: Uint8Array | number[], offset: number): void;
+/**
+ * Decode a normal texel — the two bytes {@link encodeOctahedral} wrote — back
+ * to a unit vector. Pass `out` to decode a whole layer without allocating.
+ *
+ * `u` and `v` are the stored bytes, `0..255`; a sampler hands the shaders the
+ * same numbers already divided by 255, which is the `/ 255` below and the only
+ * difference between this and the two transcriptions of it.
+ *
+ * The fold is undone without a branch, by the identity that a negative `z`
+ * means exactly `|x| + |y| - 1` of overshoot to take back off both components,
+ * each toward its own zero. Branchless because #72 measured what a branch in
+ * the vertex decode costs: the compiler holds registers for the side it skips,
+ * and an idle crowd pays for them.
+ */
+declare function decodeOctahedral<T extends Vec3Out>(u: number, v: number, out: T): T;
+declare function decodeOctahedral(u: number, v: number): Vec3Out;
+
+/**
+ * What `bakeVATInWorker` talks to: a `Worker`, or anything else that posts and
+ * receives messages the same way (a `MessagePort`, say). The worker on the
+ * other end must call {@link serveVATBakes}.
+ */
+interface VATBakeWorker {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+    addEventListener(type: 'message' | 'error', listener: (event: MessageEvent | ErrorEvent) => void): void;
+    removeEventListener(type: 'message' | 'error', listener: (event: MessageEvent | ErrorEvent) => void): void;
+}
+/**
+ * Where `serveVATBakes` listens: the worker's own global scope by default, or
+ * any other end of a message channel.
+ */
+interface VATBakeScope {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+}
+/**
+ * {@link bakeVAT}, in a Web Worker: the same arguments, the same VAT, and a
+ * page that keeps drawing frames while it bakes.
+ *
+ * ```ts
+ * // bake.worker.ts — the whole file
+ * import { serveVATBakes } from 'three-vat'
+ * serveVATBakes()
+ * ```
+ *
+ * ```ts
+ * // the page
+ * const worker = new Worker(new URL('./bake.worker.ts', import.meta.url), { type: 'module' })
+ * const vat = await bakeVATInWorker(worker, gltf.scene, gltf.animations, {
+ *   maxTextureSize: getMaxTextureSize(renderer),
+ * })
+ * ```
+ *
+ * The subtree is copied, not moved: the caller's scene is untouched, and a
+ * source geometry without normals is not given them as it would be by a bake
+ * on this thread. Materials never cross — the VAT comes back holding the
+ * caller's own, in `materialIndex` order. A refusal rejects the promise with
+ * the message `bakeVAT` would have thrown. One worker serves any number of
+ * bakes, one at a time. A track on what the bake does not read, such as a
+ * material's colour, stays on the page.
+ *
+ * What cannot be copied is refused before anything is sent: a bone outside
+ * the subtree, a keyframe track the bake reads that has a custom interpolant
+ * (glTF's cubic spline is carried), an attribute that is neither a
+ * `BufferAttribute` nor an interleaved one.
+ */
+declare function bakeVATInWorker(worker: VATBakeWorker, root: Object3D, animations: BakeInput[], options: BakeOptions & {
+    encoding: 'delta';
+}): Promise<DeltaVAT>;
+declare function bakeVATInWorker(worker: VATBakeWorker, root: Object3D, animations: BakeInput[], options: BakeOptions & {
+    encoding: 'rig';
+}): Promise<RigVAT>;
+declare function bakeVATInWorker(worker: VATBakeWorker, root: Object3D, animations: BakeInput[], options?: BakeOptions): Promise<VAT>;
+/**
+ * The worker's half of {@link bakeVATInWorker}: answer every bake the page
+ * sends, by calling `bakeVAT` here. Call it once, at the top of the worker
+ * module. Messages that are not bakes are left alone, so the worker may do
+ * other work besides. Returns a function that stops listening.
  */
-declare function makeVATTexture(data: TypedArray, width: number, height: number, type?: TextureDataType): DataTexture;
+declare function serveVATBakes(scope?: VATBakeScope): () => void;
 
-export { type BakeInput, type BakeOptions, DeltaVAT, MAX_TEXTURE_SIZE, RigVAT, VAT, bakeVAT, makeVATTexture };
+export { type BakeInput, type BakeOptions, DeltaVAT, MAX_TEXTURE_SIZE, RigVAT, VAT, type VATBakeScope, type VATBakeWorker, type Vec3Out, bakeVAT, bakeVATInWorker, decodeOctahedral, encodeOctahedral, makeVATNormalTexture, makeVATTexture, serveVATBakes };