three-vat 0.1.0 → 1.0.0

package/dist/tsl.d.ts

@@ -1,44 +1,164 @@
+import { BufferGeometry, InstancedMesh } from 'three';
 import { Node } from 'three/webgpu';
-import { V as VAT } from './types-DVtQvVjk.js';
-import 'three';
+import { b as VATClock, V as VAT, d as VATInstance, c as VATCrowd } from './instance-playback-BrGBIKLe.js';
 
+/**
+ * The real maximum texture dimension this renderer accepts, for
+ * `bakeVAT(..., { maxTextureSize })`. The baker is renderer-agnostic (it runs
+ * in Node, and in a Web Worker) so it cannot query this itself.
+ *
+ * Call this *after* `await renderer.init()` — the backend has no device before
+ * that. Handles both a WebGPU backend and the WebGL fallback backend a
+ * `WebGPURenderer` may silently switch to when WebGPU is unavailable.
+ */
+declare function getMaxTextureSize(renderer: object): number;
 /** A fluent TSL float node (has `.add`, `.mul`, … via NodeExtensions). */
 type FloatNode = Node<'float'>;
 /** A fluent TSL vec3 node. */
 type Vec3Node = Node<'vec3'>;
+/**
+ * A TSL float uniform: a node the graph reads, and a `{ value }` clock the
+ * caller sets per frame. Both halves matter — the node is what the decode
+ * samples against, the clock is what the render loop writes — which is why
+ * `createVATMesh` can hand the same object back as a {@link VATClock} and have
+ * it mean the same thing as the WebGL path's uniform.
+ */
+type VATTimeUniform = FloatNode & VATClock;
 interface VATNodeOptions {
     /**
-     * Elapsed-time uniform node (seconds). Create once with `uniform(0)` and set
+     * Elapsed-time uniform (seconds). Create once with `uniform(0)` and set
      * `.value` per frame. Defaults to a fresh `uniform(0)` you can read back.
      */
-    time?: FloatNode;
-    /** Which clip to play (index into `vat.clips`). Default `0`. */
+    time?: VATTimeUniform;
+    /**
+     * The geometry these nodes will render. When it carries the instance-playback
+     * attributes — write them with `addVATInstanceAttributes` from `three-vat`
+     * *before* calling this — each instance plays its own clip, at its own phase
+     * and rate. Without them, every instance plays `clipIndex`, phase-desynced by
+     * `desync`.
+     *
+     * Which decode the graph compiles is decided here, at build time: a TSL
+     * attribute that is missing from the geometry reads as a constant, so the
+     * fallback cannot be a shader-side branch.
+     */
+    geometry?: BufferGeometry;
+    /**
+     * The `InstancedMesh` these nodes will render, when there is one.
+     *
+     * Required for a crowd, and for one reason: three applies the instance matrix
+     * to `positionLocal` *before* it reads `positionNode`, so the decode has to
+     * displace in the geometry's own space and then re-apply the instancing
+     * itself. Without this the delta is added in instance space — unrotated and
+     * unscaled — and every instance deforms according to its own matrix.
+     *
+     * Omit it for a single, non-instanced mesh, where `positionLocal` is the
+     * geometry position and there is nothing to re-apply.
+     */
+    instancedMesh?: InstancedMesh;
+    /**
+     * Which clip to play (index into `vat.clips`). Ignored — along with
+     * `desync` — when `geometry` carries instance playback, which says all of this
+     * per instance. Default `0`.
+     */
     clipIndex?: number;
     /**
      * Max random per-instance time offset in seconds, hashed from `instanceIndex`.
-     * `0` (default) plays every instance in lockstep.
+     * `0` (default) plays every instance in lockstep. Ignored when `geometry`
+     * carries instance playback.
      */
     desync?: number;
 }
 /** Position/normal nodes to assign onto a `MeshStandardNodeMaterial` (or similar). */
 interface VATNodes {
+    /**
+     * Assign to `material.positionNode`. It carries the whole decode — the normal
+     * with it.
+     *
+     * There is deliberately no `normalNode`. A material's `normalNode` is built in
+     * the *fragment* stage (three reaches it from `normalView` through
+     * `builder.context.setupNormal()`) and is expected in **view** space, whereas a
+     * VAT's baked normals are per-vertex and in the geometry's own space. Handing
+     * an object-space normal to a fragment-stage node skipped both the instance
+     * matrix and the normal matrix, and took `vertexIndex` into the fragment stage
+     * with it — where `IndexNode` does not give you the vertex index at all, but
+     * quietly turns itself into a varying, so every fragment read a linearly
+     * *interpolated* index that addresses neither of the vertices it lies between.
+     *
+     * Writing `normalLocal` inside the vertex-stage decode instead is what the
+     * GLSL path does when it sets `objectNormal` in `beginnormal_vertex`: three
+     * then transforms it by the instance and normal matrices and interpolates the
+     * result, on both paths, for free.
+     */
     positionNode: Vec3Node;
-    normalNode: Vec3Node;
     /** The time uniform in use — set `.value` each frame. */
-    time: FloatNode;
+    time: VATTimeUniform;
 }
 /**
  * Build TSL decode nodes for a baked VAT, for the WebGPU/TSL renderer path.
- * Per-instance desync comes from `hash(instanceIndex)` — no instanced
- * attributes needed. Shadows work automatically because `positionNode` also
- * feeds the depth pass.
+ * Shadows work automatically because `positionNode` also feeds the depth pass.
  *
- * v1 limitation: a single clip per material (all instances share `clipIndex`,
- * only their phase is desynced). Per-instance clip variety is future work; use
- * the `three-vat/webgl` path for mixed-clip crowds today.
+ * Pass the `geometry` you are about to render and each instance plays the clip,
+ * phase and rate written into it by `addVATInstanceAttributes` — the same
+ * instance-playback contract the WebGL path reads (ADR-0009), so a mixed-clip
+ * crowd renders identically on either renderer. Without those attributes every
+ * instance plays `clipIndex`, desynced by a phase hashed from `instanceIndex`.
  *
- * NOTE: the TSL path is verified visually/manually in v1 (no automated GPU test).
+ * Coverage note: the node graph is tested structurally in CI (no GPU); that the
+ * two paths decode *identically* is a pixel-diff release gate.
  */
 declare function vatNodes(vat: VAT, options?: VATNodeOptions): VATNodes;
