topview-3d-cli 0.1.0__py3-none-any.whl

topview_3d_cli/_runtime/director-cli/node_modules/@topview/3d-builder/dist/evaluate/index.mjs

@@ -0,0 +1,4229 @@
+import { z } from 'zod';
+
+// src/evaluate/FrameSnapshot.ts
+function vec3(x = 0, y = 0, z2 = 0) {
+  return { x, y, z: z2 };
+}
+var CMD_POOL = Symbol("cmdPool");
+function cmdPoolOf(out) {
+  const snap = out;
+  let pool = snap[CMD_POOL];
+  if (!pool) {
+    pool = [];
+    snap[CMD_POOL] = pool;
+  }
+  return pool;
+}
+function createFrameSnapshot() {
+  const out = {
+    transforms: /* @__PURE__ */ new Map(),
+    poses: /* @__PURE__ */ new Map(),
+    motionPlayback: [],
+    camera: { position: vec3(), lookAt: vec3(0, 1.2, 0), fov: 50 }
+  };
+  out[CMD_POOL] = [];
+  return out;
+}
+function prepareFrameSnapshot(out, nodeIds) {
+  for (const id of nodeIds) {
+    if (!out.transforms.has(id)) {
+      out.transforms.set(id, {
+        position: vec3(),
+        rotation: vec3(),
+        scale: vec3(1, 1, 1),
+        lookAt: vec3(0, 1.2, 0),
+        fov: 50
+      });
+    }
+    if (!out.poses.has(id))
+      out.poses.set(id, []);
+  }
+}
+function resetFrameSnapshot(out) {
+  out.motionPlayback.length = 0;
+  for (const poses of out.poses.values())
+    poses.length = 0;
+}
+function copyVec3(dst, src) {
+  dst.x = src.x;
+  dst.y = src.y;
+  dst.z = src.z;
+}
+function ensureTransform(out, nodeId) {
+  let xf = out.transforms.get(nodeId);
+  if (xf)
+    return xf;
+  xf = {
+    position: vec3(),
+    rotation: vec3(),
+    scale: vec3(1, 1, 1),
+    lookAt: vec3(0, 1.2, 0),
+    fov: 50
+  };
+  out.transforms.set(nodeId, xf);
+  return xf;
+}
+
+// src/evaluate/camera/cameraAim.ts
+var D2R = Math.PI / 180;
+function lookDistance(pos, lookAt) {
+  if (!lookAt)
+    return 2;
+  return Math.hypot(lookAt.x - pos.x, lookAt.y - pos.y, lookAt.z - pos.z) || 2;
+}
+function lookAtFromEulerDeg(pos, rotDeg, dist) {
+  const x = rotDeg.x * D2R;
+  const y = rotDeg.y * D2R;
+  const z2 = rotDeg.z * D2R;
+  const cx = Math.cos(x);
+  const sx = Math.sin(x);
+  const cy = Math.cos(y);
+  const sy = Math.sin(y);
+  const cz = Math.cos(z2);
+  const sz = Math.sin(z2);
+  const iy = sx;
+  const iz = -cx;
+  const jx = sy * iz;
+  const jy = iy;
+  const jz = cy * iz;
+  const fx = cz * jx - sz * jy;
+  const fy = sz * jx + cz * jy;
+  const fz = jz;
+  const len = Math.hypot(fx, fy, fz) || 1;
+  const d = dist > 1e-4 ? dist : 2;
+  return {
+    x: pos.x + fx / len * d,
+    y: pos.y + fy / len * d,
+    z: pos.z + fz / len * d
+  };
+}
+
+// src/evaluate/curves/BakedCurve.ts
+function sampleCurve(curve, timeMs) {
+  const kfs = curve.keyframes;
+  if (kfs.length === 0)
+    return 0;
+  if (kfs.length === 1 || timeMs <= kfs[0].time)
+    return kfs[0].value;
+  const last = kfs[kfs.length - 1];
+  if (timeMs >= last.time)
+    return last.value;
+  let lo = 0;
+  let hi = kfs.length - 1;
+  while (lo + 1 < hi) {
+    const mid = lo + hi >> 1;
+    if (kfs[mid].time <= timeMs)
+      lo = mid;
+    else
+      hi = mid;
+  }
+  const a = kfs[lo];
+  const b = kfs[hi];
+  const span = b.time - a.time;
+  let t = span > 0 ? (timeMs - a.time) / span : 0;
+  if (a.interpolation === "bezier") {
+    t = t * t * (3 - 2 * t);
+  }
+  return a.value + (b.value - a.value) * t;
+}
+
+// src/evaluate/camera/CameraRig.ts
+var _rawOut = { position: [0, 0, 0], lookAt: [0, 0, 0], fov: 50, clipId: null };
+var curveMapCache = /* @__PURE__ */ new WeakMap();
+function curveMap(clip) {
+  let m = curveMapCache.get(clip);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    for (const c of clip.motion.curves)
+      m.set(`${c.group}:${c.arrayIndex}`, c);
+    curveMapCache.set(clip, m);
+  }
+  return m;
+}
+function clipProgress(clip, frame) {
+  const span = clip.frameEnd - clip.frameStart;
+  const p = span > 0 ? (frame - clip.frameStart) / span : 0;
+  const dur = clip.motion.durationMs;
+  if (!(dur > 0))
+    return Math.min(Math.max(p, 0), 1);
+  const ms = clip.trimStartMs + p * (clip.trimEndMs - clip.trimStartMs);
+  return Math.min(Math.max(ms / dur, 0), 1);
+}
+function applyEasing(easing, t) {
+  switch (easing) {
+    case "ease-in-out":
+      return t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t);
+    case "ease-in":
+      return t * t;
+    case "ease-out":
+      return 1 - (1 - t) * (1 - t);
+    default:
+      return t;
+  }
+}
+var D2R2 = Math.PI / 180;
+function proceduralOrbitPose(node, clip, frame) {
+  const src = clip.motion.source;
+  if (!src || src.type !== "orbit" || !src.startPosition || !src.pivot)
+    return false;
+  const e = applyEasing(src.easing, clipProgress(clip, frame));
+  const axis = src.axis ?? { x: 0, y: 1, z: 0 };
+  const al = Math.hypot(axis.x, axis.y, axis.z) || 1;
+  const ax = { x: axis.x / al, y: axis.y / al, z: axis.z / al };
+  const v = {
+    x: src.startPosition.x - src.pivot.x,
+    y: src.startPosition.y - src.pivot.y,
+    z: src.startPosition.z - src.pivot.z
+  };
+  const dot = v.x * ax.x + v.y * ax.y + v.z * ax.z;
+  const par = { x: ax.x * dot, y: ax.y * dot, z: ax.z * dot };
+  const perp = { x: v.x - par.x, y: v.y - par.y, z: v.z - par.z };
+  const ang = (src.yawDeg ?? 0) * e * D2R2;
+  const cos = Math.cos(ang);
+  const sin = Math.sin(ang);
+  const cross = {
+    x: ax.y * perp.z - ax.z * perp.y,
+    y: ax.z * perp.x - ax.x * perp.z,
+    z: ax.x * perp.y - ax.y * perp.x
+  };
+  let rp = {
+    x: perp.x * cos + cross.x * sin,
+    y: perp.y * cos + cross.y * sin,
+    z: perp.z * cos + cross.z * sin
+  };
+  const r0 = Math.hypot(perp.x, perp.y, perp.z);
+  const rd = src.radiusDelta ?? 0;
+  if (r0 > 1e-9 && rd !== 0) {
+    const k = (r0 + rd * e) / r0;
+    rp = { x: rp.x * k, y: rp.y * k, z: rp.z * k };
+  }
+  const hd = (src.heightDelta ?? 0) * e;
+  _rawOut.position[0] = src.pivot.x + par.x + ax.x * hd + rp.x;
+  _rawOut.position[1] = src.pivot.y + par.y + ax.y * hd + rp.y;
+  _rawOut.position[2] = src.pivot.z + par.z + ax.z * hd + rp.z;
+  const la0 = src.startLookAt ?? { x: 0, y: 1.2, z: 0 };
+  const la1 = src.lookAtTarget ?? la0;
+  _rawOut.lookAt[0] = la0.x + (la1.x - la0.x) * e;
+  _rawOut.lookAt[1] = la0.y + (la1.y - la0.y) * e;
+  _rawOut.lookAt[2] = la0.z + (la1.z - la0.z) * e;
+  _rawOut.fov = src.fov ?? node.camera?.fov ?? 50;
+  _rawOut.clipId = clip.id;
+  return true;
+}
+function staticPose(node) {
+  const t = node.transform;
+  const la = node.camera?.lookAt ?? { x: 0, y: 1.2, z: 0 };
+  return {
+    position: [t.position.x, t.position.y, t.position.z],
+    lookAt: [la.x, la.y, la.z],
+    fov: node.camera?.fov ?? 50,
+    clipId: null
+  };
+}
+function writeStaticPose(node, out) {
+  const t = node.transform;
+  const la = node.camera?.lookAt ?? { x: 0, y: 1.2, z: 0 };
+  out.position[0] = t.position.x;
+  out.position[1] = t.position.y;
+  out.position[2] = t.position.z;
+  out.lookAt[0] = la.x;
+  out.lookAt[1] = la.y;
+  out.lookAt[2] = la.z;
+  out.fov = node.camera?.fov ?? 50;
+  out.clipId = null;
+}
+function writeRawClipPose(node, clip, frame, _fps, out) {
+  if (proceduralOrbitPose(node, clip, frame)) {
+    out.position[0] = _rawOut.position[0];
+    out.position[1] = _rawOut.position[1];
+    out.position[2] = _rawOut.position[2];
+    out.lookAt[0] = _rawOut.lookAt[0];
+    out.lookAt[1] = _rawOut.lookAt[1];
+    out.lookAt[2] = _rawOut.lookAt[2];
+    out.fov = _rawOut.fov;
+    out.clipId = _rawOut.clipId;
+    return;
+  }
+  const speed = clip.playback?.speed ?? 1;
+  const span = clip.frameEnd - clip.frameStart;
+  const p = span > 0 ? (frame - clip.frameStart) / span : 0;
+  let ms = clip.trimStartMs + p * (clip.trimEndMs - clip.trimStartMs) * speed;
+  const trimSpan = clip.trimEndMs - clip.trimStartMs;
+  if (clip.playback?.loop && trimSpan > 0) {
+    ms = clip.trimStartMs + ((ms - clip.trimStartMs) % trimSpan + trimSpan) % trimSpan;
+  }
+  ms = Math.min(Math.max(ms, clip.trimStartMs), clip.trimEndMs);
+  const m = curveMap(clip);
+  const s = (group, idx, fallback) => {
+    const c = m.get(`${group}:${idx}`);
+    return c ? sampleCurve(c, ms) : fallback;
+  };
+  const t = node.transform;
+  const staticLa = node.camera?.lookAt ?? { x: 0, y: 1.2, z: 0 };
+  out.position[0] = s("position", 0, t.position.x);
+  out.position[1] = s("position", 1, t.position.y);
+  out.position[2] = s("position", 2, t.position.z);
+  out.lookAt[0] = s("lookAt", 0, staticLa.x);
+  out.lookAt[1] = s("lookAt", 1, staticLa.y);
+  out.lookAt[2] = s("lookAt", 2, staticLa.z);
+  out.fov = s("lens", 0, node.camera?.fov ?? 50);
+  out.clipId = clip.id;
+}
+function rawClipPose(node, clip, frame, fps) {
+  writeRawClipPose(node, clip, frame, fps, _rawOut);
+  return {
+    position: [_rawOut.position[0], _rawOut.position[1], _rawOut.position[2]],
+    lookAt: [_rawOut.lookAt[0], _rawOut.lookAt[1], _rawOut.lookAt[2]],
+    fov: _rawOut.fov,
+    clipId: _rawOut.clipId
+  };
+}
+var chainCache = /* @__PURE__ */ new WeakMap();
+function buildChain(node, clips, fps) {
+  const segs = clips.filter((c) => c.target.nodeId === node.id).sort((a, b) => a.frameStart - b.frameStart);
+  let prev = staticPose(node);
+  let first = true;
+  return segs.map((clip) => {
+    const rawFirst = rawClipPose(node, clip, clip.frameStart, fps);
+    const rawLast = rawClipPose(node, clip, clip.frameEnd, fps);
+    const offset = first ? { position: [0, 0, 0], lookAt: [0, 0, 0], fov: 0 } : {
+      position: [
+        prev.position[0] - rawFirst.position[0],
+        prev.position[1] - rawFirst.position[1],
+        prev.position[2] - rawFirst.position[2]
+      ],
+      lookAt: [
+        prev.lookAt[0] - rawFirst.lookAt[0],
+        prev.lookAt[1] - rawFirst.lookAt[1],
+        prev.lookAt[2] - rawFirst.lookAt[2]
+      ],
+      fov: prev.fov - rawFirst.fov
+    };
+    first = false;
+    const end = {
+      position: [
+        rawLast.position[0] + offset.position[0],
+        rawLast.position[1] + offset.position[1],
+        rawLast.position[2] + offset.position[2]
+      ],
+      lookAt: [
+        rawLast.lookAt[0] + offset.lookAt[0],
+        rawLast.lookAt[1] + offset.lookAt[1],
+        rawLast.lookAt[2] + offset.lookAt[2]
+      ],
+      fov: rawLast.fov + offset.fov
+    };
+    prev = { ...end, clipId: null };
+    return { clip, offset, end };
+  });
+}
+function getChain(node, clips, fps) {
+  let byNode = chainCache.get(clips);
+  if (!byNode) {
+    byNode = /* @__PURE__ */ new WeakMap();
+    chainCache.set(clips, byNode);
+  }
+  let chain = byNode.get(node);
+  if (!chain) {
+    chain = buildChain(node, clips, fps);
+    byNode.set(node, chain);
+  }
+  return chain;
+}
+function evaluateCameraPoseInto(node, clips, frame, fps, chained, out) {
+  const clip = clips.find(
+    (c) => c.target.nodeId === node.id && frame >= c.frameStart && frame <= c.frameEnd
+  );
+  if (!node.camera) {
+    writeStaticPose(node, out);
+    return;
+  }
+  if (!chained) {
+    if (!clip)
+      writeStaticPose(node, out);
+    else
+      writeRawClipPose(node, clip, frame, fps, out);
+    return;
+  }
+  const chain = getChain(node, clips, fps);
+  if (chain.length === 0) {
+    writeStaticPose(node, out);
+    return;
+  }
+  if (clip) {
+    const seg = chain.find((s) => s.clip === clip);
+    writeRawClipPose(node, clip, frame, fps, out);
+    out.position[0] += seg.offset.position[0];
+    out.position[1] += seg.offset.position[1];
+    out.position[2] += seg.offset.position[2];
+    out.lookAt[0] += seg.offset.lookAt[0];
+    out.lookAt[1] += seg.offset.lookAt[1];
+    out.lookAt[2] += seg.offset.lookAt[2];
+    out.fov += seg.offset.fov;
+    out.clipId = clip.id;
+    return;
+  }
+  if (frame < chain[0].clip.frameStart) {
+    writeStaticPose(node, out);
+    return;
+  }
+  let prev = chain[0];
+  for (const s of chain) {
+    if (s.clip.frameEnd < frame)
+      prev = s;
+    else
+      break;
+  }
+  out.position[0] = prev.end.position[0];
+  out.position[1] = prev.end.position[1];
+  out.position[2] = prev.end.position[2];
+  out.lookAt[0] = prev.end.lookAt[0];
+  out.lookAt[1] = prev.end.lookAt[1];
+  out.lookAt[2] = prev.end.lookAt[2];
+  out.fov = prev.end.fov;
+  out.clipId = null;
+}
+
+// src/evaluate/camera/subjectBinding.ts
+var DEG2RAD = Math.PI / 180;
+function subjectYawDeg(rotation) {
+  const x = rotation.x * DEG2RAD;
+  const y = rotation.y * DEG2RAD;
+  const forwardX = Math.sin(y);
+  const forwardZ = Math.cos(x) * Math.cos(y);
+  if (Math.abs(forwardX) < 1e-9 && Math.abs(forwardZ) < 1e-9)
+    return rotation.y;
+  return Math.atan2(forwardX, forwardZ) / DEG2RAD;
+}
+function subjectLocalToWorld(local, subjectPos, yawDeg) {
+  const yaw = yawDeg * DEG2RAD;
+  const cos = Math.cos(yaw);
+  const sin = Math.sin(yaw);
+  return {
+    x: subjectPos.x + local.x * cos + local.z * sin,
+    y: subjectPos.y + local.y,
+    z: subjectPos.z - local.x * sin + local.z * cos
+  };
+}
+function subjectWorldToLocal(world, subjectPos, yawDeg) {
+  const yaw = yawDeg * DEG2RAD;
+  const cos = Math.cos(yaw);
+  const sin = Math.sin(yaw);
+  const dx = world.x - subjectPos.x;
+  const dz = world.z - subjectPos.z;
+  return {
+    x: dx * cos - dz * sin,
+    y: world.y - subjectPos.y,
+    z: dx * sin + dz * cos
+  };
+}
+function subjectOverridesMotion(binding) {
+  return binding.overridesMotion !== false;
+}
+var CHARACTER_LOOK_AT_HEIGHT = 1.2;
+function characterLookAtPoint(subjectPos, offset) {
+  if (offset) {
+    return {
+      x: subjectPos.x + offset.x,
+      y: subjectPos.y + offset.y,
+      z: subjectPos.z + offset.z
+    };
+  }
+  return {
+    x: subjectPos.x,
+    y: subjectPos.y + CHARACTER_LOOK_AT_HEIGHT,
+    z: subjectPos.z
+  };
+}
+function resolveSubjectCameraPose(binding, subjectPos, subjectRotation) {
+  const yawDeg = binding.followRotation ? subjectYawDeg(subjectRotation) : 0;
+  return {
+    position: subjectLocalToWorld(binding.offset, subjectPos, yawDeg),
+    lookAt: subjectLocalToWorld(binding.lookAtOffset, subjectPos, yawDeg)
+  };
+}
+
+// src/evaluate/clips.ts
+function motionClipAt(clips, nodeId, frame) {
+  for (const clip of clips) {
+    if (clip.target.nodeId === nodeId && frame >= clip.frameStart && frame <= clip.frameEnd) {
+      return clip;
+    }
+  }
+  return null;
+}
+function motionTimeSeconds(clip, frame, fps) {
+  const speed = clip.playback.speed ?? 1;
+  const t = (Math.max(clip.frameStart, frame) - clip.frameStart) / fps * speed;
+  if (clip.playback.loop && clip.sourceDuration > 0) {
+    return clip.motion.time + t % clip.sourceDuration;
+  }
+  return Math.min(clip.motion.time + t, clip.sourceDuration);
+}
+
+// src/evaluate/curves/KeyframeTrack.ts
+function applyInterpolation(interp, t) {
+  switch (interp) {
+    case "smooth":
+      return t * t * (3 - 2 * t);
+    case "ease-in-out":
+      return t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t);
+    case "ease-in":
+      return t * t;
+    case "ease-out":
+      return 1 - (1 - t) * (1 - t);
+    case "linear":
+    default:
+      return t;
+  }
+}
+var _sortedCache = /* @__PURE__ */ new WeakMap();
+function sortedKeyframes(kfs) {
+  let sorted = _sortedCache.get(kfs);
+  if (sorted)
+    return sorted;
+  sorted = kfs.slice().sort((a, b) => a.frame - b.frame);
+  _sortedCache.set(kfs, sorted);
+  return sorted;
+}
+function sampleKeyframesInto(kfs, frame, out, extrapolate = true) {
+  if (kfs.length === 0)
+    return false;
+  const sorted = sortedKeyframes(kfs);
+  const write = (src) => {
+    const n = Math.max(src.length, out.length);
+    for (let i2 = 0; i2 < n; i2++)
+      out[i2] = src[i2] ?? 0;
+  };
+  if (frame <= sorted[0].frame) {
+    if (extrapolate !== true && frame < sorted[0].frame)
+      return false;
+    write(sorted[0].value);
+    return true;
+  }
+  const last = sorted[sorted.length - 1];
+  if (frame >= last.frame) {
+    write(last.value);
+    return true;
+  }
+  let i = 0;
+  while (i < sorted.length - 2 && sorted[i + 1].frame < frame)
+    i++;
+  const a = sorted[i];
+  const b = sorted[i + 1];
+  const span = b.frame - a.frame;
+  let t = span > 0 ? (frame - a.frame) / span : 0;
+  t = applyInterpolation(a.interpolation, t);
+  const dims = Math.max(a.value.length, b.value.length, out.length);
+  for (let j = 0; j < dims; j++) {
+    const av = a.value[j] ?? 0;
+    out[j] = av + ((b.value[j] ?? av) - av) * t;
+  }
+  return true;
+}
+
+// src/evaluate/path/catmullRom.ts
+var ARC_DIVISIONS = 200;
+var curveCache = /* @__PURE__ */ new WeakMap();
+function distSq(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const dz = a.z - b.z;
+  return dx * dx + dy * dy + dz * dz;
+}
+function interpolate(p0, p1, p2, p3, dt0, dt1, dt2, t, out) {
+  const axis = (a, b, c, d) => {
+    const t1 = (b - a) / dt0 - (c - a) / (dt0 + dt1) + (c - b) / dt1;
+    const t2 = (c - b) / dt1 - (d - b) / (dt1 + dt2) + (d - c) / dt2;
+    const c0 = b;
+    const c1 = dt1 * t1;
+    const c2 = -3 * b + 3 * c - 2 * dt1 * t1 - dt1 * t2;
+    const c3 = 2 * b - 2 * c + dt1 * t1 + dt1 * t2;
+    return c0 + c1 * t + c2 * t * t + c3 * t * t * t;
+  };
+  out.x = axis(p0.x, p1.x, p2.x, p3.x);
+  out.y = axis(p0.y, p1.y, p2.y, p3.y);
+  out.z = axis(p0.z, p1.z, p2.z, p3.z);
+}
+var _p0 = { x: 0, y: 0, z: 0 };
+var _p3 = { x: 0, y: 0, z: 0 };
+var _tmp = { x: 0, y: 0, z: 0 };
+function getPoint(cache, t, out) {
+  const points = cache.pts;
+  const l = points.length;
+  const closed = cache.closed;
+  const p = (l - (closed ? 0 : 1)) * t;
+  let intPoint = Math.floor(p);
+  let weight = p - intPoint;
+  if (closed) {
+    intPoint += intPoint > 0 ? 0 : (Math.floor(Math.abs(intPoint) / l) + 1) * l;
+  } else if (weight === 0 && intPoint === l - 1) {
+    intPoint = l - 2;
+    weight = 1;
+  }
+  let p0;
+  if (closed || intPoint > 0) {
+    p0 = points[(intPoint - 1 + l) % l];
+  } else {
+    _p0.x = points[0].x * 2 - points[1].x;
+    _p0.y = points[0].y * 2 - points[1].y;
+    _p0.z = points[0].z * 2 - points[1].z;
+    p0 = _p0;
+  }
+  const p1 = points[intPoint % l];
+  const p2 = points[(intPoint + 1) % l];
+  let p3;
+  if (closed || intPoint + 2 < l) {
+    p3 = points[(intPoint + 2) % l];
+  } else {
+    const last = points[l - 1];
+    const prev = points[l - 2];
+    _p3.x = last.x * 2 - prev.x;
+    _p3.y = last.y * 2 - prev.y;
+    _p3.z = last.z * 2 - prev.z;
+    p3 = _p3;
+  }
+  let dt0 = Math.pow(distSq(p0, p1), 0.25);
+  let dt1 = Math.pow(distSq(p1, p2), 0.25);
+  let dt2 = Math.pow(distSq(p2, p3), 0.25);
+  if (dt1 < 1e-4)
+    dt1 = 1;
+  if (dt0 < 1e-4)
+    dt0 = dt1;
+  if (dt2 < 1e-4)
+    dt2 = dt1;
+  interpolate(p0, p1, p2, p3, dt0, dt1, dt2, weight, out);
+}
+function buildCache(points, closed) {
+  const pts = points.map((p) => ({ x: p.position.x, y: p.position.y, z: p.position.z }));
+  const cache = { pts, closed, lengths: [0], total: 0 };
+  let sum = 0;
+  const a = { x: 0, y: 0, z: 0 };
+  const b = { x: 0, y: 0, z: 0 };
+  getPoint(cache, 0, a);
+  for (let i = 1; i <= ARC_DIVISIONS; i++) {
+    getPoint(cache, i / ARC_DIVISIONS, b);
+    sum += Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+    cache.lengths.push(sum);
+    a.x = b.x;
+    a.y = b.y;
+    a.z = b.z;
+  }
+  cache.total = sum;
+  return cache;
+}
+function cacheOf(points, closed) {
+  const key = points;
+  const hit = curveCache.get(key);
+  if (hit && hit.closed === closed)
+    return hit;
+  const next = buildCache(points, closed);
+  curveCache.set(key, next);
+  return next;
+}
+function uToT(cache, u) {
+  const target = Math.min(Math.max(u, 0), 1) * cache.total;
+  const lengths = cache.lengths;
+  let lo = 0;
+  let hi = ARC_DIVISIONS;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (lengths[mid] < target)
+      lo = mid;
+    else
+      hi = mid;
+  }
+  const span = lengths[hi] - lengths[lo];
+  const t = span > 0 ? (target - lengths[lo]) / span : 0;
+  return (lo + t) / ARC_DIVISIONS;
+}
+function catmullRomPointAt(points, closed, u, out) {
+  const cache = cacheOf(points, closed);
+  getPoint(cache, uToT(cache, u), out);
+}
+function catmullRomTangentAt(points, closed, u, out) {
+  const cache = cacheOf(points, closed);
+  const t = uToT(cache, u);
+  const delta = 1e-4;
+  let t1 = t - delta;
+  let t2 = t + delta;
+  if (t1 < 0)
+    t1 = closed ? t1 + 1 : 0;
+  if (t2 > 1)
+    t2 = closed ? t2 - 1 : 1;
+  getPoint(cache, t1, _tmp);
+  getPoint(cache, t2, out);
+  out.x -= _tmp.x;
+  out.y -= _tmp.y;
+  out.z -= _tmp.z;
+}
+function catmullRomLength(points, closed) {
+  return cacheOf(points, closed).total;
+}
+function catmullRomSpacedPoints(points, closed, divisions) {
+  const out = [];
+  for (let i = 0; i <= divisions; i++) {
+    const p = { x: 0, y: 0, z: 0 };
+    catmullRomPointAt(points, closed, i / divisions, p);
+    out.push(p);
+  }
+  return out;
+}
+
+// src/evaluate/path/samplePath.ts
+var _pts = [];
+var _eval = { position: { x: 0, y: 0, z: 0 }, yaw: 0 };
+var _pos = { x: 0, y: 0, z: 0 };
+var _tan = { x: 0, y: 0, z: 0 };
+var PATH_WALK_SPEED = 2;
+var PATH_CLIP_MAX_SECONDS = 15;
+var D2R3 = Math.PI / 180;
+function pathControlCentroid(pathNode) {
+  const pts = pathNode.path?.points;
+  if (!pts || pts.length === 0)
+    return { x: 0, y: 0, z: 0 };
+  let x = 0;
+  let y = 0;
+  let z2 = 0;
+  for (const p of pts) {
+    x += p.position.x;
+    y += p.position.y;
+    z2 += p.position.z;
+  }
+  const n = pts.length;
+  return { x: x / n, y: y / n, z: z2 / n };
+}
+function rotateEulerXYZ(x, y, z2, rotDeg) {
+  const rx = rotDeg.x * D2R3;
+  const ry = rotDeg.y * D2R3;
+  const rz = rotDeg.z * D2R3;
+  const cx = Math.cos(rx);
+  const sx = Math.sin(rx);
+  const cy = Math.cos(ry);
+  const sy = Math.sin(ry);
+  const cz = Math.cos(rz);
+  const sz = Math.sin(rz);
+  const x1 = x;
+  const y1 = cx * y - sx * z2;
+  const z1 = sx * y + cx * z2;
+  const x2 = cy * x1 + sy * z1;
+  const y2 = y1;
+  const z22 = -sy * x1 + cy * z1;
+  return [cz * x2 - sz * y2, sz * x2 + cz * y2, z22];
+}
+function transformPathLocalPoint(local, transform, center) {
+  const dx = (local.x - center.x) * transform.scale.x;
+  const dy = (local.y - center.y) * transform.scale.y;
+  const dz = (local.z - center.z) * transform.scale.z;
+  const [rx, ry, rz] = rotateEulerXYZ(dx, dy, dz, transform.rotation);
+  return {
+    x: rx + center.x + transform.position.x,
+    y: ry + center.y + transform.position.y,
+    z: rz + center.z + transform.position.z
+  };
+}
+function transformPathDirection(dir, transform) {
+  const dx = dir.x * transform.scale.x;
+  const dy = dir.y * transform.scale.y;
+  const dz = dir.z * transform.scale.z;
+  const [rx, ry, rz] = rotateEulerXYZ(dx, dy, dz, transform.rotation);
+  return { x: rx, y: ry, z: rz };
+}
+function pathArcLength(pathNode) {
+  const path = pathNode.path;
+  if (!path || path.points.length < 2)
+    return 0;
+  if (path.parameterization === "arc-length")
+    return catmullRomLength(path.points, path.closed);
+  let len = 0;
+  for (let i = 1; i < path.points.length; i++) {
+    const a = path.points[i - 1].position;
+    const b = path.points[i].position;
+    len += Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+  }
+  return len;
+}
+function pathClipDurationFrames(pathNode, fps) {
+  const seconds = Math.min(pathArcLength(pathNode) / PATH_WALK_SPEED, PATH_CLIP_MAX_SECONDS);
+  return Math.max(1, Math.round(seconds * fps));
+}
+function samplePathPoints(pathNode, divisions = 120) {
+  const path = pathNode.path;
+  if (!path || path.points.length < 2)
+    return [];
+  const center = pathControlCentroid(pathNode);
+  const xf = pathNode.transform;
+  const toWorld = (p) => transformPathLocalPoint(p, xf, center);
+  if (path.parameterization === "arc-length") {
+    return catmullRomSpacedPoints(path.points, path.closed, divisions).map(toWorld);
+  }
+  return [...path.points].sort((a, b) => (a.timeRatio ?? 0) - (b.timeRatio ?? 0)).map((p) => toWorld(p.position));
+}
+function evaluatePathMotionInto(pathNode, clip, frame, out) {
+  const path = pathNode.path;
+  if (!path || path.points.length < 2)
+    return false;
+  const span = clip.frameEnd - clip.frameStart;
+  const progress = span > 0 ? Math.min(Math.max((frame - clip.frameStart) / span, 0), 1) : 0;
+  const a = clip.pathStartPercent / 100;
+  const b = clip.pathEndPercent / 100;
+  const u = clip.direction === "backward" ? b - progress * (b - a) : a + progress * (b - a);
+  const center = pathControlCentroid(pathNode);
+  const xf = pathNode.transform;
+  let tanX;
+  let tanZ;
+  if (path.parameterization === "arc-length") {
+    const uc = Math.min(Math.max(u, 0), 1);
+    catmullRomPointAt(path.points, path.closed, uc, _pos);
+    catmullRomTangentAt(path.points, path.closed, uc, _tan);
+    const world = transformPathLocalPoint(_pos, xf, center);
+    out.position.x = world.x;
+    out.position.y = world.y;
+    out.position.z = world.z;
+    const dir = transformPathDirection(_tan, xf);
+    tanX = dir.x;
+    tanZ = dir.z;
+  } else {
+    _pts.length = 0;
+    for (const point of path.points)
+      _pts.push(point);
+    _pts.sort((x, y) => (x.timeRatio ?? 0) - (y.timeRatio ?? 0));
+    let i = 0;
+    while (i < _pts.length - 2 && (_pts[i + 1].timeRatio ?? 0) < u)
+      i++;
+    const p0 = _pts[i];
+    const p1 = _pts[i + 1];
+    const segSpan = (p1.timeRatio ?? 0) - (p0.timeRatio ?? 0);
+    const t = segSpan > 1e-6 ? Math.min(Math.max((u - (p0.timeRatio ?? 0)) / segSpan, 0), 1) : 0;
+    const local = {
+      x: p0.position.x + (p1.position.x - p0.position.x) * t,
+      y: p0.position.y + (p1.position.y - p0.position.y) * t,
+      z: p0.position.z + (p1.position.z - p0.position.z) * t
+    };
+    const world = transformPathLocalPoint(local, xf, center);
+    out.position.x = world.x;
+    out.position.y = world.y;
+    out.position.z = world.z;
+    const dir = transformPathDirection(
+      {
+        x: p1.position.x - p0.position.x,
+        y: p1.position.y - p0.position.y,
+        z: p1.position.z - p0.position.z
+      },
+      xf
+    );
+    tanX = dir.x;
+    tanZ = dir.z;
+  }
+  out.yaw = tanX * tanX + tanZ * tanZ > 1e-12 ? Math.atan2(tanX, tanZ) : 0;
+  return true;
+}
+function evaluatePathMotion(pathNode, clip, frame) {
+  if (!evaluatePathMotionInto(pathNode, clip, frame, _eval))
+    return null;
+  return {
+    position: { x: _eval.position.x, y: _eval.position.y, z: _eval.position.z },
+    yaw: _eval.yaw
+  };
+}
+
+// src/evaluate/evaluateSteps.ts
+var RAD2DEG = 180 / Math.PI;
+var AXES = ["x", "y", "z"];
+var POSE_KEYS = [
+  "bodyBend",
+  "bodyTilt",
+  "bodyTurn",
+  "torsoBend",
+  "torsoTilt",
+  "torsoTurn",
+  "headNod",
+  "headTilt",
+  "headTurn",
+  "lArmRaise",
+  "lArmStraddle",
+  "lArmTurn",
+  "lElbowBend",
+  "rArmRaise",
+  "rArmStraddle",
+  "rArmTurn",
+  "rElbowBend",
+  "lLegRaise",
+  "lLegStraddle",
+  "lLegTurn",
+  "lKneeBend",
+  "rLegRaise",
+  "rLegStraddle",
+  "rLegTurn",
+  "rKneeBend"
+];
+var _sample = [0, 0, 0];
+var _path = { position: { x: 0, y: 0, z: 0 }, yaw: 0 };
+var _cam = { position: [0, 0, 0], lookAt: [0, 0, 0], fov: 50, clipId: null };
+var _nodeById = /* @__PURE__ */ new Map();
+function indexSceneNodes(nodes) {
+  _nodeById.clear();
+  for (const node of nodes)
+    _nodeById.set(node.id, node);
+}
+function writeStaticTransform(xf, t) {
+  copyVec3(xf.position, t.position);
+  copyVec3(xf.rotation, t.rotation);
+  copyVec3(xf.scale, t.scale);
+}
+function applyFcurvesToTransform(xf, fcurves, nodeId, frame) {
+  for (let i = 0; i < 3; i++) {
+    const p = fcurves.evalScalar(nodeId, "transform.position", i, frame);
+    if (p !== null)
+      xf.position[AXES[i]] = p;
+    const r = fcurves.evalScalar(nodeId, "transform.rotation", i, frame);
+    if (r !== null)
+      xf.rotation[AXES[i]] = r;
+    const s = fcurves.evalScalar(nodeId, "transform.scale", i, frame);
+    if (s !== null)
+      xf.scale[AXES[i]] = s;
+  }
+}
+function emitPlayback(out, nodeId, clipId, timeSeconds) {
+  const i = out.motionPlayback.length;
+  const pool = cmdPoolOf(out);
+  let cmd = pool[i];
+  if (!cmd) {
+    cmd = { nodeId, clipId, timeSeconds, weight: 1 };
+    pool[i] = cmd;
+  } else {
+    cmd.nodeId = nodeId;
+    cmd.clipId = clipId;
+    cmd.timeSeconds = timeSeconds;
+    cmd.weight = 1;
+  }
+  out.motionPlayback.push(cmd);
+}
+function writePoseKnobs(out, nodeId, values) {
+  let arr = out.poses.get(nodeId);
+  if (!arr) {
+    arr = [];
+    out.poses.set(nodeId, arr);
+  }
+  let n = 0;
+  for (const key of POSE_KEYS) {
+    const value = values[key];
+    if (value === void 0)
+      continue;
+    let pose = arr[n];
+    if (!pose) {
+      pose = { key, value };
+      arr[n] = pose;
+    } else {
+      pose.key = key;
+      pose.value = value;
+    }
+    n += 1;
+  }
+  arr.length = n;
+}
+function evaluateCharacters(scene, frame, out) {
+  const clips = scene.timeline.animation.motionClips;
+  const fps = scene.meta.fps;
+  const fcurves = scene.fcurves;
+  for (const node of scene.nodes) {
+    if (node.type !== "character")
+      continue;
+    const xf = ensureTransform(out, node.id);
+    writeStaticTransform(xf, node.transform);
+    const clip = motionClipAt(clips, node.id, frame);
+    if (clip) {
+      emitPlayback(out, node.id, clip.id, motionTimeSeconds(clip, frame, fps));
+    } else if (node.character?.animation.mode === "pose") {
+      writePoseKnobs(out, node.id, node.character.animation.controlValues ?? {});
+    }
+    if (fcurves) {
+      for (let i = 0; i < 3; i++) {
+        const p = fcurves.evalScalar(node.id, "transform.position", i, frame);
+        if (p !== null)
+          xf.position[AXES[i]] = p;
+        if (!clip) {
+          const r = fcurves.evalScalar(node.id, "transform.rotation", i, frame);
+          if (r !== null)
+            xf.rotation[AXES[i]] = r;
+        }
+        const s = fcurves.evalScalar(node.id, "transform.scale", i, frame);
+        if (s !== null)
+          xf.scale[AXES[i]] = s;
+      }
+    }
+  }
+}
+function evaluatePaths(scene, frame, out) {
+  const fcurves = scene.fcurves;
+  for (const clip of scene.timeline.animation.pathMotionClips) {
+    const derivedRange = clip.lockedReason === "derived-from-keyframes";
+    if (frame < clip.frameStart)
+      continue;
+    if (derivedRange ? frame >= clip.frameEnd : frame > clip.frameEnd)
+      continue;
+    const pathNode = _nodeById.get(clip.pathNodeId);
+    if (!pathNode || !evaluatePathMotionInto(pathNode, clip, frame, _path))
+      continue;
+    const target = _nodeById.get(clip.target.nodeId);
+    if (target?.type === "camera")
+      continue;
+    const xf = out.transforms.get(clip.target.nodeId);
+    if (!xf)
+      continue;
+    const derived = clip.lockedReason === "derived-from-keyframes";
+    const fcPos = derived && !!(fcurves?.hasTrack(clip.target.nodeId, "transform.position") || scene.userKeys?.[clip.target.nodeId]?.position?.length);
+    if (!fcPos)
+      copyVec3(xf.position, _path.position);
+    if (clip.facing !== "path-tangent")
+      continue;
+    const yawDeg = _path.yaw * RAD2DEG;
+    xf.rotation.x = 0;
+    xf.rotation.y = yawDeg;
+    xf.rotation.z = 0;
+  }
+}
+function evaluateStaticNodes(scene, frame, out) {
+  const fcurves = scene.fcurves;
+  for (const node of scene.nodes) {
+    if (node.type !== "prop" && node.type !== "group" && node.type !== "primitive")
+      continue;
+    const xf = ensureTransform(out, node.id);
+    writeStaticTransform(xf, node.transform);
+    if (fcurves)
+      applyFcurvesToTransform(xf, fcurves, node.id, frame);
+  }
+}
+function applyUserProp(xf, prop, keys, frame) {
+  if (!keys || !sampleKeyframesInto(keys, frame, _sample, false))
+    return;
+  if (prop === "position") {
+    xf.position.x = _sample[0];
+    xf.position.y = _sample[1];
+    xf.position.z = _sample[2];
+    return;
+  }
+  if (prop === "rotation") {
+    xf.rotation.x = _sample[0];
+    xf.rotation.y = _sample[1];
+    xf.rotation.z = _sample[2];
+    return;
+  }
+  if (prop === "scale") {
+    xf.scale.x = _sample[0];
+    xf.scale.y = _sample[1];
+    xf.scale.z = _sample[2];
+  }
+}
+function derivedFacingAt(scene, nodeId, frame) {
+  for (const clip of scene.timeline.animation.pathMotionClips) {
+    if (clip.lockedReason !== "derived-from-keyframes")
+      continue;
+    if (clip.facing !== "path-tangent")
+      continue;
+    if (clip.target?.nodeId !== nodeId)
+      continue;
+    if (frame >= clip.frameStart && frame < clip.frameEnd)
+      return true;
+  }
+  return false;
+}
+function evaluateUserKeys(scene, frame, out) {
+  if (!scene.userKeysEnabled || !scene.userKeys)
+    return;
+  for (const node of scene.nodes) {
+    if (node.type === "camera" || node.type === "path")
+      continue;
+    const uk = scene.userKeys[node.id];
+    if (!uk)
+      continue;
+    const xf = out.transforms.get(node.id);
+    if (!xf)
+      continue;
+    applyUserProp(xf, "position", uk.position, frame);
+    const rotationLockedByPath = node.type === "character" && derivedFacingAt(scene, node.id, frame);
+    if (!rotationLockedByPath)
+      applyUserProp(xf, "rotation", uk.rotation, frame);
+    applyUserProp(xf, "scale", uk.scale, frame);
+  }
+}
+function writeCameraSlot(xf, pose) {
+  xf.position.x = pose.position[0];
+  xf.position.y = pose.position[1];
+  xf.position.z = pose.position[2];
+  if (!xf.lookAt)
+    xf.lookAt = { x: 0, y: 0, z: 0 };
+  xf.lookAt.x = pose.lookAt[0];
+  xf.lookAt.y = pose.lookAt[1];
+  xf.lookAt.z = pose.lookAt[2];
+  xf.fov = pose.fov;
+  xf.rotation.x = 0;
+  xf.rotation.y = 0;
+  xf.rotation.z = 0;
+  xf.useEuler = false;
+}
+function moveCameraKeepingAim(xf, next) {
+  const look = xf.lookAt;
+  if (look) {
+    look.x += next.x - xf.position.x;
+    look.y += next.y - xf.position.y;
+    look.z += next.z - xf.position.z;
+  }
+  copyVec3(xf.position, next);
+}
+function overlayCameraFcurves(xf, fcurves, nodeId, frame) {
+  const look = xf.lookAt;
+  if (!look)
+    return;
+  let hitRotation = false;
+  for (let i = 0; i < 3; i++) {
+    const pv = fcurves.evalScalar(nodeId, "transform.position", i, frame);
+    const lv = fcurves.evalScalar(nodeId, "camera.lookAt", i, frame);
+    if (pv !== null) {
+      if (lv === null)
+        look[AXES[i]] += pv - xf.position[AXES[i]];
+      xf.position[AXES[i]] = pv;
+    }
+    if (lv !== null)
+      look[AXES[i]] = lv;
+    const rv = fcurves.evalScalar(nodeId, "transform.rotation", i, frame);
+    if (rv !== null) {
+      xf.rotation[AXES[i]] = rv;
+      hitRotation = true;
+    }
+  }
+  if (hitRotation)
+    applyRotationToLookAt(xf);
+  const fv = fcurves.evalScalar(nodeId, "camera.fov", 0, frame);
+  if (fv !== null)
+    xf.fov = fv;
+}
+function overlayCameraUserKeys(xf, uk, frame) {
+  if (uk.position && sampleKeyframesInto(uk.position, frame, _sample)) {
+    moveCameraKeepingAim(xf, { x: _sample[0], y: _sample[1], z: _sample[2] });
+  }
+  if (uk.lookAt && xf.lookAt && sampleKeyframesInto(uk.lookAt, frame, _sample)) {
+    xf.lookAt.x = _sample[0];
+    xf.lookAt.y = _sample[1];
+    xf.lookAt.z = _sample[2];
+  }
+  if (uk.rotation && sampleKeyframesInto(uk.rotation, frame, _sample)) {
+    xf.rotation.x = _sample[0];
+    xf.rotation.y = _sample[1];
+    xf.rotation.z = _sample[2];
+    applyRotationToLookAt(xf);
+  }
+  if (uk.fov && sampleKeyframesInto(uk.fov, frame, _sample))
+    xf.fov = _sample[0];
+}
+function applyRotationToLookAt(xf) {
+  if (!xf.lookAt)
+    xf.lookAt = { x: 0, y: 0, z: 0 };
+  const dist = lookDistance(xf.position, xf.lookAt);
+  copyVec3(xf.lookAt, lookAtFromEulerDeg(xf.position, xf.rotation, dist));
+  xf.useEuler = true;
+}
+function writeActiveCamera(out, xf) {
+  if (!out.camera) {
+    out.camera = {
+      position: { x: 0, y: 0, z: 0 },
+      lookAt: { x: 0, y: 1.2, z: 0 },
+      fov: 50
+    };
+  }
+  copyVec3(out.camera.position, xf.position);
+  if (xf.lookAt)
+    copyVec3(out.camera.lookAt, xf.lookAt);
+  out.camera.fov = xf.fov ?? 50;
+}
+function evaluateCameras(scene, frame, out) {
+  const clips = scene.timeline.animation.cameraMotionClips;
+  const fps = scene.meta.fps;
+  const chained = scene.chainCameraMotion === true;
+  const fcurves = scene.fcurves;
+  const userKeys = scene.userKeysEnabled ? scene.userKeys : void 0;
+  let primary = null;
+  let firstCam = null;
+  for (const node of scene.nodes) {
+    if (node.type !== "camera")
+      continue;
+    evaluateCameraPoseInto(node, clips, frame, fps, chained, _cam);
+    const xf = ensureTransform(out, node.id);
+    writeCameraSlot(xf, _cam);
+    const motionOwnsKeyframes = clips.some((c) => c.target.nodeId === node.id);
+    const motionActive = clips.some(
+      (c) => c.target.nodeId === node.id && frame >= c.frameStart && frame <= c.frameEnd
+    );
+    if (fcurves && _cam.clipId === null && !motionOwnsKeyframes)
+      overlayCameraFcurves(xf, fcurves, node.id, frame);
+    const uk = userKeys?.[node.id];
+    if (uk && !motionOwnsKeyframes)
+      overlayCameraUserKeys(xf, uk, frame);
+    if (!motionActive) {
+      const pathClip = scene.timeline.animation.pathMotionClips.find((c) => {
+        if (c.target.nodeId !== node.id)
+          return false;
+        const derivedRange = c.lockedReason === "derived-from-keyframes";
+        if (derivedRange) {
+          if (motionOwnsKeyframes)
+            return false;
+          if (fcurves?.hasTrack(node.id, "transform.position") || uk?.position?.length)
+            return false;
+        }
+        if (frame < c.frameStart)
+          return false;
+        return derivedRange ? frame < c.frameEnd : frame <= c.frameEnd;
+      });
+      if (pathClip) {
+        const pathNode = _nodeById.get(pathClip.pathNodeId);
+        if (pathNode && evaluatePathMotionInto(pathNode, pathClip, frame, _path)) {
+          moveCameraKeepingAim(xf, _path.position);
+        }
+      }
+    }
+    const binding = node.camera?.subject;
+    const tp = binding?.follow ? out.transforms.get(binding.nodeId) : void 0;
+    const followOwns = Boolean(binding && tp && (_cam.clipId === null || subjectOverridesMotion(binding)));
+    if (followOwns && binding && tp) {
+      const pose = resolveSubjectCameraPose(binding, tp.position, tp.rotation);
+      copyVec3(xf.position, pose.position);
+      if (xf.lookAt)
+        copyVec3(xf.lookAt, pose.lookAt);
+      else
+        xf.lookAt = pose.lookAt;
+      xf.useEuler = false;
+    }
+    const lookAtTarget = node.camera?.lookAtTarget;
+    const clipOwnsLookAt = _cam.clipId !== null && !followOwns;
+    if (lookAtTarget?.nodeId && !clipOwnsLookAt) {
+      const targetXf = out.transforms.get(lookAtTarget.nodeId);
+      if (targetXf) {
+        const aim = characterLookAtPoint(targetXf.position, lookAtTarget.offset);
+        if (xf.lookAt)
+          copyVec3(xf.lookAt, aim);
+        else
+          xf.lookAt = aim;
+        xf.useEuler = false;
+      }
+    }
+    if (!firstCam)
+      firstCam = xf;
+    if (node.camera?.isPrimary)
+      primary = xf;
+  }
+  const active = primary ?? firstCam;
+  if (active)
+    writeActiveCamera(out, active);
+  else
+    out.camera = null;
+}
+
+// src/evaluate/evaluateFrame.ts
+function evaluateFrame(scene, frame, out) {
+  resetFrameSnapshot(out);
+  indexSceneNodes(scene.nodes);
+  evaluateCharacters(scene, frame, out);
+  evaluateStaticNodes(scene, frame, out);
+  evaluatePaths(scene, frame, out);
+  evaluateUserKeys(scene, frame, out);
+  evaluateCameras(scene, frame, out);
+}
+
+// src/evaluate/sceneFromDocument.ts
+function sceneFromDocument(doc, overlays) {
+  const tl = doc.content.timeline;
+  return {
+    meta: { fps: tl.fps, frameStart: tl.frameStart, frameEnd: tl.frameEnd },
+    nodes: doc.content.nodes,
+    timeline: tl,
+    fcurves: overlays?.fcurves ?? null,
+    userKeys: overlays?.userKeys,
+    userKeysEnabled: overlays?.userKeysEnabled,
+    chainCameraMotion: overlays?.chainCameraMotion
+  };
+}
+
+// src/evaluate/curves/FCurveSet.ts
+var USER_KEY_PROPS = ["position", "rotation", "scale", "lookAt", "fov"];
+var _autoOut = { x: 0, y: 0 };
+var _autoIn = { x: 0, y: 0 };
+var _tmpA = { frame: 0, value: 0, interp: "", id: "", inHandle: null, outHandle: null };
+var _tmpB = { frame: 0, value: 0, interp: "", id: "", inHandle: null, outHandle: null };
+function evalBezierSegment(a, b, frame) {
+  const p0x = a.frame;
+  const p0y = a.value;
+  const p1x = a.outHandle.x;
+  const p1y = a.outHandle.y;
+  const p2x = b.inHandle.x;
+  const p2y = b.inHandle.y;
+  const p3x = b.frame;
+  const p3y = b.value;
+  const xAt = (t2) => {
+    const u = 1 - t2;
+    return u * u * u * p0x + 3 * u * u * t2 * p1x + 3 * u * t2 * t2 * p2x + t2 * t2 * t2 * p3x;
+  };
+  const yAt = (t2) => {
+    const u = 1 - t2;
+    return u * u * u * p0y + 3 * u * u * t2 * p1y + 3 * u * t2 * t2 * p2y + t2 * t2 * t2 * p3y;
+  };
+  const dxAt = (t2) => {
+    const u = 1 - t2;
+    return 3 * u * u * (p1x - p0x) + 6 * u * t2 * (p2x - p1x) + 3 * t2 * t2 * (p3x - p2x);
+  };
+  let t = p3x !== p0x ? (frame - p0x) / (p3x - p0x) : 0.5;
+  t = Math.min(Math.max(t, 0), 1);
+  let ok2 = false;
+  for (let i = 0; i < 8; i++) {
+    const err = xAt(t) - frame;
+    if (Math.abs(err) < 1e-7) {
+      ok2 = true;
+      break;
+    }
+    const d = dxAt(t);
+    if (Math.abs(d) < 1e-12)
+      break;
+    const nt = t - err / d;
+    if (nt < 0 || nt > 1)
+      break;
+    t = nt;
+  }
+  if (!ok2) {
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 40; i++) {
+      const mid = (lo + hi) / 2;
+      if (xAt(mid) < frame)
+        lo = mid;
+      else
+        hi = mid;
+    }
+    t = (lo + hi) / 2;
+  }
+  return yAt(t);
+}
+function genKeyId() {
+  return `kf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+var FCurveSet = class _FCurveSet {
+  constructor(curves) {
+    /** nodeId → propPath → 分量序号 → 曲线 */
+    this.byNode = /* @__PURE__ */ new Map();
+    this.curveCount = curves.length;
+    for (const c of curves) {
+      let byProp = this.byNode.get(c.nodeId);
+      if (!byProp) {
+        byProp = /* @__PURE__ */ new Map();
+        this.byNode.set(c.nodeId, byProp);
+      }
+      let byIndex = byProp.get(c.propPath);
+      if (!byIndex) {
+        byIndex = /* @__PURE__ */ new Map();
+        byProp.set(c.propPath, byIndex);
+      }
+      byIndex.set(c.index, c);
+    }
+  }
+  static parse(json) {
+    if (!json || json.encoding !== "compact-v1" || !Array.isArray(json.fcurves)) {
+      throw new Error("\u4E0D\u662F compact-v1 \u683C\u5F0F\u7684 fcurves \u6587\u4EF6");
+    }
+    const curves = json.fcurves.map((raw) => {
+      const nodeId = Array.isArray(raw.t) ? String(raw.t[1]) : String(raw.t);
+      const keys = raw.k.map((k) => ({
+        frame: Number(k[0]),
+        value: Number(k[1]),
+        interp: String(k[2] ?? "linear"),
+        id: String(k[3] ?? ""),
+        inHandle: k[4] ? { x: Number(k[4].x), y: Number(k[4].y) } : null,
+        outHandle: k[5] ? { x: Number(k[5].x), y: Number(k[5].y) } : null
+      }));
+      keys.sort((a, b) => a.frame - b.frame);
+      return {
+        id: String(raw.id),
+        nodeId,
+        propPath: String(raw.p),
+        index: Number(raw.i ?? 0),
+        keys
+      };
+    });
+    return new _FCurveSet(curves);
+  }
+  findCurve(nodeId, propPath, index) {
+    return this.byNode.get(nodeId)?.get(propPath)?.get(index) ?? null;
+  }
+  /** 空集合（无 fcurves 的草稿首次提交拖拽时用） */
+  static empty() {
+    return new _FCurveSet([]);
+  }
+  /**
+   * upsert 一个关键帧：曲线不存在则建（id `fc_node_<nodeId>_<propPath点转下划线>_<分量>`），
+   * 键按 frame 升序插入；同帧（严格相等）替换值并保留原键 id/插值。
+   * 新键 interp='bezier'、手柄 null（运行时等价 smoothstep）。
+   */
+  upsertKey(nodeId, propPath, index, frame, value, keyId) {
+    let byProp = this.byNode.get(nodeId);
+    if (!byProp) {
+      byProp = /* @__PURE__ */ new Map();
+      this.byNode.set(nodeId, byProp);
+    }
+    let byIndex = byProp.get(propPath);
+    if (!byIndex) {
+      byIndex = /* @__PURE__ */ new Map();
+      byProp.set(propPath, byIndex);
+    }
+    let curve = byIndex.get(index);
+    if (!curve) {
+      curve = {
+        id: `fc_node_${nodeId}_${propPath.replace(/\./g, "_")}_${index}`,
+        nodeId,
+        propPath,
+        index,
+        keys: []
+      };
+      byIndex.set(index, curve);
+      this.curveCount++;
+    }
+    const keys = curve.keys;
+    let lo = 0;
+    let hi = keys.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (keys[mid].frame < frame)
+        lo = mid + 1;
+      else
+        hi = mid;
+    }
+    if (lo < keys.length && keys[lo].frame === frame) {
+      keys[lo].value = value;
+      return keys[lo];
+    }
+    const key = {
+      frame,
+      value,
+      interp: "bezier",
+      id: keyId ?? genKeyId(),
+      inHandle: null,
+      outHandle: null
+    };
+    keys.splice(lo, 0, key);
+    return key;
+  }
+  /** 某分量曲线在某帧（严格相等）是否已有键；有则返回该键 */
+  getKeyAt(nodeId, propPath, index, frame) {
+    const curve = this.findCurve(nodeId, propPath, index);
+    if (!curve)
+      return null;
+    let lo = 0;
+    let hi = curve.keys.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (curve.keys[mid].frame < frame)
+        lo = mid + 1;
+      else
+        hi = mid;
+    }
+    const k = curve.keys[lo];
+    return k && k.frame === frame ? k : null;
+  }
+  /** 某分量曲线 id（派生 clip 的 derivedSource.curveIds 用）；无曲线返回 null */
+  curveId(nodeId, propPath, index) {
+    return this.findCurve(nodeId, propPath, index)?.id ?? null;
+  }
+  /**
+   * 节点 position 曲线的关键帧列表（按帧升序）：三分量键总是一起写，
+   * 按 x 曲线的键列表取帧，y/z 取同帧值（缺任一分量则跳过该帧）。
+   * 返回值同时携带三条曲线上的键 id（派生 clip 的 derivedSource.keyframeIds 用）。
+   */
+  positionKeys(nodeId) {
+    const cx = this.findCurve(nodeId, "transform.position", 0);
+    const cy = this.findCurve(nodeId, "transform.position", 1);
+    const cz = this.findCurve(nodeId, "transform.position", 2);
+    if (!cx || !cy || !cz)
+      return [];
+    const byFrameY = new Map(cy.keys.map((k) => [k.frame, k]));
+    const byFrameZ = new Map(cz.keys.map((k) => [k.frame, k]));
+    const out = [];
+    for (const kx of cx.keys) {
+      const ky = byFrameY.get(kx.frame);
+      const kz = byFrameZ.get(kx.frame);
+      if (!ky || !kz)
+        continue;
+      out.push({
+        frame: kx.frame,
+        value: [kx.value, ky.value, kz.value],
+        keyIds: [kx.id, ky.id, kz.id]
+      });
+    }
+    return out;
+  }
+  /** 节点某条属性路径是否有曲线（任一分量存在即算有） */
+  hasTrack(nodeId, propPath) {
+    return (this.byNode.get(nodeId)?.get(propPath)?.size ?? 0) > 0;
+  }
+  /** 单分量求值；无曲线返回 null。范围外 constant 外推。 */
+  evalScalar(nodeId, propPath, index, frame) {
+    const curve = this.findCurve(nodeId, propPath, index);
+    if (!curve || curve.keys.length === 0)
+      return null;
+    const keys = curve.keys;
+    const first = keys[0];
+    const last = keys[keys.length - 1];
+    if (frame <= first.frame)
+      return first.value;
+    if (frame >= last.frame)
+      return last.value;
+    let lo = 0;
+    let hi = keys.length - 1;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (keys[mid].frame <= frame)
+        lo = mid;
+      else
+        hi = mid;
+    }
+    const a = keys[lo];
+    const b = keys[hi];
+    if (a.interp === "bezier") {
+      const span2 = b.frame - a.frame;
+      _autoOut.x = a.frame + span2 / 3;
+      _autoOut.y = a.value;
+      _autoIn.x = b.frame - span2 / 3;
+      _autoIn.y = b.value;
+      _tmpA.frame = a.frame;
+      _tmpA.value = a.value;
+      _tmpA.interp = a.interp;
+      _tmpA.id = a.id;
+      _tmpA.inHandle = a.inHandle;
+      _tmpA.outHandle = a.outHandle ?? _autoOut;
+      _tmpB.frame = b.frame;
+      _tmpB.value = b.value;
+      _tmpB.interp = b.interp;
+      _tmpB.id = b.id;
+      _tmpB.inHandle = b.inHandle ?? _autoIn;
+      _tmpB.outHandle = b.outHandle;
+      return evalBezierSegment(_tmpA, _tmpB, frame);
+    }
+    const span = b.frame - a.frame;
+    const t = span > 0 ? (frame - a.frame) / span : 0;
+    return a.value + (b.value - a.value) * t;
+  }
+  /**
+   * 把 fromId 的全部曲线拷到 toId：新曲线 id、新 key id。
+   * mapKey 可在拷贝时改值（例如套变换增量）。不改源曲线。
+   */
+  copyNode(fromId, toId, mapKey) {
+    const source = this.byNode.get(fromId);
+    if (!source || fromId === toId)
+      return;
+    let destProps = this.byNode.get(toId);
+    if (!destProps) {
+      destProps = /* @__PURE__ */ new Map();
+      this.byNode.set(toId, destProps);
+    }
+    for (const [propPath, byIndex] of source) {
+      let destIndex = destProps.get(propPath);
+      if (!destIndex) {
+        destIndex = /* @__PURE__ */ new Map();
+        destProps.set(propPath, destIndex);
+      }
+      for (const [index, curve] of byIndex) {
+        if (destIndex.has(index)) {
+          this.curveCount = Math.max(0, this.curveCount - 1);
+        }
+        destIndex.set(index, {
+          id: `fc_node_${toId}_${propPath.replace(/\./g, "_")}_${index}`,
+          nodeId: toId,
+          propPath,
+          index,
+          keys: curve.keys.map((key) => {
+            const cloned = {
+              frame: key.frame,
+              value: key.value,
+              interp: key.interp,
+              id: genKeyId(),
+              inHandle: key.inHandle ? { ...key.inHandle } : null,
+              outHandle: key.outHandle ? { ...key.outHandle } : null
+            };
+            return mapKey ? mapKey(cloned, curve) : cloned;
+          })
+        });
+        this.curveCount++;
+      }
+    }
+  }
+  /** 去掉某节点的全部曲线（删角色/机位时清轨道，curveCount 同步减） */
+  removeNode(nodeId) {
+    const byProp = this.byNode.get(nodeId);
+    if (!byProp)
+      return;
+    let n = 0;
+    for (const byIndex of byProp.values())
+      n += byIndex.size;
+    this.byNode.delete(nodeId);
+    this.curveCount = Math.max(0, this.curveCount - n);
+  }
+  /** 去掉某节点若干属性路径上的曲线（点机位时清旧 position/lookAt/fov，避免 overlay 把新机位拽回去） */
+  removeTracks(nodeId, propPaths) {
+    const byProp = this.byNode.get(nodeId);
+    if (!byProp)
+      return;
+    for (const path of propPaths) {
+      const byIndex = byProp.get(path);
+      if (!byIndex)
+        continue;
+      this.curveCount = Math.max(0, this.curveCount - byIndex.size);
+      byProp.delete(path);
+    }
+    if (byProp.size === 0)
+      this.byNode.delete(nodeId);
+  }
+  /**
+   * 删除某属性路径在指定帧（严格相等）的关键帧：所有分量曲线同帧一起删，
+   * 返回删除的键数。删空的曲线/属性路径/节点壳一并清掉，避免落盘留下 k:[]。
+   */
+  removeKeysAtFrame(nodeId, propPath, frame) {
+    const byProp = this.byNode.get(nodeId);
+    const byIndex = byProp?.get(propPath);
+    if (!byProp || !byIndex)
+      return 0;
+    let removed = 0;
+    for (const [index, curve] of byIndex) {
+      const before = curve.keys.length;
+      curve.keys = curve.keys.filter((k) => k.frame !== frame);
+      removed += before - curve.keys.length;
+      if (curve.keys.length === 0) {
+        byIndex.delete(index);
+        this.curveCount = Math.max(0, this.curveCount - 1);
+      }
+    }
+    if (byIndex.size === 0) {
+      byProp.delete(propPath);
+      if (byProp.size === 0)
+        this.byNode.delete(nodeId);
+    }
+    return removed;
+  }
+  /** 节点的全部曲线（UI 列轨道用） */
+  tracksForNode(nodeId) {
+    const out = [];
+    for (const byIndex of this.byNode.get(nodeId)?.values() ?? []) {
+      for (const c of byIndex.values())
+        out.push(c);
+    }
+    return out;
+  }
+  /** 某轨道（单分量）的关键帧列表（UI 画菱形用） */
+  keyframesForTrack(nodeId, propPath, index) {
+    const curve = this.findCurve(nodeId, propPath, index);
+    if (!curve)
+      return [];
+    return curve.keys.map((k) => ({ frame: k.frame, value: k.value }));
+  }
+  /**
+   * 某属性路径的所有分量曲线是否全程无真实变化（平台）。
+   * 用于判断派生路径的 path-tangent yaw 是否还让位给 fcurve。
+   */
+  trackIsFlat(nodeId, propPath, eps = 1e-3) {
+    const byIndex = this.byNode.get(nodeId)?.get(propPath);
+    if (!byIndex || byIndex.size === 0)
+      return false;
+    for (const c of byIndex.values()) {
+      let min = Infinity;
+      let max = -Infinity;
+      for (const k of c.keys) {
+        if (k.value < min)
+          min = k.value;
+        if (k.value > max)
+          max = k.value;
+      }
+      if (max - min > eps)
+        return false;
+    }
+    return true;
+  }
+  encode() {
+    const fcurves = [];
+    for (const byProp of this.byNode.values()) {
+      for (const byIndex of byProp.values()) {
+        for (const curve of byIndex.values()) {
+          fcurves.push({
+            id: curve.id,
+            t: ["node", curve.nodeId],
+            p: curve.propPath,
+            i: curve.index,
+            k: curve.keys.map((key) => {
+              const row = [key.frame, key.value, key.interp, key.id];
+              if (key.inHandle || key.outHandle) {
+                row.push(key.inHandle);
+                row.push(key.outHandle);
+              }
+              return row;
+            })
+          });
+        }
+      }
+    }
+    return { version: 1, encoding: "compact-v1", fcurves };
+  }
+  /**
+   * 落盘：官方 compact-v1 曲线原样保留（不把用户键烘焙进去，避免改 walk / 删键无法撤回）。
+   * 时间线「位移 / 旋转 / 缩放」读的是 userKeys 覆写层，非空时挂在 sidecar，加载后再灌回去。
+   */
+  static persist(fcurves, userKeys) {
+    const overlay = _FCurveSet.parseUserKeys({ userKeys });
+    const encoded = fcurves && fcurves.curveCount > 0 ? fcurves.encode() : { version: 1, encoding: "compact-v1", fcurves: [] };
+    if (Object.keys(overlay).length === 0)
+      return encoded;
+    return { ...encoded, userKeys: overlay };
+  }
+  /** 从 compact-v1 JSON 取出时间线覆写层（缺省 / 损坏则空对象）。 */
+  static parseUserKeys(json) {
+    if (!json || typeof json !== "object" || Array.isArray(json))
+      return {};
+    const raw = json.userKeys;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      return {};
+    const out = {};
+    for (const [nodeId, props] of Object.entries(raw)) {
+      if (!nodeId || !props || typeof props !== "object" || Array.isArray(props))
+        continue;
+      const node = {};
+      for (const prop of USER_KEY_PROPS) {
+        const keys = props[prop];
+        if (!Array.isArray(keys))
+          continue;
+        const parsed = [];
+        for (const item of keys) {
+          if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+          const rec = item;
+          if (!Array.isArray(rec.value))
+            continue;
+          const frame = Math.round(Number(rec.frame));
+          if (!Number.isFinite(frame))
+            continue;
+          parsed.push({
+            id: String(rec.id ?? ""),
+            frame,
+            value: rec.value.map((v) => {
+              const n = Number(v);
+              return Number.isFinite(n) ? n : 0;
+            }),
+            interpolation: (() => {
+              const raw2 = String(rec.interpolation ?? "linear");
+              if (raw2 === "smooth" || raw2 === "ease-in-out" || raw2 === "ease-in" || raw2 === "ease-out" || raw2 === "linear") {
+                return raw2;
+              }
+              return "linear";
+            })()
+          });
+        }
+        if (parsed.length)
+          node[prop] = parsed;
+      }
+      if (Object.keys(node).length)
+        out[nodeId] = node;
+    }
+    return out;
+  }
+  /**
+   * 用户关键帧层（userKeys）→ 官方 compact-v1 fcurves JSON。
+   * 格式：
+   *   曲线 id `fc_node_<nodeId>_<propPath 点转下划线>_<分量>`；
+   *   关键帧 [帧, 值, 插值, kfId, 入手柄?, 出手柄?]，手柄缺省 = 运行时自动水平切线；
+   *   我们的 smooth（smoothstep）与官方「bezier 无手柄」运行时行为一致 → 映射为 bezier 无手柄；
+   *   linear → linear。rotation 单位保持「度」（与官方一致，由消费方转弧度）。
+   */
+  static encodeUserKeys(userKeys) {
+    const PROP_PATH = {
+      position: "transform.position",
+      rotation: "transform.rotation",
+      scale: "transform.scale",
+      lookAt: "camera.lookAt",
+      fov: "camera.fov"
+    };
+    const kfId2 = () => `kf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const fcurves = [];
+    for (const [nodeId, props] of Object.entries(userKeys)) {
+      for (const [prop, keys] of Object.entries(props)) {
+        if (!keys || keys.length === 0)
+          continue;
+        const p = PROP_PATH[prop];
+        const components = prop === "fov" ? 1 : 3;
+        const sorted = [...keys].sort((a, b) => a.frame - b.frame);
+        for (let i = 0; i < components; i++) {
+          fcurves.push({
+            id: `fc_node_${nodeId}_${p.replace(/\./g, "_")}_${i}`,
+            t: ["node", nodeId],
+            p,
+            i,
+            k: sorted.map((k) => [
+              k.frame,
+              k.value[i] ?? 0,
+              k.interpolation === "linear" ? "linear" : "bezier",
+              kfId2()
+            ])
+          });
+        }
+      }
+    }
+    return { version: 1, encoding: "compact-v1", fcurves };
+  }
+};
+
+// src/evaluate/camera/bakeMotion.ts
+var UP = { x: 0, y: 1, z: 0 };
+var vAdd = (a, b) => ({ x: a.x + b.x, y: a.y + b.y, z: a.z + b.z });
+var vSub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y, z: a.z - b.z });
+var vScale = (a, s) => ({ x: a.x * s, y: a.y * s, z: a.z * s });
+var vDot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
+var vCross = (a, b) => ({
+  x: a.y * b.z - a.z * b.y,
+  y: a.z * b.x - a.x * b.z,
+  z: a.x * b.y - a.y * b.x
+});
+var vLen = (a) => Math.hypot(a.x, a.y, a.z);
+var vNorm = (a) => {
+  const l = vLen(a);
+  return l > 1e-9 ? vScale(a, 1 / l) : { x: 0, y: 0, z: 0 };
+};
+var vDist = (a, b) => vLen(vSub(a, b));
+var vLerp = (a, b, t) => ({
+  x: a.x + (b.x - a.x) * t,
+  y: a.y + (b.y - a.y) * t,
+  z: a.z + (b.z - a.z) * t
+});
+var lerp = (a, b, t) => a + (b - a) * t;
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+function vRotateAxis(v, axis, deg) {
+  const k = vNorm(axis);
+  const th = deg * Math.PI / 180;
+  const cos = Math.cos(th);
+  const sin = Math.sin(th);
+  const term1 = vScale(v, cos);
+  const term2 = vScale(vCross(k, v), sin);
+  const term3 = vScale(k, vDot(k, v) * (1 - cos));
+  return vAdd(vAdd(term1, term2), term3);
+}
+function cameraBasis(position, lookAt, sceneUp = UP) {
+  const forward = vNorm(vSub(lookAt, position));
+  let right = vNorm(vCross(forward, sceneUp));
+  if (vLen(right) < 1e-6)
+    right = { x: 1, y: 0, z: 0 };
+  const up = vCross(right, forward);
+  return { forward, right, up };
+}
+function localToWorld(local, b) {
+  return vAdd(vAdd(vScale(b.right, local.x), vScale(b.up, local.y)), vScale(b.forward, local.z));
+}
+function easeValue(easing, u) {
+  const t = clamp(u, 0, 1);
+  switch (easing) {
+    case "linear":
+      return t;
+    case "ease-in":
+      return t * t * t;
+    case "ease-out":
+      return 1 - Math.pow(1 - t, 3);
+    case "ease-in-out":
+    default:
+      return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+  }
+}
+function resolveCameraState(ctx) {
+  const n = ctx.cameraNode;
+  return {
+    timeMs: 0,
+    position: { ...n.transform.position },
+    lookAt: { ...n.camera?.lookAt ?? { x: 0, y: 1.2, z: 0 } },
+    fov: clamp(n.camera?.fov ?? 50, 18, 85),
+    rollDeg: void 0
+  };
+}
+function targetPoint(ctx) {
+  if (ctx.targetNode) {
+    const p = ctx.targetNode.transform.position;
+    return { x: p.x, y: p.y + 1.2, z: p.z };
+  }
+  return ctx.cameraNode.camera?.lookAt ?? { x: 0, y: 1.2, z: 0 };
+}
+function contextScale(_ctx) {
+  return 4;
+}
+function hashRand(seed, i, channel) {
+  const s = Math.sin((seed + 1) * 12.9898 + (i + 1) * 78.233 + 37.719 * channel);
+  return s - Math.trunc(s);
+}
+function lerpPoses(a, b, cfg) {
+  const count = Math.max(2, Math.round(cfg.keyframeCount ?? 2));
+  return Array.from({ length: count }, (_, i) => {
+    const u = count <= 1 ? 0 : i / (count - 1);
+    const s = easeValue(cfg.easing, u);
+    const hasRoll = a.rollDeg !== void 0 || b.rollDeg !== void 0;
+    return {
+      timeMs: lerp(0, cfg.durationMs, u),
+      position: vLerp(a.position, b.position, s),
+      lookAt: vLerp(a.lookAt, b.lookAt, s),
+      fov: lerp(a.fov, b.fov, s),
+      rollDeg: hasRoll ? lerp(a.rollDeg ?? 0, b.rollDeg ?? 0, s) : void 0
+    };
+  });
+}
+function translatePose(state, ctx, localDir, dist, lockLookAt) {
+  const b = cameraBasis(state.position, state.lookAt);
+  const offset = vScale(localToWorld(localDir, b), dist);
+  return {
+    ...state,
+    position: vAdd(state.position, offset),
+    lookAt: targetPoint(ctx) 
+  };
+}
+function bakeTranslate(recipe, ctx, cfg) {
+  const start = resolveCameraState(ctx);
+  const scale = contextScale();
+  const n = Math.max(cfg.distance ?? 1, 0) * scale;
+  const off = recipe.localOffset ?? { x: 0, y: 0, z: 1 };
+  const dir = recipe.targetSpace === "world" ? vScale(vNorm(off), 1) : localToWorld(off, cameraBasis(start.position, start.lookAt));
+  const offset = vScale(dir, n);
+  const end = {
+    ...start,
+    position: vAdd(start.position, offset),
+    lookAt: recipe.lockTarget ? targetPoint(ctx) : vAdd(start.lookAt, offset)
+  };
+  return lerpPoses(start, end, cfg);
+}
+function bakeLinePath(a, b, cfg) {
+  const N_SAMPLE = 64;
+  return Array.from({ length: N_SAMPLE }, (_, i) => {
+    const u = i / (N_SAMPLE - 1);
+    const s = easeValue(cfg.easing, u);
+    const hasRoll = a.rollDeg !== void 0 || b.rollDeg !== void 0;
+    return {
+      timeMs: lerp(0, cfg.durationMs, u),
+      position: vLerp(a.position, b.position, s),
+      lookAt: vLerp(a.lookAt, b.lookAt, s),
+      fov: lerp(a.fov, b.fov, s),
+      rollDeg: hasRoll ? lerp(a.rollDeg ?? 0, b.rollDeg ?? 0, s) : void 0
+    };
+  });
+}
+function linePathSource(a, b, cfg) {
+  return {
+    easing: cfg.easing,
+    fovEnd: b.fov,
+    fovStart: a.fov,
+    lookAt: { path: pathObj([a.lookAt, b.lookAt]), type: "curve" },
+    positionPath: pathObj([a.position, b.position]),
+    rollDeg: a.rollDeg ?? b.rollDeg,
+    type: "path"
+  };
+}
+function bakeOrbit(recipe, ctx, cfg) {
+  const start = resolveCameraState(ctx);
+  const pivot = start.lookAt;
+  const scale = contextScale();
+  const yawDeg = recipe.yawDeg ?? 0;
+  const heightDelta = (cfg.height ?? recipe.heightDelta ?? 0) * scale;
+  const radiusDelta = (recipe.radiusDelta ?? 0) * scale;
+  const startOffset = vSub(start.position, pivot);
+  const startRadius = Math.max(vLen(startOffset), 1e-3);
+  const N_SAMPLE = 96;
+  const poses = Array.from({ length: N_SAMPLE }, (_, i) => {
+    const u = i / (N_SAMPLE - 1);
+    const s = easeValue(cfg.easing, u);
+    const rotated = vRotateAxis(startOffset, UP, yawDeg * s);
+    const radius = startRadius + radiusDelta * s;
+    const scaled = vScale(vNorm(rotated), radius);
+    const pos = vAdd(vAdd(pivot, scaled), vScale(UP, heightDelta * s));
+    return {
+      timeMs: lerp(0, cfg.durationMs, u),
+      position: pos,
+      lookAt: { ...pivot },
+      fov: start.fov,
+      rollDeg: start.rollDeg
+    };
+  });
+  const source = {
+    axis: { ...UP },
+    easing: cfg.easing,
+    fov: start.fov,
+    heightDelta,
+    lookAtTarget: { ...pivot },
+    pivot: { ...pivot },
+    radiusDelta,
+    rollDeg: start.rollDeg,
+    startLookAt: { ...start.lookAt },
+    startPosition: { ...start.position },
+    type: "orbit",
+    yawDeg
+  };
+  return { poses, source };
+}
+function bakeShake(recipe, ctx, cfg) {
+  const start = resolveCameraState(ctx);
+  const count = Math.max(8, Math.round(cfg.keyframeCount ?? 12));
+  const Q = (cfg.shakeAmplitude ?? recipe.amplitude ?? 0.04) * contextScale();
+  const seed = 1;
+  return Array.from({ length: count }, (_, i) => {
+    const u = count <= 1 ? 0 : i / (count - 1);
+    const n1 = hashRand(seed, i, 1) * Q;
+    const n2 = hashRand(seed, i, 2) * Q * 0.5;
+    const n3 = hashRand(seed, i, 3) * Q * 0.35;
+    const n4 = hashRand(seed, i, 4) * Q * 0.4;
+    return {
+      timeMs: lerp(0, cfg.durationMs, u),
+      position: vAdd(start.position, { x: n1, y: n2, z: n3 }),
+      lookAt: vAdd(start.lookAt, { x: n4, y: -0.3 * n4, z: 0 }),
+      fov: start.fov,
+      rollDeg: hashRand(seed, i, 5) * (cfg.rollDeg ?? 1.2)
+    };
+  });
+}
+function makeTargetSampler(ctx, frameStart, durationMs) {
+  const tn = ctx.targetNode;
+  if (!tn)
+    return null;
+  const anim = ctx.doc.content.timeline.animation;
+  const fps = ctx.doc.content.timeline.fps;
+  const frameEnd = frameStart + Math.round(durationMs * fps / 1e3);
+  const clip = anim.pathMotionClips.find(
+    (c) => c.target.nodeId === tn.id && c.frameEnd >= frameStart && c.frameStart <= frameEnd
+  );
+  const pathNode = clip ? ctx.doc.content.nodes.find((n) => n.id === clip.pathNodeId) : void 0;
+  const base = tn.transform.position;
+  if (!clip || !pathNode) {
+    const p = { x: base.x, y: base.y + 1.2, z: base.z };
+    return () => ({ ...p });
+  }
+  return (u) => {
+    const f = frameStart + u * (frameEnd - frameStart);
+    const res = evaluatePathMotion(pathNode, clip, f);
+    const p = res?.position ?? base;
+    return { x: p.x, y: p.y + 1.2, z: p.z };
+  };
+}
+function pathObj(points, preferCurve = false) {
+  let curve = "line";
+  if (preferCurve && points.length >= 3)
+    curve = "catmullRom";
+  else if (points.length > 2)
+    curve = "polyline";
+  return { closed: void 0, curve, points: points.map((p) => ({ ...p })), tension: 0.5 };
+}
+function targetPathPoints(ctx, frameStart, durationMs) {
+  const tn = ctx.targetNode;
+  if (!tn)
+    return null;
+  const anim = ctx.doc.content.timeline.animation;
+  const fps = ctx.doc.content.timeline.fps;
+  const frameEnd = frameStart + Math.round(durationMs * fps / 1e3);
+  const clip = anim.pathMotionClips.find(
+    (c) => c.target.nodeId === tn.id && c.frameEnd >= frameStart && c.frameStart <= frameEnd
+  );
+  const pathNode = clip ? ctx.doc.content.nodes.find((n) => n.id === clip.pathNodeId) : void 0;
+  const pts = pathNode?.path?.points;
+  return clip && pathNode && pts && pts.length >= 2 ? pts : null;
+}
+function bakeTracking(pathKind, ctx, cfg, frameStart) {
+  const start = resolveCameraState(ctx);
+  const target0 = targetPoint(ctx);
+  const scale = contextScale();
+  const m = Math.max(vDist(start.position, target0), Math.max(cfg.distance ?? 1, 1e-3) * scale);
+  const h = Number.isFinite(start.position.y - target0.y) ? start.position.y - target0.y : 0;
+  const offset = pathKind === "leading" ? { x: 0, y: h, z: m } : pathKind === "profile" ? { x: m, y: h, z: 0 } : { x: 0, y: h, z: -m };
+  const pathPts = targetPathPoints(ctx, frameStart, cfg.durationMs);
+  const rawFwd = pathPts ? vSub(pathPts[pathPts.length - 1].position, pathPts[0].position) : vSub(target0, start.position);
+  const fwd = vLen(rawFwd) > 1e-9 ? vNorm(rawFwd) : { x: 0, y: 0, z: -1 };
+  const basis = cameraBasis({ x: 0, y: 0, z: 0 }, fwd);
+  const sampler = makeTargetSampler(ctx, frameStart, cfg.durationMs);
+  const lookOffsetWorld = vSub(start.lookAt, target0);
+  const lookOffsetLocal = {
+    x: vDot(lookOffsetWorld, basis.right),
+    y: vDot(lookOffsetWorld, basis.up),
+    z: vDot(lookOffsetWorld, basis.forward)
+  };
+  const N_SAMPLE = 96;
+  const poses = Array.from({ length: N_SAMPLE }, (_, i) => {
+    const u = i / (N_SAMPLE - 1);
+    const s = easeValue(cfg.easing, u);
+    const tp = sampler ? sampler(s) : target0;
+    const pos = vAdd(tp, localToWorld(offset, basis));
+    const look = vAdd(tp, localToWorld(lookOffsetLocal, basis));
+    return { timeMs: lerp(0, cfg.durationMs, u), position: pos, lookAt: look, fov: start.fov };
+  });
+  const mode = pathKind === "leading" ? "leading" : pathKind === "profile" ? "profile" : "follow";
+  const target = ctx.targetNode && ctx.targetNode.id ? { type: "node", nodeId: ctx.targetNode.id } : { type: "point", point: target0 };
+  const source = {
+    basisFallback: { forward: fwd, up: { ...UP } },
+    fov: start.fov,
+    lookAtOffset: lookOffsetLocal,
+    mode,
+    offset,
+    rollDeg: start.rollDeg,
+    target,
+    targetFallback: { forward: fwd, position: target0, up: { ...UP } },
+    type: "target-tracking"
+  };
+  return { poses, source };
+}
+function bakeFpv(ctx, cfg, frameStart) {
+  const pts = targetPathPoints(ctx, frameStart, cfg.durationMs);
+  if (!pts)
+    return null;
+  const start = resolveCameraState(ctx);
+  const sorted = [...pts].sort((a, b) => (a.timeRatio ?? 0) - (b.timeRatio ?? 0));
+  const N_SAMPLE = 96;
+  const posAt = (u) => {
+    const i = Math.min(sorted.length - 2, Math.floor(u * (sorted.length - 1)));
+    const t = u * (sorted.length - 1) - i;
+    return vLerp(sorted[i].position, sorted[i + 1].position, clamp(t, 0, 1));
+  };
+  const ahead = 1 / Math.max(4 * sorted.length, 12);
+  const poses = Array.from({ length: N_SAMPLE }, (_, i) => {
+    const u = i / (N_SAMPLE - 1);
+    const s = easeValue(cfg.easing, u);
+    const position = posAt(s);
+    const lookAt = posAt(clamp(s + ahead, 0, 1));
+    return { timeMs: lerp(0, cfg.durationMs, u), position, lookAt, fov: start.fov };
+  });
+  const source = {
+    easing: cfg.easing,
+    fovStart: start.fov,
+    lookAt: {
+      fallbackOffset: vSub(start.lookAt, start.position),
+      progressOffset: ahead,
+      type: "path-ahead"
+    },
+    positionPath: pathObj(sorted.map((p) => p.position), true),
+    rollDeg: start.rollDeg,
+    type: "path"
+  };
+  return { poses, source };
+}
+function kfId(prefix, i) {
+  return `${prefix}:${i}`;
+}
+function toCurves(poses, preset, cfg, approximated) {
+  const interpolation = cfg.easing === "linear" ? "linear" : "bezier";
+  const interp2 = poses.length > 8 ? "linear" : interpolation;
+  const build = (suffix, group, dataPath, arrayIndex, pick) => ({
+    id: `${preset.id}:${suffix}`,
+    group,
+    dataPath,
+    arrayIndex,
+    extrapolation: "constant",
+    keyframes: poses.map((p, i) => ({
+      id: kfId(`${preset.id}:${suffix}`, i),
+      time: p.timeMs,
+      value: pick(p),
+      interpolation: interp2
+    }))
+  });
+  const curves = [
+    build("position-x", "position", "camera.position", 0, (p) => p.position.x),
+    build("position-y", "position", "camera.position", 1, (p) => p.position.y),
+    build("position-z", "position", "camera.position", 2, (p) => p.position.z),
+    build("look-at-x", "lookAt", "camera.lookAt", 0, (p) => p.lookAt.x),
+    build("look-at-y", "lookAt", "camera.lookAt", 1, (p) => p.lookAt.y),
+    build("look-at-z", "lookAt", "camera.lookAt", 2, (p) => p.lookAt.z),
+    build("fov", "lens", "camera.lens.fov", 0, (p) => p.fov)
+  ];
+  if (poses.some((p) => p.rollDeg !== void 0 && p.rollDeg !== 0)) {
+    curves.push({
+      id: `${preset.id}:roll`,
+      group: "rotation",
+      dataPath: "camera.rollDeg",
+      arrayIndex: 0,
+      extrapolation: "constant",
+      keyframes: poses.map((p, i) => ({
+        id: kfId(`${preset.id}:roll`, i),
+        time: p.timeMs,
+        value: p.rollDeg ?? 0,
+        interpolation: interp2
+      }))
+    });
+  }
+  const warnings = [];
+  if (approximated)
+    warnings.push("advanced-motion-approximated");
+  if (poses.some((p) => p.fov <= 18 || p.fov >= 85))
+    warnings.push("fov-clamped");
+  return { curves, warnings: warnings.length ? warnings : void 0 };
+}
+var clipSeq = 1;
+function rand6() {
+  return Math.random().toString(36).slice(2, 8);
+}
+function checkTargetPolicy(preset, ctx) {
+  switch (preset.targetPolicy) {
+    case "required-look-at":
+    case "required-focus-target":
+      return ctx.targetNode ? null : "missing-target";
+    default:
+      return null;
+  }
+}
+function sampleCameraMotionPoses(preset, ctx, frameStart, userConfig) {
+  const reason = checkTargetPolicy(preset, ctx);
+  if (reason)
+    return { ok: false, reason };
+  const cfg = {
+    ...preset.defaultConfig,
+    ...userConfig,
+    strength: clamp(userConfig?.strength ?? preset.defaultConfig.strength, 0, 1)
+  };
+  if (!Number.isFinite(cfg.durationMs) || cfg.durationMs <= 0)
+    return { ok: false, reason: "invalid-config" };
+  const recipe = preset.recipe;
+  let poses;
+  let approximated = false;
+  let source;
+  const start = resolveCameraState(ctx);
+  switch (recipe.type) {
+    case "static": {
+      poses = [start, { ...start, timeMs: cfg.durationMs }];
+      break;
+    }
+    case "pan-tilt": {
+      const dist = Math.max(vDist(start.position, start.lookAt), 1e-3);
+      const b = cameraBasis(start.position, start.lookAt);
+      const yaw = recipe.yawDeg ?? 0;
+      const pitch = recipe.pitchDeg ?? 0;
+      let fwd = vRotateAxis(b.forward, UP, yaw);
+      fwd = vRotateAxis(fwd, b.right, pitch);
+      const end = { ...start, lookAt: vAdd(start.position, vScale(fwd, dist)) };
+      poses = lerpPoses(start, end, cfg);
+      break;
+    }
+    case "translate": {
+      poses = bakeTranslate(recipe, ctx, cfg);
+      break;
+    }
+    case "zoom": {
+      const delta = cfg.fovDelta ?? recipe.fovDelta ?? 0;
+      const end = { ...start, fov: clamp(start.fov + delta, 18, 85) };
+      poses = lerpPoses(start, end, cfg);
+      break;
+    }
+    case "orbit": {
+      const r = bakeOrbit(recipe, ctx, cfg);
+      poses = r.poses;
+      source = r.source;
+      break;
+    }
+    case "shake": {
+      poses = bakeShake(recipe, ctx, cfg);
+      approximated = true;
+      break;
+    }
+    case "focus-shift": {
+      const end = { ...start, lookAt: targetPoint(ctx) };
+      poses = lerpPoses(start, end, cfg);
+      approximated = true;
+      break;
+    }
+    case "path": {
+      const kind = recipe.pathKind ?? "slider-reveal";
+      if (kind === "follow" || kind === "leading" || kind === "profile") {
+        const r = bakeTracking(kind, ctx, cfg, frameStart);
+        poses = r.poses;
+        source = r.source;
+        break;
+      }
+      if (kind === "fpv") {
+        const fpv = bakeFpv(ctx, cfg, frameStart);
+        if (fpv) {
+          poses = fpv.poses;
+          source = fpv.source;
+          break;
+        }
+        const end2 = translatePose(start, ctx, { x: 0, y: 0, z: 1 }, 1.4 * contextScale());
+        poses = bakeLinePath(start, end2, cfg);
+        source = linePathSource(start, end2, cfg);
+        approximated = true;
+        break;
+      }
+      const scale = contextScale();
+      let end;
+      switch (kind) {
+        case "slider-reveal":
+          end = translatePose(start, ctx, { x: 1, y: 0, z: 0 }, scale);
+          break;
+        case "foreground-wipe":
+          end = translatePose(start, ctx, { x: 1, y: 0, z: 0 }, 0.8 * scale);
+          break;
+        case "push-through":
+          end = translatePose(start, ctx, { x: 0, y: 0, z: 1 }, 1.4 * scale);
+          break;
+        case "aerial":
+          end = {
+            ...translatePose(start, ctx, { x: 0.6, y: 0.5, z: -0.25 }, scale),
+            fov: clamp(start.fov + (cfg.fovDelta ?? 6), 18, 85)
+          };
+          break;
+        case "dive":
+          end = translatePose(start, ctx, { x: 0, y: -0.7, z: 0.8 }, scale);
+          break;
+        case "pull-away":
+          end = {
+            ...translatePose(start, ctx, { x: 0, y: 0.7, z: -1 }, scale),
+            fov: clamp(start.fov + (cfg.fovDelta ?? 8), 18, 85)
+          };
+          break;
+        default:
+          return { ok: false, reason: `unsupported-path-kind:${kind}` };
+      }
+      poses = bakeLinePath(start, end, cfg);
+      source = linePathSource(start, end, cfg);
+      if (kind === "aerial" || kind === "pull-away" || kind === "push-through" || kind === "slider-reveal" || kind === "foreground-wipe" || kind === "dive") {
+        approximated = true;
+      }
+      break;
+    }
+    default:
+      return { ok: false, reason: `unsupported-recipe:${recipe.type}` };
+  }
+  return { ok: true, poses, cfg, approximated, source };
+}
+function bakeCameraMotionPoses(preset, ctx, frameStart, userConfig) {
+  const sampled = sampleCameraMotionPoses(preset, ctx, frameStart, userConfig);
+  if (!sampled.ok || !sampled.poses)
+    return { ok: false, reason: sampled.reason };
+  return { ok: true, poses: sampled.poses };
+}
+function bakeCameraMotionClip(preset, ctx, frameStart, userConfig) {
+  const sampled = sampleCameraMotionPoses(preset, ctx, frameStart, userConfig);
+  if (!sampled.ok || !sampled.poses || !sampled.cfg)
+    return { ok: false, reason: sampled.reason };
+  const { poses, cfg, approximated = false, source } = sampled;
+  const { curves, warnings } = toCurves(poses, preset, cfg, approximated);
+  const fps = ctx.doc.content.timeline.fps;
+  const spanFrames = Math.max(1, Math.round(cfg.durationMs * fps / 1e3));
+  const outerId = `camera_motion_clip_${Date.now().toString(36)}_${rand6()}`;
+  const motionId = `camera_motion_clip_${clipSeq++}`;
+  const clip = {
+    id: outerId,
+    target: { type: "node", nodeId: ctx.cameraNode.id },
+    focusTarget: { type: "center" },
+    frameStart,
+    frameEnd: frameStart + spanFrames,
+    trimStartMs: 0,
+    trimEndMs: cfg.durationMs,
+    playback: {
+      version: 1,
+      speed: 1,
+      loop: false,
+      loopMode: "ping-pong",
+      baseDurationFrames: spanFrames
+    },
+    motion: {
+      id: motionId,
+      version: 1,
+      presetId: preset.id,
+      label: preset.name,
+      timeUnit: "millisecond",
+      durationMs: cfg.durationMs,
+      metadata: {
+        generatedAt: Date.now(),
+        cameraNodeId: ctx.cameraNode.id,
+        targetNodeId: ctx.targetNode?.id,
+        // 本次烘焙用的合并参数（defaultConfig + 用户调参），重烘焙时叠加修改
+        // —— 注意：官方 metadata 只有 generatedAt/cameraNodeId/targetNodeId/
+        //    secondaryTargetNodeId/occluderNodeId，config 是我们为重烘焙额外加的
+        config: cfg
+      },
+      // 原版：确定性 recipe（C()）无 source；采样类（k()/I()）写 source 描述对象
+      source,
+      // 原版：无 warning 时整个字段省略（undefined），不写 null
+      warnings,
+      curves
+    }
+  };
+  return { ok: true, clip };
+}
+function applyCameraPresetToNode(node, preset) {
+  node.transform.position = { ...preset.position };
+  node.transform.rotation = { ...preset.rotation };
+  if (node.camera) {
+    node.camera.fov = preset.fov;
+    node.camera.lookAt = { ...preset.lookAt };
+    delete node.camera.subject;
+  }
+}
+function applyCameraPresetToSubject(node, preset, subject) {
+  const offset = {
+    x: preset.position.x - preset.lookAt.x,
+    y: preset.position.y,
+    z: preset.position.z - preset.lookAt.z
+  };
+  const lookAtOffset = { x: 0, y: preset.lookAt.y, z: 0 };
+  const binding = {
+    nodeId: subject.id,
+    distance: Math.hypot(offset.x, offset.z) || 1,
+    offset,
+    lookAtOffset,
+    // 默认不跟随：机位只按人物当前姿态摆一次，之后可以自由拖。
+    // 用户在 Inspector 勾上「跟随人物」后才会跟着走。
+    follow: false,
+    followRotation: true,
+    overridesMotion: true
+  };
+  const pose = resolveSubjectCameraPose(binding, subject.transform.position, subject.transform.rotation);
+  node.transform.position = pose.position;
+  node.transform.rotation = {
+    ...preset.rotation,
+    y: preset.rotation.y + subjectYawDeg(subject.transform.rotation)
+  };
+  if (node.camera) {
+    node.camera.fov = preset.fov;
+    node.camera.lookAt = pose.lookAt;
+    node.camera.subject = binding;
+  }
+}
+
+// src/evaluate/camera/cameraMotionRange.ts
+function defaultVideoExportEndFrame(clips, cameraId, timelineEnd) {
+  const scoped = cameraId ? clips.filter((clip) => clip.target.nodeId === cameraId) : clips;
+  if (scoped.length === 0)
+    return timelineEnd;
+  return Math.min(timelineEnd, Math.max(...scoped.map((clip) => clip.frameEnd)));
+}
+
+// src/evaluate/editSequence.ts
+function emptyEditorial() {
+  return {
+    version: 1,
+    activeSequenceId: "sequence_1",
+    sequences: [{ id: "sequence_1", clips: [] }]
+  };
+}
+function getEditorial(document) {
+  return document.content.editorial ?? emptyEditorial();
+}
+function getEditSequence(document, sequenceId) {
+  return getEditorial(document).sequences.find((sequence) => sequence.id === sequenceId) ?? null;
+}
+function getClipDurationFrames(clip) {
+  return clip.sourceFrameEnd - clip.sourceFrameStart + 1;
+}
+function getEditSequenceDurationFrames(clips) {
+  let total = 0;
+  for (const clip of clips) {
+    const duration = getClipDurationFrames(clip);
+    if (duration > 0)
+      total += duration;
+  }
+  return total;
+}
+function resolveEditSequenceFrame(clips, sequenceFrame) {
+  if (!Number.isInteger(sequenceFrame) || sequenceFrame < 0)
+    return null;
+  let cursor = 0;
+  for (let i = 0; i < clips.length; i++) {
+    const clip = clips[i];
+    const duration = getClipDurationFrames(clip);
+    if (duration <= 0)
+      continue;
+    if (sequenceFrame >= cursor && sequenceFrame < cursor + duration) {
+      const clipLocalFrame = sequenceFrame - cursor;
+      return {
+        clipId: clip.id,
+        cameraNodeId: clip.cameraNodeId,
+        sourceFrame: clip.sourceFrameStart + clipLocalFrame,
+        clipIndex: i,
+        clipLocalFrame
+      };
+    }
+    cursor += duration;
+  }
+  return null;
+}
+function collectCameraIds(nodes) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (node.type === "camera")
+      ids.add(node.id);
+  }
+  return ids;
+}
+function validateClip(document, sequenceId, clip, cameraIds) {
+  const timeline = document.content.timeline;
+  const issues = [];
+  const details = { sequenceId, clipId: clip.id };
+  if (!Number.isInteger(clip.sourceFrameStart) || !Number.isInteger(clip.sourceFrameEnd)) {
+    issues.push({
+      code: "non-integer-frame",
+      ...details,
+      message: `clip ${clip.id} source frames must be integers`
+    });
+  }
+  if (clip.sourceFrameEnd < clip.sourceFrameStart) {
+    issues.push({
+      code: "inverted-range",
+      ...details,
+      message: `clip ${clip.id} sourceFrameEnd < sourceFrameStart`
+    });
+  }
+  if (clip.sourceFrameStart < timeline.frameStart || clip.sourceFrameEnd > timeline.frameEnd) {
+    issues.push({
+      code: "out-of-timeline",
+      ...details,
+      message: `clip ${clip.id} source range is outside timeline.frameStart..frameEnd`
+    });
+  }
+  if (!cameraIds.has(clip.cameraNodeId)) {
+    issues.push({
+      code: "missing-camera",
+      ...details,
+      message: `clip ${clip.id} references missing camera ${clip.cameraNodeId}`
+    });
+  }
+  return issues;
+}
+function validateEditorial(document, options = {}) {
+  const editorial = getEditorial(document);
+  const issues = [];
+  if (editorial.sequences.length === 0) {
+    return [{ code: "empty-editorial", message: "editorial.sequences is empty" }];
+  }
+  const sequenceIds = /* @__PURE__ */ new Set();
+  for (const sequence of editorial.sequences) {
+    if (sequenceIds.has(sequence.id)) {
+      issues.push({
+        code: "duplicate-sequence-id",
+        sequenceId: sequence.id,
+        message: `duplicate sequence id ${sequence.id}`
+      });
+    }
+    sequenceIds.add(sequence.id);
+  }
+  if (!sequenceIds.has(editorial.activeSequenceId)) {
+    issues.push({
+      code: "active-sequence-missing",
+      sequenceId: editorial.activeSequenceId,
+      message: `active sequence ${editorial.activeSequenceId} does not exist`
+    });
+  }
+  const clipIds = /* @__PURE__ */ new Set();
+  for (const sequence of editorial.sequences) {
+    for (const clip of sequence.clips) {
+      if (clipIds.has(clip.id)) {
+        issues.push({
+          code: "duplicate-clip-id",
+          sequenceId: sequence.id,
+          clipId: clip.id,
+          message: `duplicate clip id ${clip.id}`
+        });
+      }
+      clipIds.add(clip.id);
+    }
+  }
+  const sequences = options.sequenceId ? editorial.sequences.filter((sequence) => sequence.id === options.sequenceId) : editorial.sequences;
+  if (options.sequenceId && sequences.length === 0) {
+    issues.push({
+      code: "missing-sequence",
+      sequenceId: options.sequenceId,
+      message: `sequence ${options.sequenceId} does not exist`
+    });
+    return issues;
+  }
+  const cameraIds = collectCameraIds(document.content.nodes);
+  for (const sequence of sequences) {
+    if (options.requireClips && sequence.clips.length === 0) {
+      issues.push({
+        code: "empty-sequence",
+        sequenceId: sequence.id,
+        message: `sequence ${sequence.id} has no clips`
+      });
+    }
+    for (const clip of sequence.clips) {
+      issues.push(...validateClip(document, sequence.id, clip, cameraIds));
+    }
+  }
+  return issues;
+}
+
+// src/evaluate/editSequenceOps.ts
+var PLAYBACK_BLOCKING = /* @__PURE__ */ new Set([
+  "empty-editorial",
+  "missing-sequence",
+  "empty-sequence",
+  "duplicate-sequence-id",
+  "duplicate-clip-id",
+  "missing-camera",
+  "non-integer-frame",
+  "inverted-range",
+  "out-of-timeline"
+]);
+function cloneEditorial(editorial) {
+  return JSON.parse(JSON.stringify(editorial));
+}
+function emptyEditorial2() {
+  return {
+    version: 1,
+    activeSequenceId: "sequence_1",
+    sequences: [{ id: "sequence_1", clips: [] }]
+  };
+}
+function materializeEditorial(document) {
+  return document.content.editorial ? cloneEditorial(document.content.editorial) : emptyEditorial2();
+}
+function rand62() {
+  return Math.random().toString(36).slice(2, 8).padEnd(6, "0");
+}
+function uniqueId(used, prefix) {
+  for (let i = 0; i < 32; i++) {
+    const id = `${prefix}_${Date.now().toString(36)}_${rand62()}`;
+    if (!used.has(id))
+      return id;
+  }
+  throw new Error(`unable to allocate unique id with prefix ${prefix}`);
+}
+function collectIds(editorial) {
+  const sequences = /* @__PURE__ */ new Set();
+  const clips = /* @__PURE__ */ new Set();
+  for (const sequence of editorial.sequences) {
+    sequences.add(sequence.id);
+    for (const clip of sequence.clips)
+      clips.add(clip.id);
+  }
+  return { sequences, clips };
+}
+function hasDuplicateIds(editorial) {
+  const sequences = /* @__PURE__ */ new Set();
+  const clips = /* @__PURE__ */ new Set();
+  for (const sequence of editorial.sequences) {
+    if (sequences.has(sequence.id))
+      return true;
+    sequences.add(sequence.id);
+    for (const clip of sequence.clips) {
+      if (clips.has(clip.id))
+        return true;
+      clips.add(clip.id);
+    }
+  }
+  return false;
+}
+function allocateSequenceId(editorial) {
+  return uniqueId(collectIds(editorial).sequences, "sequence");
+}
+function allocateClipId(editorial) {
+  return uniqueId(collectIds(editorial).clips, "edit_clip");
+}
+function findEditClip(editorial, clipId) {
+  for (let sequenceIndex = 0; sequenceIndex < editorial.sequences.length; sequenceIndex++) {
+    const sequence = editorial.sequences[sequenceIndex];
+    const clipIndex = sequence.clips.findIndex((clip) => clip.id === clipId);
+    if (clipIndex >= 0)
+      return { sequence, sequenceIndex, clipIndex };
+  }
+  return null;
+}
+function getActiveEditSequence(document) {
+  const editorial = getEditorial(document);
+  return editorial.sequences.find((sequence) => sequence.id === editorial.activeSequenceId) ?? null;
+}
+function clipSequenceSpan(clips, index) {
+  if (index < 0 || index >= clips.length)
+    return null;
+  let sequenceStart = 0;
+  for (let i = 0; i < index; i++) {
+    const duration = getClipDurationFrames(clips[i]);
+    if (duration > 0)
+      sequenceStart += duration;
+  }
+  return { sequenceStart, duration: Math.max(0, getClipDurationFrames(clips[index])) };
+}
+function playbackIssues(document, sequenceId) {
+  return validateEditorial(document, { sequenceId, requireClips: true }).filter(
+    (issue) => issue.code !== "active-sequence-missing" && PLAYBACK_BLOCKING.has(issue.code)
+  );
+}
+function fail(error, issues) {
+  return issues ? { ok: false, error, issues } : { ok: false, error };
+}
+function ok(editorial, createdId) {
+  return createdId ? { ok: true, editorial, createdId } : { ok: true, editorial };
+}
+function requireEditorial(document) {
+  if (!document)
+    return fail("no-document");
+  const editorial = materializeEditorial(document);
+  if (hasDuplicateIds(editorial))
+    return fail("duplicate-id");
+  return editorial;
+}
+function normalizeName(name) {
+  if (name == null)
+    return void 0;
+  const trimmed = name.trim();
+  return trimmed || void 0;
+}
+function isCamera(document, cameraNodeId) {
+  return document.content.nodes.some((node) => node.id === cameraNodeId && node.type === "camera");
+}
+function normalizeRange(document, start, end) {
+  const sourceFrameStart = Math.round(start);
+  const sourceFrameEnd = Math.round(end);
+  const { frameStart, frameEnd } = document.content.timeline;
+  if (!Number.isInteger(sourceFrameStart) || !Number.isInteger(sourceFrameEnd) || sourceFrameEnd < sourceFrameStart || sourceFrameStart < frameStart || sourceFrameEnd > frameEnd) {
+    return null;
+  }
+  return { sourceFrameStart, sourceFrameEnd };
+}
+function createSequence(document, input = {}) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const name = normalizeName(input.name);
+  const id = allocateSequenceId(editorial);
+  const sequence = { id, clips: [] };
+  if (typeof name === "string")
+    sequence.name = name;
+  editorial.sequences.push(sequence);
+  if (input.activate !== false)
+    editorial.activeSequenceId = id;
+  return ok(editorial, id);
+}
+function renameSequence(document, sequenceId, name) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const sequence = editorial.sequences.find((item) => item.id === sequenceId);
+  if (!sequence)
+    return fail("missing-sequence");
+  const next = normalizeName(name);
+  if (typeof next === "string")
+    sequence.name = next;
+  else
+    delete sequence.name;
+  return ok(editorial);
+}
+function duplicateSequence(document, sequenceId, input = {}) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const index = editorial.sequences.findIndex((item) => item.id === sequenceId);
+  if (index < 0)
+    return fail("missing-sequence");
+  const source = editorial.sequences[index];
+  const copy = JSON.parse(JSON.stringify(source));
+  copy.id = allocateSequenceId(editorial);
+  editorial.sequences.splice(index + 1, 0, copy);
+  copy.clips = source.clips.map((clip) => ({
+    ...JSON.parse(JSON.stringify(clip)),
+    id: allocateClipId(editorial)
+  }));
+  if (input.activate !== false)
+    editorial.activeSequenceId = copy.id;
+  return ok(editorial, copy.id);
+}
+function deleteSequence(document, sequenceId) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const index = editorial.sequences.findIndex((item) => item.id === sequenceId);
+  if (index < 0)
+    return fail("missing-sequence");
+  if (editorial.sequences.length === 1)
+    return fail("last-sequence");
+  editorial.sequences.splice(index, 1);
+  if (editorial.activeSequenceId === sequenceId) {
+    const neighbor = editorial.sequences[Math.max(0, index - 1)];
+    editorial.activeSequenceId = neighbor.id;
+  }
+  return ok(editorial);
+}
+function activateSequence(document, sequenceId) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  if (!editorial.sequences.some((item) => item.id === sequenceId)) {
+    return fail("missing-sequence");
+  }
+  editorial.activeSequenceId = sequenceId;
+  return ok(editorial);
+}
+function clearSequenceClips(document, sequenceId) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const sequence = editorial.sequences.find((item) => item.id === sequenceId);
+  if (!sequence)
+    return fail("missing-sequence");
+  sequence.clips = [];
+  return ok(editorial);
+}
+function insertEditClip(document, input) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const sequence = editorial.sequences.find((item) => item.id === input.sequenceId);
+  if (!sequence)
+    return fail("missing-sequence");
+  if (!isCamera(document, input.cameraNodeId))
+    return fail("invalid-camera");
+  const range = normalizeRange(document, input.sourceFrameStart, input.sourceFrameEnd);
+  if (!range)
+    return fail("invalid-range");
+  const index = input.index ?? sequence.clips.length;
+  if (!Number.isInteger(index) || index < 0 || index > sequence.clips.length) {
+    return fail("invalid-index");
+  }
+  const clip = {
+    id: allocateClipId(editorial),
+    cameraNodeId: input.cameraNodeId,
+    ...range
+  };
+  sequence.clips.splice(index, 0, clip);
+  return ok(editorial, clip.id);
+}
+function updateEditClip(document, clipId, patch) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const found = findEditClip(editorial, clipId);
+  if (!found)
+    return fail("missing-clip");
+  const clip = found.sequence.clips[found.clipIndex];
+  const cameraNodeId = patch.cameraNodeId ?? clip.cameraNodeId;
+  if (patch.cameraNodeId !== void 0 && !isCamera(document, cameraNodeId)) {
+    return fail("invalid-camera");
+  }
+  const range = normalizeRange(
+    document,
+    patch.sourceFrameStart ?? clip.sourceFrameStart,
+    patch.sourceFrameEnd ?? clip.sourceFrameEnd
+  );
+  if (!range)
+    return fail("invalid-range");
+  found.sequence.clips[found.clipIndex] = { ...clip, cameraNodeId, ...range };
+  return ok(editorial);
+}
+function moveEditClip(document, clipId, toIndex) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const found = findEditClip(editorial, clipId);
+  if (!found)
+    return fail("missing-clip");
+  const clips = found.sequence.clips;
+  if (!Number.isInteger(toIndex) || toIndex < 0 || toIndex >= clips.length) {
+    return fail("invalid-index");
+  }
+  if (toIndex === found.clipIndex)
+    return ok(editorial);
+  const [moved] = clips.splice(found.clipIndex, 1);
+  clips.splice(toIndex, 0, moved);
+  return ok(editorial);
+}
+function duplicateEditClip(document, clipId, input = {}) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const found = findEditClip(editorial, clipId);
+  if (!found)
+    return fail("missing-clip");
+  const source = found.sequence.clips[found.clipIndex];
+  const index = input.index ?? found.clipIndex + 1;
+  if (!Number.isInteger(index) || index < 0 || index > found.sequence.clips.length) {
+    return fail("invalid-index");
+  }
+  const copy = {
+    ...JSON.parse(JSON.stringify(source)),
+    id: allocateClipId(editorial)
+  };
+  found.sequence.clips.splice(index, 0, copy);
+  return ok(editorial, copy.id);
+}
+function deleteEditClip(document, clipId) {
+  const editorial = requireEditorial(document);
+  if (!("sequences" in editorial))
+    return editorial;
+  const found = findEditClip(editorial, clipId);
+  if (!found)
+    return fail("missing-clip");
+  found.sequence.clips.splice(found.clipIndex, 1);
+  return ok(editorial);
+}
+function defaultInsertRange(document, sourceFrame, spanFrames = 60) {
+  const { frameStart, frameEnd } = document.content.timeline;
+  const span = Math.max(1, Math.round(spanFrames));
+  const preferredStart = Math.round(sourceFrame);
+  const preferredEnd = preferredStart + span - 1;
+  if (preferredStart >= frameStart && preferredEnd <= frameEnd) {
+    return { sourceFrameStart: preferredStart, sourceFrameEnd: preferredEnd };
+  }
+  if (preferredEnd > frameEnd) {
+    return {
+      sourceFrameStart: Math.max(frameStart, frameEnd - span + 1),
+      sourceFrameEnd: frameEnd
+    };
+  }
+  return {
+    sourceFrameStart: frameStart,
+    sourceFrameEnd: Math.min(frameStart + span - 1, frameEnd)
+  };
+}
+
+// src/evaluate/timecode.ts
+function safeFps(fps) {
+  return Math.max(1, Math.round(fps));
+}
+function framesToSeconds(frame, fps) {
+  return frame / safeFps(fps);
+}
+function secondsToFrame(seconds, fps) {
+  return Math.round(seconds * safeFps(fps));
+}
+function formatTimecode(frame, fps) {
+  const rate = safeFps(fps);
+  const total = Math.max(0, Math.round(frame));
+  const ff = total % rate;
+  const seconds = Math.floor(total / rate);
+  const ss = seconds % 60;
+  const mm = Math.floor(seconds / 60) % 60;
+  const hh = Math.floor(seconds / 3600);
+  return `${pad2(hh)}:${pad2(mm)}:${pad2(ss)}:${pad2(ff)}`;
+}
+function parseTimecode(value, fps) {
+  const match = value.trim().match(/^(\d+):(\d{2}):(\d{2}):(\d{2})$/);
+  if (!match)
+    return null;
+  const rate = safeFps(fps);
+  const hh = Number(match[1]);
+  const mm = Number(match[2]);
+  const ss = Number(match[3]);
+  const ff = Number(match[4]);
+  if (mm > 59 || ss > 59 || ff >= rate)
+    return null;
+  return ((hh * 60 + mm) * 60 + ss) * rate + ff;
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+// src/contract/skyColor.ts
+var DEFAULT_SKY_COLOR = "#1e1e1e";
+var LEGACY_DEFAULT_SKY_COLOR = "#060608";
+var HEX6 = /^#[0-9a-fA-F]{6}$/;
+var HEX3 = /^#[0-9a-fA-F]{3}$/;
+function expandHex3(raw) {
+  const r = raw[1];
+  const g = raw[2];
+  const b = raw[3];
+  return `#${r}${r}${g}${g}${b}${b}`;
+}
+function normalizeSkyHex(value) {
+  if (typeof value !== "string")
+    return null;
+  const raw = value.trim();
+  if (HEX6.test(raw))
+    return raw;
+  if (HEX3.test(raw))
+    return expandHex3(raw);
+  return null;
+}
+function isLeakedBrowserSkyColor(value) {
+  const raw = value.trim().toLowerCase();
+  return raw === "#0000ff" || raw === "#00f" || raw === "blue";
+}
+function isEmptyDirectorGenesis(nodes) {
+  if (!Array.isArray(nodes))
+    return true;
+  return nodes.length <= 1;
+}
+function resolveSkyColor(value, emptyGenesis) {
+  const normalized = normalizeSkyHex(value);
+  if (!normalized || normalized.toLowerCase() === LEGACY_DEFAULT_SKY_COLOR)
+    return DEFAULT_SKY_COLOR;
+  if (emptyGenesis && isLeakedBrowserSkyColor(value ?? ""))
+    return DEFAULT_SKY_COLOR;
+  return normalized;
+}
+function hydrateSkyColor(doc) {
+  const background = doc.content.environment?.background;
+  if (!background)
+    return doc;
+  const next = resolveSkyColor(background.skyColor, isEmptyDirectorGenesis(doc.content.nodes));
+  if (background.skyColor === next)
+    return doc;
+  background.skyColor = next;
+  return doc;
+}
+
+// src/contract/validate.ts
+var vec3Schema = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number()
+});
+var transformSchema = z.object({
+  position: vec3Schema,
+  rotation: vec3Schema,
+  scale: vec3Schema
+});
+var nodeRefSchema = z.object({
+  type: z.string(),
+  nodeId: z.string()
+}).passthrough();
+var playbackSchema = z.object({
+  version: z.number(),
+  speed: z.number(),
+  loop: z.boolean(),
+  loopMode: z.string(),
+  baseDurationFrames: z.number().optional()
+}).passthrough();
+var curveKeyframeSchema = z.object({
+  id: z.string(),
+  time: z.number(),
+  value: z.number(),
+  interpolation: z.enum(["linear", "bezier"])
+}).passthrough();
+var bakedCurveSchema = z.object({
+  id: z.string(),
+  group: z.enum(["position", "lookAt", "lens", "rotation"]),
+  dataPath: z.string(),
+  arrayIndex: z.number(),
+  extrapolation: z.string(),
+  keyframes: z.array(curveKeyframeSchema)
+}).passthrough();
+var cameraMotionClipSchema = z.object({
+  id: z.string(),
+  target: nodeRefSchema,
+  focusTarget: z.object({ type: z.string() }).passthrough().optional(),
+  frameStart: z.number(),
+  frameEnd: z.number(),
+  trimStartMs: z.number(),
+  trimEndMs: z.number(),
+  playback: playbackSchema,
+  motion: z.object({
+    id: z.string(),
+    version: z.number(),
+    presetId: z.string(),
+    label: z.string(),
+    timeUnit: z.string(),
+    durationMs: z.number(),
+    metadata: z.unknown().optional(),
+    source: z.unknown().optional(),
+    warnings: z.array(z.string()).nullable().optional(),
+    curves: z.array(bakedCurveSchema)
+  }).passthrough()
+}).passthrough();
+var motionClipSchema = z.object({
+  id: z.string(),
+  source: z.string(),
+  sourceDuration: z.number(),
+  frameStart: z.number(),
+  frameEnd: z.number(),
+  target: nodeRefSchema,
+  playback: playbackSchema,
+  motion: z.object({
+    assetId: z.string(),
+    name: z.string(),
+    source: z.string(),
+    sourceRig: z.string(),
+    url: z.string(),
+    inPlace: z.boolean(),
+    loop: z.boolean(),
+    speed: z.number(),
+    time: z.number()
+  }).passthrough()
+}).passthrough();
+var pathMotionClipSchema = z.object({
+  id: z.string(),
+  status: z.string(),
+  locked: z.boolean(),
+  lockedReason: z.string().optional(),
+  source: z.string(),
+  target: nodeRefSchema,
+  pathNodeId: z.string(),
+  pathName: z.string(),
+  pathLength: z.number(),
+  pathStartPercent: z.number(),
+  pathEndPercent: z.number(),
+  direction: z.string(),
+  facing: z.string(),
+  frameStart: z.number(),
+  frameEnd: z.number(),
+  playback: playbackSchema,
+  derivedSource: z.unknown().optional()
+}).passthrough();
+var editSequenceClipSchema = z.object({
+  id: z.string().min(1),
+  cameraNodeId: z.string().min(1),
+  sourceFrameStart: z.number().int(),
+  sourceFrameEnd: z.number().int()
+}).passthrough().refine(
+  (clip) => clip.sourceFrameEnd >= clip.sourceFrameStart,
+  { message: "sourceFrameEnd must be >= sourceFrameStart", path: ["sourceFrameEnd"] }
+);
+var editSequenceSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().refine((name) => name.trim().length > 0, {
+    message: "name must not be blank"
+  }).optional(),
+  clips: z.array(editSequenceClipSchema)
+}).passthrough();
+var editorialSchema = z.object({
+  version: z.literal(1),
+  activeSequenceId: z.string().min(1),
+  sequences: z.array(editSequenceSchema).min(1)
+}).passthrough();
+var timelineSchema = z.object({
+  version: z.number(),
+  fps: z.number(),
+  frameStart: z.number(),
+  frameEnd: z.number(),
+  usePreviewRange: z.boolean(),
+  animation: z.object({
+    fcurves: z.array(z.unknown()),
+    fcurvesRef: z.unknown().optional(),
+    cameraMotionClips: z.array(cameraMotionClipSchema),
+    motionTransitions: z.array(z.unknown()).optional(),
+    motionClips: z.array(motionClipSchema),
+    pathMotionClips: z.array(pathMotionClipSchema)
+  }).passthrough()
+}).passthrough();
+var draftNodeSchema = z.object({
+  id: z.string(),
+  type: z.enum(["camera", "character", "prop", "path", "group", "primitive"]),
+  name: z.string(),
+  visible: z.boolean(),
+  locked: z.boolean(),
+  transform: transformSchema,
+  metadata: z.unknown().optional(),
+  parentId: z.string().optional(),
+  children: z.array(z.string()).optional(),
+  group: z.object({
+    appearance: z.object({ color: z.string() }).passthrough(),
+    kind: z.string(),
+    label: z.object({
+      showLabel: z.boolean(),
+      scale: z.number(),
+      yOffset: z.number()
+    }).passthrough().optional(),
+    layout: z.record(z.unknown()).optional()
+  }).passthrough().optional(),
+  primitive: z.object({
+    kind: z.string(),
+    parameters: z.record(z.unknown()),
+    appearance: z.object({ color: z.string() }).passthrough().optional(),
+    label: z.object({ showLabel: z.boolean() }).passthrough().optional()
+  }).passthrough().optional(),
+  camera: z.object({
+    projection: z.string(),
+    fov: z.number(),
+    fovAxis: z.string(),
+    near: z.number(),
+    far: z.number(),
+    isPrimary: z.boolean(),
+    lookAt: vec3Schema
+  }).passthrough().optional(),
+  character: z.object({
+    placeholder: z.boolean(),
+    gender: z.string(),
+    motionId: z.string().nullable().optional(),
+    appearance: z.object({ color: z.string() }).passthrough(),
+    label: z.object({
+      showLabel: z.boolean(),
+      scale: z.number(),
+      yOffset: z.number()
+    }).passthrough(),
+    animation: z.object({
+      mode: z.string(),
+      controlValues: z.record(z.number())
+    }).passthrough()
+  }).passthrough().optional(),
+  prop: z.object({
+    category: z.string(),
+    appearance: z.object({ color: z.string() }).passthrough().optional(),
+    label: z.object({ showLabel: z.boolean() }).passthrough().optional()
+  }).passthrough().optional(),
+  path: z.object({
+    source: z.string(),
+    curve: z.string(),
+    closed: z.boolean(),
+    groundSnap: z.boolean(),
+    parameterization: z.string(),
+    smoothing: z.number(),
+    points: z.array(z.object({
+      id: z.string(),
+      position: vec3Schema,
+      timeRatio: z.number().optional()
+    }).passthrough())
+  }).passthrough().optional()
+}).passthrough();
+var draftContentSchema = z.object({
+  version: z.number(),
+  aspectRatio: z.string(),
+  activeShotCameraNodeId: z.string(),
+  generate: z.string().optional(),
+  scenePlan: z.unknown().optional(),
+  settings: z.unknown().optional(),
+  environment: z.object({
+    background: z.object({
+      mode: z.string(),
+      skyColor: z.string()
+    }).passthrough(),
+    display: z.object({
+      characterLabelsVisible: z.boolean(),
+      groundVisible: z.boolean(),
+      groundHeight: z.number(),
+      groundOpacity: z.number()
+    }).passthrough(),
+    sphere: z.unknown().optional(),
+    transform: transformSchema.optional()
+  }).passthrough(),
+  asset: z.object({
+    motionPath: z.array(z.object({
+      id: z.string(),
+      path: z.string()
+    }).passthrough())
+  }).passthrough(),
+  nodes: z.array(draftNodeSchema),
+  physicalConstraints: z.array(z.unknown()),
+  timeline: timelineSchema,
+  editorial: editorialSchema.optional()
+}).passthrough();
+var directorDocumentSchema = z.object({
+  type: z.string(),
+  pippitAssetId: z.string(),
+  extra: z.unknown().optional(),
+  content: draftContentSchema
+}).passthrough();
+function parseDirectorDocument(json) {
+  return hydrateSkyColor(directorDocumentSchema.parse(json));
+}
+var fcurveHandleSchema = z.object({
+  x: z.number(),
+  y: z.number()
+}).passthrough();
+var compactKeyframeSchema = z.array(
+  z.union([z.number(), z.string(), fcurveHandleSchema, z.null()])
+).min(3);
+var compactCurveSchema = z.object({
+  id: z.string(),
+  t: z.union([z.tuple([z.string(), z.string()]), z.string()]),
+  p: z.string(),
+  i: z.number().optional(),
+  k: z.array(compactKeyframeSchema)
+}).passthrough();
+var fcurvesCompactV1Schema = z.object({
+  version: z.literal(1),
+  encoding: z.literal("compact-v1"),
+  fcurves: z.array(compactCurveSchema)
+}).passthrough();
+
+// src/contract/aspectRatio.ts
+var AUTO_ASPECT_RATIO = "auto";
+var DEFAULT_ASPECT_RATIO = AUTO_ASPECT_RATIO;
+
+// src/contract/emptyDraft.ts
+function makeEmptyDraft(name, fps, totalFrames, camera) {
+  const nodes = [];
+  if (camera) {
+    nodes.push({
+      id: "camera_1",
+      type: "camera",
+      name: "Main Camera",
+      visible: true,
+      locked: false,
+      transform: {
+        position: { ...camera.position },
+        rotation: { ...camera.rotation },
+        scale: { x: 1, y: 1, z: 1 }
+      },
+      camera: {
+        projection: "perspective",
+        fov: camera.fov,
+        fovAxis: "vertical",
+        near: 0.1,
+        far: 2e3,
+        isPrimary: true,
+        lookAt: { ...camera.lookAt }
+      }
+    });
+  }
+  return {
+    type: "biz/scene3d-director-document",
+    pippitAssetId: "",
+    extra: { customDraftName: name },
+    content: {
+      version: 1,
+      aspectRatio: DEFAULT_ASPECT_RATIO,
+      activeShotCameraNodeId: camera ? "camera_1" : "",
+      environment: {
+        background: { mode: "color", skyColor: DEFAULT_SKY_COLOR },
+        display: {
+          characterLabelsVisible: true,
+          groundVisible: true,
+          groundHeight: 0,
+          groundOpacity: 1
+        }
+      },
+      asset: { motionPath: [] },
+      nodes,
+      physicalConstraints: [],
+      editorial: {
+        version: 1,
+        activeSequenceId: "sequence_1",
+        sequences: [{ id: "sequence_1", clips: [] }]
+      },
+      timeline: {
+        version: 1,
+        fps,
+        frameStart: 0,
+        frameEnd: Math.max(1, Math.round(totalFrames)),
+        usePreviewRange: false,
+        animation: {
+          fcurves: [],
+          cameraMotionClips: [],
+          motionTransitions: [],
+          motionClips: [],
+          pathMotionClips: []
+        }
+      }
+    }
+  };
+}
+
+// src/data/defaultCharacter.ts
+var DEFAULT_CHARACTER = {
+  name: "Female",
+  gender: "female",
+  color: "#bababa",
+  posePresetId: "stand"
+};
+var INITIAL_DRAFT_SEED = "default-character-v1";
+
+// src/data/cameraLibrary.ts
+var CAMERA_PRESETS = [{ "id": "current", "name": "\u5F53\u524D\u89C6\u89D2", "fov": 50, "position": { "x": 0, "y": 1.6246041243470328, "z": 4.246041243470324 }, "rotation": { "x": 0, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1.2, "z": 0 } }, { "id": "front-medium", "name": "\u6B63\u9762\u4E2D\u666F", "fov": 50, "position": { "x": 0, "y": 1.8, "z": 5 }, "rotation": { "x": -8, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1.2, "z": 0 } }, { "id": "front-close", "name": "\u6B63\u9762\u7279\u5199", "fov": 35, "position": { "x": 0, "y": 1.6, "z": 2.6 }, "rotation": { "x": -6, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1.35, "z": 0 } }, { "id": "front-wide", "name": "\u6B63\u9762\u5168\u666F", "fov": 70, "position": { "x": 0, "y": 2.4, "z": 7.5 }, "rotation": { "x": -14, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1.1, "z": 0 } }, { "id": "side-follow", "name": "\u4FA7\u9762\u8DDF\u62CD", "fov": 50, "position": { "x": 4.8, "y": 1.8, "z": 0.8 }, "rotation": { "x": -8, "y": 78, "z": 0 }, "lookAt": { "x": 0, "y": 1.2, "z": 0 } }, { "id": "side-close", "name": "\u4FA7\u9762\u8FD1\u666F", "fov": 42, "position": { "x": 3, "y": 1.7, "z": 0.4 }, "rotation": { "x": -7, "y": 85, "z": 0 }, "lookAt": { "x": 0, "y": 1.25, "z": 0 } }, { "id": "back-medium", "name": "\u80CC\u9762\u4E2D\u666F", "fov": 50, "position": { "x": 0, "y": 1.8, "z": -5 }, "rotation": { "x": -8, "y": 180, "z": 0 }, "lookAt": { "x": 0, "y": 1.2, "z": 0 } }, { "id": "top-wide", "name": "\u4FEF\u62CD\u5168\u666F", "fov": 70, "position": { "x": 0, "y": 6.5, "z": 4.2 }, "rotation": { "x": -58, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1, "z": 0 } }, { "id": "forty-five", "name": "45\xB0 \u4FEF\u62CD", "fov": 50, "position": { "x": 4.2, "y": 4.6, "z": 4.2 }, "rotation": { "x": -40, "y": 40, "z": 0 }, "lookAt": { "x": 0, "y": 1.2, "z": 0 } }, { "id": "low-angle", "name": "\u4F4E\u89D2\u5EA6\u4EF0\u62CD", "fov": 45, "position": { "x": 0, "y": 0.55, "z": 3.2 }, "rotation": { "x": 16, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1.7, "z": 0 } }, { "id": "low-wide", "name": "\u4F4E\u89D2\u5EA6\u5E7F\u89D2", "fov": 90, "position": { "x": 0, "y": 0.45, "z": 2.8 }, "rotation": { "x": 18, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 1.6, "z": 0 } }, { "id": "over-shoulder", "name": "\u8FC7\u80A9\u955C\u5934", "fov": 45, "position": { "x": -1.4, "y": 1.6, "z": 2.8 }, "rotation": { "x": -6, "y": -22, "z": 0 }, "lookAt": { "x": 0.4, "y": 1.35, "z": 0 } }, { "id": "over-shoulder-right", "name": "\u8FC7\u80A9\u955C\u5934\uFF08\u53F3\uFF09", "fov": 45, "position": { "x": 1.4, "y": 1.6, "z": 2.8 }, "rotation": { "x": -6, "y": 22, "z": 0 }, "lookAt": { "x": -0.4, "y": 1.35, "z": 0 } }, { "id": "bird-eye", "name": "\u9E1F\u77B0", "fov": 80, "position": { "x": 0, "y": 8, "z": 0.2 }, "rotation": { "x": -88, "y": 0, "z": 0 }, "lookAt": { "x": 0, "y": 0, "z": 0 } }, { "id": "dutch", "name": "\u8377\u5170\u89D2", "fov": 50, "position": { "x": 2.8, "y": 1.7, "z": 4.2 }, "rotation": { "x": -10, "y": 32, "z": 12 }, "lookAt": { "x": 0, "y": 1.2, "z": 0 } }];
+var CAMERA_MOTIONS = [{ "id": "static_shot", "name": "\u56FA\u5B9A\u955C\u5934", "subtitle": "\u673A\u4F4D\u548C\u65B9\u5411\u4E0D\u53D8", "description": "\u8FD0\u955C\uFF1A\u56FA\u5B9A\u673A\u4F4D\uFF0C\u955C\u5934\u4F4D\u7F6E\u548C\u62CD\u6444\u65B9\u5411\u90FD\u4FDD\u6301\u4E0D\u53D8\uFF0C\u753B\u9762\u6784\u56FE\u7A33\u5B9A\uFF0C\u7531\u4E3B\u4F53\u52A8\u4F5C\u6216\u753B\u9762\u5185\u90E8\u53D8\u5316\u5F62\u6210\u8FD0\u52A8\u611F\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6 }, "recipe": { "type": "static" } }, { "id": "tilt_up", "name": "\u955C\u5934\u4E0A\u6447", "subtitle": "\u56FA\u5B9A\u673A\u4F4D\u5411\u4E0A\u8F6C\u52A8", "description": "\u8FD0\u955C\uFF1A\u56FA\u5B9A\u673A\u4F4D\u4E0A\u6447\uFF0C\u955C\u5934\u4F4D\u7F6E\u4E0D\u79FB\u52A8\uFF0C\u53EA\u6CBF\u5782\u76F4\u65B9\u5411\u7F13\u6162\u5411\u4E0A\u8F6C\u52A8\uFF0C\u753B\u9762\u91CD\u5FC3\u4ECE\u4E0B\u65B9\u9010\u6B65\u79FB\u5411\u4E0A\u65B9\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 12 }, "recipe": { "type": "pan-tilt", "pitchDeg": 12 } }, { "id": "tilt_down", "name": "\u955C\u5934\u4E0B\u6447", "subtitle": "\u56FA\u5B9A\u673A\u4F4D\u5411\u4E0B\u8F6C\u52A8", "description": "\u8FD0\u955C\uFF1A\u56FA\u5B9A\u673A\u4F4D\u4E0B\u6447\uFF0C\u955C\u5934\u4F4D\u7F6E\u4E0D\u79FB\u52A8\uFF0C\u53EA\u6CBF\u5782\u76F4\u65B9\u5411\u7F13\u6162\u5411\u4E0B\u8F6C\u52A8\uFF0C\u753B\u9762\u91CD\u5FC3\u4ECE\u4E0A\u65B9\u9010\u6B65\u79FB\u5411\u4E0B\u65B9\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 12 }, "recipe": { "type": "pan-tilt", "pitchDeg": -12 } }, { "id": "pan_left", "name": "\u955C\u5934\u5DE6\u6447", "subtitle": "\u56FA\u5B9A\u673A\u4F4D\u5411\u5DE6\u8F6C\u52A8", "description": "\u8FD0\u955C\uFF1A\u56FA\u5B9A\u673A\u4F4D\u5DE6\u6447\uFF0C\u955C\u5934\u4F4D\u7F6E\u4E0D\u79FB\u52A8\uFF0C\u53EA\u6CBF\u6C34\u5E73\u65B9\u5411\u7F13\u6162\u5411\u5DE6\u8F6C\u52A8\uFF0C\u8BA9\u753B\u9762\u5185\u5BB9\u4ECE\u53F3\u5411\u5DE6\u8FDE\u7EED\u53D8\u5316\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 12 }, "recipe": { "type": "pan-tilt", "yawDeg": 12 } }, { "id": "pan_right", "name": "\u955C\u5934\u53F3\u6447", "subtitle": "\u56FA\u5B9A\u673A\u4F4D\u5411\u53F3\u8F6C\u52A8", "description": "\u8FD0\u955C\uFF1A\u56FA\u5B9A\u673A\u4F4D\u53F3\u6447\uFF0C\u955C\u5934\u4F4D\u7F6E\u4E0D\u79FB\u52A8\uFF0C\u53EA\u6CBF\u6C34\u5E73\u65B9\u5411\u7F13\u6162\u5411\u53F3\u8F6C\u52A8\uFF0C\u8BA9\u753B\u9762\u5185\u5BB9\u4ECE\u5DE6\u5411\u53F3\u8FDE\u7EED\u53D8\u5316\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 12 }, "recipe": { "type": "pan-tilt", "yawDeg": -12 } }, { "id": "crane_up", "name": "\u955C\u5934\u4E0A\u5347", "subtitle": "\u5782\u76F4\u4E0A\u5347\u5E76\u4FDD\u6301\u65B9\u5411", "description": "\u8FD0\u955C\uFF1A\u955C\u5934\u5782\u76F4\u4E0A\u5347\uFF0C\u62CD\u6444\u65B9\u5411\u57FA\u672C\u4FDD\u6301\u7A33\u5B9A\uFF0C\u673A\u4F4D\u9AD8\u5EA6\u4ECE\u4F4E\u5230\u9AD8\u53D8\u5316\uFF0C\u753B\u9762\u89C6\u89D2\u968F\u9AD8\u5EA6\u4EA7\u751F\u53D8\u5316\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 0.8 }, "recipe": { "type": "translate", "localOffset": { "x": 0, "y": 1, "z": 0 }, "targetSpace": "world" } }, { "id": "crane_down", "name": "\u955C\u5934\u4E0B\u964D", "subtitle": "\u5782\u76F4\u4E0B\u964D\u5E76\u4FDD\u6301\u65B9\u5411", "description": "\u8FD0\u955C\uFF1A\u955C\u5934\u5782\u76F4\u4E0B\u964D\uFF0C\u62CD\u6444\u65B9\u5411\u57FA\u672C\u4FDD\u6301\u7A33\u5B9A\uFF0C\u673A\u4F4D\u9AD8\u5EA6\u4ECE\u9AD8\u5230\u4F4E\u53D8\u5316\uFF0C\u753B\u9762\u89C6\u89D2\u968F\u9AD8\u5EA6\u4EA7\u751F\u53D8\u5316\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 0.8 }, "recipe": { "type": "translate", "localOffset": { "x": 0, "y": -1, "z": 0 }, "targetSpace": "world" } }, { "id": "truck_left", "name": "\u955C\u5934\u5DE6\u79FB", "subtitle": "\u6A2A\u5411\u5DE6\u79FB\u5E76\u4FDD\u6301\u65B9\u5411", "description": "\u8FD0\u955C\uFF1A\u955C\u5934\u5DE6\u79FB\uFF0C\u673A\u4F4D\u6574\u4F53\u5411\u5DE6\u6A2A\u5411\u5E73\u79FB\uFF0C\u62CD\u6444\u65B9\u5411\u57FA\u672C\u4E0D\u53D8\uFF0C\u524D\u666F\u4E0E\u80CC\u666F\u5F62\u6210\u81EA\u7136\u89C6\u5DEE\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 0.8 }, "recipe": { "type": "translate", "localOffset": { "x": -1, "y": 0, "z": 0 } } }, { "id": "truck_right", "name": "\u955C\u5934\u53F3\u79FB", "subtitle": "\u6A2A\u5411\u53F3\u79FB\u5E76\u4FDD\u6301\u65B9\u5411", "description": "\u8FD0\u955C\uFF1A\u955C\u5934\u53F3\u79FB\uFF0C\u673A\u4F4D\u6574\u4F53\u5411\u53F3\u6A2A\u5411\u5E73\u79FB\uFF0C\u62CD\u6444\u65B9\u5411\u57FA\u672C\u4E0D\u53D8\uFF0C\u524D\u666F\u4E0E\u80CC\u666F\u5F62\u6210\u81EA\u7136\u89C6\u5DEE\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 0.8 }, "recipe": { "type": "translate", "localOffset": { "x": 1, "y": 0, "z": 0 } } }, { "id": "dolly_in", "name": "\u955C\u5934\u524D\u63A8", "subtitle": "\u6CBF\u955C\u5934\u65B9\u5411\u524D\u63A8", "description": "\u8FD0\u955C\uFF1A\u955C\u5934\u7F13\u6162\u524D\u63A8\uFF0C\u673A\u4F4D\u6CBF\u955C\u5934\u671D\u5411\u5411\u524D\u79FB\u52A8\uFF0C\u4E3B\u4F53\u5728\u753B\u9762\u4E2D\u9010\u6E10\u53D8\u5927\uFF0C\u7A7A\u95F4\u5C42\u6B21\u4EA7\u751F\u81EA\u7136\u89C6\u5DEE\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 0.8 }, "recipe": { "type": "translate", "localOffset": { "x": 0, "y": 0, "z": 1 }, "lockTarget": true } }, { "id": "dolly_out", "name": "\u955C\u5934\u540E\u79FB", "subtitle": "\u6CBF\u955C\u5934\u65B9\u5411\u540E\u62C9", "description": "\u8FD0\u955C\uFF1A\u955C\u5934\u7F13\u6162\u540E\u62C9\uFF0C\u673A\u4F4D\u6CBF\u955C\u5934\u671D\u5411\u5411\u540E\u79FB\u52A8\uFF0C\u4E3B\u4F53\u5728\u753B\u9762\u4E2D\u9010\u6E10\u53D8\u5C0F\uFF0C\u753B\u9762\u8303\u56F4\u9010\u6B65\u53D8\u5BBD\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 0.8 }, "recipe": { "type": "translate", "localOffset": { "x": 0, "y": 0, "z": -1 }, "lockTarget": true } }, { "id": "zoom_in", "name": "\u53D8\u7126\u63A8\u8FDB", "subtitle": "\u673A\u4F4D\u4E0D\u52A8\u753B\u9762\u6536\u7D27", "description": "\u8FD0\u955C\uFF1A\u7F13\u6162\u53D8\u7126\u63A8\u8FDB\uFF0C\u673A\u4F4D\u4FDD\u6301\u4E0D\u52A8\uFF0C\u53EA\u901A\u8FC7\u7126\u8DDD\u53D8\u5316\u8BA9\u753B\u9762\u8303\u56F4\u9010\u6E10\u6536\u7D27\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "fovDelta": -12 }, "recipe": { "type": "zoom", "fovDelta": -12 } }, { "id": "zoom_out", "name": "\u53D8\u7126\u62C9\u8FDC", "subtitle": "\u673A\u4F4D\u4E0D\u52A8\u753B\u9762\u653E\u5BBD", "description": "\u8FD0\u955C\uFF1A\u7F13\u6162\u53D8\u7126\u62C9\u8FDC\uFF0C\u673A\u4F4D\u4FDD\u6301\u4E0D\u52A8\uFF0C\u53EA\u901A\u8FC7\u7126\u8DDD\u53D8\u5316\u8BA9\u753B\u9762\u8303\u56F4\u9010\u6E10\u653E\u5BBD\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "fovDelta": 12 }, "recipe": { "type": "zoom", "fovDelta": 12 } }, { "id": "handheld_shot", "name": "\u624B\u6301\u62CD\u6444", "subtitle": "\u8F7B\u5FAE\u81EA\u7136\u6643\u52A8", "description": "\u8FD0\u955C\uFF1A\u624B\u6301\u62CD\u6444\uFF0C\u955C\u5934\u5E26\u8F7B\u5FAE\u81EA\u7136\u6643\u52A8\u548C\u8FD1\u8DDD\u79BB\u4E34\u573A\u611F\uFF0C\u53EF\u968F\u4E3B\u4F53\u52A8\u4F5C\u4EA7\u751F\u5C0F\u5E45\u8C03\u6574\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "keyframeCount": 12, "shakeAmplitude": 0.04 }, "recipe": { "type": "shake", "amplitude": 0.04, "frequency": 3 } }, { "id": "slider_reveal", "name": "\u6A2A\u6ED1\u63ED\u793A", "subtitle": "\u6A2A\u5411\u6ED1\u51FA\u906E\u6321", "description": "\u8FD0\u955C\uFF1A\u6A2A\u6ED1\u63ED\u793A\uFF0C\u955C\u5934\u4ECE\u906E\u6321\u5173\u7CFB\u4E2D\u6A2A\u5411\u6ED1\u51FA\uFF0C\u9010\u6B65\u9732\u51FA\u88AB\u906E\u6321\u7684\u4E3B\u4F53\u6216\u5173\u952E\u4FE1\u606F\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6, "distance": 1 }, "recipe": { "type": "path", "pathKind": "slider-reveal" } }, { "id": "foreground_wipe", "name": "\u524D\u666F\u64E6\u8FC7", "subtitle": "\u8FD1\u666F\u906E\u6321\u64E6\u8FC7\u753B\u9762", "description": "\u8FD0\u955C\uFF1A\u524D\u666F\u64E6\u8FC7\uFF0C\u8FD1\u5904\u906E\u6321\u7269\u4ECE\u955C\u5934\u524D\u63A0\u8FC7\u5E76\u77ED\u6682\u8986\u76D6\u753B\u9762\uFF0C\u968F\u540E\u9732\u51FA\u65B0\u7684\u753B\u9762\u5185\u5BB9\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "required-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6 }, "recipe": { "type": "path", "pathKind": "foreground-wipe" } }, { "id": "push_through", "name": "\u7A7F\u8D8A\u955C\u5934", "subtitle": "\u5FEB\u901F\u524D\u63A8\u8FDB\u5165\u540E\u666F", "description": "\u8FD0\u955C\uFF1A\u7A7F\u8D8A\u955C\u5934\uFF0C\u955C\u5934\u6301\u7EED\u5FEB\u901F\u5411\u524D\u63A8\u8FDB\uFF0C\u5E76\u4EA7\u751F\u77ED\u6682\u8FD0\u52A8\u6A21\u7CCA\uFF0C\u7A7F\u8FC7\u660E\u786E\u7684\u524D\u666F\u8FB9\u754C\u6216\u7A7A\u95F4\u5C42\u6B21\uFF0C\u8FDB\u5165\u540E\u65B9\u753B\u9762\uFF0C\u6700\u540E\u843D\u5230\u65B0\u7684\u6784\u56FE\u6216\u76EE\u6807\u4E0A\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 1200, "easing": "ease-in", "strength": 0.6, "distance": 1.4 }, "recipe": { "type": "path", "pathKind": "push-through" } }, { "id": "whip_pan", "name": "\u7529\u6447", "subtitle": "\u5FEB\u901F\u6C34\u5E73\u7529\u5230\u65B0\u6784\u56FE", "description": "\u8FD0\u955C\uFF1A\u7529\u6447\uFF0C\u955C\u5934\u5FEB\u901F\u6C34\u5E73\u8F6C\u52A8\u5E76\u4EA7\u751F\u77ED\u6682\u8FD0\u52A8\u6A21\u7CCA\uFF0C\u6700\u540E\u843D\u5230\u65B0\u7684\u6784\u56FE\u6216\u76EE\u6807\u4E0A\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 700, "easing": "ease-out", "strength": 0.6, "angleDeg": 52 }, "recipe": { "type": "pan-tilt", "yawDeg": -52 } }, { "id": "rack_focus", "name": "\u7126\u70B9\u8F6C\u79FB", "subtitle": "\u7126\u70B9\u5728\u5C42\u6B21\u95F4\u5207\u6362", "description": "\u8FD0\u955C\uFF1A\u7126\u70B9\u8F6C\u79FB\uFF0C\u955C\u5934\u4F4D\u7F6E\u53EF\u4EE5\u4E0D\u53D8\uFF0C\u7126\u70B9\u4ECE\u4E00\u4E2A\u753B\u9762\u5C42\u6B21\u5E73\u6ED1\u5207\u6362\u5230\u53E6\u4E00\u4E2A\u753B\u9762\u5C42\u6B21\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "required-focus-target", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2e3, "easing": "ease-in-out", "strength": 0.6 }, "recipe": { "type": "focus-shift" } }, { "id": "crash_zoom", "name": "\u6025\u901F\u53D8\u7126", "subtitle": "\u5FEB\u901F\u6536\u7D27\u5230\u76EE\u6807\u533A\u57DF", "description": "\u8FD0\u955C\uFF1A\u6025\u901F\u53D8\u7126\u63A8\u8FDB\uFF0C\u673A\u4F4D\u4FDD\u6301\u4E0D\u52A8\uFF0C\u753B\u9762\u8303\u56F4\u5FEB\u901F\u6536\u7D27\u5230\u76EE\u6807\u533A\u57DF\uFF0C\u5F62\u6210\u7A81\u7136\u5F3A\u8C03\u3002", "categoryId": "basic", "categoryName": "\u57FA\u7840\u63A7\u5236", "targetPolicy": "none", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 700, "easing": "ease-out", "strength": 0.6, "fovDelta": -24 }, "recipe": { "type": "zoom", "fovDelta": -24 } }, { "id": "follow_tracking", "name": "\u8DDF\u968F\u62CD\u6444", "subtitle": "\u8DDF\u968F\u4E3B\u4F53\u4FDD\u6301\u6784\u56FE", "description": "\u8FD0\u955C\uFF1A\u8DDF\u968F\u62CD\u6444\uFF0C\u955C\u5934\u8DDF\u968F\u4E3B\u4F53\u8FD0\u52A8\u65B9\u5411\u79FB\u52A8\uFF0C\u4E0E\u4E3B\u4F53\u4FDD\u6301\u76F8\u5BF9\u7A33\u5B9A\u7684\u8DDD\u79BB\u548C\u6784\u56FE\u3002", "categoryId": "character", "categoryName": "\u4EBA\u7269\u8DDF\u62CD", "targetPolicy": "required-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2400, "easing": "ease-in-out", "strength": 0.6, "distance": 1, "keyframeCount": 8 }, "recipe": { "type": "path", "pathKind": "follow" } }, { "id": "leading_tracking", "name": "\u8FCE\u9762\u8DDF\u62CD", "subtitle": "\u4E3B\u4F53\u524D\u65B9\u540C\u6B65\u540E\u9000", "description": "\u8FD0\u955C\uFF1A\u8FCE\u9762\u8DDF\u62CD\uFF0C\u955C\u5934\u4F4D\u4E8E\u4E3B\u4F53\u524D\u65B9\u5E76\u968F\u4E3B\u4F53\u8FD0\u52A8\u540C\u6B65\u540E\u9000\uFF0C\u4FDD\u6301\u4E3B\u4F53\u6B63\u9762\u4FE1\u606F\u7A33\u5B9A\u53EF\u89C1\u3002", "categoryId": "character", "categoryName": "\u4EBA\u7269\u8DDF\u62CD", "targetPolicy": "required-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2400, "easing": "ease-in-out", "strength": 0.6, "distance": 1, "keyframeCount": 8 }, "recipe": { "type": "path", "pathKind": "leading" } }, { "id": "profile_tracking", "name": "\u4FA7\u9762\u8DDF\u62CD", "subtitle": "\u4E3B\u4F53\u4FA7\u65B9\u5E73\u884C\u79FB\u52A8", "description": "\u8FD0\u955C\uFF1A\u4FA7\u9762\u8DDF\u62CD\uFF0C\u955C\u5934\u5728\u4E3B\u4F53\u4FA7\u65B9\u4E0E\u5176\u5E73\u884C\u79FB\u52A8\uFF0C\u4FDD\u6301\u4FA7\u5411\u6784\u56FE\u7A33\u5B9A\uFF0C\u5E76\u5F62\u6210\u6A2A\u5411\u7A7A\u95F4\u89C6\u5DEE\u3002", "categoryId": "character", "categoryName": "\u4EBA\u7269\u8DDF\u62CD", "targetPolicy": "required-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2400, "easing": "ease-in-out", "strength": 0.6, "distance": 1, "keyframeCount": 8 }, "recipe": { "type": "path", "pathKind": "profile" } }, { "id": "orbit_180", "name": "\u73AF\u7ED5\u62CD\u6444", "subtitle": "\u56F4\u7ED5\u4E3B\u4F53\u65CB\u8F6C 180\xB0 \u6216 360\xB0", "description": "\u8FD0\u955C\uFF1A\u73AF\u7ED5\u62CD\u6444\uFF0C\u955C\u5934\u56F4\u7ED5\u4E3B\u4F53\u5E73\u7A33\u65CB\u8F6C\uFF0C\u652F\u6301 180\xB0 \u6216 360\xB0\uFF0C\u4E3B\u4F53\u4FDD\u6301\u5728\u753B\u9762\u6838\u5FC3\u4F4D\u7F6E\uFF0C\u80CC\u666F\u4EA7\u751F\u8FDE\u7EED\u65CB\u8F6C\u89C6\u5DEE\u3002", "categoryId": "character", "categoryName": "\u4EBA\u7269\u8DDF\u62CD", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2600, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 180 }, "recipe": { "type": "orbit", "yawDeg": 180 } }, { "id": "ascending_orbit", "name": "\u76D8\u65CB\u62AC\u5347", "subtitle": "\u73AF\u7ED5\u4E3B\u4F53\u5E76\u9010\u6E10\u5347\u9AD8", "description": "\u8FD0\u955C\uFF1A\u76D8\u65CB\u62AC\u5347\uFF0C\u955C\u5934\u56F4\u7ED5\u4E3B\u4F53\u65CB\u8F6C\u7684\u540C\u65F6\u9010\u6E10\u5347\u9AD8\uFF0C\u4E3B\u4F53\u4FDD\u6301\u9501\u5B9A\uFF0C\u673A\u4F4D\u9AD8\u5EA6\u6301\u7EED\u53D8\u5316\u3002", "categoryId": "character", "categoryName": "\u4EBA\u7269\u8DDF\u62CD", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2600, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 150, "height": 0.7 }, "recipe": { "type": "orbit", "yawDeg": 150, "heightDelta": 0.7 } }, { "id": "descending_orbit", "name": "\u76D8\u65CB\u4E0B\u964D", "subtitle": "\u73AF\u7ED5\u4E3B\u4F53\u5E76\u9010\u6E10\u964D\u4F4E", "description": "\u8FD0\u955C\uFF1A\u76D8\u65CB\u4E0B\u964D\uFF0C\u955C\u5934\u56F4\u7ED5\u4E3B\u4F53\u65CB\u8F6C\u7684\u540C\u65F6\u9010\u6E10\u964D\u4F4E\uFF0C\u4E3B\u4F53\u4FDD\u6301\u9501\u5B9A\uFF0C\u673A\u4F4D\u9AD8\u5EA6\u6301\u7EED\u53D8\u5316\u3002", "categoryId": "character", "categoryName": "\u4EBA\u7269\u8DDF\u62CD", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2600, "easing": "ease-in-out", "strength": 0.6, "angleDeg": 150, "height": -0.7 }, "recipe": { "type": "orbit", "yawDeg": 150, "heightDelta": -0.7 } }, { "id": "aerial_establishing", "name": "\u9AD8\u7A7A\u822A\u62CD", "subtitle": "\u9AD8\u89D2\u5EA6\u7A33\u5B9A\u6ED1\u884C", "description": "\u8FD0\u955C\uFF1A\u9AD8\u7A7A\u822A\u62CD\uFF0C\u955C\u5934\u4EE5\u9AD8\u89D2\u5EA6\u4FEF\u89C6\u753B\u9762\uFF0C\u5E76\u4FDD\u6301\u7A33\u5B9A\u6ED1\u884C\uFF0C\u7528\u4E8E\u5448\u73B0\u7A7A\u95F4\u5173\u7CFB\u548C\u6574\u4F53\u5E03\u5C40\u3002", "categoryId": "space", "categoryName": "\u7A7A\u95F4\u822A\u62CD", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2600, "easing": "ease-in-out", "strength": 0.6, "distance": 1.2, "height": 0.8, "fovDelta": 6 }, "recipe": { "type": "path", "pathKind": "aerial" } }, { "id": "fpv_flythrough", "name": "\u7A7F\u8D8A\u673A\u8FD0\u955C", "subtitle": "\u7B2C\u4E00\u89C6\u89D2\u9AD8\u901F\u7A7F\u884C", "description": "\u8FD0\u955C\uFF1A\u7A7F\u8D8A\u673A\u8FD0\u955C\uFF0C\u955C\u5934\u4EE5\u7B2C\u4E00\u89C6\u89D2\u9AD8\u901F\u7A7F\u884C\u7A7A\u95F4\uFF0C\u8D34\u8FD1\u573A\u666F\u8FB9\u754C\u548C\u4E3B\u4F53\u7075\u6D3B\u98DE\u884C\uFF0C\u5E26\u660E\u663E\u901F\u5EA6\u611F\u4E0E\u6EDA\u8F6C\u4FEF\u4EF0\u53D8\u5316\u3002", "categoryId": "space", "categoryName": "\u7A7A\u95F4\u822A\u62CD", "targetPolicy": "required-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2600, "easing": "ease-in-out", "strength": 0.6, "keyframeCount": 12 }, "recipe": { "type": "path", "pathKind": "fpv" } }, { "id": "drone_dive", "name": "\u4FEF\u51B2\u4E0B\u964D", "subtitle": "\u4ECE\u9AD8\u5904\u4FEF\u51B2\u9760\u8FD1", "description": "\u8FD0\u955C\uFF1A\u4FEF\u51B2\u4E0B\u964D\uFF0C\u955C\u5934\u4ECE\u9AD8\u5904\u5411\u76EE\u6807\u65B9\u5411\u5FEB\u901F\u4E0B\u964D\u5E76\u9760\u8FD1\uFF0C\u5F62\u6210\u660E\u663E\u901F\u5EA6\u611F\u548C\u538B\u8FEB\u611F\u3002", "categoryId": "space", "categoryName": "\u7A7A\u95F4\u822A\u62CD", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 1800, "easing": "ease-in-out", "strength": 0.6, "distance": 1.2, "height": -1 }, "recipe": { "type": "path", "pathKind": "dive" } }, { "id": "pull_away", "name": "\u62C9\u5347\u79BB\u573A", "subtitle": "\u5411\u540E\u5E76\u5411\u4E0A\u79BB\u573A", "description": "\u8FD0\u955C\uFF1A\u62C9\u5347\u79BB\u573A\uFF0C\u955C\u5934\u4ECE\u4E3B\u4F53\u9644\u8FD1\u5411\u540E\u5E76\u5411\u4E0A\u79FB\u52A8\uFF0C\u4E3B\u4F53\u5728\u753B\u9762\u4E2D\u9010\u6E10\u53D8\u5C0F\uFF0C\u753B\u9762\u8303\u56F4\u9010\u6B65\u6269\u5927\u3002", "categoryId": "space", "categoryName": "\u7A7A\u95F4\u822A\u62CD", "targetPolicy": "optional-look-at", "parameterSchema": { "durationMs": { "min": 400, "max": 6e3, "step": 100 }, "strength": { "min": 0, "max": 1, "step": 0.05 } }, "defaultConfig": { "durationMs": 2600, "easing": "ease-in-out", "strength": 0.6, "distance": 1.4, "height": 1, "fovDelta": 8 }, "recipe": { "type": "path", "pathKind": "pull-away" } }];
+var CAMERA_FOV_MIN = 12;
+var CAMERA_FOV_MAX = 120;
+
+// src/data/poseLibraryBank.ts
+var POSE_LIBRARY_TAG_ORDER = ["stand", "sit", "lie", "move", "action"];
+var PoseLibraryBank = class {
+  constructor() {
+    this.poses = [];
+    this.byId = {};
+  }
+  set(items) {
+    const previous = this.byId;
+    this.poses = [...items].map((item) => {
+      const old = previous[item.id];
+      if (old?.bonesLoaded) {
+        return {
+          ...item,
+          hips: old.hips,
+          bones: old.bones,
+          bonesLoaded: true,
+          modelUrl: item.modelUrl || old.modelUrl
+        };
+      }
+      return item;
+    }).sort((a, b) => a.rank - b.rank || a.id.localeCompare(b.id));
+    this.byId = Object.fromEntries(this.poses.map((pose) => [pose.id, pose]));
+  }
+  applyBones(id, hips, bones) {
+    const current = this.byId[id];
+    const next = current ? { ...current, hips, bones, bonesLoaded: true } : {
+      id,
+      name: id,
+      nameZh: id,
+      tag: "",
+      tags: [],
+      rank: 100,
+      hips,
+      bones,
+      bonesLoaded: true
+    };
+    this.byId[id] = next;
+    this.poses = current ? this.poses.map((pose) => pose.id === id ? next : pose) : [...this.poses, next].sort((a, b) => a.rank - b.rank || a.id.localeCompare(b.id));
+    return next;
+  }
+  get(id) {
+    if (!id)
+      return void 0;
+    return this.byId[id];
+  }
+  has(id) {
+    return !!this.get(id);
+  }
+  list(tag) {
+    if (!tag || tag === "all")
+      return [...this.poses];
+    return this.poses.filter((pose) => pose.tag === tag || pose.tags.includes(tag));
+  }
+  listTags() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const pose of this.poses) {
+      if (pose.tag)
+        seen.add(pose.tag);
+      for (const item of pose.tags) {
+        if (item)
+          seen.add(item);
+      }
+    }
+    const known = POSE_LIBRARY_TAG_ORDER.filter((item) => seen.has(item));
+    const rest = [...seen].filter((item) => !POSE_LIBRARY_TAG_ORDER.includes(item)).sort();
+    return [...known, ...rest];
+  }
+  defaultId() {
+    return this.poses[0]?.id;
+  }
+  rootOffset(poseId) {
+    const pose = this.get(poseId);
+    if (!pose || !pose.bonesLoaded)
+      return null;
+    const baseId = this.defaultId();
+    const basePose = baseId ? this.get(baseId) : void 0;
+    const base = basePose?.bonesLoaded ? basePose.hips : [0, 0, 0];
+    return {
+      x: pose.hips[0] - base[0],
+      y: pose.hips[1] - base[1],
+      z: pose.hips[2] - base[2]
+    };
+  }
+};
+var defaultPoseLibraryBank = new PoseLibraryBank();
+
+// src/data/poseControls.ts
+var POSE_CONTROLS = [
+  { key: "bodyBend", label: "\u8EAB\u4F53\u5F2F\u66F2", group: "body", min: -90, max: 90 },
+  { key: "bodyTilt", label: "\u8EAB\u4F53\u4FA7\u503E", group: "body", min: -45, max: 45 },
+  { key: "bodyTurn", label: "\u8EAB\u4F53\u626D\u8F6C", group: "body", min: -90, max: 90 },
+  { key: "torsoBend", label: "\u8EAF\u5E72\u5F2F\u66F2", group: "torso", min: -45, max: 45 },
+  { key: "torsoTilt", label: "\u8EAF\u5E72\u4FA7\u503E", group: "torso", min: -30, max: 30 },
+  { key: "torsoTurn", label: "\u8EAF\u5E72\u626D\u8F6C", group: "torso", min: -45, max: 45 },
+  { key: "headNod", label: "\u70B9\u5934", group: "head", min: -60, max: 60 },
+  { key: "headTilt", label: "\u5934\u90E8\u4FA7\u503E", group: "head", min: -30, max: 30 },
+  { key: "headTurn", label: "\u8F6C\u5934", group: "head", min: -90, max: 90 },
+  { key: "lArmRaise", label: "\u5DE6\u81C2\u62AC\u5347", group: "leftArm", min: -90, max: 180 },
+  { key: "lArmStraddle", label: "\u5DE6\u81C2\u5C55\u5F00", group: "leftArm", min: -10, max: 90 },
+  { key: "lArmTurn", label: "\u5DE6\u81C2\u626D\u8F6C", group: "leftArm", min: -90, max: 90 },
+  { key: "lElbowBend", label: "\u5DE6\u8098\u5F2F\u66F2", group: "leftArm", min: 0, max: 150 },
+  { key: "rArmRaise", label: "\u53F3\u81C2\u62AC\u5347", group: "rightArm", min: -90, max: 180 },
+  { key: "rArmStraddle", label: "\u53F3\u81C2\u5C55\u5F00", group: "rightArm", min: -10, max: 90 },
+  { key: "rArmTurn", label: "\u53F3\u81C2\u626D\u8F6C", group: "rightArm", min: -90, max: 90 },
+  { key: "rElbowBend", label: "\u53F3\u8098\u5F2F\u66F2", group: "rightArm", min: 0, max: 150 },
+  { key: "lLegRaise", label: "\u5DE6\u817F\u62AC\u5347", group: "leftLeg", min: -90, max: 90 },
+  { key: "lLegStraddle", label: "\u5DE6\u817F\u5916\u5C55", group: "leftLeg", min: -30, max: 60 },
+  { key: "lLegTurn", label: "\u5DE6\u817F\u626D\u8F6C", group: "leftLeg", min: -45, max: 45 },
+  { key: "lKneeBend", label: "\u5DE6\u819D\u5F2F\u66F2", group: "leftLeg", min: 0, max: 150 },
+  { key: "rLegRaise", label: "\u53F3\u817F\u62AC\u5347", group: "rightLeg", min: -90, max: 90 },
+  { key: "rLegStraddle", label: "\u53F3\u817F\u5916\u5C55", group: "rightLeg", min: -30, max: 60 },
+  { key: "rLegTurn", label: "\u53F3\u817F\u626D\u8F6C", group: "rightLeg", min: -45, max: 45 },
+  { key: "rKneeBend", label: "\u53F3\u819D\u5F2F\u66F2", group: "rightLeg", min: 0, max: 150 }
+];
+
+// src/data/posePresets.ts
+var POSE_PRESETS = [
+  {
+    id: "stand",
+    name: "\u7AD9\u7ACB",
+    controlValues: {
+      torsoBend: 2,
+      headNod: -10,
+      lArmRaise: -5,
+      lArmStraddle: 12,
+      rArmRaise: -5,
+      rArmStraddle: 14,
+      lElbowBend: 15,
+      rElbowBend: 15
+    }
+  },
+  {
+    id: "tpose",
+    name: "T\u578B",
+    controlValues: {}
+  },
+  {
+    id: "walk",
+    name: "\u884C\u8D70",
+    controlValues: {
+      torsoBend: 3,
+      torsoTurn: 5,
+      headNod: -5,
+      lArmRaise: 40,
+      lArmStraddle: 9,
+      rArmRaise: -8,
+      rArmStraddle: 27,
+      rArmTurn: -4,
+      lElbowBend: 37,
+      rElbowBend: 26,
+      lLegRaise: -10,
+      rLegRaise: 36,
+      rLegStraddle: -2,
+      lKneeBend: 22,
+      rKneeBend: 41
+    }
+  },
+  {
+    id: "run",
+    name: "\u8DD1\u6B65",
+    controlValues: {
+      bodyBend: -2,
+      torsoBend: 3,
+      torsoTurn: 5,
+      headNod: -10,
+      lArmRaise: -26,
+      lArmStraddle: 23,
+      lArmTurn: 14,
+      rArmRaise: 23,
+      rArmStraddle: 14,
+      rArmTurn: 19,
+      lElbowBend: 60,
+      rElbowBend: 89,
+      lLegRaise: 50,
+      rLegRaise: -20,
+      lKneeBend: 18,
+      rKneeBend: 36
+    }
+  },
+  {
+    id: "sit",
+    name: "\u5750\u59FF",
+    controlValues: {
+      bodyBend: -5,
+      torsoBend: 5,
+      headNod: -5,
+      lArmStraddle: 8,
+      lArmTurn: 6,
+      rArmStraddle: 15,
+      rArmTurn: 16,
+      lElbowBend: 80,
+      rElbowBend: 80,
+      lLegRaise: 90,
+      lLegStraddle: 5,
+      rLegRaise: 90,
+      rLegStraddle: 5,
+      lKneeBend: 90,
+      rKneeBend: 90
+    },
+    rootOffsetY: -0.28
+  },
+  {
+    id: "crouch",
+    name: "\u8E72\u4E0B",
+    controlValues: {
+      bodyBend: 20,
+      bodyTurn: 4,
+      bodyTilt: 1,
+      torsoBend: 32,
+      torsoTilt: -3,
+      headNod: -24,
+      headTurn: -6,
+      headTilt: 1,
+      lArmRaise: 34,
+      lArmStraddle: 18,
+      lArmTurn: 18,
+      rArmRaise: 34,
+      rArmStraddle: 18,
+      rArmTurn: -18,
+      lElbowBend: 86,
+      rElbowBend: 86,
+      lLegRaise: 88,
+      lLegStraddle: 12,
+      lLegTurn: -3,
+      rLegRaise: 88,
+      rLegStraddle: 8,
+      rLegTurn: 2,
+      lKneeBend: 146,
+      rKneeBend: 146
+    },
+    rootOffsetY: -0.58
+  },
+  {
+    id: "one_knee",
+    name: "\u5355\u819D\u8DEA",
+    controlValues: {
+      bodyBend: -4,
+      bodyTurn: -2,
+      bodyTilt: 6,
+      torsoBend: 24,
+      torsoTurn: -6,
+      torsoTilt: -3,
+      headNod: -10,
+      headTurn: 3,
+      headTilt: -2,
+      lArmRaise: 14,
+      lArmStraddle: 18,
+      lArmTurn: 6,
+      rArmRaise: 8,
+      rArmStraddle: 18,
+      rArmTurn: -4,
+      lElbowBend: 70,
+      rElbowBend: 42,
+      lLegRaise: 82,
+      lLegStraddle: 6,
+      lLegTurn: 4,
+      rLegRaise: -5,
+      rLegStraddle: 6,
+      rLegTurn: -8,
+      lKneeBend: 86,
+      rKneeBend: 130
+    },
+    rootOffsetY: -0.54
+  },
+  {
+    id: "two_knees",
+    name: "\u53CC\u819D\u8DEA",
+    controlValues: {
+      bodyBend: 8,
+      torsoBend: 6,
+      headNod: -5,
+      lArmRaise: -5,
+      lArmStraddle: 7,
+      rArmRaise: -5,
+      rArmStraddle: 10,
+      lElbowBend: 15,
+      rElbowBend: 15,
+      lLegRaise: -10,
+      rLegRaise: -9,
+      lKneeBend: 108,
+      rKneeBend: 104
+    },
+    rootOffsetY: -0.26
+  },
+  {
+    id: "lean",
+    name: "\u501A\u9760",
+    controlValues: {
+      bodyTilt: -5,
+      torsoBend: -3,
+      torsoTurn: 5,
+      torsoTilt: -5,
+      headNod: -10,
+      headTurn: 10,
+      headTilt: -5,
+      lArmRaise: -5,
+      lArmStraddle: 13,
+      rArmRaise: -10,
+      rArmStraddle: 16,
+      lElbowBend: 15,
+      rElbowBend: 20,
+      lLegStraddle: 5,
+      rLegRaise: 20,
+      rLegTurn: 10,
+      rKneeBend: 40
+    }
+  },
+  {
+    id: "bow",
+    name: "\u97A0\u8EAC",
+    controlValues: {
+      bodyBend: 24,
+      bodyTurn: 1,
+      torsoBend: 30,
+      torsoTilt: -1,
+      headNod: 18,
+      headTurn: -3,
+      headTilt: 1,
+      lArmRaise: -8,
+      lArmStraddle: 8,
+      rArmRaise: -8,
+      rArmStraddle: 8,
+      lElbowBend: 4,
+      rElbowBend: 4,
+      lKneeBend: 4,
+      rKneeBend: 4
+    }
+  },
+  {
+    id: "think",
+    name: "\u601D\u8003",
+    controlValues: {
+      bodyBend: -2,
+      bodyTurn: 2,
+      bodyTilt: 1,
+      torsoBend: 7,
+      torsoTurn: 2,
+      torsoTilt: 1,
+      headNod: 14,
+      headTurn: 8,
+      headTilt: -3,
+      lArmRaise: 42,
+      lArmStraddle: -8,
+      lArmTurn: -10,
+      rArmRaise: 8,
+      rArmStraddle: 22,
+      rArmTurn: 39,
+      lElbowBend: 98,
+      rElbowBend: 107,
+      lLegStraddle: 4,
+      rLegStraddle: 4
+    }
+  },
+  {
+    id: "fight",
+    name: "\u683C\u6597",
+    controlValues: {
+      bodyBend: 10,
+      bodyTurn: -24,
+      bodyTilt: 8,
+      torsoBend: 18,
+      torsoTilt: -4,
+      headNod: -7,
+      headTurn: 24,
+      headTilt: -10,
+      lArmRaise: 78,
+      lArmStraddle: 24,
+      lArmTurn: 8,
+      rArmRaise: 82,
+      rArmStraddle: 48,
+      rArmTurn: 45,
+      lElbowBend: 84,
+      rElbowBend: 124,
+      lLegRaise: 46,
+      lLegStraddle: 18,
+      lLegTurn: 8,
+      rLegRaise: 34,
+      rLegStraddle: 14,
+      rLegTurn: -2,
+      lKneeBend: 55,
+      rKneeBend: 78
+    }
+  },
+  {
+    id: "kick",
+    name: "\u8E22\u7403",
+    controlValues: {
+      bodyBend: -8,
+      bodyTurn: -12,
+      bodyTilt: -5,
+      torsoBend: -10,
+      torsoTurn: -16,
+      torsoTilt: 8,
+      headNod: 8,
+      headTurn: -12,
+      headTilt: 2,
+      lArmRaise: -34,
+      lArmStraddle: 34,
+      lArmTurn: -8,
+      rArmRaise: 42,
+      rArmStraddle: 28,
+      rArmTurn: 12,
+      lElbowBend: 34,
+      rElbowBend: 44,
+      lLegRaise: -8,
+      lLegStraddle: 3,
+      lLegTurn: -4,
+      rLegRaise: 104,
+      rLegStraddle: 3,
+      lKneeBend: 16,
+      rKneeBend: 10
+    }
+  },
+  {
+    id: "throw",
+    name: "\u6295\u63B7",
+    controlValues: {
+      bodyBend: 5,
+      bodyTurn: -2,
+      torsoBend: 4,
+      torsoTurn: 15,
+      torsoTilt: -5,
+      headNod: -5,
+      headTurn: -15,
+      lArmRaise: 7,
+      lArmStraddle: 17,
+      rArmRaise: 77,
+      rArmTurn: 90,
+      lElbowBend: 88,
+      rElbowBend: 96,
+      lLegRaise: 15,
+      lLegStraddle: 5,
+      rLegRaise: -10,
+      rLegStraddle: 5,
+      lKneeBend: 26,
+      rKneeBend: 36
+    }
+  },
+  {
+    id: "push",
+    name: "\u63A8\u8FDB",
+    controlValues: {
+      bodyBend: -1,
+      torsoBend: 19,
+      headNod: -5,
+      lArmRaise: 100,
+      lArmStraddle: 6,
+      lArmTurn: 5,
+      rArmRaise: 101,
+      rArmStraddle: 11,
+      lElbowBend: 14,
+      lLegRaise: 41,
+      rLegRaise: -15,
+      lKneeBend: 35,
+      rKneeBend: 10
+    }
+  },
+  {
+    id: "wave",
+    name: "\u62DB\u624B",
+    controlValues: {
+      torsoBend: 2,
+      torsoTurn: -10,
+      headNod: -5,
+      headTurn: 15,
+      headTilt: 5,
+      lArmStraddle: 6,
+      rArmRaise: 62,
+      rArmStraddle: -10,
+      rArmTurn: 90,
+      lElbowBend: 62,
+      rElbowBend: 94
+    }
+  },
+  // 以下 3 个在预设表里但 UI 网格未展示（hidden）。
+  {
+    id: "stretch",
+    name: "\u4F38\u624B",
+    hidden: true,
+    controlValues: {
+      bodyBend: -5,
+      torsoBend: -16,
+      torsoTilt: 3,
+      headNod: -25,
+      lArmRaise: 115,
+      lArmStraddle: -10,
+      lArmTurn: 10,
+      rArmRaise: 133,
+      rArmStraddle: -10,
+      rArmTurn: -10,
+      lElbowBend: 59,
+      rElbowBend: 53,
+      lLegStraddle: 10,
+      rLegStraddle: 10
+    }
+  },
+  {
+    id: "arms_crossed",
+    name: "\u62B1\u81C2",
+    hidden: true,
+    controlValues: {
+      torsoTurn: 2,
+      headNod: -8,
+      lArmRaise: 7,
+      lArmStraddle: 22,
+      lArmTurn: 17,
+      rArmRaise: 8,
+      rArmStraddle: 22,
+      rArmTurn: 39,
+      lElbowBend: 107,
+      rElbowBend: 107,
+      lLegStraddle: 5,
+      rLegStraddle: 5
+    }
+  },
+  {
+    id: "phone",
+    name: "\u770B\u624B\u673A",
+    hidden: true,
+    controlValues: {
+      torsoBend: 5,
+      headNod: 17,
+      lArmRaise: 55,
+      lArmStraddle: -10,
+      lArmTurn: -4,
+      rArmRaise: 24,
+      rArmStraddle: -10,
+      rArmTurn: -13,
+      lElbowBend: 89,
+      rElbowBend: 43,
+      lLegStraddle: 5,
+      rLegStraddle: 5
+    }
+  }
+];
+var POSE_PRESET_BY_ID = Object.fromEntries(
+  POSE_PRESETS.map((p) => [p.id, p])
+);
+
+// src/evaluate/studioIntents.ts
+var CHARACTER_COLORS = ["#7fb2e0", "#e0a37f", "#9fe07f", "#d07fe0", "#e0d06a", "#6ad0c0"];
+var DEFAULT_MOTION_DURATION_SECONDS = 2;
+var StudioIntentError = class extends Error {
+  constructor(code, message) {
+    super(message ?? code);
+    this.name = "StudioIntentError";
+    this.code = code;
+  }
+};
+function uniqueNodeName(doc, base) {
+  const names = doc.content.nodes.map((n) => n.name);
+  const taken = new Set(names);
+  const prefix = `${base}_`;
+  let max = taken.has(base) ? 1 : 0;
+  for (const name of names) {
+    if (!name.startsWith(prefix))
+      continue;
+    const n = Number(name.slice(prefix.length));
+    if (Number.isInteger(n) && n > 0)
+      max = Math.max(max, n);
+  }
+  let next = max + 1;
+  let candidate = `${base}_${next}`;
+  while (taken.has(candidate)) {
+    next += 1;
+    candidate = `${base}_${next}`;
+  }
+  return candidate;
+}
+function nextIndexedId(existing, prefix) {
+  let n = 1;
+  while (existing.includes(`${prefix}${n}`))
+    n += 1;
+  return `${prefix}${n}`;
+}
+function clampCameraFov(fov) {
+  return Math.min(CAMERA_FOV_MAX, Math.max(CAMERA_FOV_MIN, fov));
+}
+function dollyTowardLookAt(pos, lookAt, distance) {
+  const dx = pos.x - lookAt.x;
+  const dy = pos.y - lookAt.y;
+  const dz = pos.z - lookAt.z;
+  const old = Math.hypot(dx, dy, dz);
+  if (old < 1e-6)
+    return { x: lookAt.x, y: lookAt.y, z: lookAt.z + distance };
+  const scale = distance / old;
+  return { x: lookAt.x + dx * scale, y: lookAt.y + dy * scale, z: lookAt.z + dz * scale };
+}
+function listStudioCameraPresets() {
+  return CAMERA_PRESETS.filter((preset) => preset.id !== "current").map((preset) => ({ id: preset.id, name: preset.name, fov: preset.fov }));
+}
+function allIds(doc) {
+  return [
+    ...doc.content.nodes.map((n) => n.id),
+    ...doc.content.timeline.animation.motionClips.map((c) => c.id),
+    ...doc.content.timeline.animation.cameraMotionClips.map((c) => c.id),
+    ...doc.content.asset.motionPath.map((e) => e.id)
+  ];
+}
+function requireUnusedId(doc, id) {
+  if (allIds(doc).includes(id))
+    throw new StudioIntentError("node-exists", id);
+  return id;
+}
+function buildCharacterNode(doc, intent, poseBank = defaultPoseLibraryBank) {
+  const charCount = doc.content.nodes.filter((n) => n.type === "character").length;
+  const id = intent.nodeId ? requireUnusedId(doc, intent.nodeId) : nextIndexedId(allIds(doc), "user_chr_");
+  return {
+    id,
+    type: "character",
+    name: uniqueNodeName(doc, intent.name),
+    visible: true,
+    locked: false,
+    transform: {
+      position: { x: charCount * 1, y: 0, z: 0 },
+      rotation: { x: 0, y: 0, z: 0 },
+      scale: { x: 1, y: 1, z: 1 }
+    },
+    metadata: {
+      modelUrl: intent.modelUrl,
+      assetId: intent.libraryId,
+      ...intent.rig ? { rig: intent.rig } : {}
+    },
+    character: {
+      placeholder: false,
+      gender: "unknown",
+      motionId: null,
+      appearance: { color: CHARACTER_COLORS[charCount % CHARACTER_COLORS.length] },
+      label: { showLabel: true, scale: 1, yOffset: 0 },
+      animation: { mode: "pose", posePresetId: poseBank.defaultId(), controlValues: {} }
+    }
+  };
+}
+function buildPropNode(doc, intent) {
+  const id = intent.nodeId ? requireUnusedId(doc, intent.nodeId) : nextIndexedId(allIds(doc), "user_prop_");
+  return {
+    id,
+    type: "prop",
+    name: intent.name,
+    visible: true,
+    locked: false,
+    transform: {
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { x: 0, y: 0, z: 0 },
+      scale: { x: 1, y: 1, z: 1 }
+    },
+    metadata: { modelUrl: intent.modelUrl, assetId: intent.libraryId },
+    prop: { category: "user" }
+  };
+}
+function buildCameraNode(doc, intent) {
+  if (intent.presetId === "current") {
+    throw new StudioIntentError("current-viewport-unavailable");
+  }
+  const preset = CAMERA_PRESETS.find((p) => p.id === intent.presetId);
+  if (!preset)
+    throw new StudioIntentError("preset-not-found", intent.presetId);
+  const id = intent.nodeId ? requireUnusedId(doc, intent.nodeId) : nextIndexedId(allIds(doc), "user_cam_");
+  const node = {
+    id,
+    type: "camera",
+    name: uniqueNodeName(doc, preset.name),
+    visible: true,
+    locked: false,
+    transform: {
+      position: { ...preset.position },
+      rotation: { ...preset.rotation },
+      scale: { x: 1, y: 1, z: 1 }
+    },
+    camera: {
+      projection: "perspective",
+      fov: preset.fov,
+      fovAxis: "vertical",
+      near: 0.1,
+      far: 2e3,
+      isPrimary: false,
+      lookAt: { ...preset.lookAt }
+    }
+  };
+  applyCameraPresetToNode(node, preset);
+  if (intent.subjectNodeId) {
+    const subject = doc.content.nodes.find(
+      (n) => n.id === intent.subjectNodeId && n.type === "character"
+    );
+    if (!subject)
+      throw new StudioIntentError("missing-character", intent.subjectNodeId);
+    applyCameraPresetToSubject(node, preset, subject);
+  }
+  return node;
+}
+function resolveMotionDurationSeconds(doc, intent) {
+  if (intent.durationSeconds !== void 0 && Number.isFinite(intent.durationSeconds)) {
+    return Math.max(1 / Math.max(doc.content.timeline.fps, 1), intent.durationSeconds);
+  }
+  return DEFAULT_MOTION_DURATION_SECONDS;
+}
+function shiftOverlappingMotionClips(sameTarget, frameStart, frameEnd) {
+  const shifted = /* @__PURE__ */ new Map();
+  let cursorStart = frameStart;
+  let cursorEnd = frameEnd;
+  for (const existing of sameTarget) {
+    if (existing.frameEnd <= cursorStart || existing.frameStart >= cursorEnd)
+      continue;
+    const next = {
+      ...existing,
+      frameStart: cursorEnd,
+      frameEnd: cursorEnd + (existing.frameEnd - existing.frameStart)
+    };
+    shifted.set(existing.id, next);
+    cursorStart = next.frameStart;
+    cursorEnd = next.frameEnd;
+  }
+  return shifted;
+}
+function appendMotionClip(doc, intent) {
+  const target = doc.content.nodes.find((n) => n.id === intent.targetNodeId && n.type === "character");
+  if (!target)
+    throw new StudioIntentError("missing-character", intent.targetNodeId);
+  const fps = doc.content.timeline.fps || 30;
+  const durationSeconds = resolveMotionDurationSeconds(doc, intent);
+  const durationFrames = Math.max(1, Math.round(durationSeconds * fps));
+  const frameStart = Math.max(0, Math.floor(intent.frameStart ?? 0));
+  const frameEnd = frameStart + durationFrames;
+  const clipId = intent.clipId ? requireUnusedId(doc, intent.clipId) : nextIndexedId(allIds(doc), "user_mc_");
+  const assetId = intent.libraryId;
+  const clip = {
+    id: clipId,
+    source: "user-library",
+    sourceDuration: durationSeconds,
+    frameStart,
+    frameEnd,
+    target: { type: "character", nodeId: target.id },
+    playback: { version: 1, speed: 1, loop: true, loopMode: "repeat" },
+    motion: {
+      assetId,
+      name: intent.name,
+      source: "user-library",
+      sourceRig: "mixamorig",
+      url: intent.fbxKey,
+      inPlace: true,
+      loop: true,
+      speed: 1,
+      time: 0
+    }
+  };
+  const tl = doc.content.timeline;
+  const sameTarget = tl.animation.motionClips.filter((c) => c.target.nodeId === target.id).sort((a, b) => a.frameStart - b.frameStart);
+  const shifted = shiftOverlappingMotionClips(sameTarget, frameStart, frameEnd);
+  tl.animation.motionClips = tl.animation.motionClips.map((c) => shifted.get(c.id) ?? c).concat(clip);
+  if (!doc.content.asset.motionPath.some((e) => e.id === assetId || e.path === intent.fbxKey)) {
+    doc.content.asset.motionPath.push({ id: assetId, path: intent.fbxKey });
+  }
+  return clip;
+}
+function applyPoseInPlace(doc, intent, poseBank = defaultPoseLibraryBank) {
+  const node = doc.content.nodes.find((n) => n.id === intent.nodeId);
+  if (!node)
+    throw new StudioIntentError("missing-node", intent.nodeId);
+  if (!node.character)
+    throw new StudioIntentError("missing-character", intent.nodeId);
+  const libraryPose = poseBank.get(intent.presetId);
+  const preset = libraryPose ? void 0 : POSE_PRESET_BY_ID[intent.presetId];
+  if (!libraryPose && !preset)
+    throw new StudioIntentError("preset-not-found", intent.presetId);
+  const anim = node.character.animation;
+  anim.mode = "pose";
+  if (libraryPose) {
+    anim.posePresetId = libraryPose.id;
+    anim.controlValues = {};
+    anim.rootPositionOffset = poseBank.rootOffset(libraryPose.id) ?? { x: 0, y: 0, z: 0 };
+    return;
+  }
+  if (preset) {
+    anim.posePresetId = preset.id;
+    anim.controlValues = Object.fromEntries(
+      POSE_CONTROLS.map((c) => [c.key, preset.controlValues[c.key] ?? 0])
+    );
+    anim.rootPositionOffset = { x: 0, y: preset.rootOffsetY ?? 0, z: 0 };
+  }
+}
+function setCameraFovInPlace(doc, intent) {
+  const cam = doc.content.nodes.find((n) => n.id === intent.cameraNodeId && n.type === "camera");
+  if (!cam?.camera)
+    throw new StudioIntentError("missing-camera", intent.cameraNodeId);
+  cam.camera.fov = clampCameraFov(intent.fov);
+}
+function setCameraDistanceInPlace(doc, intent) {
+  const cam = doc.content.nodes.find((n) => n.id === intent.cameraNodeId && n.type === "camera");
+  if (!cam?.camera)
+    throw new StudioIntentError("missing-camera", intent.cameraNodeId);
+  const nextDist = Math.max(0.1, intent.distance);
+  const lookAt = cam.camera.lookAt;
+  const nextPos = dollyTowardLookAt(cam.transform.position, lookAt, nextDist);
+  const binding = cam.camera.subject;
+  if (binding) {
+    const subject = doc.content.nodes.find((n) => n.id === binding.nodeId && n.type === "character");
+    if (!subject)
+      throw new StudioIntentError("subject-missing", binding.nodeId);
+    const yawDeg = binding.followRotation ? subjectYawDeg(subject.transform.rotation) : 0;
+    binding.offset = subjectWorldToLocal(nextPos, subject.transform.position, yawDeg);
+    binding.lookAtOffset = subjectWorldToLocal(lookAt, subject.transform.position, yawDeg);
+    binding.distance = nextDist;
+  }
+  cam.transform.position = nextPos;
+}
+function mergeVec3(base, patch) {
+  if (!patch)
+    return { ...base };
+  return {
+    x: patch.x === void 0 ? base.x : patch.x,
+    y: patch.y === void 0 ? base.y : patch.y,
+    z: patch.z === void 0 ? base.z : patch.z
+  };
+}
+function patchNodeTransformInPlace(doc, intent) {
+  const node = doc.content.nodes.find((n) => n.id === intent.nodeId);
+  if (!node)
+    throw new StudioIntentError("missing-node", intent.nodeId);
+  node.transform.position = mergeVec3(node.transform.position, intent.position);
+  node.transform.rotation = mergeVec3(node.transform.rotation, intent.rotation);
+  node.transform.scale = mergeVec3(node.transform.scale, intent.scale);
+}
+function applyStudioIntentInPlace(document, intent, poseBank = defaultPoseLibraryBank) {
+  switch (intent.type) {
+    case "add-character": {
+      const node = buildCharacterNode(document, intent, poseBank);
+      document.content.nodes.push(node);
+      return { createdIds: [node.id], nodeId: node.id };
+    }
+    case "add-prop": {
+      const node = buildPropNode(document, intent);
+      document.content.nodes.push(node);
+      return { createdIds: [node.id], nodeId: node.id };
+    }
+    case "add-camera": {
+      const node = buildCameraNode(document, intent);
+      document.content.nodes.push(node);
+      return { createdIds: [node.id], nodeId: node.id };
+    }
+    case "add-motion": {
+      const clip = appendMotionClip(document, intent);
+      return { createdIds: [clip.id], clipId: clip.id };
+    }
+    case "apply-pose":
+      applyPoseInPlace(document, intent, poseBank);
+      return { createdIds: [], nodeId: intent.nodeId };
+    case "set-fov":
+      setCameraFovInPlace(document, intent);
+      return { createdIds: [], nodeId: intent.cameraNodeId };
+    case "set-distance":
+      setCameraDistanceInPlace(document, intent);
+      return { createdIds: [], nodeId: intent.cameraNodeId };
+    case "patch-transform":
+      patchNodeTransformInPlace(document, intent);
+      return { createdIds: [], nodeId: intent.nodeId };
+    default: {
+      const neverIntent = intent;
+      throw new StudioIntentError("invalid-intent", JSON.stringify(neverIntent));
+    }
+  }
+}
+function applyStudioIntent(input) {
+  const document = JSON.parse(JSON.stringify(input.document));
+  const applied = applyStudioIntentInPlace(document, input.intent, input.poseBank);
+  return {
+    document,
+    fcurves: input.fcurves,
+    createdIds: applied.createdIds,
+    nodeId: applied.nodeId,
+    clipId: applied.clipId
+  };
+}
+
+// src/evaluate/initialDraft.ts
+var CHARACTER_PAGE_SIZE = 100;
+function pickDefaultCharacter(items, preset = DEFAULT_CHARACTER) {
+  const characters = items.filter(
+    (item) => "file" in item && typeof item.file === "string" && item.file.length > 0
+  );
+  const wanted = preset.name.trim().toLowerCase();
+  return characters.find((item) => item.name.trim().toLowerCase() === wanted) ?? characters[0] ?? null;
+}
+function seedDefaultCharacterInPlace(doc, entry, preset = DEFAULT_CHARACTER) {
+  const node = buildCharacterNode(doc, {
+    libraryId: entry.id,
+    name: entry.name,
+    modelUrl: entry.file,
+    rig: entry.rig
+  });
+  node.transform.position = { x: 0, y: 0, z: 0 };
+  if (node.character) {
+    node.character.gender = preset.gender;
+    node.character.appearance.color = preset.color;
+  }
+  doc.content.nodes.push(node);
+  applyPoseInPlace(doc, { nodeId: node.id, presetId: preset.posePresetId });
+  doc.extra = {
+    ...typeof doc.extra === "object" && doc.extra !== null ? doc.extra : {},
+    initialSeed: INITIAL_DRAFT_SEED
+  };
+  return node.id;
+}
+async function createInitialDraft(adapter, input) {
+  const preset = input.character ?? DEFAULT_CHARACTER;
+  const doc = makeEmptyDraft(input.name, input.fps, input.totalFrames, input.camera);
+  let items;
+  try {
+    const page = await adapter.searchAssets({
+      kind: "character",
+      pageNo: 1,
+      pageSize: CHARACTER_PAGE_SIZE
+    });
+    items = page.items;
+  } catch {
+    return doc;
+  }
+  const entry = pickDefaultCharacter(items, preset);
+  if (entry)
+    seedDefaultCharacterInPlace(doc, entry, preset);
+  return doc;
+}
+
+export { CAMERA_MOTIONS, CAMERA_PRESETS, DEFAULT_CHARACTER, DEFAULT_SKY_COLOR, FCurveSet, INITIAL_DRAFT_SEED, StudioIntentError, activateSequence, allocateClipId, allocateSequenceId, appendMotionClip, applyCameraPresetToNode, applyPoseInPlace, applyStudioIntent, applyStudioIntentInPlace, bakeCameraMotionClip as bakeCameraMotion, bakeCameraMotionClip, bakeCameraMotionPoses, buildCameraNode, buildCharacterNode, buildPropNode, clampCameraFov, clearSequenceClips, clipSequenceSpan, createFrameSnapshot, createInitialDraft, createSequence, defaultInsertRange, defaultVideoExportEndFrame, deleteEditClip, deleteSequence, directorDocumentSchema, dollyTowardLookAt, duplicateEditClip, duplicateSequence, emptyEditorial2 as emptyEditorial, evaluateFrame, evaluatePathMotion, evaluatePathMotionInto, fcurvesCompactV1Schema, findEditClip, formatTimecode, framesToSeconds, getActiveEditSequence, getClipDurationFrames, getEditSequence, getEditSequenceDurationFrames, getEditorial, insertEditClip, listStudioCameraPresets, makeEmptyDraft, materializeEditorial, moveEditClip, parseDirectorDocument, parseTimecode, patchNodeTransformInPlace, pathArcLength, pathClipDurationFrames, pathControlCentroid, pickDefaultCharacter, playbackIssues, prepareFrameSnapshot, renameSequence, resolveEditSequenceFrame, samplePathPoints, sceneFromDocument, secondsToFrame, seedDefaultCharacterInPlace, setCameraDistanceInPlace, setCameraFovInPlace, transformPathLocalPoint, uniqueNodeName, updateEditClip, validateEditorial };