@ikijs/engine 0.1.0

package/dist/index.js

@@ -0,0 +1,1420 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HairChainMotion: () => HairChainMotion,
+  IdleMotion: () => IdleMotion,
+  IkiPlayer: () => IkiPlayer,
+  ParameterStore: () => ParameterStore,
+  PhysicsMotion: () => PhysicsMotion,
+  multiply: () => multiply,
+  rotate: () => rotate,
+  scale: () => scale,
+  toMat3: () => toMat3,
+  translate: () => translate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/math.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/parameter-store.ts
+var ParameterStore = class {
+  params = /* @__PURE__ */ new Map();
+  values = /* @__PURE__ */ new Map();
+  /**
+   * Resting value per id: the declared default clamped into range, resolved
+   * ONCE here so `reset()` is a straight copy and a malformed descriptor is
+   * reported once rather than on every reset.
+   */
+  defaults = /* @__PURE__ */ new Map();
+  constructor(parameters) {
+    for (const param of parameters) {
+      this.params.set(param.id, param);
+      if (!Number.isFinite(param.default)) {
+        console.error(
+          `Iki: parameter "${param.id}" has a non-finite default; resting at the neutral in-range value instead`
+        );
+      }
+      const base = Number.isFinite(param.default) ? param.default : 0;
+      this.defaults.set(param.id, clamp(base, param.min, param.max));
+    }
+    for (const [id, value] of this.defaults) this.values.set(id, value);
+  }
+  /**
+   * Set a parameter's value, clamped to its range. Unknown ids are ignored, as
+   * are non-finite values: this is the boundary a host drives with live signals,
+   * and `clamp` cannot filter NaN (`Math.max(min, Math.min(max, NaN))` is NaN),
+   * so one bad lip-sync/gaze frame would otherwise poison every binding that
+   * reads the parameter. A dropped write holds the last good pose.
+   */
+  set(id, value) {
+    const param = this.params.get(id);
+    if (!param) return;
+    if (!Number.isFinite(value)) return;
+    this.values.set(id, clamp(value, param.min, param.max));
+  }
+  /** Current value, or 0 if the id is unknown. */
+  get(id) {
+    return this.values.get(id) ?? 0;
+  }
+  /** Position of a parameter within its range, 0..1. */
+  normalized(id) {
+    const param = this.params.get(id);
+    if (!param || param.max === param.min) return 0;
+    return (this.get(id) - param.min) / (param.max - param.min);
+  }
+  /** Reset every parameter to its resting value (see `defaults`). */
+  reset() {
+    for (const [id, value] of this.defaults) this.values.set(id, value);
+  }
+  list() {
+    return [...this.params.values()];
+  }
+};
+
+// src/affine.ts
+function translate(tx, ty) {
+  return [1, 0, 0, 1, tx, ty];
+}
+function scale(sx, sy) {
+  return [sx, 0, 0, sy, 0, 0];
+}
+function rotate(degrees) {
+  const r = degrees * Math.PI / 180;
+  const c = Math.cos(r);
+  const s = Math.sin(r);
+  return [c, s, -s, c, 0, 0];
+}
+function multiply(a, b) {
+  return [
+    a[0] * b[0] + a[2] * b[1],
+    a[1] * b[0] + a[3] * b[1],
+    a[0] * b[2] + a[2] * b[3],
+    a[1] * b[2] + a[3] * b[3],
+    a[0] * b[4] + a[2] * b[5] + a[4],
+    a[1] * b[4] + a[3] * b[5] + a[5]
+  ];
+}
+function toMat3(a) {
+  return new Float32Array([a[0], a[1], 0, a[2], a[3], 0, a[4], a[5], 1]);
+}
+
+// src/deform.ts
+var IDENTITY_TRANSFORM = {
+  x: 0,
+  y: 0,
+  rotation: 0,
+  scaleX: 1,
+  scaleY: 1,
+  opacity: 1
+};
+function evaluateTransform(transform, bindings, params) {
+  const base = transform ?? IDENTITY_TRANSFORM;
+  const result = {
+    x: base.x,
+    y: base.y,
+    rotation: base.rotation ?? 0,
+    scaleX: base.scaleX ?? 1,
+    scaleY: base.scaleY ?? 1,
+    opacity: base.opacity ?? 1
+  };
+  for (const binding of bindings ?? []) {
+    const t = params.normalized(binding.parameter);
+    const value = binding.from + (binding.to - binding.from) * t;
+    switch (binding.channel) {
+      case "translateX":
+        result.x += value;
+        break;
+      case "translateY":
+        result.y += value;
+        break;
+      case "rotate":
+        result.rotation += value;
+        break;
+      case "scaleX":
+        result.scaleX += value;
+        break;
+      case "scaleY":
+        result.scaleY += value;
+        break;
+      case "opacity":
+        result.opacity *= value;
+        break;
+    }
+  }
+  return result;
+}
+function deformerLocalMatrix(d, params) {
+  const t = evaluateTransform(d.transform, d.bindings, params);
+  const trs = multiply(
+    multiply(translate(t.x, t.y), rotate(t.rotation)),
+    scale(t.scaleX, t.scaleY)
+  );
+  return multiply(
+    multiply(translate(d.pivot.x, d.pivot.y), trs),
+    translate(-d.pivot.x, -d.pivot.y)
+  );
+}
+function resolveDeformerWorlds(deformers, params) {
+  const matrixDeformers = deformers.filter(
+    (d) => d.kind === "matrix" || d.kind === void 0
+  );
+  const byId = new Map(
+    matrixDeformers.map((d) => [d.id, d])
+  );
+  const worldById = /* @__PURE__ */ new Map();
+  function resolve(d) {
+    const cached = worldById.get(d.id);
+    if (cached) return cached;
+    const local = deformerLocalMatrix(d, params);
+    let world;
+    if (d.parent === void 0) {
+      world = local;
+    } else {
+      const parentDef = byId.get(d.parent);
+      if (!parentDef) {
+        throw new Error(
+          `unresolved deformer parent "${d.parent}" \u2014 model not validated?`
+        );
+      }
+      world = multiply(resolve(parentDef), local);
+    }
+    worldById.set(d.id, world);
+    return world;
+  }
+  for (const d of matrixDeformers) {
+    resolve(d);
+  }
+  return worldById;
+}
+
+// src/warp.ts
+function accumulateKeyformOffsets(keyforms, value, out) {
+  const ks = keyforms;
+  if (value <= ks[0].value) {
+    const { offsets } = ks[0];
+    for (let i = 0; i < offsets.length; i++) {
+      out[i] += offsets[i];
+    }
+  } else if (value >= ks[ks.length - 1].value) {
+    const { offsets } = ks[ks.length - 1];
+    for (let i = 0; i < offsets.length; i++) {
+      out[i] += offsets[i];
+    }
+  } else {
+    let lo = ks[0];
+    let hi = ks[1];
+    for (let k = 1; k < ks.length - 1; k++) {
+      if (ks[k].value <= value) {
+        lo = ks[k];
+        hi = ks[k + 1];
+      }
+    }
+    const t = (value - lo.value) / (hi.value - lo.value);
+    const loOff = lo.offsets;
+    const hiOff = hi.offsets;
+    for (let i = 0; i < loOff.length; i++) {
+      out[i] += loOff[i] + (hiOff[i] - loOff[i]) * t;
+    }
+  }
+}
+function accumulate2DKeyformOffsets(valuesX, valuesY, keyforms2d, vx, vy, out) {
+  const lastX = valuesX.length - 1;
+  const lastY = valuesY.length - 1;
+  let ix;
+  let tx;
+  if (vx <= valuesX[0]) {
+    ix = 0;
+    tx = 0;
+  } else if (vx >= valuesX[lastX]) {
+    ix = lastX - 1;
+    tx = 1;
+  } else {
+    ix = 0;
+    for (let k = 0; k < lastX - 1; k++) {
+      if (valuesX[k + 1] <= vx) ix = k + 1;
+    }
+    tx = (vx - valuesX[ix]) / (valuesX[ix + 1] - valuesX[ix]);
+  }
+  let iy;
+  let ty;
+  if (vy <= valuesY[0]) {
+    iy = 0;
+    ty = 0;
+  } else if (vy >= valuesY[lastY]) {
+    iy = lastY - 1;
+    ty = 1;
+  } else {
+    iy = 0;
+    for (let k = 0; k < lastY - 1; k++) {
+      if (valuesY[k + 1] <= vy) iy = k + 1;
+    }
+    ty = (vy - valuesY[iy]) / (valuesY[iy + 1] - valuesY[iy]);
+  }
+  const W = valuesX.length;
+  const c00 = keyforms2d[iy * W + ix];
+  const c10 = keyforms2d[iy * W + ix + 1];
+  const c01 = keyforms2d[(iy + 1) * W + ix];
+  const c11 = keyforms2d[(iy + 1) * W + ix + 1];
+  const o00 = c00.offsets;
+  const o10 = c10.offsets;
+  const o01 = c01.offsets;
+  const o11 = c11.offsets;
+  for (let n = 0; n < o00.length; n++) {
+    const top = o00[n] + (o10[n] - o00[n]) * tx;
+    const bot = o01[n] + (o11[n] - o01[n]) * tx;
+    out[n] += top + (bot - top) * ty;
+  }
+}
+function applyWarps(rest, warps, params, out) {
+  out.set(rest);
+  if (!warps || warps.length === 0) return;
+  for (const warp of warps) {
+    accumulateKeyformOffsets(warp.keyforms, params.get(warp.parameter), out);
+  }
+}
+
+// src/warp-grid.ts
+function resolveWarpGrids(deformers, params, matrixWorlds) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const d of deformers) {
+    if (d.kind !== "warp") continue;
+    const { cols, rows, points: restPoints } = d.grid;
+    const points = Float32Array.from(restPoints);
+    for (const warp of d.warps ?? []) {
+      accumulateKeyformOffsets(
+        warp.keyforms,
+        params.get(warp.parameter),
+        points
+      );
+    }
+    if (d.warp2d !== void 0) {
+      accumulate2DKeyformOffsets(
+        d.warp2d.valuesX,
+        d.warp2d.valuesY,
+        d.warp2d.keyforms2d,
+        params.get(d.warp2d.parameter),
+        params.get(d.warp2d.parameterY),
+        points
+      );
+    }
+    if (d.parent !== void 0) {
+      const parentAffine = matrixWorlds.get(d.parent);
+      if (parentAffine) {
+        for (let i = 0; i < points.length; i += 2) {
+          const x = points[i];
+          const y = points[i + 1];
+          points[i] = parentAffine[0] * x + parentAffine[2] * y + parentAffine[4];
+          points[i + 1] = parentAffine[1] * x + parentAffine[3] * y + parentAffine[5];
+        }
+      }
+    }
+    resolved.set(d.id, { cols, rows, points });
+  }
+  return resolved;
+}
+function bindPointToRestGrid(x, y, restGrid) {
+  const { cols, rows, points } = restGrid;
+  const stride = cols + 1;
+  let col = cols - 1;
+  for (let c = 0; c < cols; c++) {
+    const xRight2 = points[(c + 1) * 2];
+    if (x < xRight2) {
+      col = c;
+      break;
+    }
+  }
+  const xLeft = points[col * 2];
+  const xRight = points[(col + 1) * 2];
+  const s = clamp((x - xLeft) / (xRight - xLeft), 0, 1);
+  let row = rows - 1;
+  for (let r = 0; r < rows; r++) {
+    const yBottom2 = points[(r + 1) * stride * 2 + 1];
+    if (y > yBottom2) {
+      row = r;
+      break;
+    }
+  }
+  const yTop = points[row * stride * 2 + 1];
+  const yBottom = points[(row + 1) * stride * 2 + 1];
+  const t = clamp((yTop - y) / (yTop - yBottom), 0, 1);
+  return { cell: row * cols + col, s, t };
+}
+function applyWarpToChild(localVerts, partAffine, restGrid, deformedGrid, out) {
+  const n = localVerts.length / 2;
+  for (let v = 0; v < n; v++) {
+    const lx = localVerts[v * 2];
+    const ly = localVerts[v * 2 + 1];
+    const mx = partAffine[0] * lx + partAffine[2] * ly + partAffine[4];
+    const my = partAffine[1] * lx + partAffine[3] * ly + partAffine[5];
+    const binding = bindPointToRestGrid(mx, my, restGrid);
+    const [sx, sy] = sampleWarpGrid(deformedGrid, binding);
+    out[v * 2] = sx;
+    out[v * 2 + 1] = sy;
+  }
+}
+function sampleWarpGrid(grid, binding) {
+  const { cols, points } = grid;
+  const stride = cols + 1;
+  const row = Math.floor(binding.cell / cols);
+  const col = binding.cell % cols;
+  const { s, t } = binding;
+  const i00 = (row * stride + col) * 2;
+  const i10 = (row * stride + col + 1) * 2;
+  const i01 = ((row + 1) * stride + col) * 2;
+  const i11 = ((row + 1) * stride + col + 1) * 2;
+  const topX = points[i00] + (points[i10] - points[i00]) * s;
+  const topY = points[i00 + 1] + (points[i10 + 1] - points[i00 + 1]) * s;
+  const botX = points[i01] + (points[i11] - points[i01]) * s;
+  const botY = points[i01 + 1] + (points[i11 + 1] - points[i01 + 1]) * s;
+  return [topX + (botX - topX) * t, topY + (botY - topY) * t];
+}
+
+// src/player.ts
+var MASK_ALPHA_CUTOFF = 0.5;
+var IkiPlayer = class {
+  constructor(canvas) {
+    this.canvas = canvas;
+    const gl = canvas.getContext("webgl2", {
+      alpha: true,
+      // The whole pipeline is premultiplied-alpha: the fragment shader
+      // multiplies rgb by alpha, the blend function is ONE /
+      // ONE_MINUS_SRC_ALPHA, and the page compositor reads the framebuffer
+      // as premultiplied. Straight-alpha (`premultipliedAlpha: false`) cannot
+      // be made consistent with SRC_ALPHA-style blending: semi-transparent
+      // pixels over a transparent background come out premultiplied anyway
+      // and composite too dark.
+      premultipliedAlpha: true,
+      // Stencil buffer backs clip masks (a part rendered only inside its masks'
+      // coverage). Granted by every modern browser; the load() guard reports if not.
+      stencil: true
+    });
+    if (!gl) throw new Error("WebGL2 is not available in this browser");
+    this.gl = gl;
+    this.stencilAvailable = gl.getContextAttributes()?.stencil ?? false;
+    this.program = createProgram(gl, VERTEX_SHADER, FRAGMENT_SHADER);
+    this.uMatrix = getUniform(gl, this.program, "u_matrix");
+    this.uColor = getUniform(gl, this.program, "u_color");
+    this.uUseTexture = getUniform(gl, this.program, "u_useTexture");
+    this.uTex = getUniform(gl, this.program, "u_tex");
+    this.uUvOffset = getUniform(gl, this.program, "u_uvOffset");
+    this.uUvScale = getUniform(gl, this.program, "u_uvScale");
+    this.uUseMeshUv = getUniform(gl, this.program, "u_useMeshUv");
+    this.uAlphaCutoff = getUniform(gl, this.program, "u_alphaCutoff");
+    this.aPos = gl.getAttribLocation(this.program, "a_pos");
+    this.aUv = gl.getAttribLocation(this.program, "a_uv");
+    this.quad = createUnitQuad(gl);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+  }
+  canvas;
+  gl;
+  program;
+  quad;
+  uMatrix;
+  uColor;
+  uUseTexture;
+  uTex;
+  uUvOffset;
+  uUvScale;
+  uUseMeshUv;
+  uAlphaCutoff;
+  aPos;
+  aUv;
+  /** True when the context granted a stencil buffer; clipping needs it. */
+  stencilAvailable;
+  model;
+  parts = [];
+  params = new ParameterStore([]);
+  rafId;
+  /** Uploaded textures, index-aligned with `model.textures`; `null` = unusable. */
+  textures = [];
+  /** Bumped by every `load` and by `destroy`; lets a stale async load bail. */
+  loadGeneration = 0;
+  destroyed = false;
+  /**
+   * Engine-internal mesh buffers, keyed by the part's INDEX in `this.parts`
+   * (NOT by part id — duplicate ids must not swap buffers).
+   */
+  partMeshes = /* @__PURE__ */ new Map();
+  /**
+   * Clip groups resolved once per `load()`: consumer part index (into `this.parts`)
+   * → its mask part indices. A part absent from this map is unclipped.
+   */
+  partClipGroups = /* @__PURE__ */ new Map();
+  /**
+   * Load a model and reset parameters to their defaults. All textures are
+   * decoded and uploaded before the model is swapped in — the swap is atomic,
+   * so you never see a partially-textured frame. `start()` may be called any
+   * time, but nothing renders until the first `load()` resolves. For an
+   * embedded `data:` atlas this is near-instant.
+   *
+   * Individual texture decode/upload failures are non-fatal: they are logged
+   * via `console.error`, the affected parts are skipped, and `load()` still
+   * resolves — the returned {@link IkiLoadResult} lists the indices of any
+   * textures that failed, so a host can detect and report a partial load. The
+   * model is assumed already validated by `@ikijs/format`.
+   *
+   * Mesh buffer allocation failure IS fatal (unlike per-texture skip) because
+   * textures have an `IkiLoadResult.failedTextures` reporting surface and mesh
+   * buffers have none — there is no partial-mesh concept in the format.
+   */
+  async load(model) {
+    const { gl } = this;
+    const generation = ++this.loadGeneration;
+    const sources = model.textures ?? [];
+    const decoded = await Promise.allSettled(
+      sources.map((tex) => decodeTexture(tex.source))
+    );
+    if (generation !== this.loadGeneration || this.destroyed) {
+      for (const result of decoded) {
+        if (result.status === "fulfilled" && result.value) result.value.close();
+      }
+      return { failedTextures: [], superseded: true };
+    }
+    const maxTextureSizeRaw = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+    const maxTextureSize = typeof maxTextureSizeRaw === "number" ? maxTextureSizeRaw : void 0;
+    if (maxTextureSize === void 0) {
+      console.error("Iki: WebGL context lost during load()");
+    }
+    drainGlErrors(gl);
+    const uploaded = decoded.map((result, i) => {
+      if (result.status === "rejected") {
+        console.error(`Iki: failed to decode textures[${i}]`, result.reason);
+        return null;
+      }
+      const bitmap = result.value;
+      if (!bitmap) return null;
+      if (maxTextureSize !== void 0 && (bitmap.width > maxTextureSize || bitmap.height > maxTextureSize)) {
+        console.error(
+          `Iki: textures[${i}] is ${bitmap.width}x${bitmap.height}, over this device's ${maxTextureSize}px limit`
+        );
+        bitmap.close();
+        return null;
+      }
+      const texture = gl.createTexture();
+      if (!texture) {
+        bitmap.close();
+        console.error(`Iki: failed to allocate GL texture for textures[${i}]`);
+        return null;
+      }
+      gl.bindTexture(gl.TEXTURE_2D, texture);
+      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+      drainGlErrors(gl);
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        bitmap
+      );
+      bitmap.close();
+      const uploadError = gl.getError();
+      if (uploadError !== gl.NO_ERROR) {
+        gl.deleteTexture(texture);
+        console.error(
+          `Iki: failed to upload textures[${i}] (GL error 0x${uploadError.toString(16)})`
+        );
+        return null;
+      }
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      return texture;
+    });
+    const nextParts = [...model.parts].sort((a, b) => a.order - b.order);
+    const nextPartMeshes = /* @__PURE__ */ new Map();
+    for (let i = 0; i < nextParts.length; i++) {
+      const part = nextParts[i];
+      if (!part.mesh) continue;
+      const { mesh } = part;
+      const currentPartBuffers = [];
+      const positionBuf = gl.createBuffer();
+      if (!positionBuf) {
+        deletePartMeshBuffers(gl, nextPartMeshes);
+        deleteUploadedTextures(gl, uploaded);
+        throw new Error("Iki: failed to allocate mesh buffer");
+      }
+      currentPartBuffers.push(positionBuf);
+      const uvBuf = gl.createBuffer();
+      if (!uvBuf) {
+        for (const b of currentPartBuffers) gl.deleteBuffer(b);
+        deletePartMeshBuffers(gl, nextPartMeshes);
+        deleteUploadedTextures(gl, uploaded);
+        throw new Error("Iki: failed to allocate mesh buffer");
+      }
+      currentPartBuffers.push(uvBuf);
+      const indexBuf = gl.createBuffer();
+      if (!indexBuf) {
+        for (const b of currentPartBuffers) gl.deleteBuffer(b);
+        deletePartMeshBuffers(gl, nextPartMeshes);
+        deleteUploadedTextures(gl, uploaded);
+        throw new Error("Iki: failed to allocate mesh buffer");
+      }
+      const rest = new Float32Array(mesh.vertices);
+      const warpDeformer = part.deformer !== void 0 ? model.deformers?.find(
+        (d) => d.kind === "warp" && d.id === part.deformer
+      ) : void 0;
+      const isWarpChild = warpDeformer !== void 0;
+      const hasWarps = (part.warps?.length ?? 0) > 0;
+      const dynamic = hasWarps || isWarpChild;
+      const scratch = dynamic ? new Float32Array(mesh.vertices.length) : void 0;
+      const local = isWarpChild ? new Float32Array(mesh.vertices.length) : void 0;
+      drainGlErrors(gl);
+      gl.bindBuffer(gl.ARRAY_BUFFER, positionBuf);
+      gl.bufferData(
+        gl.ARRAY_BUFFER,
+        rest,
+        dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW
+      );
+      gl.bindBuffer(gl.ARRAY_BUFFER, uvBuf);
+      gl.bufferData(
+        gl.ARRAY_BUFFER,
+        new Float32Array(mesh.uvs),
+        gl.STATIC_DRAW
+      );
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuf);
+      gl.bufferData(
+        gl.ELEMENT_ARRAY_BUFFER,
+        new Uint16Array(mesh.indices),
+        gl.STATIC_DRAW
+      );
+      const meshUploadError = gl.getError();
+      if (meshUploadError !== gl.NO_ERROR) {
+        for (const b of currentPartBuffers) gl.deleteBuffer(b);
+        gl.deleteBuffer(indexBuf);
+        deletePartMeshBuffers(gl, nextPartMeshes);
+        deleteUploadedTextures(gl, uploaded);
+        throw new Error(
+          `Iki: failed to upload mesh buffers for part "${part.id}" (GL error 0x${meshUploadError.toString(16)})`
+        );
+      }
+      nextPartMeshes.set(i, {
+        position: positionBuf,
+        uv: uvBuf,
+        index: indexBuf,
+        indexCount: mesh.indices.length,
+        rest,
+        scratch,
+        warps: part.warps,
+        warpDeformer,
+        local
+      });
+    }
+    const nextClipGroups = /* @__PURE__ */ new Map();
+    const indexById = /* @__PURE__ */ new Map();
+    for (let i = 0; i < nextParts.length; i++) {
+      indexById.set(nextParts[i].id, i);
+    }
+    for (let i = 0; i < nextParts.length; i++) {
+      const clip = nextParts[i].clip;
+      if (!clip) continue;
+      const maskIndices = clip.masks.map((maskId) => indexById.get(maskId)).filter((mi) => mi !== void 0);
+      if (maskIndices.length > 0) nextClipGroups.set(i, maskIndices);
+    }
+    if (nextClipGroups.size > 0 && !this.stencilAvailable) {
+      console.error(
+        "Iki: model uses clip masks but this WebGL2 context has no stencil buffer; rendering unclipped"
+      );
+    }
+    deletePartMeshBuffers(gl, this.partMeshes);
+    for (const texture of this.textures) {
+      if (texture) gl.deleteTexture(texture);
+    }
+    this.model = model;
+    this.params = new ParameterStore(model.parameters);
+    this.parts = nextParts;
+    this.partMeshes = nextPartMeshes;
+    this.partClipGroups = nextClipGroups;
+    this.textures = uploaded;
+    return {
+      failedTextures: uploaded.flatMap((t, i) => t === null ? [i] : []),
+      superseded: false
+    };
+  }
+  /**
+   * Start the render loop. Safe to call more than once, and a no-op after
+   * {@link destroy} — the program and buffers the loop draws with are gone, so
+   * restarting would only spray GL errors.
+   */
+  start() {
+    if (this.rafId !== void 0 || this.destroyed) return;
+    const loop = () => {
+      this.renderFrame();
+      this.rafId = requestAnimationFrame(loop);
+    };
+    this.rafId = requestAnimationFrame(loop);
+  }
+  stop() {
+    if (this.rafId === void 0) return;
+    cancelAnimationFrame(this.rafId);
+    this.rafId = void 0;
+  }
+  /**
+   * Set a parameter value (clamped to its range). Unknown ids and non-finite
+   * values are ignored — see {@link ParameterStore.set}.
+   */
+  setParameter(id, value) {
+    this.params.set(id, value);
+  }
+  /**
+   * Current value of a parameter, or 0 for an unknown id.
+   *
+   * Hosts need this to avoid shadowing the engine's state: the motion drivers
+   * read the live pose to compute the next one, and without a read accessor
+   * every host has to keep its own mirror of what it last wrote — and keep that
+   * mirror's clamping in step with {@link ParameterStore} by hand.
+   */
+  getParameter(id) {
+    return this.params.get(id);
+  }
+  /** The model's parameter descriptors, for building UI or host wiring. */
+  getParameters() {
+    return this.params.list();
+  }
+  destroy() {
+    this.stop();
+    this.destroyed = true;
+    ++this.loadGeneration;
+    const { gl } = this;
+    for (const texture of this.textures) {
+      if (texture) gl.deleteTexture(texture);
+    }
+    this.textures = [];
+    deletePartMeshBuffers(gl, this.partMeshes);
+    this.partMeshes = /* @__PURE__ */ new Map();
+    gl.deleteBuffer(this.quad);
+    gl.deleteProgram(this.program);
+  }
+  renderFrame() {
+    const { gl, canvas } = this;
+    const dpr = window.devicePixelRatio || 1;
+    const width = Math.max(1, Math.floor(canvas.clientWidth * dpr));
+    const height = Math.max(1, Math.floor(canvas.clientHeight * dpr));
+    if (canvas.width !== width || canvas.height !== height) {
+      canvas.width = width;
+      canvas.height = height;
+    }
+    gl.viewport(0, 0, width, height);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+    if (!this.model) return;
+    const { width: modelW, height: modelH } = this.model.canvas;
+    const fit = Math.min(width / modelW, height / modelH);
+    const clipX = fit * 2 / width;
+    const clipY = fit * 2 / height;
+    gl.useProgram(this.program);
+    const deformerWorlds = this.model.deformers && this.model.deformers.length > 0 ? resolveDeformerWorlds(this.model.deformers, this.params) : void 0;
+    const warpGrids = this.model.deformers?.some((d) => d.kind === "warp") ? resolveWarpGrids(
+      this.model.deformers,
+      this.params,
+      deformerWorlds ?? /* @__PURE__ */ new Map()
+    ) : void 0;
+    gl.uniform1f(this.uAlphaCutoff, 0);
+    for (let index = 0; index < this.parts.length; index++) {
+      const maskIndices = this.partClipGroups.get(index);
+      if (maskIndices && this.stencilAvailable) {
+        this.drawClipped(
+          index,
+          maskIndices,
+          clipX,
+          clipY,
+          deformerWorlds,
+          warpGrids
+        );
+      } else {
+        this.drawPart(index, clipX, clipY, deformerWorlds, warpGrids);
+      }
+    }
+  }
+  /**
+   * Draw a clipped part: stencil the union of its masks' alpha coverage, then
+   * draw the part only where the stencil was written. The mask parts also draw
+   * normally in their own `order` slot — this is an EXTRA, color-free pass over
+   * the same per-frame deformed geometry. All stencil/colorMask state the pass
+   * touches is restored before returning so later parts are unaffected.
+   */
+  drawClipped(index, maskIndices, clipX, clipY, deformerWorlds, warpGrids) {
+    const { gl } = this;
+    gl.clear(gl.STENCIL_BUFFER_BIT);
+    gl.enable(gl.STENCIL_TEST);
+    gl.colorMask(false, false, false, false);
+    gl.stencilMask(255);
+    gl.stencilFunc(gl.ALWAYS, 1, 255);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
+    gl.uniform1f(this.uAlphaCutoff, MASK_ALPHA_CUTOFF);
+    for (const maskIndex of maskIndices) {
+      this.drawPart(maskIndex, clipX, clipY, deformerWorlds, warpGrids);
+    }
+    gl.uniform1f(this.uAlphaCutoff, 0);
+    gl.colorMask(true, true, true, true);
+    gl.stencilMask(0);
+    gl.stencilFunc(gl.EQUAL, 1, 255);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+    this.drawPart(index, clipX, clipY, deformerWorlds, warpGrids);
+    gl.disable(gl.STENCIL_TEST);
+    gl.stencilMask(255);
+    gl.stencilFunc(gl.ALWAYS, 0, 255);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+  }
+  /**
+   * Draw a single part with its full per-part material + geometry state. Shared
+   * by the normal pass, the stencil mask-write pass, and the masked consumer
+   * draw — so every path prepares the SAME complete uniform/texture/VBO state
+   * (the caller only sets stencil/colorMask/u_alphaCutoff around it).
+   */
+  drawPart(index, clipX, clipY, deformerWorlds, warpGrids) {
+    const { gl } = this;
+    const part = this.parts[index];
+    const texture = part.texture ? this.textures[part.texture.index] : void 0;
+    if (part.texture && !texture) return;
+    const t = this.evaluate(part);
+    const warpChild = this.partMeshes.get(index)?.warpDeformer;
+    let m;
+    if (warpChild) {
+      m = scale(clipX, clipY);
+    } else if (part.deformer !== void 0) {
+      const dWorld = deformerWorlds.get(part.deformer);
+      if (!dWorld) {
+        throw new Error(
+          `part "${part.id}" references unknown deformer "${part.deformer}"`
+        );
+      }
+      m = multiply(multiply(scale(clipX, clipY), dWorld), translate(t.x, t.y));
+      m = multiply(m, rotate(t.rotation));
+      m = multiply(m, scale(part.width * t.scaleX, part.height * t.scaleY));
+    } else {
+      m = multiply(scale(clipX, clipY), translate(t.x, t.y));
+      m = multiply(m, rotate(t.rotation));
+      m = multiply(m, scale(part.width * t.scaleX, part.height * t.scaleY));
+    }
+    const [r, g, b, a] = part.color;
+    gl.uniformMatrix3fv(this.uMatrix, false, toMat3(m));
+    gl.uniform4f(this.uColor, r, g, b, a * t.opacity);
+    if (part.texture && texture) {
+      const { uv } = part.texture;
+      gl.uniform1i(this.uUseTexture, 1);
+      gl.activeTexture(gl.TEXTURE0);
+      gl.bindTexture(gl.TEXTURE_2D, texture);
+      gl.uniform1i(this.uTex, 0);
+      gl.uniform2f(this.uUvOffset, uv.x, uv.y);
+      gl.uniform2f(this.uUvScale, uv.width, uv.height);
+    } else {
+      gl.uniform1i(this.uUseTexture, 0);
+    }
+    if (part.mesh) {
+      const pm = this.partMeshes.get(index);
+      if (!pm) {
+        throw new Error(`Iki: mesh buffers missing for part "${part.id}"`);
+      }
+      gl.uniform1i(this.uUseMeshUv, 1);
+      if (pm.warpDeformer) {
+        const warpDef = pm.warpDeformer;
+        const grid = warpGrids.get(warpDef.id);
+        applyWarps(pm.rest, pm.warps, this.params, pm.local);
+        const trs = evaluateTransform(
+          part.transform,
+          part.bindings,
+          this.params
+        );
+        const partAffine = multiply(
+          multiply(translate(trs.x, trs.y), rotate(trs.rotation)),
+          scale(part.width * trs.scaleX, part.height * trs.scaleY)
+        );
+        applyWarpToChild(
+          pm.local,
+          partAffine,
+          warpDef.grid,
+          grid,
+          pm.scratch
+        );
+        gl.bindBuffer(gl.ARRAY_BUFFER, pm.position);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, pm.scratch);
+      } else if (pm.warps && pm.warps.length > 0) {
+        applyWarps(pm.rest, pm.warps, this.params, pm.scratch);
+        gl.bindBuffer(gl.ARRAY_BUFFER, pm.position);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, pm.scratch);
+      }
+      gl.bindBuffer(gl.ARRAY_BUFFER, pm.position);
+      gl.enableVertexAttribArray(this.aPos);
+      gl.vertexAttribPointer(this.aPos, 2, gl.FLOAT, false, 0, 0);
+      gl.bindBuffer(gl.ARRAY_BUFFER, pm.uv);
+      gl.enableVertexAttribArray(this.aUv);
+      gl.vertexAttribPointer(this.aUv, 2, gl.FLOAT, false, 0, 0);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, pm.index);
+      gl.drawElements(gl.TRIANGLES, pm.indexCount, gl.UNSIGNED_SHORT, 0);
+    } else {
+      gl.uniform1i(this.uUseMeshUv, 0);
+      gl.disableVertexAttribArray(this.aUv);
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.quad);
+      gl.enableVertexAttribArray(this.aPos);
+      gl.vertexAttribPointer(this.aPos, 2, gl.FLOAT, false, 0, 0);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    }
+  }
+  /** Resolve a part's effective transform from its base plus active bindings. */
+  evaluate(part) {
+    return evaluateTransform(part.transform, part.bindings, this.params);
+  }
+};
+var VERTEX_SHADER = `#version 300 es
+in vec2 a_pos;
+in vec2 a_uv;
+uniform mat3 u_matrix;
+uniform vec2 u_uvOffset;
+uniform vec2 u_uvScale;
+uniform bool u_useMeshUv;
+out vec2 v_uv;
+void main() {
+  if (u_useMeshUv) {
+    // Mesh path: UVs are already top-left atlas-space; pass straight through,
+    // no flip (the only flip in the pipeline lives in the quad branch below).
+    v_uv = a_uv;
+  } else {
+    // Quad path: a_pos corners are +/-0.5; lift to 0..1 (y-up), then map into
+    // the atlas sub-rect with a single V flip so the result is top-left UVs.
+    vec2 uvLocal = a_pos + 0.5;
+    v_uv = vec2(
+      u_uvOffset.x + uvLocal.x * u_uvScale.x,
+      u_uvOffset.y + (1.0 - uvLocal.y) * u_uvScale.y
+    );
+  }
+  vec3 p = u_matrix * vec3(a_pos, 1.0);
+  gl_Position = vec4(p.xy, 0.0, 1.0);
+}`;
+var FRAGMENT_SHADER = `#version 300 es
+precision mediump float;
+uniform vec4 u_color;
+uniform bool u_useTexture;
+uniform sampler2D u_tex;
+uniform float u_alphaCutoff;
+in vec2 v_uv;
+out vec4 outColor;
+void main() {
+  vec4 base = u_useTexture ? texture(u_tex, v_uv) : vec4(1.0);
+  vec4 tinted = base * u_color;
+  // 0 for normal draws (no-op); raised during the stencil mask-write pass so
+  // only opaque mask coverage marks the stencil (the transparent fringe is cut).
+  if (tinted.a < u_alphaCutoff) discard;
+  // Premultiply: the blend function and the canvas compositing contract
+  // (premultipliedAlpha: true) both expect rgb already scaled by alpha.
+  outColor = vec4(tinted.rgb * tinted.a, tinted.a);
+}`;
+async function decodeTexture(source) {
+  if (!source.startsWith("data:")) {
+    console.warn(
+      "Iki: external texture sources are unsupported in v1; skipping",
+      source.slice(0, 32)
+    );
+    return null;
+  }
+  const blob = await (await fetch(source)).blob();
+  return createImageBitmap(blob, {
+    imageOrientation: "none",
+    premultiplyAlpha: "none"
+  });
+}
+function createUnitQuad(gl) {
+  const buffer = gl.createBuffer();
+  if (!buffer) throw new Error("failed to allocate quad buffer");
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.bufferData(
+    gl.ARRAY_BUFFER,
+    new Float32Array([-0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5]),
+    gl.STATIC_DRAW
+  );
+  return buffer;
+}
+function drainGlErrors(gl) {
+  for (let i = 0; i < 32 && gl.getError() !== gl.NO_ERROR; i++) {
+  }
+}
+function deletePartMeshBuffers(gl, meshes) {
+  for (const pm of meshes.values()) {
+    gl.deleteBuffer(pm.position);
+    gl.deleteBuffer(pm.uv);
+    gl.deleteBuffer(pm.index);
+  }
+}
+function deleteUploadedTextures(gl, textures) {
+  for (const texture of textures) {
+    if (texture) gl.deleteTexture(texture);
+  }
+}
+function createProgram(gl, vertexSrc, fragmentSrc) {
+  const program = gl.createProgram();
+  if (!program) throw new Error("failed to allocate WebGL program");
+  gl.attachShader(program, compileShader(gl, gl.VERTEX_SHADER, vertexSrc));
+  gl.attachShader(program, compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc));
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`program link failed: ${log}`);
+  }
+  return program;
+}
+function compileShader(gl, type, source) {
+  const shader = gl.createShader(type);
+  if (!shader) throw new Error("failed to allocate shader");
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`shader compile failed: ${log}`);
+  }
+  return shader;
+}
+function getUniform(gl, program, name) {
+  const loc = gl.getUniformLocation(program, name);
+  if (!loc) throw new Error(`uniform not found: ${name}`);
+  return loc;
+}
+
+// src/idle-motion.ts
+var import_format = require("@ikijs/format");
+
+// src/frame-clock.ts
+var MAX_DT_MS = 100;
+var FIXED_DT_S = 1 / 60;
+var MAX_SUBSTEPS = 6;
+var FixedStepClock = class {
+  prevNowMs = void 0;
+  accumulatorS = 0;
+  /**
+   * True until the first {@link advance}. Drivers seed their rest pose on that
+   * frame and integrate nothing, so a model loaded mid-motion does not kick.
+   */
+  get isSeedFrame() {
+    return this.prevNowMs === void 0;
+  }
+  /**
+   * Fold `nowMs` into the accumulator and return how many {@link FIXED_DT_S}
+   * sub-steps to run this frame. On the seed frame it only records the
+   * timestamp and returns 0. A non-monotonic `nowMs` floors to 0 — no rewind.
+   */
+  advance(nowMs) {
+    if (!Number.isFinite(nowMs)) return 0;
+    if (this.prevNowMs === void 0) {
+      this.prevNowMs = nowMs;
+      return 0;
+    }
+    const dtMs = clamp(nowMs - this.prevNowMs, 0, MAX_DT_MS);
+    this.prevNowMs = nowMs;
+    this.accumulatorS += dtMs / 1e3;
+    let steps = 0;
+    while (this.accumulatorS >= FIXED_DT_S && steps < MAX_SUBSTEPS) {
+      this.accumulatorS -= FIXED_DT_S;
+      steps++;
+    }
+    return steps;
+  }
+};
+
+// src/idle-motion.ts
+var BLINK_INTERVAL_MIN_MS = 1500;
+var BLINK_INTERVAL_MAX_MS = 6e3;
+var BLINK_DURATION_MS = 120;
+var BREATH_PERIOD_MS = 3500;
+var GAZE_RADIUS = 0.3;
+var GAZE_RETARGET_MIN_MS = 1200;
+var GAZE_RETARGET_MAX_MS = 3e3;
+var GAZE_EASE_RATE = 1e-3;
+var SWAY_X_AMP_A_DEG = 2.2;
+var SWAY_X_PERIOD_A_MS = 6100;
+var SWAY_X_AMP_B_DEG = 1.3;
+var SWAY_X_PERIOD_B_MS = 9700;
+var SWAY_Y_AMP_DEG = 1.6;
+var SWAY_Y_PERIOD_MS = 7300;
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function blinkEnvelope(phase) {
+  return 2 * Math.abs(phase - 0.5);
+}
+function randomInDisk(rng, radius) {
+  const r = Math.sqrt(rng()) * radius;
+  const theta = rng() * 2 * Math.PI;
+  return [r * Math.cos(theta), r * Math.sin(theta)];
+}
+var IdleMotion = class {
+  sink;
+  rng;
+  // Internal clock: advances by clamped dt, NOT by raw wall-clock jumps.
+  // This is the only clock blink/breath/gaze scheduling reads.
+  clockMs = 0;
+  prevNowMs = void 0;
+  // Blink state
+  nextBlinkAtMs;
+  blinkStartMs = -1;
+  // -1 means not currently blinking
+  // Gaze state
+  gazeCurrentX = 0;
+  gazeCurrentY = 0;
+  gazeTargetX = 0;
+  gazeTargetY = 0;
+  nextGazeRetargetMs;
+  constructor(sink, options) {
+    this.sink = sink;
+    this.rng = options?.rng ?? Math.random;
+    this.nextBlinkAtMs = lerp(
+      BLINK_INTERVAL_MIN_MS,
+      BLINK_INTERVAL_MAX_MS,
+      this.rng()
+    );
+    this.nextGazeRetargetMs = lerp(
+      GAZE_RETARGET_MIN_MS,
+      GAZE_RETARGET_MAX_MS,
+      this.rng()
+    );
+  }
+  /**
+   * Advance the idle animation to the given wall-clock timestamp (milliseconds).
+   *
+   * On the first call: record prevNowMs, emit the resting pose, and return —
+   * no animation advance happens so there is no jump from time 0.
+   *
+   * On subsequent calls: compute dt = clamp(nowMs - prevNowMs, 0, MAX_DT_MS)
+   * and advance the internal clock by dt. A non-monotonic nowMs produces a
+   * negative raw delta that the clamp floors to 0 — no rewind.
+   */
+  update(nowMs) {
+    if (!Number.isFinite(nowMs)) return;
+    if (this.prevNowMs === void 0) {
+      this.prevNowMs = nowMs;
+      this.emitRestingPose();
+      return;
+    }
+    const rawDt = nowMs - this.prevNowMs;
+    const dt = clamp(rawDt, 0, MAX_DT_MS);
+    this.prevNowMs = nowMs;
+    this.clockMs += dt;
+    const eyeVal = this.advanceBlink();
+    this.sink(import_format.StandardParameter.EyeOpenLeft, eyeVal);
+    this.sink(import_format.StandardParameter.EyeOpenRight, eyeVal);
+    const breath = this.advanceBreath();
+    this.advanceGaze(dt);
+    this.sink(import_format.StandardParameter.Breath, breath);
+    this.sink(import_format.StandardParameter.EyeballX, this.gazeCurrentX);
+    this.sink(import_format.StandardParameter.EyeballY, this.gazeCurrentY);
+    this.sink(import_format.StandardParameter.AngleX, this.swayX());
+    this.sink(import_format.StandardParameter.AngleY, this.swayY());
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  emitRestingPose() {
+    this.sink(import_format.StandardParameter.EyeOpenLeft, 1);
+    this.sink(import_format.StandardParameter.EyeOpenRight, 1);
+    this.sink(import_format.StandardParameter.Breath, 0.5);
+    this.sink(import_format.StandardParameter.EyeballX, 0);
+    this.sink(import_format.StandardParameter.EyeballY, 0);
+    this.sink(import_format.StandardParameter.AngleX, 0);
+    this.sink(import_format.StandardParameter.AngleY, 0);
+  }
+  /** Returns the current eye-open value (0..1) and advances blink state. */
+  advanceBlink() {
+    const { clockMs } = this;
+    if (this.blinkStartMs >= 0) {
+      const phase = (clockMs - this.blinkStartMs) / BLINK_DURATION_MS;
+      if (phase >= 1) {
+        this.blinkStartMs = -1;
+        this.nextBlinkAtMs = clockMs + lerp(BLINK_INTERVAL_MIN_MS, BLINK_INTERVAL_MAX_MS, this.rng());
+        return 1;
+      }
+      return blinkEnvelope(phase);
+    }
+    if (clockMs >= this.nextBlinkAtMs) {
+      this.blinkStartMs = clockMs;
+      return blinkEnvelope(0);
+    }
+    return 1;
+  }
+  advanceBreath() {
+    return 0.5 + 0.5 * Math.sin(2 * Math.PI * this.clockMs / BREATH_PERIOD_MS);
+  }
+  /** Horizontal head sway in degrees, pure function of the internal clock. */
+  swayX() {
+    const t = 2 * Math.PI * this.clockMs;
+    return SWAY_X_AMP_A_DEG * Math.sin(t / SWAY_X_PERIOD_A_MS) + SWAY_X_AMP_B_DEG * Math.sin(t / SWAY_X_PERIOD_B_MS);
+  }
+  /** Vertical head sway in degrees, pure function of the internal clock. */
+  swayY() {
+    return SWAY_Y_AMP_DEG * Math.sin(2 * Math.PI * this.clockMs / SWAY_Y_PERIOD_MS);
+  }
+  /** Ease gaze current toward target; pick a new target on the internal clock. */
+  advanceGaze(dt) {
+    if (this.clockMs >= this.nextGazeRetargetMs) {
+      const [tx, ty] = randomInDisk(this.rng, GAZE_RADIUS);
+      this.gazeTargetX = tx;
+      this.gazeTargetY = ty;
+      this.nextGazeRetargetMs = this.clockMs + lerp(GAZE_RETARGET_MIN_MS, GAZE_RETARGET_MAX_MS, this.rng());
+    }
+    const factor = 1 - Math.pow(1 - GAZE_EASE_RATE, dt);
+    this.gazeCurrentX = lerp(this.gazeCurrentX, this.gazeTargetX, factor);
+    this.gazeCurrentY = lerp(this.gazeCurrentY, this.gazeTargetY, factor);
+  }
+};
+
+// src/physics-motion.ts
+function signedNormalized(value, param) {
+  const rest = clamp(param.default, param.min, param.max);
+  const den = Math.max(Math.abs(param.max - rest), Math.abs(rest - param.min));
+  if (den === 0) return 0;
+  return clamp((value - rest) / den, -1, 1);
+}
+var PhysicsMotion = class {
+  rigs;
+  read;
+  sink;
+  params;
+  // Integrator state, owned here — never stored in a ParameterStore.
+  state;
+  clock = new FixedStepClock();
+  constructor(rigs, params, read, sink) {
+    this.rigs = rigs;
+    this.read = read;
+    this.sink = sink;
+    this.params = new Map(params.map((p) => [p.id, p]));
+    this.state = rigs.map(() => ({ x: 0, v: 0 }));
+  }
+  /**
+   * Advance every rig to the given wall-clock timestamp (milliseconds).
+   *
+   * First call: seed each spring to rest AT its current target (so a model
+   * loaded with a nonzero input does not kick), emit the resting output, and
+   * return without integrating — mirroring IdleMotion's first-frame behavior.
+   *
+   * Subsequent calls: {@link FixedStepClock} folds the clamped frame delta into
+   * its accumulator and returns how many {@link FIXED_DT_S} sub-steps are due;
+   * the spring advances that many semi-implicit Euler steps, then each rig emits
+   * its output once. The clock's dt clamp and sub-step cap plus the symplectic
+   * integrator are what keep it stable across hitches.
+   */
+  update(nowMs) {
+    if (this.clock.isSeedFrame) {
+      this.clock.advance(nowMs);
+      for (let i = 0; i < this.rigs.length; i++) {
+        const st = this.state[i];
+        st.x = this.targetFor(this.rigs[i]);
+        st.v = 0;
+        this.emit(this.rigs[i], st);
+      }
+      return;
+    }
+    const steps = this.clock.advance(nowMs);
+    const targets = this.rigs.map((rig) => this.targetFor(rig));
+    for (let s = 0; s < steps; s++) {
+      for (let i = 0; i < this.rigs.length; i++) {
+        this.step(this.rigs[i], this.state[i], targets[i]);
+      }
+    }
+    for (let i = 0; i < this.rigs.length; i++) {
+      const st = this.state[i];
+      if (!Number.isFinite(st.x) || !Number.isFinite(st.v)) {
+        st.x = Number.isFinite(targets[i]) ? targets[i] : 0;
+        st.v = 0;
+      }
+      this.emit(this.rigs[i], st);
+    }
+  }
+  /** Spring target = signed-normalized input value × weight. */
+  targetFor(rig) {
+    const param = this.params.get(rig.input.parameter);
+    const value = this.read(rig.input.parameter);
+    const norm = param ? signedNormalized(value, param) : 0;
+    return norm * rig.input.weight;
+  }
+  /** One semi-implicit (symplectic) Euler sub-step of FIXED_DT_S seconds. */
+  step(rig, st, target) {
+    const accel = (rig.stiffness * (target - st.x) - rig.damping * st.v) / rig.mass;
+    st.v += accel * FIXED_DT_S;
+    st.x += st.v * FIXED_DT_S;
+  }
+  /** Write outputDefault + x * scale onto the output param via the sink. */
+  emit(rig, st) {
+    const outParam = this.params.get(rig.output.parameter);
+    const outDefault = outParam ? clamp(outParam.default, outParam.min, outParam.max) : 0;
+    const value = outDefault + st.x * rig.output.scale;
+    this.sink(
+      rig.output.parameter,
+      Number.isFinite(value) ? value : outDefault
+    );
+  }
+};
+
+// src/hair-chain-motion.ts
+var DEG2RAD = Math.PI / 180;
+var RAD2DEG = 180 / Math.PI;
+var HairChainMotion = class {
+  chainData;
+  params;
+  deformers;
+  store;
+  read;
+  sink;
+  clock = new FixedStepClock();
+  constructor(chains, params, deformers, read, sink) {
+    this.params = new Map(params.map((p) => [p.id, p]));
+    this.deformers = deformers;
+    this.store = new ParameterStore(params);
+    this.read = read;
+    this.sink = sink;
+    this.chainData = chains.map((chain) => ({
+      chain,
+      restAnglesRad: chain.segments.map(
+        (seg) => seg.restAngle !== void 0 ? seg.restAngle * DEG2RAD : 0
+      ),
+      state: chain.segments.map(() => ({ angle: 0, angularVelocity: 0 }))
+    }));
+  }
+  /**
+   * Advance every chain to the given wall-clock timestamp (milliseconds).
+   *
+   * First call: seed every segment to θ=0/ω=0 (rest), emit the rest output
+   * (outDefault + 0), and return without integrating — mirrors PhysicsMotion's
+   * first-frame behavior so a model loaded in motion does not kick.
+   *
+   * Subsequent calls: dt = clamp(nowMs - prevNowMs, 0, MAX_DT_MS) → seconds into
+   * accumulator. The per-frame world snapshot (anchor world angles) is taken ONCE
+   * per update() — NOT per chain — so all chains share a consistent frame snapshot.
+   * Fixed FIXED_DT_S sub-steps are run root→tip, capped at MAX_SUBSTEPS; leftover
+   * time is carried to the next frame. Segments emit after substeps (even on zero
+   * substeps) with a non-finite guard.
+   */
+  update(nowMs) {
+    if (this.clock.isSeedFrame) {
+      this.clock.advance(nowMs);
+      for (const cd of this.chainData) {
+        for (let i = 0; i < cd.chain.segments.length; i++) {
+          cd.state[i].angle = 0;
+          cd.state[i].angularVelocity = 0;
+          this.emitSegment(cd.chain.segments[i], cd.state[i]);
+        }
+      }
+      return;
+    }
+    const steps = this.clock.advance(nowMs);
+    for (const param of this.params.values()) {
+      this.store.set(param.id, this.read(param.id));
+    }
+    const worldMap = resolveDeformerWorlds(this.deformers, this.store);
+    const anchorAnglesRad = this.chainData.map(
+      (cd) => this.anchorWorldAngleRad(worldMap, cd.chain.anchorDeformer)
+    );
+    for (let s = 0; s < steps; s++) {
+      for (let c = 0; c < this.chainData.length; c++) {
+        this.stepChain(this.chainData[c], anchorAnglesRad[c]);
+      }
+    }
+    for (const cd of this.chainData) {
+      for (let i = 0; i < cd.chain.segments.length; i++) {
+        const st = cd.state[i];
+        if (!Number.isFinite(st.angle) || !Number.isFinite(st.angularVelocity)) {
+          st.angle = 0;
+          st.angularVelocity = 0;
+        }
+        this.emitSegment(cd.chain.segments[i], st);
+      }
+    }
+  }
+  /**
+   * Extract world rotation (radians) from the anchor's Affine tuple.
+   * Affine = [a,b,c,d,e,f]; rotation column = (a,b) → atan2(b,a).
+   *
+   * If the anchor id is absent from the map, THROWS an internal Error — the
+   * format validator guarantees the anchor exists, so absence is an invariant
+   * break (mirrors resolveDeformerWorlds' throw on an unresolved parent,
+   * deform.ts:141).
+   */
+  anchorWorldAngleRad(worldMap, anchorId) {
+    const world = worldMap.get(anchorId);
+    if (!world) {
+      throw new Error(
+        `HairChainMotion: anchor deformer "${anchorId}" not found in resolved world map \u2014 model not validated?`
+      );
+    }
+    return Math.atan2(world[1], world[0]);
+  }
+  /**
+   * One fixed sub-step of FIXED_DT_S seconds for all segments in a chain.
+   *
+   * Segments are integrated ROOT→TIP so each segment can read its upstream
+   * neighbor's current-substep state when computing the world angle Φ_i.
+   * (The chain is causal root-to-tip; reversing the order would use stale θ
+   * values from the previous substep for Φ_i computation.)
+   *
+   * Per-segment semi-implicit (symplectic) Euler:
+   *   Φ_i = anchorWorldAngleRad + Σ_{j≤i}(restAngle_j + θ_j)
+   *   α_i = (−stiffness_i·θ_i − strength·sin(Φ_i − gravityAngle_rad) − damping_i·ω_i) / mass_i
+   *   ω_i += α_i · FIXED_DT_S   (velocity updated FIRST = semi-implicit)
+   *   θ_i += ω_i · FIXED_DT_S   (position updated from NEW velocity)
+   *
+   * The spring term is −stiffness·θ (restoring θ→0); restAngle does NOT appear
+   * in the spring term, only in Φ_i for the gravity torque.
+   */
+  stepChain(cd, anchorAngleRad) {
+    const { chain, restAnglesRad, state } = cd;
+    const gravityAngleRad = chain.gravity.angle * DEG2RAD;
+    const strength = chain.gravity.strength;
+    let worldAngleAccumRad = anchorAngleRad;
+    for (let i = 0; i < chain.segments.length; i++) {
+      const seg = chain.segments[i];
+      const st = state[i];
+      worldAngleAccumRad += restAnglesRad[i] + st.angle;
+      const phi = worldAngleAccumRad;
+      const alpha = (-seg.stiffness * st.angle - strength * Math.sin(phi - gravityAngleRad) - seg.damping * st.angularVelocity) / seg.mass;
+      st.angularVelocity += alpha * FIXED_DT_S;
+      st.angle += st.angularVelocity * FIXED_DT_S;
+    }
+  }
+  /** Emit outDefault + (θ_i · RAD2DEG) · scale for one segment. */
+  emitSegment(seg, st) {
+    const outParam = this.params.get(seg.output.parameter);
+    const outDefault = outParam ? clamp(outParam.default, outParam.min, outParam.max) : 0;
+    const value = outDefault + st.angle * RAD2DEG * seg.output.scale;
+    this.sink(
+      seg.output.parameter,
+      Number.isFinite(value) ? value : outDefault
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HairChainMotion,
+  IdleMotion,
+  IkiPlayer,
+  ParameterStore,
+  PhysicsMotion,
+  multiply,
+  rotate,
+  scale,
+  toMat3,
+  translate
+});
+//# sourceMappingURL=index.js.map