@nice2dev/ui-graphics 1.3.14 → 1.3.16

package/dist/cjs/animation/physics.js

@@ -1,295 +1,268 @@
-'use strict';
-
-var rigMath = require('./rig/rigMath.js');
-var rigTypes = require('./rig/rigTypes.js');
-
-/**
- * physics.ts — 2D physics simulation for animation (ragdoll, cloth).
- *
- * Verlet integration with constraints for realistic body/cloth simulation.
- */
-// ── Constants ───────────────────────────────────────────────────
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const rigMath = require("./rig/rigMath.js");
+const rigTypes = require("./rig/rigTypes.js");
 const DEFAULT_PHYSICS = {
-    gravity: { x: 0, y: 980 },
-    damping: 0.99,
-    iterations: 4,
-    timestep: 1 / 60,
+  gravity: { x: 0, y: 980 },
+  damping: 0.99,
+  iterations: 4,
+  timestep: 1 / 60
 };
-// ── Verlet Engine ───────────────────────────────────────────────
 function createParticle(x, y, mass = 1, pinned = false) {
-    const p = { pos: { x, y }, prev: { x, y }, acc: { x: 0, y: 0 }, mass, pinned };
-    Object.defineProperty(p, 'x', {
-        get() {
-            return this.pos.x;
-        },
-        set(v) {
-            this.pos.x = v;
-        },
-        enumerable: false,
-        configurable: true,
-    });
-    Object.defineProperty(p, 'y', {
-        get() {
-            return this.pos.y;
-        },
-        set(v) {
-            this.pos.y = v;
-        },
-        enumerable: false,
-        configurable: true,
-    });
-    return p;
+  const p = { pos: { x, y }, prev: { x, y }, acc: { x: 0, y: 0 }, mass, pinned };
+  Object.defineProperty(p, "x", {
+    get() {
+      return this.pos.x;
+    },
+    set(v) {
+      this.pos.x = v;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(p, "y", {
+    get() {
+      return this.pos.y;
+    },
+    set(v) {
+      this.pos.y = v;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return p;
 }
 function stepParticles(particles, config) {
-    const dt2 = config.timestep * config.timestep;
-    for (const p of particles) {
-        if (p.pinned) {
-            continue;
-        }
-        const vx = (p.pos.x - p.prev.x) * config.damping;
-        const vy = (p.pos.y - p.prev.y) * config.damping;
-        p.prev.x = p.pos.x;
-        p.prev.y = p.pos.y;
-        p.pos.x += vx + (config.gravity.x + p.acc.x) * dt2;
-        p.pos.y += vy + (config.gravity.y + p.acc.y) * dt2;
-        p.acc.x = 0;
-        p.acc.y = 0;
+  const dt2 = config.timestep * config.timestep;
+  for (const p of particles) {
+    if (p.pinned) {
+      continue;
     }
+    const vx = (p.pos.x - p.prev.x) * config.damping;
+    const vy = (p.pos.y - p.prev.y) * config.damping;
+    p.prev.x = p.pos.x;
+    p.prev.y = p.pos.y;
+    p.pos.x += vx + (config.gravity.x + p.acc.x) * dt2;
+    p.pos.y += vy + (config.gravity.y + p.acc.y) * dt2;
+    p.acc.x = 0;
+    p.acc.y = 0;
+  }
 }
 function solveConstraints(particles, constraints, iterations) {
-    for (let i = 0; i < iterations; i++) {
-        for (const c of constraints) {
-            const a = particles[c.a];
-            const b = particles[c.b];
-            const dx = b.pos.x - a.pos.x;
-            const dy = b.pos.y - a.pos.y;
-            const dist = Math.hypot(dx, dy) || 0.001;
-            const diff = ((c.restLength - dist) / dist) * c.stiffness;
-            const ox = dx * diff * 0.5;
-            const oy = dy * diff * 0.5;
-            if (!a.pinned) {
-                a.pos.x -= ox;
-                a.pos.y -= oy;
-            }
-            if (!b.pinned) {
-                b.pos.x += ox;
-                b.pos.y += oy;
-            }
-        }
+  for (let i = 0; i < iterations; i++) {
+    for (const c of constraints) {
+      const a = particles[c.a];
+      const b = particles[c.b];
+      const dx = b.pos.x - a.pos.x;
+      const dy = b.pos.y - a.pos.y;
+      const dist = Math.hypot(dx, dy) || 1e-3;
+      const diff = (c.restLength - dist) / dist * c.stiffness;
+      const ox = dx * diff * 0.5;
+      const oy = dy * diff * 0.5;
+      if (!a.pinned) {
+        a.pos.x -= ox;
+        a.pos.y -= oy;
+      }
+      if (!b.pinned) {
+        b.pos.x += ox;
+        b.pos.y += oy;
+      }
     }
+  }
 }
-// ── Ragdoll ─────────────────────────────────────────────────────
 const RAGDOLL_BONES = [
-    { name: 'pelvis', length: 0 },
-    { name: 'spineLower', parent: 'pelvis', length: 0.1 },
-    { name: 'spineUpper', parent: 'spineLower', length: 0.1 },
-    { name: 'neck', parent: 'spineUpper', length: 0.05 },
-    { name: 'head', parent: 'neck', length: 0.08 },
-    { name: 'lShoulder', parent: 'spineUpper', length: 0.06 },
-    { name: 'lUpperArm', parent: 'lShoulder', length: 0.12 },
-    { name: 'lForearm', parent: 'lUpperArm', length: 0.1 },
-    { name: 'lHand', parent: 'lForearm', length: 0.05 },
-    { name: 'rShoulder', parent: 'spineUpper', length: 0.06 },
-    { name: 'rUpperArm', parent: 'rShoulder', length: 0.12 },
-    { name: 'rForearm', parent: 'rUpperArm', length: 0.1 },
-    { name: 'rHand', parent: 'rForearm', length: 0.05 },
-    { name: 'lThigh', parent: 'pelvis', length: 0.15 },
-    { name: 'lShin', parent: 'lThigh', length: 0.14 },
-    { name: 'lFoot', parent: 'lShin', length: 0.05 },
-    { name: 'rThigh', parent: 'pelvis', length: 0.15 },
-    { name: 'rShin', parent: 'rThigh', length: 0.14 },
-    { name: 'rFoot', parent: 'rShin', length: 0.05 },
+  { name: "pelvis", length: 0 },
+  { name: "spineLower", parent: "pelvis", length: 0.1 },
+  { name: "spineUpper", parent: "spineLower", length: 0.1 },
+  { name: "neck", parent: "spineUpper", length: 0.05 },
+  { name: "head", parent: "neck", length: 0.08 },
+  { name: "lShoulder", parent: "spineUpper", length: 0.06 },
+  { name: "lUpperArm", parent: "lShoulder", length: 0.12 },
+  { name: "lForearm", parent: "lUpperArm", length: 0.1 },
+  { name: "lHand", parent: "lForearm", length: 0.05 },
+  { name: "rShoulder", parent: "spineUpper", length: 0.06 },
+  { name: "rUpperArm", parent: "rShoulder", length: 0.12 },
+  { name: "rForearm", parent: "rUpperArm", length: 0.1 },
+  { name: "rHand", parent: "rForearm", length: 0.05 },
+  { name: "lThigh", parent: "pelvis", length: 0.15 },
+  { name: "lShin", parent: "lThigh", length: 0.14 },
+  { name: "lFoot", parent: "lShin", length: 0.05 },
+  { name: "rThigh", parent: "pelvis", length: 0.15 },
+  { name: "rShin", parent: "rThigh", length: 0.14 },
+  { name: "rFoot", parent: "rShin", length: 0.05 }
 ];
-/** Create a ragdoll simulation from a rig pose. */
 function createRagdoll(cfg = {}) {
-    var _a, _b, _c;
-    const size = (_a = cfg.size) !== null && _a !== void 0 ? _a : 200;
-    const offsetX = (_b = cfg.x) !== null && _b !== void 0 ? _b : 0;
-    const offsetY = (_c = cfg.y) !== null && _c !== void 0 ? _c : 0;
-    const particles = [];
-    const constraints = [];
-    const boneMap = {};
-    // Create particles for each bone joint
-    const fk = rigMath.solveFK(rigTypes.DEFAULT_RIG, rigTypes.DEFAULT_POSE, size);
-    for (const bone of RAGDOLL_BONES) {
-        const solved = fk[bone.name];
-        const x = (solved ? solved.x : size / 2) + offsetX;
-        const y = (solved ? solved.y : size / 2) + offsetY;
-        boneMap[bone.name] = particles.length;
-        particles.push(createParticle(x, y));
+  const size = cfg.size ?? 200;
+  const offsetX = cfg.x ?? 0;
+  const offsetY = cfg.y ?? 0;
+  const particles = [];
+  const constraints = [];
+  const boneMap = {};
+  const fk = rigMath.solveFK(rigTypes.DEFAULT_RIG, rigTypes.DEFAULT_POSE, size);
+  for (const bone of RAGDOLL_BONES) {
+    const solved = fk[bone.name];
+    const x = (solved ? solved.x : size / 2) + offsetX;
+    const y = (solved ? solved.y : size / 2) + offsetY;
+    boneMap[bone.name] = particles.length;
+    particles.push(createParticle(x, y));
+  }
+  for (const bone of RAGDOLL_BONES) {
+    if (!bone.parent) {
+      continue;
     }
-    // Create distance constraints along bone chain
-    for (const bone of RAGDOLL_BONES) {
-        if (!bone.parent) {
-            continue;
-        }
-        const ai = boneMap[bone.parent];
-        const bi = boneMap[bone.name];
-        const restLen = bone.length * size;
-        constraints.push({ a: ai, b: bi, restLength: restLen, stiffness: 0.8 });
-    }
-    return { particles, constraints, boneMap };
+    const ai = boneMap[bone.parent];
+    const bi = boneMap[bone.name];
+    const restLen = bone.length * size;
+    constraints.push({ a: ai, b: bi, restLength: restLen, stiffness: 0.8 });
+  }
+  return { particles, constraints, boneMap };
 }
-/** Step the ragdoll simulation forward by one frame. Returns the same sim for chaining. */
 function stepRagdoll(sim, configOrDt = {}, gravity) {
-    const cfg = { ...DEFAULT_PHYSICS };
-    if (typeof configOrDt === 'number') {
-        cfg.timestep = configOrDt;
-        if (typeof gravity === 'number') {
-            cfg.gravity = { x: 0, y: gravity };
-        }
-        else if (gravity) {
-            cfg.gravity = gravity;
-        }
-    }
-    else {
-        Object.assign(cfg, configOrDt);
+  const cfg = { ...DEFAULT_PHYSICS };
+  if (typeof configOrDt === "number") {
+    cfg.timestep = configOrDt;
+    if (typeof gravity === "number") {
+      cfg.gravity = { x: 0, y: gravity };
+    } else if (gravity) {
+      cfg.gravity = gravity;
     }
-    stepParticles(sim.particles, cfg);
-    solveConstraints(sim.particles, sim.constraints, cfg.iterations);
-    return sim;
+  } else {
+    Object.assign(cfg, configOrDt);
+  }
+  stepParticles(sim.particles, cfg);
+  solveConstraints(sim.particles, sim.constraints, cfg.iterations);
+  return sim;
 }
-/** Extract a RigPose from the current ragdoll particle positions. */
 function ragdollToPose(sim) {
-    const pose = {};
-    for (const bone of RAGDOLL_BONES) {
-        if (!bone.parent) {
-            continue;
-        }
-        const ai = sim.boneMap[bone.parent];
-        const bi = sim.boneMap[bone.name];
-        const a = sim.particles[ai];
-        const b = sim.particles[bi];
-        const angle = (Math.atan2(b.pos.y - a.pos.y, b.pos.x - a.pos.x) * 180) / Math.PI;
-        pose[bone.name] = angle;
+  const pose = {};
+  for (const bone of RAGDOLL_BONES) {
+    if (!bone.parent) {
+      continue;
     }
-    return pose;
+    const ai = sim.boneMap[bone.parent];
+    const bi = sim.boneMap[bone.name];
+    const a = sim.particles[ai];
+    const b = sim.particles[bi];
+    const angle = Math.atan2(b.pos.y - a.pos.y, b.pos.x - a.pos.x) * 180 / Math.PI;
+    pose[bone.name] = angle;
+  }
+  return pose;
 }
-/** Apply a force impulse to a ragdoll particle. Returns the same sim for chaining. */
 function applyImpulse(sim, boneName, force) {
-    const idx = sim.boneMap[boneName];
-    if (idx === undefined) {
-        return sim;
-    }
-    const p = sim.particles[idx];
-    p.acc.x += force.x / p.mass;
-    p.acc.y += force.y / p.mass;
+  const idx = sim.boneMap[boneName];
+  if (idx === void 0) {
     return sim;
+  }
+  const p = sim.particles[idx];
+  p.acc.x += force.x / p.mass;
+  p.acc.y += force.y / p.mass;
+  return sim;
 }
 function createCloth(cfgOrCols, rowsArg, spacingArg, origin) {
-    let cfg;
-    let originX = 0;
-    let originY = 0;
-    if (typeof cfgOrCols === 'number') {
-        const cols = cfgOrCols;
-        const rows = rowsArg !== null && rowsArg !== void 0 ? rowsArg : cols;
-        const spacing = spacingArg !== null && spacingArg !== void 0 ? spacingArg : 20;
-        cfg = { cols, rows, width: cols * spacing, height: rows * spacing };
-        if (origin) {
-            originX = origin.x;
-            originY = origin.y;
-        }
-    }
-    else {
-        cfg = cfgOrCols;
+  let cfg;
+  let originX = 0;
+  let originY = 0;
+  if (typeof cfgOrCols === "number") {
+    const cols2 = cfgOrCols;
+    const rows2 = rowsArg ?? cols2;
+    const spacing = spacingArg ?? 20;
+    cfg = { cols: cols2, rows: rows2, width: cols2 * spacing, height: rows2 * spacing };
+    if (origin) {
+      originX = origin.x;
+      originY = origin.y;
     }
-    const { width, height, cols, rows, pinTop = true, stiffness = 0.9 } = cfg;
-    const particles = [];
-    const constraints = [];
-    const spacingX = width / cols;
-    const spacingY = height / rows;
-    // Create particle grid
-    for (let r = 0; r <= rows; r++) {
-        for (let c = 0; c <= cols; c++) {
-            const x = c * spacingX + originX;
-            const y = r * spacingY + originY;
-            const pinned = pinTop && r === 0;
-            particles.push(createParticle(x, y, 1, pinned));
-        }
+  } else {
+    cfg = cfgOrCols;
+  }
+  const { width, height, cols, rows, pinTop = true, stiffness = 0.9 } = cfg;
+  const particles = [];
+  const constraints = [];
+  const spacingX = width / cols;
+  const spacingY = height / rows;
+  for (let r = 0; r <= rows; r++) {
+    for (let c = 0; c <= cols; c++) {
+      const x = c * spacingX + originX;
+      const y = r * spacingY + originY;
+      const pinned = pinTop && r === 0;
+      particles.push(createParticle(x, y, 1, pinned));
     }
-    const idx = (r, c) => r * (cols + 1) + c;
-    // Structural constraints (horizontal + vertical)
-    for (let r = 0; r <= rows; r++) {
-        for (let c = 0; c <= cols; c++) {
-            if (c < cols) {
-                constraints.push({ a: idx(r, c), b: idx(r, c + 1), restLength: spacingX, stiffness });
-            }
-            if (r < rows) {
-                constraints.push({ a: idx(r, c), b: idx(r + 1, c), restLength: spacingY, stiffness });
-            }
-        }
+  }
+  const idx = (r, c) => r * (cols + 1) + c;
+  for (let r = 0; r <= rows; r++) {
+    for (let c = 0; c <= cols; c++) {
+      if (c < cols) {
+        constraints.push({ a: idx(r, c), b: idx(r, c + 1), restLength: spacingX, stiffness });
+      }
+      if (r < rows) {
+        constraints.push({ a: idx(r, c), b: idx(r + 1, c), restLength: spacingY, stiffness });
+      }
     }
-    // Shear constraints (diagonals for stability)
-    const diagLen = Math.hypot(spacingX, spacingY);
-    for (let r = 0; r < rows; r++) {
-        for (let c = 0; c < cols; c++) {
-            constraints.push({
-                a: idx(r, c),
-                b: idx(r + 1, c + 1),
-                restLength: diagLen,
-                stiffness: stiffness * 0.5,
-            });
-            constraints.push({
-                a: idx(r, c + 1),
-                b: idx(r + 1, c),
-                restLength: diagLen,
-                stiffness: stiffness * 0.5,
-            });
-        }
+  }
+  const diagLen = Math.hypot(spacingX, spacingY);
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      constraints.push({
+        a: idx(r, c),
+        b: idx(r + 1, c + 1),
+        restLength: diagLen,
+        stiffness: stiffness * 0.5
+      });
+      constraints.push({
+        a: idx(r, c + 1),
+        b: idx(r + 1, c),
+        restLength: diagLen,
+        stiffness: stiffness * 0.5
+      });
     }
-    const sim = { particles, constraints, cols, rows };
-    Object.defineProperty(sim, 'width', {
-        get() {
-            return this.cols + 1;
-        },
-        enumerable: false,
-        configurable: true,
-    });
-    Object.defineProperty(sim, 'height', {
-        get() {
-            return this.rows + 1;
-        },
-        enumerable: false,
-        configurable: true,
-    });
-    return sim;
+  }
+  const sim = { particles, constraints, cols, rows };
+  Object.defineProperty(sim, "width", {
+    get() {
+      return this.cols + 1;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(sim, "height", {
+    get() {
+      return this.rows + 1;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return sim;
 }
-/** Step the cloth simulation forward by one frame. Returns the same sim for chaining. */
 function stepCloth(sim, configOrDt = {}, gravity) {
-    const cfg = { ...DEFAULT_PHYSICS };
-    if (typeof configOrDt === 'number') {
-        cfg.timestep = configOrDt;
-        if (typeof gravity === 'number') {
-            cfg.gravity = { x: 0, y: gravity };
-        }
-        else if (gravity) {
-            cfg.gravity = gravity;
-        }
-    }
-    else {
-        Object.assign(cfg, configOrDt);
+  const cfg = { ...DEFAULT_PHYSICS };
+  if (typeof configOrDt === "number") {
+    cfg.timestep = configOrDt;
+    if (typeof gravity === "number") {
+      cfg.gravity = { x: 0, y: gravity };
+    } else if (gravity) {
+      cfg.gravity = gravity;
     }
-    stepParticles(sim.particles, cfg);
-    solveConstraints(sim.particles, sim.constraints, cfg.iterations);
-    return sim;
+  } else {
+    Object.assign(cfg, configOrDt);
+  }
+  stepParticles(sim.particles, cfg);
+  solveConstraints(sim.particles, sim.constraints, cfg.iterations);
+  return sim;
 }
-/** Get cloth vertex positions as objects with x/y/pinned. */
 function clothVertices(sim) {
-    return sim.particles.map((p) => ({ x: p.pos.x, y: p.pos.y, pinned: p.pinned }));
+  return sim.particles.map((p) => ({ x: p.pos.x, y: p.pos.y, pinned: p.pinned }));
 }
 function pinClothParticle(sim, a, b, pinned) {
-    if (b === undefined) {
-        if (a >= 0 && a < sim.particles.length) {
-            sim.particles[a].pinned = true;
-        }
-        return;
-    }
-    const idx = b * (sim.cols + 1) + a;
-    if (idx >= 0 && idx < sim.particles.length) {
-        sim.particles[idx].pinned = pinned !== null && pinned !== void 0 ? pinned : true;
+  if (b === void 0) {
+    if (a >= 0 && a < sim.particles.length) {
+      sim.particles[a].pinned = true;
     }
+    return;
+  }
+  const idx = b * (sim.cols + 1) + a;
+  if (idx >= 0 && idx < sim.particles.length) {
+    sim.particles[idx].pinned = pinned ?? true;
+  }
 }
-
 exports.applyImpulse = applyImpulse;
 exports.clothVertices = clothVertices;
 exports.createCloth = createCloth;

package/dist/cjs/animation/rig/RigPlayer.js

@@ -1,63 +1,60 @@
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var React = require('react');
-var choreoRigBridge = require('./choreoRigBridge.js');
-var ik = require('./ik.js');
-var poseOps = require('./poseOps.js');
-var RiggedBody = require('./RiggedBody.js');
-var rigMath = require('./rigMath.js');
-var rigTypes = require('./rigTypes.js');
-
-const NiceRigPlayer = /* @__PURE__ */ React.forwardRef(({ character, rig, pose, size, debug }, ref) => {
-    var _a;
-    const [current, setCurrent] = React.useState({ ...rigTypes.DEFAULT_POSE, ...(pose !== null && pose !== void 0 ? pose : {}) });
-    const r = rig !== null && rig !== void 0 ? rig : rigTypes.DEFAULT_RIG;
-    const S = Math.max(140, Math.floor((_a = size !== null && size !== void 0 ? size : character.size) !== null && _a !== void 0 ? _a : 180));
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const choreoRigBridge = require("./choreoRigBridge.js");
+const ik = require("./ik.js");
+const poseOps = require("./poseOps.js");
+const RiggedBody = require("./RiggedBody.js");
+const rigMath = require("./rigMath.js");
+const rigTypes = require("./rigTypes.js");
+const NiceRigPlayer = /* @__PURE__ */ React.forwardRef(
+  ({ character, rig, pose, size, debug }, ref) => {
+    const [current, setCurrent] = React.useState({ ...rigTypes.DEFAULT_POSE, ...pose ?? {} });
+    const r = rig ?? rigTypes.DEFAULT_RIG;
+    const S = Math.max(140, Math.floor(size ?? character.size ?? 180));
     const setNow = (p) => setCurrent({ ...rigTypes.DEFAULT_POSE, ...p });
     const aimRightHandAt = (x, y) => {
-        const fk = rigMath.solveFK(r, { ...rigTypes.DEFAULT_POSE, ...current }, S);
-        const L1 = Math.hypot(fk.rUpperArm.x2 - fk.rUpperArm.x, fk.rUpperArm.y2 - fk.rUpperArm.y);
-        const L2 = Math.hypot(fk.rForearm.x2 - fk.rForearm.x, fk.rForearm.y2 - fk.rForearm.y);
-        const { upper, fore } = ik.solveTwoBoneIK(fk.rShoulder.x, fk.rShoulder.y, L1, L2, x, y);
-        setNow({ ...current, rUpperArm: upper, rForearm: fore });
+      const fk = rigMath.solveFK(r, { ...rigTypes.DEFAULT_POSE, ...current }, S);
+      const L1 = Math.hypot(fk.rUpperArm.x2 - fk.rUpperArm.x, fk.rUpperArm.y2 - fk.rUpperArm.y);
+      const L2 = Math.hypot(fk.rForearm.x2 - fk.rForearm.x, fk.rForearm.y2 - fk.rForearm.y);
+      const { upper, fore } = ik.solveTwoBoneIK(fk.rShoulder.x, fk.rShoulder.y, L1, L2, x, y);
+      setNow({ ...current, rUpperArm: upper, rForearm: fore });
     };
     const raiseCardIK = async (_score, durationMs = 450) => {
-        const fk = rigMath.solveFK(r, { ...rigTypes.DEFAULT_POSE, ...current }, S);
-        const tx = fk.head.x2 + S * 0.12;
-        const ty = fk.head.y2 - S * 0.05;
-        const L1 = Math.hypot(fk.rUpperArm.x2 - fk.rUpperArm.x, fk.rUpperArm.y2 - fk.rUpperArm.y);
-        const L2 = Math.hypot(fk.rForearm.x2 - fk.rForearm.x, fk.rForearm.y2 - fk.rForearm.y);
-        const { upper, fore } = ik.solveTwoBoneIK(fk.rShoulder.x, fk.rShoulder.y, L1, L2, tx, ty);
-        const target = { ...current, rUpperArm: upper, rForearm: fore, head: 60 };
-        await poseOps.tweenPose(current, target, durationMs, setNow, poseOps.ease.inOut);
+      const fk = rigMath.solveFK(r, { ...rigTypes.DEFAULT_POSE, ...current }, S);
+      const tx = fk.head.x2 + S * 0.12;
+      const ty = fk.head.y2 - S * 0.05;
+      const L1 = Math.hypot(fk.rUpperArm.x2 - fk.rUpperArm.x, fk.rUpperArm.y2 - fk.rUpperArm.y);
+      const L2 = Math.hypot(fk.rForearm.x2 - fk.rForearm.x, fk.rForearm.y2 - fk.rForearm.y);
+      const { upper, fore } = ik.solveTwoBoneIK(fk.rShoulder.x, fk.rShoulder.y, L1, L2, tx, ty);
+      const target = { ...current, rUpperArm: upper, rForearm: fore, head: 60 };
+      await poseOps.tweenPose(current, target, durationMs, setNow, poseOps.ease.inOut);
     };
     React.useImperativeHandle(ref, () => ({
-        setPose: setNow,
-        tweenTo: (p, durationMs = 450) => poseOps.tweenPose(current, { ...rigTypes.DEFAULT_POSE, ...p }, durationMs, setNow, poseOps.ease.inOut),
-        playChoreo: async (steps, defaultMs = 450) => {
-            var _a, _b, _c, _d, _e;
-            let cur = current;
-            for (const s of steps) {
-                if (s.pose === 'raiseCard') {
-                    await raiseCardIK(undefined, (_b = (_a = s.options) === null || _a === void 0 ? void 0 : _a.duration) !== null && _b !== void 0 ? _b : defaultMs);
-                    cur = { ...current };
-                }
-                else {
-                    const target = choreoRigBridge.rigPoseFor(s.pose);
-                    await poseOps.tweenPose(cur, target, (_d = (_c = s.options) === null || _c === void 0 ? void 0 : _c.duration) !== null && _d !== void 0 ? _d : defaultMs, setNow, poseOps.ease.inOut);
-                    cur = target;
-                }
-                const hold = (_e = s.holdMs) !== null && _e !== void 0 ? _e : 0;
-                if (hold > 0) {
-                    await new Promise((r) => setTimeout(r, hold));
-                }
-            }
-        },
-        aimRightHandAt,
-        raiseCardIK,
+      setPose: setNow,
+      tweenTo: (p, durationMs = 450) => poseOps.tweenPose(current, { ...rigTypes.DEFAULT_POSE, ...p }, durationMs, setNow, poseOps.ease.inOut),
+      playChoreo: async (steps, defaultMs = 450) => {
+        let cur = current;
+        for (const s of steps) {
+          if (s.pose === "raiseCard") {
+            await raiseCardIK(void 0, s.options?.duration ?? defaultMs);
+            cur = { ...current };
+          } else {
+            const target = choreoRigBridge.rigPoseFor(s.pose);
+            await poseOps.tweenPose(cur, target, s.options?.duration ?? defaultMs, setNow, poseOps.ease.inOut);
+            cur = target;
+          }
+          const hold = s.holdMs ?? 0;
+          if (hold > 0) {
+            await new Promise((r2) => setTimeout(r2, hold));
+          }
+        }
+      },
+      aimRightHandAt,
+      raiseCardIK
     }));
-    return jsxRuntime.jsx(RiggedBody, { character: character, rig: r, pose: current, size: S, debug: debug });
-});
-
-module.exports = NiceRigPlayer;
+    return /* @__PURE__ */ jsxRuntime.jsx(RiggedBody.default, { character, rig: r, pose: current, size: S, debug });
+  }
+);
+exports.default = NiceRigPlayer;