@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-F53SFGW5.js

@@ -0,0 +1,1878 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/animation/index.ts
+var animation_exports = {};
+__export(animation_exports, {
+  AnimClip: () => AnimClip,
+  AnimationEngine: () => AnimationEngine,
+  AnimationGraph: () => AnimationGraph,
+  AnimationTransitionSystem: () => AnimationTransitionSystem,
+  AvatarController: () => AvatarController,
+  BoneSystem: () => BoneSystem,
+  CutsceneBuilder: () => CutsceneBuilder,
+  CutsceneTimeline: () => CutsceneTimeline,
+  Easing: () => Easing,
+  IKSolver: () => IKSolver,
+  MorphTargetSystem: () => MorphTargetSystem,
+  SkeletalBlender: () => SkeletalBlender,
+  SpringAnimator: () => SpringAnimator,
+  SpringPresets: () => SpringPresets,
+  Timeline: () => Timeline,
+  TransitionSystem: () => TransitionSystem,
+  Vec3SpringAnimator: () => Vec3SpringAnimator,
+  animationTraitHandler: () => animationTraitHandler,
+  getSharedAnimationEngine: () => getSharedAnimationEngine
+});
+
+// src/animation/AnimationClip.ts
+var AnimClip = class {
+  id;
+  name;
+  tracks = [];
+  events = [];
+  _duration = 0;
+  loop = false;
+  speed = 1;
+  wrapMode = "once";
+  constructor(id, name, duration) {
+    this.id = id;
+    this.name = name;
+    this._duration = duration;
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setLoop(loop) {
+    this.loop = loop;
+    this.wrapMode = loop ? "loop" : "once";
+  }
+  isLooping() {
+    return this.loop;
+  }
+  setSpeed(speed) {
+    this.speed = Math.max(0.01, speed);
+  }
+  getSpeed() {
+    return this.speed;
+  }
+  setWrapMode(mode) {
+    this.wrapMode = mode;
+  }
+  getWrapMode() {
+    return this.wrapMode;
+  }
+  getDuration() {
+    return this._duration;
+  }
+  // ---------------------------------------------------------------------------
+  // Tracks
+  // ---------------------------------------------------------------------------
+  addTrack(track) {
+    this.tracks.push(track);
+    for (const kf of track.keyframes) {
+      if (kf.time > this._duration) this._duration = kf.time;
+    }
+  }
+  getTrack(id) {
+    return this.tracks.find((t) => t.id === id);
+  }
+  getTracks() {
+    return [...this.tracks];
+  }
+  getTrackCount() {
+    return this.tracks.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  addEvent(time, name, data = {}) {
+    this.events.push({ time, name, data });
+    this.events.sort((a, b) => a.time - b.time);
+  }
+  getEventsInRange(fromTime, toTime) {
+    return this.events.filter((e) => e.time >= fromTime && e.time < toTime);
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  // ---------------------------------------------------------------------------
+  // Sampling
+  // ---------------------------------------------------------------------------
+  sample(time) {
+    const wrapped = this.wrapTime(time);
+    const result = /* @__PURE__ */ new Map();
+    for (const track of this.tracks) {
+      const value = this.sampleTrack(track, wrapped);
+      const key = track.component ? `${track.targetPath}.${track.property}.${track.component}` : `${track.targetPath}.${track.property}`;
+      result.set(key, value);
+    }
+    return result;
+  }
+  sampleTrack(track, time) {
+    const kfs = track.keyframes;
+    if (kfs.length === 0) return 0;
+    if (kfs.length === 1) return typeof kfs[0].value === "number" ? kfs[0].value : 0;
+    let i = 0;
+    for (; i < kfs.length - 1; i++) {
+      if (time < kfs[i + 1].time) break;
+    }
+    if (i >= kfs.length - 1) i = kfs.length - 2;
+    const k0 = kfs[i];
+    const k1 = kfs[i + 1];
+    const dt = k1.time - k0.time;
+    const t = dt > 0 ? (time - k0.time) / dt : 0;
+    const v0 = typeof k0.value === "number" ? k0.value : 0;
+    const v1 = typeof k1.value === "number" ? k1.value : 0;
+    switch (track.interpolation) {
+      case "step":
+        return v0;
+      case "linear":
+        return v0 + (v1 - v0) * t;
+      case "cubic": {
+        const m0 = k0.outTangent ?? 0;
+        const m1 = k1.inTangent ?? 0;
+        const t2 = t * t, t3 = t2 * t;
+        return (2 * t3 - 3 * t2 + 1) * v0 + (t3 - 2 * t2 + t) * m0 * dt + (-2 * t3 + 3 * t2) * v1 + (t3 - t2) * m1 * dt;
+      }
+      default:
+        return v0 + (v1 - v0) * t;
+    }
+  }
+  wrapTime(time) {
+    if (this._duration <= 0) return 0;
+    const t = time * this.speed;
+    switch (this.wrapMode) {
+      case "once":
+        return Math.min(t, this._duration);
+      case "clamp":
+        return Math.max(0, Math.min(t, this._duration));
+      case "loop":
+        return (t % this._duration + this._duration) % this._duration;
+      case "ping-pong": {
+        const cycle = t / this._duration;
+        const phase = cycle % 2;
+        return phase < 1 ? phase * this._duration : (2 - phase) * this._duration;
+      }
+      default:
+        return t;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Blending
+  // ---------------------------------------------------------------------------
+  static blend(a, b, weight) {
+    const result = /* @__PURE__ */ new Map();
+    const allKeys = /* @__PURE__ */ new Set([...a.keys(), ...b.keys()]);
+    for (const key of allKeys) {
+      const va = a.get(key) ?? 0;
+      const vb = b.get(key) ?? 0;
+      result.set(key, va * (1 - weight) + vb * weight);
+    }
+    return result;
+  }
+};
+
+// src/animation/AnimationEngine.ts
+var Easing = {
+  linear: (t) => t,
+  easeInQuad: (t) => t * t,
+  easeOutQuad: (t) => t * (2 - t),
+  easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  easeInCubic: (t) => t * t * t,
+  easeOutCubic: (t) => --t * t * t + 1,
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+  easeInExpo: (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
+  easeOutExpo: (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t),
+  easeInOutExpo: (t) => {
+    if (t === 0 || t === 1) return t;
+    return t < 0.5 ? Math.pow(2, 20 * t - 10) / 2 : (2 - Math.pow(2, -20 * t + 10)) / 2;
+  },
+  easeOutBack: (t) => {
+    const c1 = 1.70158;
+    const c3 = c1 + 1;
+    return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+  },
+  easeOutElastic: (t) => {
+    if (t === 0 || t === 1) return t;
+    return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * (2 * Math.PI / 3)) + 1;
+  },
+  easeOutBounce: (t) => {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) return n1 * t * t;
+    else if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + 0.75;
+    else if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    else return n1 * (t -= 2.625 / d1) * t + 0.984375;
+  }
+};
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function interpolateKeyframes(keyframes, t) {
+  if (keyframes.length === 0) return 0;
+  if (keyframes.length === 1) return keyframes[0].value;
+  t = Math.max(0, Math.min(1, t));
+  let prevKf = keyframes[0];
+  let nextKf = keyframes[keyframes.length - 1];
+  for (let i = 0; i < keyframes.length - 1; i++) {
+    if (t >= keyframes[i].time && t <= keyframes[i + 1].time) {
+      prevKf = keyframes[i];
+      nextKf = keyframes[i + 1];
+      break;
+    }
+  }
+  const segmentDuration = nextKf.time - prevKf.time;
+  const localT = segmentDuration > 0 ? (t - prevKf.time) / segmentDuration : 1;
+  const easingFn = nextKf.easing || Easing.linear;
+  const easedT = easingFn(localT);
+  return lerp(prevKf.value, nextKf.value, easedT);
+}
+var AnimationEngine = class {
+  animations = /* @__PURE__ */ new Map();
+  propertySetters = /* @__PURE__ */ new Map();
+  /**
+   * Register an animation clip and start playing it.
+   */
+  play(clip, setter) {
+    this.animations.set(clip.id, {
+      clip,
+      elapsed: -clip.delay,
+      // Negative = waiting for delay
+      isPlaying: true,
+      isPaused: false,
+      direction: 1,
+      loopCount: 0
+    });
+    this.propertySetters.set(clip.id, setter);
+  }
+  /**
+   * Stop and remove an animation.
+   */
+  stop(clipId) {
+    this.animations.delete(clipId);
+    this.propertySetters.delete(clipId);
+  }
+  /**
+   * Pause an animation.
+   */
+  pause(clipId) {
+    const anim = this.animations.get(clipId);
+    if (anim) anim.isPaused = true;
+  }
+  /**
+   * Resume a paused animation.
+   */
+  resume(clipId) {
+    const anim = this.animations.get(clipId);
+    if (anim) anim.isPaused = false;
+  }
+  /**
+   * Check if an animation is active.
+   */
+  isActive(clipId) {
+    return this.animations.has(clipId);
+  }
+  /**
+   * Get all active animation IDs.
+   */
+  getActiveIds() {
+    return Array.from(this.animations.keys());
+  }
+  /**
+   * Update all active animations. Call this every frame.
+   */
+  update(delta) {
+    const toRemove = [];
+    for (const [id, anim] of this.animations) {
+      if (anim.isPaused || !anim.isPlaying) continue;
+      anim.elapsed += delta;
+      if (anim.elapsed < 0) continue;
+      const { clip } = anim;
+      const effectiveElapsed = anim.elapsed;
+      let normalizedT = clip.duration > 0 ? effectiveElapsed / clip.duration : 1;
+      if (normalizedT >= 1) {
+        if (clip.pingPong) {
+          const cycles = Math.floor(effectiveElapsed / clip.duration);
+          anim.loopCount += cycles;
+          anim.elapsed -= clip.duration;
+          anim.direction *= -1;
+          normalizedT = clip.duration > 0 ? anim.elapsed / clip.duration : 1;
+        } else if (clip.loop) {
+          anim.elapsed = effectiveElapsed % clip.duration;
+          anim.loopCount++;
+          normalizedT = clip.duration > 0 ? anim.elapsed / clip.duration : 0;
+        } else {
+          normalizedT = 1;
+          anim.isPlaying = false;
+          toRemove.push(id);
+        }
+      }
+      const sampleT = anim.direction === -1 ? 1 - normalizedT : normalizedT;
+      const value = interpolateKeyframes(clip.keyframes, sampleT);
+      const setter = this.propertySetters.get(id);
+      if (setter) setter(value);
+    }
+    for (const id of toRemove) {
+      const anim = this.animations.get(id);
+      if (anim?.clip.onComplete) anim.clip.onComplete();
+      this.animations.delete(id);
+      this.propertySetters.delete(id);
+    }
+  }
+  /**
+   * Stop all animations.
+   */
+  clear() {
+    this.animations.clear();
+    this.propertySetters.clear();
+  }
+};
+
+// src/animation/AnimationGraph.ts
+var AnimationGraph = class {
+  clips = /* @__PURE__ */ new Map();
+  layers = [];
+  defaultGraph;
+  constructor() {
+    this.defaultGraph = {
+      states: /* @__PURE__ */ new Map(),
+      transitions: [],
+      currentState: "",
+      parameters: /* @__PURE__ */ new Map(),
+      activeTransition: null
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Clip Management
+  // ---------------------------------------------------------------------------
+  addClip(clip) {
+    this.clips.set(clip.id, clip);
+  }
+  getClip(id) {
+    return this.clips.get(id);
+  }
+  removeClip(id) {
+    return this.clips.delete(id);
+  }
+  getClipIds() {
+    return [...this.clips.keys()];
+  }
+  // ---------------------------------------------------------------------------
+  // State Management
+  // ---------------------------------------------------------------------------
+  addState(id, clipId, options = {}) {
+    const state = {
+      id,
+      clipId,
+      speed: options.speed ?? 1,
+      loop: options.loop ?? true,
+      currentTime: 0,
+      weight: 0,
+      isPlaying: false
+    };
+    this.defaultGraph.states.set(id, state);
+    if (this.defaultGraph.states.size === 1) {
+      this.defaultGraph.currentState = id;
+      state.weight = 1;
+      state.isPlaying = true;
+    }
+    return state;
+  }
+  getState(id) {
+    return this.defaultGraph.states.get(id);
+  }
+  getCurrentState() {
+    return this.defaultGraph.currentState;
+  }
+  // ---------------------------------------------------------------------------
+  // Transitions
+  // ---------------------------------------------------------------------------
+  addTransition(transition) {
+    this.defaultGraph.transitions.push(transition);
+  }
+  // ---------------------------------------------------------------------------
+  // Parameters
+  // ---------------------------------------------------------------------------
+  setParameter(name, value) {
+    this.defaultGraph.parameters.set(name, value);
+  }
+  getParameter(name) {
+    return this.defaultGraph.parameters.get(name);
+  }
+  setTrigger(name) {
+    this.defaultGraph.parameters.set(name, true);
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    const graph = this.defaultGraph;
+    const output = /* @__PURE__ */ new Map();
+    if (!graph.activeTransition) {
+      for (const t of graph.transitions) {
+        if (t.fromState !== graph.currentState) continue;
+        if (this.evaluateCondition(t.condition, graph)) {
+          graph.activeTransition = {
+            from: t.fromState,
+            to: t.toState,
+            progress: 0,
+            duration: t.duration
+          };
+          const toState = graph.states.get(t.toState);
+          if (toState) {
+            toState.currentTime = 0;
+            toState.isPlaying = true;
+          }
+          if (t.condition.type === "trigger") {
+            graph.parameters.delete(t.condition.name);
+          }
+          break;
+        }
+      }
+    }
+    if (graph.activeTransition) {
+      graph.activeTransition.progress += dt / graph.activeTransition.duration;
+      const fromState = graph.states.get(graph.activeTransition.from);
+      const toState = graph.states.get(graph.activeTransition.to);
+      const blend = Math.min(1, graph.activeTransition.progress);
+      if (fromState) fromState.weight = 1 - blend;
+      if (toState) toState.weight = blend;
+      if (graph.activeTransition.progress >= 1) {
+        if (fromState) {
+          fromState.weight = 0;
+          fromState.isPlaying = false;
+        }
+        if (toState) toState.weight = 1;
+        graph.currentState = graph.activeTransition.to;
+        graph.activeTransition = null;
+      }
+    }
+    for (const [, state] of graph.states) {
+      if (!state.isPlaying) continue;
+      const clip = this.clips.get(state.clipId);
+      if (!clip) continue;
+      state.currentTime += dt * state.speed;
+      if (state.loop) {
+        state.currentTime %= clip.duration;
+      } else {
+        state.currentTime = Math.min(state.currentTime, clip.duration);
+      }
+      for (const track of clip.tracks) {
+        const value = this.sampleTrack(track, state.currentTime);
+        const existing = output.get(track.targetProperty) || 0;
+        output.set(track.targetProperty, existing + value * state.weight);
+      }
+    }
+    return output;
+  }
+  // ---------------------------------------------------------------------------
+  // Layers
+  // ---------------------------------------------------------------------------
+  addLayer(layer) {
+    this.layers.push(layer);
+  }
+  getLayers() {
+    return [...this.layers];
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  evaluateCondition(condition, graph) {
+    switch (condition.type) {
+      case "finished": {
+        const currentState = graph.states.get(graph.currentState);
+        if (!currentState) return false;
+        const clip = this.clips.get(currentState.clipId);
+        return clip ? currentState.currentTime >= clip.duration : false;
+      }
+      case "trigger":
+        return graph.parameters.get(condition.name) === true;
+      case "parameter": {
+        const val = graph.parameters.get(condition.name);
+        if (val === void 0) return false;
+        switch (condition.comparator) {
+          case ">":
+            return val > condition.value;
+          case "<":
+            return val < condition.value;
+          case "==":
+            return val === condition.value;
+          case "!=":
+            return val !== condition.value;
+        }
+        return false;
+      }
+    }
+  }
+  sampleTrack(track, time) {
+    const kfs = track.keyframes;
+    if (kfs.length === 0) return 0;
+    if (kfs.length === 1 || time <= kfs[0].time) return kfs[0].value;
+    if (time >= kfs[kfs.length - 1].time) return kfs[kfs.length - 1].value;
+    let i = 0;
+    while (i < kfs.length - 1 && kfs[i + 1].time < time) i++;
+    const kf0 = kfs[i];
+    const kf1 = kfs[i + 1];
+    const t = (time - kf0.time) / (kf1.time - kf0.time);
+    switch (track.interpolation) {
+      case "step":
+        return kf0.value;
+      case "cubic": {
+        const t2 = t * t;
+        const t3 = t2 * t;
+        const h1 = 2 * t3 - 3 * t2 + 1;
+        const h2 = t3 - 2 * t2 + t;
+        const h3 = -2 * t3 + 3 * t2;
+        const h4 = t3 - t2;
+        const dt = kf1.time - kf0.time;
+        return h1 * kf0.value + h2 * (kf0.outTangent || 0) * dt + h3 * kf1.value + h4 * (kf1.inTangent || 0) * dt;
+      }
+      case "linear":
+      default:
+        return kf0.value + (kf1.value - kf0.value) * t;
+    }
+  }
+};
+
+// src/animation/SpringAnimator.ts
+var SpringPresets = {
+  /** Snappy, minimal bounce — good for buttons, toggles */
+  stiff: { stiffness: 300, damping: 30, mass: 1, precision: 0.01 },
+  /** Default responsive spring */
+  default: { stiffness: 170, damping: 26, mass: 1, precision: 0.01 },
+  /** Gentle, bouncy — good for dialogs, modals */
+  gentle: { stiffness: 120, damping: 14, mass: 1, precision: 0.01 },
+  /** Wobbly — fun/playful animations */
+  wobbly: { stiffness: 180, damping: 12, mass: 1, precision: 0.01 },
+  /** Slow, heavy — good for large panels */
+  slow: { stiffness: 80, damping: 20, mass: 2, precision: 0.01 },
+  /** Molasses — ultra-slow drift */
+  molasses: { stiffness: 40, damping: 30, mass: 3, precision: 5e-3 }
+};
+var SpringAnimator = class {
+  current;
+  target;
+  velocity = 0;
+  config;
+  atRest = true;
+  onUpdate;
+  onRest;
+  constructor(initialValue, config = {}, onUpdate, onRest) {
+    this.current = initialValue;
+    this.target = initialValue;
+    this.config = { ...SpringPresets.default, ...config };
+    this.onUpdate = onUpdate;
+    this.onRest = onRest;
+  }
+  /**
+   * Set a new target value. The spring will animate towards it.
+   */
+  setTarget(target) {
+    this.target = target;
+    this.atRest = false;
+  }
+  /**
+   * Instantly jump to a value (no animation).
+   */
+  setValue(value) {
+    this.current = value;
+    this.target = value;
+    this.velocity = 0;
+    this.atRest = true;
+    if (this.onUpdate) this.onUpdate(value);
+  }
+  /**
+   * Apply an impulse (instant velocity change).
+   */
+  impulse(force) {
+    this.velocity += force;
+    this.atRest = false;
+  }
+  /**
+   * Step the spring simulation forward.
+   * Uses semi-implicit Euler integration.
+   */
+  update(delta) {
+    if (this.atRest) return this.current;
+    const { stiffness, damping, mass, precision } = this.config;
+    const displacement = this.current - this.target;
+    const springForce = -stiffness * displacement;
+    const dampingForce = -damping * this.velocity;
+    const acceleration = (springForce + dampingForce) / mass;
+    this.velocity += acceleration * delta;
+    this.current += this.velocity * delta;
+    if (Math.abs(this.velocity) < precision && Math.abs(displacement) < precision) {
+      this.current = this.target;
+      this.velocity = 0;
+      this.atRest = true;
+      if (this.onUpdate) this.onUpdate(this.current);
+      if (this.onRest) this.onRest();
+      return this.current;
+    }
+    if (this.onUpdate) this.onUpdate(this.current);
+    return this.current;
+  }
+  /**
+   * Get current value.
+   */
+  getValue() {
+    return this.current;
+  }
+  /**
+   * Check if the spring has settled.
+   */
+  isAtRest() {
+    return this.atRest;
+  }
+  /**
+   * Change spring configuration dynamically.
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+var Vec3SpringAnimator = class {
+  x;
+  y;
+  z;
+  constructor(initial, config = {}, onUpdate) {
+    const notifyAll = () => {
+      if (onUpdate) {
+        onUpdate({ x: this.x.getValue(), y: this.y.getValue(), z: this.z.getValue() });
+      }
+    };
+    this.x = new SpringAnimator(initial.x, config, notifyAll);
+    this.y = new SpringAnimator(initial.y, config, notifyAll);
+    this.z = new SpringAnimator(initial.z, config, notifyAll);
+  }
+  setTarget(target) {
+    this.x.setTarget(target.x);
+    this.y.setTarget(target.y);
+    this.z.setTarget(target.z);
+  }
+  update(delta) {
+    return {
+      x: this.x.update(delta),
+      y: this.y.update(delta),
+      z: this.z.update(delta)
+    };
+  }
+  getValue() {
+    return { x: this.x.getValue(), y: this.y.getValue(), z: this.z.getValue() };
+  }
+  isAtRest() {
+    return this.x.isAtRest() && this.y.isAtRest() && this.z.isAtRest();
+  }
+};
+
+// src/animation/AnimationTrait.ts
+var sharedEngine = null;
+function getSharedAnimationEngine() {
+  if (!sharedEngine) {
+    sharedEngine = new AnimationEngine();
+  }
+  return sharedEngine;
+}
+var nodeSpringMap = /* @__PURE__ */ new Map();
+var easingLookup = {
+  linear: Easing.linear,
+  "ease-in": Easing.easeInQuad,
+  "ease-out": Easing.easeOutQuad,
+  "ease-in-out": Easing.easeInOutQuad,
+  "ease-in-cubic": Easing.easeInCubic,
+  "ease-out-cubic": Easing.easeOutCubic,
+  "ease-in-out-cubic": Easing.easeInOutCubic,
+  "ease-out-back": Easing.easeOutBack,
+  "ease-out-elastic": Easing.easeOutElastic,
+  "ease-out-bounce": Easing.easeOutBounce,
+  "ease-in-expo": Easing.easeInExpo,
+  "ease-out-expo": Easing.easeOutExpo
+};
+function resolveEasing(name) {
+  if (!name) return Easing.linear;
+  return easingLookup[name] || Easing.linear;
+}
+var animationTraitHandler = {
+  name: "animate",
+  defaultConfig: {
+    clips: [],
+    springs: [],
+    autoPlay: true
+  },
+  onAttach(node, config, _context) {
+    const engine = getSharedAnimationEngine();
+    const nodeId = node.id || "unknown";
+    if (config.autoPlay && config.clips) {
+      for (const clipDef of config.clips) {
+        const clip = {
+          id: `${nodeId}_${clipDef.property}`,
+          property: clipDef.property,
+          keyframes: clipDef.keyframes.map((kf) => ({
+            time: kf.time,
+            value: kf.value,
+            easing: resolveEasing(kf.easing)
+          })),
+          duration: clipDef.duration,
+          loop: clipDef.loop || false,
+          pingPong: clipDef.pingPong || false,
+          delay: clipDef.delay || 0
+        };
+        engine.play(clip, (value) => {
+          setNestedProperty(node, clipDef.property, value);
+        });
+      }
+    }
+    if (config.springs) {
+      const springs = /* @__PURE__ */ new Map();
+      for (const springDef of config.springs) {
+        const presetConfig = springDef.preset ? SpringPresets[springDef.preset] : SpringPresets.default;
+        const mergedConfig = { ...presetConfig, ...springDef.config || {} };
+        const initial = getNestedProperty(node, springDef.property) ?? 0;
+        const spring = new SpringAnimator(initial, mergedConfig, (value) => {
+          setNestedProperty(node, springDef.property, value);
+        });
+        spring.setTarget(springDef.target);
+        springs.set(springDef.property, spring);
+      }
+      nodeSpringMap.set(nodeId, springs);
+    }
+  },
+  onDetach(node, _config, _context) {
+    const nodeId = node.id || "unknown";
+    const engine = getSharedAnimationEngine();
+    for (const id of engine.getActiveIds()) {
+      if (id.startsWith(nodeId)) {
+        engine.stop(id);
+      }
+    }
+    nodeSpringMap.delete(nodeId);
+  },
+  onUpdate(node, _config, _context, delta) {
+    const nodeId = node.id || "unknown";
+    const springs = nodeSpringMap.get(nodeId);
+    if (springs) {
+      for (const spring of springs.values()) {
+        spring.update(delta);
+      }
+    }
+  }
+};
+function setNestedProperty(node, path, value) {
+  if (!node.properties) return;
+  const parts = path.split(".");
+  let target = node.properties;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (target[parts[i]] === void 0) target[parts[i]] = {};
+    target = target[parts[i]];
+  }
+  target[parts[parts.length - 1]] = value;
+}
+function getNestedProperty(node, path) {
+  if (!node.properties) return void 0;
+  const parts = path.split(".");
+  let target = node.properties;
+  for (const part of parts) {
+    if (target === void 0 || target === null) return void 0;
+    target = target[part];
+  }
+  return target;
+}
+
+// src/animation/AnimationTransitions.ts
+var DEFAULT_CONFIG = {
+  duration: 0.5,
+  curve: "ease_in_out",
+  settleThreshold: 0.1
+};
+var AnimationTransitionSystem = class {
+  config;
+  activeBlends = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  startAnimToRagdoll(entityId, currentPose) {
+    this.activeBlends.set(entityId, {
+      direction: "animation_to_ragdoll",
+      progress: 0,
+      duration: this.config.duration,
+      sourcePose: currentPose.map((p) => ({
+        ...p,
+        position: { ...p.position },
+        rotation: { ...p.rotation }
+      })),
+      isComplete: false
+    });
+  }
+  startRagdollToAnim(entityId, currentPose) {
+    this.activeBlends.set(entityId, {
+      direction: "ragdoll_to_animation",
+      progress: 0,
+      duration: this.config.duration,
+      sourcePose: currentPose.map((p) => ({
+        ...p,
+        position: { ...p.position },
+        rotation: { ...p.rotation }
+      })),
+      isComplete: false
+    });
+  }
+  update(dt, ragdollPoses, animPoses) {
+    const results = /* @__PURE__ */ new Map();
+    for (const [entityId, blend] of this.activeBlends) {
+      if (blend.isComplete) continue;
+      blend.progress = Math.min(1, blend.progress + dt / blend.duration);
+      const t = this.applyCurve(blend.progress);
+      const ragdoll = ragdollPoses.get(entityId) || blend.sourcePose;
+      const anim = animPoses.get(entityId) || blend.sourcePose;
+      const blended = [];
+      for (let i = 0; i < blend.sourcePose.length; i++) {
+        const source = blend.sourcePose[i];
+        const ragBone = ragdoll.find((b) => b.boneId === source.boneId) || source;
+        const animBone = anim.find((b) => b.boneId === source.boneId) || source;
+        const fromBone = blend.direction === "animation_to_ragdoll" ? animBone : ragBone;
+        const toBone = blend.direction === "animation_to_ragdoll" ? ragBone : animBone;
+        blended.push({
+          boneId: source.boneId,
+          position: this.lerpVec3(fromBone.position, toBone.position, t),
+          rotation: this.slerpQuat(fromBone.rotation, toBone.rotation, t)
+        });
+      }
+      results.set(entityId, blended);
+      if (blend.progress >= 1) {
+        blend.isComplete = true;
+      }
+    }
+    return results;
+  }
+  isTransitioning(entityId) {
+    const blend = this.activeBlends.get(entityId);
+    return blend !== void 0 && !blend.isComplete;
+  }
+  getBlendProgress(entityId) {
+    return this.activeBlends.get(entityId)?.progress ?? 0;
+  }
+  clearTransition(entityId) {
+    this.activeBlends.delete(entityId);
+  }
+  getActiveTransitionCount() {
+    let count = 0;
+    for (const [, blend] of this.activeBlends) {
+      if (!blend.isComplete) count++;
+    }
+    return count;
+  }
+  applyCurve(t) {
+    switch (this.config.curve) {
+      case "ease_in":
+        return t * t;
+      case "ease_out":
+        return 1 - (1 - t) * (1 - t);
+      case "ease_in_out":
+        return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+      case "linear":
+      default:
+        return t;
+    }
+  }
+  lerpVec3(a, b, t) {
+    return {
+      x: a.x + (b.x - a.x) * t,
+      y: a.y + (b.y - a.y) * t,
+      z: a.z + (b.z - a.z) * t
+    };
+  }
+  slerpQuat(a, b, t) {
+    let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    let bx = b.x, by = b.y, bz = b.z, bw = b.w;
+    if (dot < 0) {
+      bx = -bx;
+      by = -by;
+      bz = -bz;
+      bw = -bw;
+      dot = -dot;
+    }
+    const rx = a.x + (bx - a.x) * t;
+    const ry = a.y + (by - a.y) * t;
+    const rz = a.z + (bz - a.z) * t;
+    const rw = a.w + (bw - a.w) * t;
+    const len = Math.sqrt(rx * rx + ry * ry + rz * rz + rw * rw) || 1;
+    return { x: rx / len, y: ry / len, z: rz / len, w: rw / len };
+  }
+};
+
+// src/animation/AvatarController.ts
+var AvatarController = class {
+  solver;
+  bones;
+  calibrated = false;
+  // Configuration for VRIK
+  config = {
+    headOffset: { x: 0, y: -0.1, z: 0 },
+    // Neck pivot relative to HMD
+    shoulderWidth: 0.4,
+    spineLength: 0.6
+  };
+  constructor(solver, bones) {
+    this.solver = solver;
+    this.bones = bones;
+  }
+  /**
+   * Calibrate avatar scale based on user height
+   */
+  calibrate(_userHeight) {
+    this.calibrated = true;
+  }
+  /**
+   * Update IK targets from VR input
+   */
+  update(input) {
+    if (!this.calibrated) return;
+    this.solver.setTarget(
+      "leftArm",
+      input.leftHand.position[0],
+      input.leftHand.position[1],
+      input.leftHand.position[2]
+    );
+    this.solver.setTarget(
+      "rightArm",
+      input.rightHand.position[0],
+      input.rightHand.position[1],
+      input.rightHand.position[2]
+    );
+    const leftHandBone = this.bones.getBone("LeftHand");
+    if (leftHandBone) {
+    }
+    this.solver.solveAll();
+  }
+};
+
+// src/animation/BoneSystem.ts
+var BoneSystem = class {
+  bones = /* @__PURE__ */ new Map();
+  roots = [];
+  dirty = true;
+  // ---------------------------------------------------------------------------
+  // Bone Management
+  // ---------------------------------------------------------------------------
+  addBone(id, name, parentId, local) {
+    const defaultTransform = () => ({
+      tx: 0,
+      ty: 0,
+      tz: 0,
+      rx: 0,
+      ry: 0,
+      rz: 0,
+      rw: 1,
+      sx: 1,
+      sy: 1,
+      sz: 1
+    });
+    const bone = {
+      id,
+      name,
+      parentId,
+      local: { ...defaultTransform(), ...local },
+      world: defaultTransform(),
+      bindInverse: defaultTransform(),
+      childIds: []
+    };
+    this.bones.set(id, bone);
+    if (parentId) {
+      const parent = this.bones.get(parentId);
+      if (parent) parent.childIds.push(id);
+    } else {
+      this.roots.push(id);
+    }
+    this.dirty = true;
+  }
+  getBone(id) {
+    return this.bones.get(id);
+  }
+  getBoneCount() {
+    return this.bones.size;
+  }
+  getRoots() {
+    return [...this.roots];
+  }
+  // ---------------------------------------------------------------------------
+  // Pose Application
+  // ---------------------------------------------------------------------------
+  setLocalTransform(id, transform) {
+    const bone = this.bones.get(id);
+    if (!bone) return;
+    Object.assign(bone.local, transform);
+    this.dirty = true;
+  }
+  // ---------------------------------------------------------------------------
+  // World-Space Update
+  // ---------------------------------------------------------------------------
+  updateWorldTransforms() {
+    if (!this.dirty) return;
+    for (const rootId of this.roots) this.updateBoneChain(rootId);
+    this.dirty = false;
+  }
+  updateBoneChain(id) {
+    const bone = this.bones.get(id);
+    if (!bone) return;
+    if (bone.parentId) {
+      const parent = this.bones.get(bone.parentId);
+      bone.world = this.combineTransforms(parent.world, bone.local);
+    } else {
+      bone.world = { ...bone.local };
+    }
+    for (const childId of bone.childIds) this.updateBoneChain(childId);
+  }
+  // ---------------------------------------------------------------------------
+  // Bind Pose
+  // ---------------------------------------------------------------------------
+  captureBindPose() {
+    this.updateWorldTransforms();
+    for (const bone of this.bones.values()) {
+      bone.bindInverse = this.invertTransform(bone.world);
+    }
+  }
+  getSkinningMatrix(id) {
+    const bone = this.bones.get(id);
+    if (!bone) return null;
+    this.updateWorldTransforms();
+    return this.combineTransforms(bone.world, bone.bindInverse);
+  }
+  // ---------------------------------------------------------------------------
+  // Transform Math (simplified)
+  // ---------------------------------------------------------------------------
+  combineTransforms(parent, child) {
+    return {
+      tx: parent.tx + child.tx * parent.sx,
+      ty: parent.ty + child.ty * parent.sy,
+      tz: parent.tz + child.tz * parent.sz,
+      rx: child.rx,
+      ry: child.ry,
+      rz: child.rz,
+      rw: child.rw,
+      // Simplified — no quat multiply
+      sx: parent.sx * child.sx,
+      sy: parent.sy * child.sy,
+      sz: parent.sz * child.sz
+    };
+  }
+  invertTransform(t) {
+    const isx = t.sx !== 0 ? 1 / t.sx : 0;
+    const isy = t.sy !== 0 ? 1 / t.sy : 0;
+    const isz = t.sz !== 0 ? 1 / t.sz : 0;
+    return {
+      tx: -t.tx * isx,
+      ty: -t.ty * isy,
+      tz: -t.tz * isz,
+      rx: -t.rx,
+      ry: -t.ry,
+      rz: -t.rz,
+      rw: t.rw,
+      // Conjugate
+      sx: isx,
+      sy: isy,
+      sz: isz
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getWorldPosition(id) {
+    const bone = this.bones.get(id);
+    if (!bone) return null;
+    this.updateWorldTransforms();
+    return { x: bone.world.tx, y: bone.world.ty, z: bone.world.tz };
+  }
+  getChain(leafId) {
+    const chain = [];
+    let current = leafId;
+    while (current) {
+      chain.unshift(current);
+      current = this.bones.get(current)?.parentId ?? "";
+    }
+    return chain;
+  }
+};
+
+// src/animation/CutsceneTimeline.ts
+var CutsceneTimeline = class {
+  cutscenes = /* @__PURE__ */ new Map();
+  callbacks = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Cutscene Management
+  // ---------------------------------------------------------------------------
+  load(definition) {
+    this.cutscenes.set(definition.id, {
+      definition,
+      currentTime: 0,
+      isPlaying: false,
+      isPaused: false,
+      speed: 1,
+      activeEvents: /* @__PURE__ */ new Set(),
+      completedEvents: /* @__PURE__ */ new Set(),
+      triggeredCallbacks: []
+    });
+    return definition.id;
+  }
+  play(id, startTime = 0) {
+    const state = this.cutscenes.get(id);
+    if (!state) return false;
+    state.isPlaying = true;
+    state.isPaused = false;
+    state.currentTime = startTime;
+    state.activeEvents.clear();
+    state.completedEvents.clear();
+    state.triggeredCallbacks = [];
+    return true;
+  }
+  pause(id) {
+    const state = this.cutscenes.get(id);
+    if (state) state.isPaused = true;
+  }
+  resume(id) {
+    const state = this.cutscenes.get(id);
+    if (state) state.isPaused = false;
+  }
+  stop(id) {
+    const state = this.cutscenes.get(id);
+    if (!state) return;
+    state.isPlaying = false;
+    state.isPaused = false;
+    state.currentTime = 0;
+    state.activeEvents.clear();
+  }
+  setSpeed(id, speed) {
+    const state = this.cutscenes.get(id);
+    if (state) state.speed = Math.max(0, speed);
+  }
+  seek(id, time) {
+    const state = this.cutscenes.get(id);
+    if (!state) return;
+    state.currentTime = Math.max(0, Math.min(time, state.definition.duration));
+    state.completedEvents.clear();
+    state.activeEvents.clear();
+    state.triggeredCallbacks = [];
+  }
+  // ---------------------------------------------------------------------------
+  // Callbacks
+  // ---------------------------------------------------------------------------
+  registerCallback(callbackId, fn) {
+    this.callbacks.set(callbackId, fn);
+  }
+  unregisterCallback(callbackId) {
+    this.callbacks.delete(callbackId);
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    const activeEventsPerCutscene = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.cutscenes) {
+      if (!state.isPlaying || state.isPaused) continue;
+      state.currentTime += dt * state.speed;
+      if (state.currentTime >= state.definition.duration) {
+        if (state.definition.loop) {
+          state.currentTime %= state.definition.duration;
+          state.completedEvents.clear();
+          state.triggeredCallbacks = [];
+        } else {
+          state.currentTime = state.definition.duration;
+          state.isPlaying = false;
+        }
+      }
+      const currentActive = [];
+      for (const track of state.definition.tracks) {
+        if (track.muted) continue;
+        for (const event of track.events) {
+          const eventEnd = event.startTime + event.duration;
+          const isActive = state.currentTime >= event.startTime && state.currentTime < eventEnd;
+          if (isActive) {
+            state.activeEvents.add(event.id);
+            currentActive.push(event);
+            if (event.type === "callback" && !state.triggeredCallbacks.includes(event.id)) {
+              const callbackId = event.data.callbackId;
+              const fn = this.callbacks.get(callbackId);
+              if (fn) fn();
+              state.triggeredCallbacks.push(event.id);
+            }
+          } else if (state.currentTime >= eventEnd) {
+            state.activeEvents.delete(event.id);
+            state.completedEvents.add(event.id);
+          }
+        }
+      }
+      activeEventsPerCutscene.set(id, currentActive);
+    }
+    return activeEventsPerCutscene;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getState(id) {
+    return this.cutscenes.get(id);
+  }
+  isPlaying(id) {
+    return this.cutscenes.get(id)?.isPlaying ?? false;
+  }
+  getCurrentTime(id) {
+    return this.cutscenes.get(id)?.currentTime ?? 0;
+  }
+  getProgress(id) {
+    const state = this.cutscenes.get(id);
+    if (!state) return 0;
+    return state.currentTime / state.definition.duration;
+  }
+  removeCutscene(id) {
+    return this.cutscenes.delete(id);
+  }
+};
+var CutsceneBuilder = class {
+  tracks = [];
+  eventCounter = 0;
+  id;
+  name;
+  constructor(id, name) {
+    this.id = id;
+    this.name = name;
+  }
+  addTrack(name, targetEntity) {
+    this.tracks.push({
+      id: `track_${this.tracks.length}`,
+      name,
+      targetEntity,
+      events: [],
+      muted: false
+    });
+    return this;
+  }
+  addEvent(trackIndex, type, startTime, duration, data = {}) {
+    if (trackIndex < this.tracks.length) {
+      this.tracks[trackIndex].events.push({
+        id: `event_${this.eventCounter++}`,
+        type,
+        startTime,
+        duration,
+        data
+      });
+    }
+    return this;
+  }
+  build() {
+    const maxEnd = this.tracks.reduce(
+      (max, track) => Math.max(max, ...track.events.map((e) => e.startTime + e.duration)),
+      0
+    );
+    return {
+      id: this.id,
+      name: this.name,
+      duration: maxEnd,
+      tracks: this.tracks,
+      loop: false
+    };
+  }
+};
+
+// src/animation/IKSolver.ts
+var IKSolver = class {
+  chains = /* @__PURE__ */ new Map();
+  footConfig = {
+    rayHeight: 1,
+    rayLength: 2,
+    footOffset: 0.05,
+    blendSpeed: 10,
+    enabled: false
+  };
+  footPositions = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Chain Management
+  // ---------------------------------------------------------------------------
+  addChain(chain) {
+    this.chains.set(chain.id, chain);
+  }
+  removeChain(id) {
+    return this.chains.delete(id);
+  }
+  getChain(id) {
+    return this.chains.get(id);
+  }
+  getChainCount() {
+    return this.chains.size;
+  }
+  setTarget(chainId, x, y, z) {
+    const chain = this.chains.get(chainId);
+    if (chain) chain.target = { x, y, z };
+  }
+  setPoleTarget(chainId, x, y, z) {
+    const chain = this.chains.get(chainId);
+    if (chain) chain.poleTarget = { x, y, z };
+  }
+  setWeight(chainId, weight) {
+    const chain = this.chains.get(chainId);
+    if (chain) chain.weight = Math.max(0, Math.min(1, weight));
+  }
+  // ---------------------------------------------------------------------------
+  // Two-Bone IK
+  // ---------------------------------------------------------------------------
+  solveTwoBone(chainId) {
+    const chain = this.chains.get(chainId);
+    if (!chain || chain.bones.length < 2) return false;
+    const root = chain.bones[0];
+    const mid = chain.bones[1];
+    const end = chain.bones.length > 2 ? chain.bones[2] : null;
+    const a = root.length;
+    const b = mid.length;
+    const target = chain.target;
+    const dx = target[0] - root.position[0];
+    const dy = target[1] - root.position[1];
+    const dz = target[2] - root.position[2];
+    const distSq = dx * dx + dy * dy + dz * dz;
+    const dist = Math.sqrt(distSq);
+    const maxReach = a + b;
+    const minReach = Math.abs(a - b);
+    const clampedDist = Math.max(minReach + 1e-3, Math.min(maxReach - 1e-3, dist));
+    const cosAngle = (a * a + b * b - clampedDist * clampedDist) / (2 * a * b);
+    const _midAngle = Math.acos(Math.max(-1, Math.min(1, cosAngle)));
+    const rootAngle = Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
+    const cosA = (a * a + clampedDist * clampedDist - b * b) / (2 * a * clampedDist);
+    const rootBendAngle = Math.acos(Math.max(-1, Math.min(1, cosA)));
+    const totalRootAngle = rootAngle + rootBendAngle * chain.weight;
+    mid.position = [
+      root.position[0] + Math.cos(totalRootAngle) * a * (dx / (dist || 1)),
+      root.position[1] + Math.sin(totalRootAngle) * a,
+      root.position[2] + Math.cos(totalRootAngle) * a * (dz / (dist || 1))
+    ];
+    if (end) {
+      const blendedTarget = [
+        end.position[0] + (target[0] - end.position[0]) * chain.weight,
+        end.position[1] + (target[1] - end.position[1]) * chain.weight,
+        end.position[2] + (target[2] - end.position[2]) * chain.weight
+      ];
+      end.position = blendedTarget;
+    }
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // CCD (Cyclic Coordinate Descent)
+  // ---------------------------------------------------------------------------
+  solveCCD(chainId) {
+    const chain = this.chains.get(chainId);
+    if (!chain || chain.bones.length < 2) return false;
+    const target = chain.target;
+    const bones = chain.bones;
+    for (let iter = 0; iter < chain.iterations; iter++) {
+      for (let i = bones.length - 2; i >= 0; i--) {
+        const bone = bones[i];
+        const endEffector = bones[bones.length - 1];
+        const toEnd = {
+          x: endEffector.position[0] - bone.position[0],
+          y: endEffector.position[1] - bone.position[1],
+          z: endEffector.position[2] - bone.position[2]
+        };
+        const toTarget = {
+          x: target[0] - bone.position[0],
+          y: target[1] - bone.position[1],
+          z: target[2] - bone.position[2]
+        };
+        const angleEnd = Math.atan2(toEnd.y, toEnd.x);
+        const angleTarget = Math.atan2(toTarget.y, toTarget.x);
+        let angle = (angleTarget - angleEnd) * chain.weight;
+        if (bone.minAngle !== void 0 && bone.maxAngle !== void 0) {
+          angle = Math.max(bone.minAngle, Math.min(bone.maxAngle, angle));
+        }
+        const cosA = Math.cos(angle), sinA = Math.sin(angle);
+        for (let j = i + 1; j < bones.length; j++) {
+          const child = bones[j];
+          const rx = child.position[0] - bone.position[0];
+          const ry = child.position[1] - bone.position[1];
+          child.position = [
+            bone.position[0] + rx * cosA - ry * sinA,
+            bone.position[1] + rx * sinA + ry * cosA,
+            child.position[2]
+          ];
+        }
+      }
+      const end = bones[bones.length - 1];
+      const dx = end.position[0] - target[0];
+      const dy = end.position[1] - target[1];
+      const dz = end.position[2] - target[2];
+      if (dx * dx + dy * dy + dz * dz < 1e-3) return true;
+    }
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // Foot Placement
+  // ---------------------------------------------------------------------------
+  setFootPlacement(config) {
+    Object.assign(this.footConfig, config);
+  }
+  getFootPlacement() {
+    return { ...this.footConfig };
+  }
+  updateFootPlacement(footId, groundHeight, dt) {
+    const current = this.footPositions.get(footId) ?? { x: 0, y: 0, z: 0 };
+    const targetY = groundHeight + this.footConfig.footOffset;
+    const blend = Math.min(1, this.footConfig.blendSpeed * dt);
+    const result = {
+      x: current.x,
+      y: current.y + (targetY - current.y) * blend,
+      z: current.z
+    };
+    this.footPositions.set(footId, result);
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // Solve All
+  // ---------------------------------------------------------------------------
+  solveAll() {
+    for (const chain of this.chains.values()) {
+      if (chain.bones.length === 2 || chain.bones.length === 3) {
+        this.solveTwoBone(chain.id);
+      } else {
+        this.solveCCD(chain.id);
+      }
+    }
+  }
+};
+
+// src/animation/MorphTargets.ts
+var MorphTargetSystem = class {
+  targets = /* @__PURE__ */ new Map();
+  presets = /* @__PURE__ */ new Map();
+  vertexCount;
+  constructor(vertexCount) {
+    this.vertexCount = vertexCount;
+  }
+  // ---------------------------------------------------------------------------
+  // Target Management
+  // ---------------------------------------------------------------------------
+  addTarget(name, deltas) {
+    this.targets.set(name, { name, deltas, weight: 0 });
+  }
+  removeTarget(name) {
+    this.targets.delete(name);
+  }
+  setWeight(name, weight) {
+    const target = this.targets.get(name);
+    if (target) target.weight = Math.max(0, Math.min(1, weight));
+  }
+  getWeight(name) {
+    return this.targets.get(name)?.weight ?? 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Preset Management
+  // ---------------------------------------------------------------------------
+  addPreset(name, weights) {
+    this.presets.set(name, { name, weights });
+  }
+  applyPreset(name) {
+    const preset = this.presets.get(name);
+    if (!preset) return;
+    for (const [targetName, weight] of preset.weights) {
+      this.setWeight(targetName, weight);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Vertex Computation
+  // ---------------------------------------------------------------------------
+  computeDeformedPositions(basePositions) {
+    const result = new Float32Array(basePositions);
+    for (const target of this.targets.values()) {
+      if (target.weight <= 0) continue;
+      for (const delta of target.deltas) {
+        const idx = delta.vertexIndex * 3;
+        if (idx + 2 < result.length) {
+          result[idx] += delta.dx * target.weight;
+          result[idx + 1] += delta.dy * target.weight;
+          result[idx + 2] += delta.dz * target.weight;
+        }
+      }
+    }
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // Interpolation
+  // ---------------------------------------------------------------------------
+  lerpWeights(targetWeights, t) {
+    for (const [name, targetWeight] of targetWeights) {
+      const current = this.getWeight(name);
+      this.setWeight(name, current + (targetWeight - current) * t);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getTargetCount() {
+    return this.targets.size;
+  }
+  getActiveTargets() {
+    return [...this.targets.values()].filter((t) => t.weight > 0).map((t) => t.name);
+  }
+  getVertexCount() {
+    return this.vertexCount;
+  }
+};
+
+// src/animation/SkeletalBlender.ts
+var SkeletalBlender = class {
+  layers = [];
+  blendedPoses = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Layer Management
+  // ---------------------------------------------------------------------------
+  addLayer(layer) {
+    this.layers.push(layer);
+  }
+  removeLayer(id) {
+    this.layers = this.layers.filter((l) => l.id !== id);
+  }
+  setLayerWeight(id, weight) {
+    const layer = this.layers.find((l) => l.id === id);
+    if (layer) layer.weight = Math.max(0, Math.min(1, weight));
+  }
+  getLayerWeight(id) {
+    return this.layers.find((l) => l.id === id)?.weight ?? 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Blending
+  // ---------------------------------------------------------------------------
+  blend() {
+    this.blendedPoses.clear();
+    for (const layer of this.layers) {
+      if (layer.weight <= 0) continue;
+      for (const pose of layer.poses) {
+        if (layer.mask && !layer.mask.has(pose.boneId)) continue;
+        const existing = this.blendedPoses.get(pose.boneId);
+        if (!existing || layer.mode === "override") {
+          const base = existing ?? {
+            boneId: pose.boneId,
+            tx: 0,
+            ty: 0,
+            tz: 0,
+            sx: 1,
+            sy: 1,
+            sz: 1
+          };
+          this.blendedPoses.set(pose.boneId, this.lerpPose(base, pose, layer.weight));
+        } else {
+          this.blendedPoses.set(pose.boneId, {
+            boneId: pose.boneId,
+            tx: existing.tx + pose.tx * layer.weight,
+            ty: existing.ty + pose.ty * layer.weight,
+            tz: existing.tz + pose.tz * layer.weight,
+            sx: existing.sx * (1 + (pose.sx - 1) * layer.weight),
+            sy: existing.sy * (1 + (pose.sy - 1) * layer.weight),
+            sz: existing.sz * (1 + (pose.sz - 1) * layer.weight)
+          });
+        }
+      }
+    }
+    return new Map(this.blendedPoses);
+  }
+  // ---------------------------------------------------------------------------
+  // Crossfade
+  // ---------------------------------------------------------------------------
+  crossfade(fromId, toId, t) {
+    this.setLayerWeight(fromId, 1 - t);
+    this.setLayerWeight(toId, t);
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  lerpPose(a, b, t) {
+    return {
+      boneId: a.boneId,
+      tx: a.tx + (b.tx - a.tx) * t,
+      ty: a.ty + (b.ty - a.ty) * t,
+      tz: a.tz + (b.tz - a.tz) * t,
+      sx: a.sx + (b.sx - a.sx) * t,
+      sy: a.sy + (b.sy - a.sy) * t,
+      sz: a.sz + (b.sz - a.sz) * t
+    };
+  }
+  getLayerCount() {
+    return this.layers.length;
+  }
+  getBlendedPose(boneId) {
+    return this.blendedPoses.get(boneId);
+  }
+};
+
+// src/animation/Timeline.ts
+var Timeline = class {
+  entries = [];
+  config;
+  engine;
+  elapsed = 0;
+  isPlaying = false;
+  isPaused = false;
+  currentLoop = 0;
+  direction = 1;
+  totalDuration = 0;
+  constructor(config = {}, engine) {
+    this.config = {
+      mode: "sequential",
+      loop: false,
+      loopCount: 1,
+      pingPong: false,
+      delay: 0,
+      ...config
+    };
+    this.engine = engine || new AnimationEngine();
+  }
+  /**
+   * Add an animation to the timeline.
+   */
+  add(clip, setter, startOffset) {
+    this.entries.push({ clip, setter, startOffset });
+    this.recalcDuration();
+    return this;
+  }
+  /**
+   * Start playing the timeline.
+   */
+  play() {
+    this.elapsed = -this.config.delay;
+    this.isPlaying = true;
+    this.isPaused = false;
+    this.currentLoop = 0;
+    this.direction = 1;
+  }
+  pause() {
+    this.isPaused = true;
+  }
+  resume() {
+    this.isPaused = false;
+  }
+  stop() {
+    this.isPlaying = false;
+    this.engine.clear();
+  }
+  /**
+   * Update the timeline. Call every frame.
+   */
+  update(delta) {
+    if (!this.isPlaying || this.isPaused) return;
+    this.elapsed += delta * this.direction;
+    if (this.elapsed < 0) return;
+    const _t = this.totalDuration > 0 ? this.elapsed / this.totalDuration : 1;
+    if (this.config.mode === "sequential") {
+      this.updateSequential(this.elapsed);
+    } else {
+      this.updateParallel(this.elapsed);
+    }
+    this.engine.update(delta);
+    if (this.elapsed >= this.totalDuration) {
+      this.handleCompletion();
+    }
+  }
+  updateSequential(elapsed) {
+    let cumulativeTime = 0;
+    for (const entry of this.entries) {
+      const clipStart = cumulativeTime + (entry.clip.delay || 0);
+      const clipEnd = clipStart + entry.clip.duration;
+      if (elapsed >= clipStart && elapsed < clipEnd) {
+        if (!this.engine.isActive(entry.clip.id)) {
+          this.engine.play(entry.clip, entry.setter);
+        }
+      }
+      cumulativeTime = clipEnd;
+    }
+  }
+  updateParallel(elapsed) {
+    for (const entry of this.entries) {
+      const offset = entry.startOffset || 0;
+      if (elapsed >= offset && !this.engine.isActive(entry.clip.id)) {
+        const adjustedClip = {
+          ...entry.clip,
+          delay: Math.max(0, offset - elapsed)
+        };
+        this.engine.play(adjustedClip, entry.setter);
+      }
+    }
+  }
+  handleCompletion() {
+    this.currentLoop++;
+    if (this.config.pingPong) {
+      this.direction *= -1;
+      this.elapsed = this.direction === -1 ? this.totalDuration : 0;
+      this.engine.clear();
+      if (this.config.onLoop) this.config.onLoop(this.currentLoop);
+      if (!this.config.loop && this.currentLoop >= this.config.loopCount * 2) {
+        this.isPlaying = false;
+        if (this.config.onComplete) this.config.onComplete();
+      }
+    } else if (this.config.loop) {
+      if (this.config.loopCount !== -1 && this.currentLoop >= this.config.loopCount) {
+        this.isPlaying = false;
+        if (this.config.onComplete) this.config.onComplete();
+      } else {
+        this.elapsed = 0;
+        this.engine.clear();
+        if (this.config.onLoop) this.config.onLoop(this.currentLoop);
+      }
+    } else {
+      this.isPlaying = false;
+      if (this.config.onComplete) this.config.onComplete();
+    }
+  }
+  recalcDuration() {
+    if (this.config.mode === "sequential") {
+      this.totalDuration = this.entries.reduce(
+        (sum, e) => sum + e.clip.duration + (e.clip.delay || 0),
+        0
+      );
+    } else {
+      this.totalDuration = this.entries.reduce(
+        (max, e) => Math.max(max, (e.startOffset || 0) + e.clip.duration),
+        0
+      );
+    }
+  }
+  /**
+   * Get total duration of the timeline.
+   */
+  getDuration() {
+    return this.totalDuration;
+  }
+  /**
+   * Get current elapsed time.
+   */
+  getElapsed() {
+    return Math.max(0, this.elapsed);
+  }
+  /**
+   * Get normalized progress (0-1).
+   */
+  getProgress() {
+    return this.totalDuration > 0 ? Math.max(0, Math.min(1, this.elapsed / this.totalDuration)) : 0;
+  }
+};
+
+// src/animation/TransitionSystem.ts
+var TransitionSystem = class {
+  engine;
+  constructor(engine) {
+    this.engine = engine || new AnimationEngine();
+  }
+  getEngine() {
+    return this.engine;
+  }
+  /**
+   * Fade in/out (opacity 0 <-> 1)
+   */
+  fade(nodeId, direction, setter, options = {}) {
+    const { duration = 0.3, easing = Easing.easeOutQuad, delay = 0, onComplete } = options;
+    const from = direction === "in" ? 0 : 1;
+    const to = direction === "in" ? 1 : 0;
+    this.engine.play(
+      {
+        id: `${nodeId}_fade`,
+        property: "opacity",
+        keyframes: [
+          { time: 0, value: from },
+          { time: 1, value: to, easing }
+        ],
+        duration,
+        loop: false,
+        pingPong: false,
+        delay,
+        onComplete
+      },
+      setter
+    );
+  }
+  /**
+   * Scale in/out (scale 0 <-> 1)
+   */
+  scale(nodeId, direction, setter, options = {}) {
+    const { duration = 0.35, easing = Easing.easeOutBack, delay = 0, onComplete } = options;
+    const from = direction === "in" ? 0 : 1;
+    const to = direction === "in" ? 1 : 0;
+    this.engine.play(
+      {
+        id: `${nodeId}_scale`,
+        property: "scale",
+        keyframes: [
+          { time: 0, value: from },
+          { time: 1, value: to, easing }
+        ],
+        duration,
+        loop: false,
+        pingPong: false,
+        delay,
+        onComplete
+      },
+      setter
+    );
+  }
+  /**
+   * Slide from a direction (e.g., slide up from below)
+   */
+  slide(nodeId, direction, axis, distance, setter, options = {}) {
+    const { duration = 0.4, easing = Easing.easeOutCubic, delay = 0, onComplete } = options;
+    const from = direction === "in" ? distance : 0;
+    const to = direction === "in" ? 0 : distance;
+    this.engine.play(
+      {
+        id: `${nodeId}_slide_${axis}`,
+        property: `slide_${axis}`,
+        keyframes: [
+          { time: 0, value: from },
+          { time: 1, value: to, easing }
+        ],
+        duration,
+        loop: false,
+        pingPong: false,
+        delay,
+        onComplete
+      },
+      setter
+    );
+  }
+  /**
+   * Combined: Scale + Fade (common for dialogs/menus)
+   */
+  popIn(nodeId, scaleSetter, opacitySetter, options = {}) {
+    const { duration = 0.35, delay = 0, onComplete } = options;
+    this.scale(nodeId, "in", scaleSetter, { duration, delay, easing: Easing.easeOutBack });
+    this.fade(nodeId, "in", opacitySetter, { duration: duration * 0.6, delay, onComplete });
+  }
+  /**
+   * Combined: Scale + Fade out
+   */
+  popOut(nodeId, scaleSetter, opacitySetter, options = {}) {
+    const { duration = 0.25, delay = 0, onComplete } = options;
+    this.scale(nodeId, "out", scaleSetter, { duration, delay, easing: Easing.easeInQuad });
+    this.fade(nodeId, "out", opacitySetter, { duration, delay, onComplete });
+  }
+  /**
+   * Update all transitions. Must be called every frame.
+   */
+  update(delta) {
+    this.engine.update(delta);
+  }
+};
+
+export {
+  AnimClip,
+  Easing,
+  AnimationEngine,
+  AnimationGraph,
+  SpringPresets,
+  SpringAnimator,
+  Vec3SpringAnimator,
+  getSharedAnimationEngine,
+  animationTraitHandler,
+  AnimationTransitionSystem,
+  AvatarController,
+  BoneSystem,
+  CutsceneTimeline,
+  CutsceneBuilder,
+  IKSolver,
+  MorphTargetSystem,
+  SkeletalBlender,
+  Timeline,
+  TransitionSystem,
+  animation_exports
+};