+/**
+ * The decode's arithmetic: the position delta and the normal this instance reads
+ * at this moment, as nodes — before the vertex-stage writes that place them.
+ *
+ * @internal Split out and exported for the structural tests. A `Fn` body is
+ * opaque to graph traversal (its statements are not built until the shader is),
+ * and structural assertions are the only TSL coverage CI can run without a GPU —
+ * so the arithmetic that matters stays reachable as a graph. Not re-exported
+ * from `three-vat`; nothing outside this package should build against it.
+ */
+declare function vatDecode(vat: VAT, options?: VATNodeOptions): {
+    position: Vec3Node;
+    normal: Vec3Node;
+};
+/** Options for {@link createVATMesh}. */
+interface CreateVATMeshOptions {
+    /**
+     * The playback clock to drive this crowd from, in seconds. Pass one — from
+     * `uniform(0)` — to run several VAT meshes off a single time value, or to
+     * keep the node for wiring elsewhere in a graph, which the returned `time`
+     * gives back as a plain clock. Defaults to a fresh `uniform(0)`.
+     *
+     * The one place the two paths' signatures differ: `three-vat/webgl` takes a
+     * `THREE.IUniform` here. Both are `{ value }` clocks, and code that lets the
+     * call make its own is identical on either path.
+     */
+    time?: VATTimeUniform;
+}
+/**
+ * Turn a baked VAT and a list of instances into a crowd ready to render: an
+ * `InstancedMesh` whose geometry carries the instance-playback contract and
+ * whose materials decode the VAT on the vertex stage.
+ *
+ * ```ts
+ * const { mesh, time } = createVATMesh(vat, instances)
+ * mesh.castShadow = mesh.receiveShadow = true
+ * scene.add(mesh)
+ * // per frame:
+ * time.value = clock.elapsedTime
+ * ```
+ *
+ * The same call, the same signature and the same return as `three-vat/webgl`:
+ * a crowd moves between `WebGLRenderer` and `WebGPURenderer` by changing the
+ * import line and nothing else. The one asymmetry is absorbed here rather than
+ * passed on — this path attaches **no depth material**, because `positionNode`
+ * already feeds the depth pass, whereas the WebGL path must patch one by hand
+ * or cast bind-pose shadows.
+ *
+ * Instance matrices and `castShadow`/`receiveShadow` stay yours, as on the
+ * WebGL path: `mesh.setMatrixAt` then `mesh.computeBoundingSphere()`, or
+ * `frustumCulled = false` when the matrices change every frame.
+ */
+declare function createVATMesh(vat: VAT, instances: VATInstance[], options?: CreateVATMeshOptions): VATCrowd;
 
-export { type VATNodeOptions, type VATNodes, vatNodes };
+export { type CreateVATMeshOptions, type VATNodeOptions, type VATNodes, type VATTimeUniform, createVATMesh, getMaxTextureSize, vatDecode, vatNodes };

package/dist/tsl.js

@@ -1,30 +1,87 @@
-import { uniform, float, int, hash, instanceIndex, vertexIndex, positionLocal, textureLoad, ivec2, mix } from 'three/tsl';
+import { createCrowdGeometry, PLAYBACK_ATTRIBUTES } from './chunk-SXTVASKG.js';
+import { InstancedMesh } from 'three';
+import { uniform, Fn, positionLocal, positionGeometry, normalLocal, instancedMesh, int, vertexIndex, textureLoad, ivec2, mix, float, hash, instanceIndex, attribute } from 'three/tsl';
 
-// src/tsl.ts
-function vatNodes(vat, options = {}) {
-  const { time = uniform(0), clipIndex = 0, desync = 0 } = options;
+function getMaxTextureSize(renderer) {
+  const backend = renderer.backend;
+  const device = backend?.["device"];
+  if (device?.limits?.maxTextureDimension2D) return device.limits.maxTextureDimension2D;
+  const gl = backend?.["gl"];
+  if (gl) return gl.getParameter(gl.MAX_TEXTURE_SIZE);
+  throw new Error("three-vat: renderer has no initialized backend \u2014 call `await renderer.init()` first");
+}
+var floatAttribute = (name) => attribute(name, "float");
+function attributePlayback() {
+  const frames = floatAttribute(PLAYBACK_ATTRIBUTES.clipFrames);
+  return {
+    startFrame: int(floatAttribute(PLAYBACK_ATTRIBUTES.clipStart)),
+    frames,
+    duration: frames.div(floatAttribute(PLAYBACK_ATTRIBUTES.clipFps)),
+    timeOffset: floatAttribute(PLAYBACK_ATTRIBUTES.timeOffset),
+    speed: floatAttribute(PLAYBACK_ATTRIBUTES.speed)
+  };
+}
+function clipAt(vat, clipIndex) {
   const clip = vat.clips[clipIndex];
   if (!clip) {
     throw new Error(`three-vat: clipIndex ${clipIndex} out of range (${vat.clips.length} clips)`);
   }
-  const frames = float(clip.frames);
-  const startFrame = int(clip.startFrame);
-  const duration = float(clip.frames / clip.fps);
-  const offset = hash(instanceIndex).mul(desync);
+  return clip;
+}
+function hashedPlayback(clip, desync) {
+  return {
+    startFrame: int(clip.startFrame),
+    frames: float(clip.frames),
+    duration: float(clip.frames / clip.fps),
+    timeOffset: hash(instanceIndex).mul(desync),
+    speed: float(1)
+  };
+}
+function checkPlaybackAttributes(geometry) {
+  const names = Object.values(PLAYBACK_ATTRIBUTES);
+  const missing = names.filter((name) => geometry.getAttribute(name) === void 0);
+  if (missing.length === 0) return true;
+  if (missing.length === names.length) return false;
+  throw new Error(
+    `three-vat: geometry carries only part of the instance-playback contract (missing ${missing.join(", ")}) \u2014 write all of it with \`addVATInstanceAttributes\` from \`three-vat\`, or pass no geometry for the hashed default`
+  );
+}
+function vatNodes(vat, options = {}) {
+  const { time = uniform(0), instancedMesh: instanced } = options;
+  const { position, normal } = vatDecode(vat, options);
+  const decode = Fn(() => {
+    positionLocal.assign((instanced ? positionGeometry : positionLocal).add(position));
+    normalLocal.assign(normal);
+    if (instanced) instancedMesh(instanced);
+    return positionLocal;
+  }, "vec3");
+  return { positionNode: decode(), time };
+}
+function vatDecode(vat, options = {}) {
+  const { time = uniform(0), geometry, clipIndex = 0, desync = 0 } = options;
+  const playback = geometry && checkPlaybackAttributes(geometry) ? attributePlayback() : hashedPlayback(clipAt(vat, clipIndex), desync);
   const vertexRow = int(vertexIndex);
   const sample = (tex) => {
-    const t = time.add(offset).div(duration).fract().mul(frames);
+    const t = time.mul(playback.speed).add(playback.timeOffset).div(playback.duration).fract().mul(playback.frames);
     const f0 = int(t);
-    const f1 = int(f0.add(1).toFloat().mod(frames));
-    const s0 = textureLoad(tex, ivec2(vertexRow, f0.add(startFrame))).xyz;
-    const s1 = textureLoad(tex, ivec2(vertexRow, f1.add(startFrame))).xyz;
+    const f1 = int(f0.add(1).toFloat().mod(playback.frames));
+    const s0 = textureLoad(tex, ivec2(vertexRow, f0.add(playback.startFrame))).xyz;
+    const s1 = textureLoad(tex, ivec2(vertexRow, f1.add(playback.startFrame))).xyz;
     return mix(s0, s1, t.fract());
   };
   return {
-    positionNode: positionLocal.add(sample(vat.positionTexture)),
-    normalNode: sample(vat.normalTexture).normalize(),
-    time
+    position: sample(vat.positionTexture),
+    normal: sample(vat.normalTexture).normalize()
   };
 }
+function createVATMesh(vat, instances, options = {}) {
+  const time = options.time ?? uniform(0);
+  const geometry = createCrowdGeometry(vat, instances);
+  const materials = vat.materials.map((source) => source.clone());
+  const mesh = new InstancedMesh(geometry, materials, instances.length);
+  const { positionNode } = vatNodes(vat, { time, geometry, instancedMesh: mesh });
+  for (const material of materials) material.positionNode = positionNode;
+  return { mesh, time };
+}
 
-export { vatNodes };
+export { createVATMesh, getMaxTextureSize, vatDecode, vatNodes };

package/dist/webgl.d.ts

@@ -1,25 +1,35 @@
-import { IUniform, BufferGeometry, MeshDepthMaterial, Material } from 'three';
-import { V as VAT } from './types-DVtQvVjk.js';
+import { IUniform, MeshDepthMaterial, WebGLRenderer, Material } from 'three';
+import { d as VATInstance$1, e as addVATInstanceAttributes, V as VAT, c as VATCrowd } from './instance-playback-BrGBIKLe.js';
 
+/**
+ * The real maximum texture dimension this GPU accepts, for
+ * `bakeVAT(..., { maxTextureSize })`. The baker cannot query this itself — it
+ * is renderer-agnostic so it can run in Node or a Web Worker — so read it
+ * here and hand it over. Desktop typically reports 16384, but mobile GPUs
+ * commonly report 4096 or 8192, which is exactly the case a hardcoded default
+ * bakes straight past.
+ */
+declare function getMaxTextureSize(renderer: WebGLRenderer): number;
 /** The shared uniform driving every VAT-patched material's playback clock. */
 interface VATUniforms {
     uVatTime: IUniform<number>;
 }
 /** Create the shared time uniform. Update `uVatTime.value` once per frame. */
 declare function createVATUniforms(time?: number): VATUniforms;
-/** Per-instance playback state consumed by the patched shader. */
-interface VATInstance {
-    clip: Pick<VAT['clips'][number], 'startFrame' | 'frames' | 'fps'>;
-    /** Phase offset in seconds — desyncs the crowd. */
-    timeOffset: number;
-    /** Playback rate multiplier. */
-    speed: number;
-}
 /**
- * Attach the per-instance attributes the WebGL decode reads: clip band, fps,
- * time offset, and speed. Call on the instanced geometry before rendering.
+ * The instance-playback contract now lives in the core entry point, so both
+ * decode paths can read it (ADR-0009).
+ *
+ * @deprecated Renamed to `addVATInstanceAttributes` and moved to `three-vat`.
+ * Removed from `three-vat/webgl` in the next minor version — import it from
+ * `three-vat` instead.
+ */
+declare const addInstancedVATAttributes: typeof addVATInstanceAttributes;
+/**
+ * @deprecated Moved to `three-vat`. Removed from `three-vat/webgl` in the next
+ * minor version — import `VATInstance` from `three-vat` instead.
  */
-declare function addInstancedVATAttributes(geometry: BufferGeometry, instances: VATInstance[]): void;
+type VATInstance = VATInstance$1;
 /**
  * Patch any built-in material so its vertex stage samples the VAT instead of
  * skinning. Works on the render material and on `MeshDepthMaterial` (needed for
@@ -34,5 +44,45 @@ declare function patchVATMaterial<T extends Material>(material: T, vat: VAT, uni
  * `MeshDistanceMaterial`).
  */
 declare function createVATDepthMaterial(vat: VAT, uniforms: VATUniforms): MeshDepthMaterial;
+/** Options for {@link createVATMesh}. */
+interface CreateVATMeshOptions {
+    /**
+     * The playback clock to drive this crowd from, in seconds. Pass one — from
+     * {@link createVATUniforms} or any `{ value }` — to run several VAT meshes off
+     * a single time value. Defaults to a fresh clock at `0`, returned to you as
+     * `time`. The TSL path's `vatNodes` takes its clock the same way.
+     */
+    time?: IUniform<number>;
+}
+/**
+ * Turn a baked VAT and a list of instances into a crowd ready to render: an
+ * `InstancedMesh` whose geometry carries the instance-playback contract, whose
+ * materials decode the VAT, and whose shadows are deformed rather than frozen
+ * in the bind pose.
+ *
+ * ```ts
+ * const { mesh, time } = createVATMesh(vat, instances)
+ * mesh.castShadow = mesh.receiveShadow = true
+ * scene.add(mesh)
+ * // per frame:
+ * time.value = clock.elapsedTime
+ * ```
+ *
+ * Two things stay yours, because only you can know them:
+ *
+ * - **Instance matrices.** Write them with `mesh.setMatrixAt`, then
+ *   `mesh.instanceMatrix.needsUpdate = true`. An `InstancedMesh` caches the
+ *   bounding sphere it culls against, so call `mesh.computeBoundingSphere()`
+ *   after placing the crowd, or set `mesh.frustumCulled = false` when the
+ *   matrices change every frame.
+ * - **`castShadow` / `receiveShadow`**, which are scene decisions. The depth and
+ *   distance materials the shadow passes need are already attached either way.
+ *
+ * Everything here is the exported primitives — {@link addVATInstanceAttributes},
+ * {@link patchVATMaterial}, {@link createVATDepthMaterial} — composed in the one
+ * order that is correct. Reach for them directly only when rendering onto
+ * something other than a plain `InstancedMesh`.
+ */
+declare function createVATMesh(vat: VAT, instances: VATInstance$1[], options?: CreateVATMeshOptions): VATCrowd;
 
-export { type VATInstance, type VATUniforms, addInstancedVATAttributes, createVATDepthMaterial, createVATUniforms, patchVATMaterial };
+export { type CreateVATMeshOptions, type VATInstance, type VATUniforms, addInstancedVATAttributes, createVATDepthMaterial, createVATMesh, createVATUniforms, getMaxTextureSize, patchVATMaterial };

package/dist/webgl.js

@@ -1,30 +1,13 @@
-import { InstancedBufferAttribute, MeshDepthMaterial, RGBADepthPacking } from 'three';
+import { addVATInstanceAttributes, createCrowdGeometry } from './chunk-SXTVASKG.js';
+import { MeshDepthMaterial, RGBADepthPacking, InstancedMesh, MeshDistanceMaterial } from 'three';
 
-// src/webgl.ts
+function getMaxTextureSize(renderer) {
+  return renderer.capabilities.maxTextureSize;
+}
 function createVATUniforms(time = 0) {
   return { uVatTime: { value: time } };
 }
-function addInstancedVATAttributes(geometry, instances) {
-  const n = instances.length;
-  const clipStart = new Float32Array(n);
-  const clipFrames = new Float32Array(n);
-  const clipFps = new Float32Array(n);
-  const timeOffset = new Float32Array(n);
-  const speed = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    const inst = instances[i];
-    clipStart[i] = inst.clip.startFrame;
-    clipFrames[i] = inst.clip.frames;
-    clipFps[i] = inst.clip.fps;
-    timeOffset[i] = inst.timeOffset;
-    speed[i] = inst.speed;
-  }
-  geometry.setAttribute("aClipStart", new InstancedBufferAttribute(clipStart, 1));
-  geometry.setAttribute("aClipFrames", new InstancedBufferAttribute(clipFrames, 1));
-  geometry.setAttribute("aClipFps", new InstancedBufferAttribute(clipFps, 1));
-  geometry.setAttribute("aTimeOffset", new InstancedBufferAttribute(timeOffset, 1));
-  geometry.setAttribute("aSpeed", new InstancedBufferAttribute(speed, 1));
-}
+var addInstancedVATAttributes = addVATInstanceAttributes;
 var DECODE_PRELUDE = (
   /* glsl */
   `
@@ -77,5 +60,14 @@ function createVATDepthMaterial(vat, uniforms) {
   patchVATMaterial(depth, vat, uniforms);
   return depth;
 }
+function createVATMesh(vat, instances, options = {}) {
+  const uniforms = options.time ? { uVatTime: options.time } : createVATUniforms();
+  const geometry = createCrowdGeometry(vat, instances);
+  const materials = vat.materials.map((source) => patchVATMaterial(source.clone(), vat, uniforms));
+  const mesh = new InstancedMesh(geometry, materials, instances.length);
+  mesh.customDepthMaterial = createVATDepthMaterial(vat, uniforms);
+  mesh.customDistanceMaterial = patchVATMaterial(new MeshDistanceMaterial(), vat, uniforms);
+  return { mesh, time: uniforms.uVatTime };
+}
 
-export { addInstancedVATAttributes, createVATDepthMaterial, createVATUniforms, patchVATMaterial };
+export { addInstancedVATAttributes, createVATDepthMaterial, createVATMesh, createVATUniforms, getMaxTextureSize, patchVATMaterial };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-vat",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Bake glTF animation clips into vertex animation textures for zero-CPU instanced crowds in three.js.",
   "type": "module",
   "license": "MIT",
@@ -34,15 +34,6 @@
       "import": "./dist/tsl.js"
     }
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build",
-    "example": "pnpm --dir examples dev"
-  },
   "keywords": [
     "three",
     "threejs",
@@ -68,5 +59,20 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "fetch:test-assets": "node scripts/fetch-test-assets.mjs",
+    "typecheck": "tsc --noEmit",
+    "release": "pnpm publish ${NPM_OTP:+--otp=\"$NPM_OTP\"} && pnpm verify:published",
+    "verify:published": "node scripts/verify-published.mjs",
+    "example": "pnpm --filter three-vat-example dev",
+    "build:examples": "pnpm --filter three-vat-example build",
+    "test:examples": "pnpm --filter three-vat-example test",
+    "parity": "pnpm --filter three-vat-example parity",
+    "typecheck:examples": "pnpm --filter three-vat-example typecheck"
   }
-}
+}

package/dist/types-DVtQvVjk.d.ts

@@ -1,45 +0,0 @@
-import { DataTexture, Box3 } from 'three';
-
-/** One baked animation range within a VAT's stacked frame rows. */
-interface VATClip {
-    /** Clip name, taken from the source `AnimationClip`. */
-    name: string;
-    /** First frame row (y) of this clip in the texture. */
-    startFrame: number;
-    /** Number of frame rows baked for this clip. */
-    frames: number;
-    /** Effective frames-per-second of the bake (`frames / duration`). */
-    fps: number;
-    /** Source clip duration in seconds. */
-    duration: number;
-    /**
-     * Largest per-vertex position-delta magnitude (metres) across the clip.
-     * Near-zero means the clip baked as a frozen pose — the diagnostic for a
-     * mis-targeted or genuinely static clip.
-     */
-    maxDelta: number;
-}
-/**
- * A baked Vertex Animation Texture: the position/normal `DataTexture`s plus the
- * clip table and bounds needed to decode and render them. Produced by
- * {@link bakeVAT} (runtime) or `loadVAT` (offline); the two paths yield
- * identical objects.
- */
-interface VAT {
-    /** RGBA float texture of per-vertex position deltas (`x = vertex`, `y = frame`). */
-    positionTexture: DataTexture;
-    /** RGBA float texture of per-vertex absolute normals (`x = vertex`, `y = frame`). */
-    normalTexture: DataTexture;
-    /** Clip table: name → `{ startFrame, frames, fps, ... }`. */
-    clips: VATClip[];
-    /** Union of every baked frame's bounds; use as the geometry bounding box. */
-    bounds: Box3;
-    /** Vertex count (texture width). */
-    vertexCount: number;
-    /** Total frame rows across all clips (texture height). */
-    totalFrames: number;
-    /** Position encoding. Only `'delta'` in v1. */
-    encoding: 'delta';
-}
-
-export type { VAT as V, VATClip as a };