@pixerate/flair 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1263 @@
+import "./chunk-CFCLT2XL.js";
+import {
+  EASES,
+  STEP_MS,
+  SVG_PICTURE,
+  SvgPlayer,
+  defaultDataKey,
+  lerpAttr,
+  lerpData,
+  parseSvg,
+  stepData,
+  stepProgress,
+  stepStart,
+  svgDuration,
+  svgFrame,
+  svgMotionIssues,
+  svgOpeningTag,
+  svgView
+} from "./chunk-G5FNZDTA.js";
+import {
+  ALL_BLEND_MODES,
+  EFFECT_FADE_MS,
+  EFFECT_TYPES,
+  MemorySceneBoard,
+  NO_CHECK,
+  SMALL_TEXT_PX,
+  ShaderFrames,
+  ShaderRenderer,
+  ThumbnailPool,
+  blendRgba,
+  checkShot,
+  effectGone,
+  effectOpacity,
+  evaluateBehavior,
+  fractalWiggle,
+  getGlslBlendFunction,
+  hash64,
+  mixSeeds,
+  noise1d,
+  noise3d,
+  playScene,
+  quinticFade,
+  recordGif,
+  registerThumbnail,
+  reviewScene,
+  sharedThumbnailPool,
+  simulateScene,
+  standaloneHtml,
+  standaloneSceneHtml,
+  titleBox,
+  touchedIds,
+  unitFloat,
+  validateScene
+} from "./chunk-JWZCPMFG.js";
+import {
+  BUILTIN_UNIFORMS,
+  ImageLoadError,
+  SVG_EDGE,
+  ShaderCompileError,
+  TextureCache,
+  VERTEX_SOURCE,
+  applyAscCdl,
+  applyLiftGammaGain,
+  applyTextureSettings,
+  applyVibrance,
+  compileShader,
+  convertColorSpace,
+  createContext,
+  drawFrame,
+  formatCompileError,
+  getColorGradingGLSL,
+  getOklabGLSL,
+  getWhiteBalanceGains,
+  interpolateOklab,
+  interpolateOklch,
+  isSvgUrl,
+  linearRgbToSrgb,
+  linearSrgbToOklab,
+  linearToSrgb,
+  loadImage,
+  oklabToLinearSrgb,
+  oklabToOklch,
+  oklabToSrgb,
+  oklchToOklab,
+  parseCompileLog,
+  preloadImages,
+  releaseImages,
+  resetGlCaches,
+  sizeSvg,
+  srgbToLinear,
+  srgbToLinearRgb,
+  srgbToOklab,
+  wrapSource
+} from "./chunk-HKXOHRCD.js";
+import {
+  ALL_TRANSITION_TYPES,
+  blendTransitionPixel,
+  getTransitionGLSL,
+  sampleTransition
+} from "./chunk-EHDJ3CPJ.js";
+import {
+  ManualClock,
+  jitter,
+  pageHidden,
+  realClock
+} from "./chunk-WMZQCUFJ.js";
+import {
+  calculateShotTimings,
+  createLottieEase,
+  exportCmx3600Edl,
+  exportFcp7Xml,
+  exportLottie,
+  exportMotn,
+  framesToTimecode,
+  timecodeToFrames
+} from "./chunk-UQQNZSYL.js";
+import {
+  CAMERA_MS,
+  DEFAULT_STAGE,
+  areaOf,
+  between,
+  boardHeight,
+  boundsOf,
+  calculateFramingRect,
+  centreOf,
+  easeInOutCubic,
+  frame,
+  isDeleteCommand,
+  isElementCommand,
+  isUpdateCommand,
+  overlapArea,
+  viewAt,
+  visibleRect
+} from "./chunk-36DTNSHU.js";
+import {
+  checkControlValue,
+  coerceControlValue,
+  componentCount,
+  controlValue,
+  describeValue,
+  hexToRgb,
+  humanise,
+  imageUrls,
+  isImageUrl,
+  parseControls,
+  rgbToHex
+} from "./chunk-J55UBNAT.js";
+
+// src/time/retiming.ts
+function loopTime(t, duration, start = 0) {
+  if (duration <= 0) return start;
+  const rel = t - start;
+  const mod = (rel % duration + duration) % duration;
+  return start + mod;
+}
+function pingPongTime(t, duration, start = 0) {
+  if (duration <= 0) return start;
+  const period = 2 * duration;
+  const rel = t - start;
+  const mod = (rel % period + period) % period;
+  const offset = mod <= duration ? mod : period - mod;
+  return start + offset;
+}
+function holdTime(_t, holdAt) {
+  return holdAt;
+}
+function strobeTime(t, fps, unit = "ms") {
+  if (fps <= 0) return t;
+  const interval = (unit === "ms" ? 1e3 : 1) / fps;
+  return Math.floor(t / interval) * interval;
+}
+function speedRampTime(t, start, duration, ease = "easeInOut") {
+  if (duration <= 0 || t <= start) return t;
+  if (t >= start + duration) return t;
+  const p = (t - start) / duration;
+  let eased;
+  switch (ease) {
+    case "linear":
+      eased = p;
+      break;
+    case "easeIn":
+      eased = p * p;
+      break;
+    case "easeOut":
+      eased = p * (2 - p);
+      break;
+    case "easeInOut":
+    default:
+      eased = p < 0.5 ? 2 * p * p : -1 + (4 - 2 * p) * p;
+      break;
+  }
+  return start + eased * duration;
+}
+
+// src/time/keyframe.ts
+var EASY_EASE = {
+  speed: 0,
+  influence: 1 / 3
+};
+function bez1d(p0, p1, p2, p3, u) {
+  const v = 1 - u;
+  return v * v * v * p0 + 3 * v * v * u * p1 + 3 * v * u * u * p2 + u * u * u * p3;
+}
+function bez1dDerivative(p0, p1, p2, p3, u) {
+  const v = 1 - u;
+  return 3 * v * v * (p1 - p0) + 6 * v * u * (p2 - p1) + 3 * u * u * (p3 - p2);
+}
+function solveBezierU(x0, x1, x2, x3, x) {
+  if (x <= x0) return 0;
+  if (x >= x3) return 1;
+  if (Math.abs(x1 - x3) < 1e-12 && Math.abs(x2 - x0) < 1e-12) {
+    const progress = (x - x0) / (x3 - x0);
+    return 0.5 + Math.cbrt((progress - 0.5) * 0.25);
+  }
+  let u = (x - x0) / (x3 - x0);
+  for (let iter = 0; iter < 8; iter++) {
+    const f = bez1d(x0, x1, x2, x3, u) - x;
+    const d = bez1dDerivative(x0, x1, x2, x3, u);
+    if (Math.abs(d) < 1e-12) break;
+    if (Math.abs(f / d) < 1e-12) return u;
+    const nextU = u - f / d;
+    if (nextU < 0 || nextU > 1) break;
+    u = nextU;
+  }
+  let lo = 0;
+  let hi = 1;
+  for (let iter = 0; iter < 60; iter++) {
+    const mid = (lo + hi) * 0.5;
+    if (bez1d(x0, x1, x2, x3, mid) < x) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return (lo + hi) * 0.5;
+}
+function easeProgress(outSpeedNorm, outInfluence, inSpeedNorm, inInfluence, x) {
+  const i0 = Math.min(1, Math.max(0, outInfluence));
+  const i1 = Math.min(1, Math.max(0, inInfluence));
+  const u = solveBezierU(0, i0, 1 - i1, 1, x);
+  return bez1d(0, outSpeedNorm * i0, 1 - inSpeedNorm * i1, 1, u);
+}
+function evaluateKeyframeSegment(from, to, duration, t, outEase = EASY_EASE, inEase = EASY_EASE) {
+  if (duration <= 0 || t <= 0) return from;
+  if (t >= duration) return to;
+  const delta = to - from;
+  const x = t / duration;
+  if (Math.abs(delta) < 1e-12) {
+    return from;
+  }
+  const outSpeedNorm = outEase.speed * duration / delta;
+  const inSpeedNorm = inEase.speed * duration / delta;
+  const progress = easeProgress(outSpeedNorm, outEase.influence, inSpeedNorm, inEase.influence, x);
+  return from + progress * delta;
+}
+
+// src/time/timecode.ts
+var COMMON_FRAME_RATES = {
+  FPS_23_976: { num: 24e3, den: 1001 },
+  FPS_24: { num: 24, den: 1 },
+  FPS_25: { num: 25, den: 1 },
+  FPS_29_97: { num: 3e4, den: 1001 },
+  FPS_30: { num: 30, den: 1 },
+  FPS_48: { num: 48, den: 1 },
+  FPS_50: { num: 50, den: 1 },
+  FPS_59_94: { num: 6e4, den: 1001 },
+  FPS_60: { num: 60, den: 1 },
+  FPS_120: { num: 120, den: 1 }
+};
+function gcd(a, b) {
+  let x = Math.abs(Math.round(a));
+  let y = Math.abs(Math.round(b));
+  while (y !== 0) {
+    const t = y;
+    y = x % y;
+    x = t;
+  }
+  return x || 1;
+}
+function createFrameRate(num, den = 1) {
+  if (den <= 0 || num <= 0) {
+    return { num: 30, den: 1 };
+  }
+  const g = gcd(num, den);
+  return { num: Math.round(num / g), den: Math.round(den / g) };
+}
+function getTimecodeBase(rate) {
+  return Math.ceil(rate.num / rate.den);
+}
+function supportsDropFrame(rate) {
+  return rate.den === 1001 && getTimecodeBase(rate) % 30 === 0;
+}
+function getDropFrameCount(rate) {
+  const base = getTimecodeBase(rate);
+  return Math.floor(base / 15);
+}
+function framesToSMPTE(frame2, rate = COMMON_FRAME_RATES.FPS_30, dropFrame = false) {
+  const isDrop = dropFrame && supportsDropFrame(rate);
+  const neg = frame2 < 0;
+  let n = Math.abs(Math.round(frame2));
+  const base = getTimecodeBase(rate);
+  const drop = getDropFrameCount(rate);
+  if (isDrop) {
+    const perMinute = base * 60 - drop;
+    const per10Minutes = perMinute * 10 + drop;
+    const d = Math.floor(n / per10Minutes);
+    const m = n % per10Minutes;
+    n += drop * 9 * d;
+    if (m > drop) {
+      n += drop * Math.floor((m - drop) / perMinute);
+    }
+  }
+  const frames = n % base;
+  const seconds = Math.floor(n / base) % 60;
+  const minutes = Math.floor(n / (base * 60)) % 60;
+  const hours = Math.floor(n / (base * 3600));
+  return { negative: neg, hours, minutes, seconds, frames };
+}
+function smpteToFrames(fields, rate = COMMON_FRAME_RATES.FPS_30, dropFrame = false) {
+  const isDrop = dropFrame && supportsDropFrame(rate);
+  const base = getTimecodeBase(rate);
+  const drop = getDropFrameCount(rate);
+  const totalSecs = fields.hours * 3600 + fields.minutes * 60 + fields.seconds;
+  let n = totalSecs * base + fields.frames;
+  if (isDrop) {
+    const totalMinutes = fields.hours * 60 + fields.minutes;
+    n -= drop * (totalMinutes - Math.floor(totalMinutes / 10));
+  }
+  return n;
+}
+function formatTimecode(frame2, rate = COMMON_FRAME_RATES.FPS_30, dropFrame = false) {
+  const isDrop = dropFrame && supportsDropFrame(rate);
+  const { negative, hours, minutes, seconds, frames } = framesToSMPTE(frame2, rate, isDrop);
+  const sep = isDrop ? ";" : ":";
+  const base = getTimecodeBase(rate);
+  const frameWidth = base >= 100 ? 3 : 2;
+  const hStr = String(hours).padStart(2, "0");
+  const mStr = String(minutes).padStart(2, "0");
+  const sStr = String(seconds).padStart(2, "0");
+  const fStr = String(frames).padStart(frameWidth, "0");
+  return `${negative ? "-" : ""}${hStr}${sep}${mStr}${sep}${sStr}${sep}${fStr}`;
+}
+function parseTimecode(input, rate = COMMON_FRAME_RATES.FPS_30, dropFrame = false, currentFrame = 0) {
+  const s = input.trim();
+  if (!s) {
+    throw new Error("Empty timecode string");
+  }
+  let relativeSign = null;
+  let body = s;
+  if (s.startsWith("+")) {
+    relativeSign = 1;
+    body = s.slice(1);
+  } else if (s.startsWith("-")) {
+    relativeSign = -1;
+    body = s.slice(1);
+  }
+  const parts = body.split(/[:;.,]/);
+  let parsedFrame = 0;
+  if (parts.length === 1) {
+    const digits = parts[0];
+    if (!/^\d+$/.test(digits)) {
+      throw new Error(`Invalid timecode: "${input}"`);
+    }
+    if (relativeSign !== null) {
+      const count = parseInt(digits, 10);
+      return currentFrame + relativeSign * count;
+    }
+    const nums = [];
+    let end = digits.length;
+    while (end > 0) {
+      const start = Math.max(0, end - 2);
+      nums.unshift(parseInt(digits.slice(start, end), 10));
+      end = start;
+    }
+    const padded = [0, 0, 0, 0];
+    const offset = 4 - nums.length;
+    for (let i = 0; i < nums.length; i++) {
+      padded[offset + i] = nums[i];
+    }
+    const [h, m, sec, fr] = padded;
+    parsedFrame = smpteToFrames(
+      { hours: h, minutes: m, seconds: sec, frames: fr },
+      rate,
+      dropFrame
+    );
+  } else {
+    if (parts.length > 4) {
+      throw new Error(`Too many timecode fields in "${input}"`);
+    }
+    const nums = parts.map((p) => p.length === 0 ? 0 : parseInt(p, 10));
+    if (nums.some((n) => isNaN(n))) {
+      throw new Error(`Invalid number in timecode: "${input}"`);
+    }
+    const padded = [0, 0, 0, 0];
+    const offset = 4 - nums.length;
+    for (let i = 0; i < nums.length; i++) {
+      padded[offset + i] = nums[i];
+    }
+    const [h, m, sec, fr] = padded;
+    parsedFrame = smpteToFrames(
+      { hours: h, minutes: m, seconds: sec, frames: fr },
+      rate,
+      dropFrame
+    );
+  }
+  if (relativeSign !== null) {
+    return currentFrame + relativeSign * parsedFrame;
+  }
+  return parsedFrame;
+}
+
+// src/scene/rig.ts
+function setRigWidget(rig, widgetName, value) {
+  const widget = rig.widgets[widgetName];
+  if (!widget) {
+    throw new Error(`Rig widget "${widgetName}" not found.`);
+  }
+  const updatedWidgets = { ...rig.widgets };
+  if (widget.type === "slider") {
+    if (typeof value !== "number") {
+      throw new Error(`Slider widget "${widgetName}" expects numeric value.`);
+    }
+    updatedWidgets[widgetName] = { ...widget, value };
+  } else if (widget.type === "popup") {
+    if (typeof value !== "string") {
+      throw new Error(`Popup widget "${widgetName}" expects string value.`);
+    }
+    updatedWidgets[widgetName] = { ...widget, selected: value };
+  } else if (widget.type === "toggle") {
+    if (typeof value !== "boolean") {
+      throw new Error(`Toggle widget "${widgetName}" expects boolean value.`);
+    }
+    updatedWidgets[widgetName] = { ...widget, enabled: value };
+  }
+  return { widgets: updatedWidgets };
+}
+function resolveWidgetValues(widget) {
+  if (widget.type === "popup") {
+    return widget.options[widget.selected] ?? {};
+  }
+  if (widget.type === "toggle") {
+    return widget.enabled ? widget.on : widget.off;
+  }
+  if (widget.type === "slider") {
+    const { snapshots, value } = widget;
+    if (!snapshots || snapshots.length === 0) return {};
+    const sorted = [...snapshots].sort((a, b) => a.at - b.at);
+    if (value <= sorted[0].at) {
+      return { ...sorted[0].values };
+    }
+    if (value >= sorted[sorted.length - 1].at) {
+      return { ...sorted[sorted.length - 1].values };
+    }
+    let idx = 0;
+    while (idx < sorted.length - 1 && sorted[idx + 1].at < value) {
+      idx++;
+    }
+    const s0 = sorted[idx];
+    const s1 = sorted[idx + 1];
+    const span = s1.at - s0.at;
+    const t = span > 0 ? (value - s0.at) / span : 0;
+    const result = {};
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(s0.values), ...Object.keys(s1.values)]);
+    for (const k of allKeys) {
+      const v0 = s0.values[k];
+      const v1 = s1.values[k];
+      if (typeof v0 === "number" && typeof v1 === "number") {
+        result[k] = v0 + (v1 - v0) * t;
+      } else if (v0 !== void 0 && v1 !== void 0) {
+        result[k] = t < 0.5 ? v0 : v1;
+      } else {
+        result[k] = v1 !== void 0 ? v1 : v0;
+      }
+    }
+    return result;
+  }
+  return {};
+}
+function applyRig(rig, scene) {
+  const nextMedia = {};
+  if (scene.media) {
+    for (const [id, m] of Object.entries(scene.media)) {
+      nextMedia[id] = {
+        ...m,
+        values: { ...m.values ?? {} }
+      };
+    }
+  }
+  const nextShots = scene.shots.map((shot) => {
+    if (!shot.run) return { ...shot };
+    return {
+      ...shot,
+      run: shot.run.map((cmd) => {
+        if (cmd.type === "element" && "element" in cmd && cmd.element) {
+          return { ...cmd, element: { ...cmd.element } };
+        }
+        if (cmd.type === "update" && "props" in cmd && cmd.props) {
+          return { ...cmd, props: { ...cmd.props } };
+        }
+        return { ...cmd };
+      })
+    };
+  });
+  const resolvedAll = {};
+  for (const widget of Object.values(rig.widgets)) {
+    Object.assign(resolvedAll, resolveWidgetValues(widget));
+  }
+  for (const [targetKey, val] of Object.entries(resolvedAll)) {
+    if (targetKey.startsWith("media.")) {
+      const parts = targetKey.split(".");
+      const mediaId = parts[1];
+      const prop = parts.length > 3 && parts[2] === "values" ? parts[3] : parts[2];
+      if (nextMedia[mediaId]) {
+        nextMedia[mediaId].values[prop] = val;
+      }
+    } else if (targetKey.startsWith("element.")) {
+      const parts = targetKey.split(".");
+      const elId = parts[1];
+      const prop = parts[2];
+      for (const shot of nextShots) {
+        if (shot.run) {
+          for (const cmd of shot.run) {
+            if (cmd.type === "element" && "element" in cmd && cmd.element?.id === elId) {
+              cmd.element[prop] = val;
+            } else if (cmd.type === "update" && "id" in cmd && cmd.id === elId) {
+              cmd.props[prop] = val;
+            }
+          }
+        }
+      }
+    } else {
+      const uniformName = targetKey.replace(/^uniforms\./, "");
+      for (const m of Object.values(nextMedia)) {
+        m.values[uniformName] = val;
+      }
+    }
+  }
+  return {
+    ...scene,
+    media: Object.keys(nextMedia).length > 0 ? nextMedia : scene.media,
+    shots: nextShots,
+    rig
+  };
+}
+
+// src/scene/replicator.ts
+function expandReplicator(prototype, config) {
+  const count = Math.max(0, Math.floor(config.count));
+  if (count === 0) return [];
+  const originX = config.origin ? config.origin[0] : prototype.x;
+  const originY = config.origin ? config.origin[1] : prototype.y;
+  const elements = [];
+  for (let i = 0; i < count; i++) {
+    const el = {
+      ...prototype,
+      id: `${prototype.id}_${i}`
+    };
+    let px = originX;
+    let py = originY;
+    switch (config.pattern) {
+      case "grid": {
+        const cols = config.columns ?? Math.ceil(Math.sqrt(count));
+        const colSpacing = config.columnSpacing ?? prototype.width + 20;
+        const rowSpacing = config.rowSpacing ?? prototype.height + 20;
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        px = originX + col * colSpacing;
+        py = originY + row * rowSpacing;
+        break;
+      }
+      case "line": {
+        if (config.startPoint && config.endPoint) {
+          const t = count > 1 ? i / (count - 1) : 0;
+          px = config.startPoint[0] + (config.endPoint[0] - config.startPoint[0]) * t;
+          py = config.startPoint[1] + (config.endPoint[1] - config.startPoint[1]) * t;
+        } else {
+          const spacing = config.spacing ?? prototype.width + 20;
+          px = originX + i * spacing;
+          py = originY;
+        }
+        break;
+      }
+      case "circle": {
+        const radius = config.radius ?? 150;
+        const angleStep = 2 * Math.PI / count;
+        const angle = (config.startAngle ?? 0) + i * angleStep;
+        px = originX + radius * Math.cos(angle);
+        py = originY + radius * Math.sin(angle);
+        break;
+      }
+      case "spiral": {
+        const baseRadius = config.radius ?? 40;
+        const tightness = config.spiralTightness ?? 12;
+        const angleStep = Math.PI / 4;
+        const angle = (config.startAngle ?? 0) + i * angleStep;
+        const r = baseRadius + tightness * i;
+        px = originX + r * Math.cos(angle);
+        py = originY + r * Math.sin(angle);
+        break;
+      }
+    }
+    el.x = px;
+    el.y = py;
+    if (config.sequence && config.sequence.offset !== void 0) {
+      const { property, offset } = config.sequence;
+      if (property === "opacity") {
+        const base = prototype.opacity ?? 1;
+        el.opacity = Math.max(0, Math.min(1, base + i * offset));
+      } else if (property === "rotation") {
+        const base = prototype.rotation ?? 0;
+        el.rotation = base + i * offset;
+      } else if (property === "scale") {
+        const factor = 1 + i * offset;
+        el.width = Math.max(1, prototype.width * factor);
+        el.height = Math.max(1, prototype.height * factor);
+      } else if (property === "x") {
+        el.x += i * offset;
+      } else if (property === "y") {
+        el.y += i * offset;
+      }
+    }
+    elements.push(el);
+  }
+  return elements;
+}
+
+// src/scene/motionpath.ts
+function toVec3(p) {
+  if (!p) return [0, 0, 0];
+  return [p[0], p[1], p[2] ?? 0];
+}
+function cubicPos(p0, p1, p2, p3, t) {
+  const u = 1 - t;
+  const a = u * u * u;
+  const b = 3 * u * u * t;
+  const c = 3 * u * t * t;
+  const d = t * t * t;
+  return [
+    a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0],
+    a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1],
+    a * p0[2] + b * p1[2] + c * p2[2] + d * p3[2]
+  ];
+}
+function cubicVel(p0, p1, p2, p3, t) {
+  const u = 1 - t;
+  const a = -3 * u * u;
+  const b = 3 * u * u - 6 * u * t;
+  const c = 6 * u * t - 3 * t * t;
+  const d = 3 * t * t;
+  return [
+    a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0],
+    a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1],
+    a * p0[2] + b * p1[2] + c * p2[2] + d * p3[2]
+  ];
+}
+function cubicAcc(p0, p1, p2, p3, t) {
+  const u = 1 - t;
+  const a = 6 * u;
+  const b = -12 * u + 6 * t;
+  const c = 6 * u - 12 * t;
+  const d = 6 * t;
+  return [
+    a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0],
+    a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1],
+    a * p0[2] + b * p1[2] + c * p2[2] + d * p3[2]
+  ];
+}
+function dist3(a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const dz = b[2] - a[2];
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function createMotionPath(waypoints, options) {
+  if (waypoints.length < 2) {
+    throw new Error("SpatialMotionPath requires at least 2 waypoints.");
+  }
+  const closed = options?.closed ?? false;
+  const segmentCount = closed ? waypoints.length : waypoints.length - 1;
+  const segments = [];
+  let totalLength = 0;
+  for (let i = 0; i < segmentCount; i++) {
+    const nextIdx = (i + 1) % waypoints.length;
+    const w0 = waypoints[i];
+    const w1 = waypoints[nextIdx];
+    const p0 = toVec3(w0.point);
+    const outT = toVec3(w0.outTangent);
+    const p1 = [p0[0] + outT[0], p0[1] + outT[1], p0[2] + outT[2]];
+    const p3 = toVec3(w1.point);
+    const inT = toVec3(w1.inTangent);
+    const p2 = [p3[0] + inT[0], p3[1] + inT[1], p3[2] + inT[2]];
+    const chord = dist3(p0, p1) + dist3(p1, p2) + dist3(p2, p3);
+    const stepCount = Math.max(16, Math.min(256, Math.ceil(chord / (options?.resolution ?? 2))));
+    const samples = [];
+    let segLen = 0;
+    let prev = p0;
+    samples.push({ t: 0, s: 0, pos: p0 });
+    for (let k = 1; k <= stepCount; k++) {
+      const t = k / stepCount;
+      const pos = cubicPos(p0, p1, p2, p3, t);
+      segLen += dist3(prev, pos);
+      samples.push({ t, s: segLen, pos });
+      prev = pos;
+    }
+    segments.push({
+      p0,
+      p1,
+      p2,
+      p3,
+      length: segLen,
+      samples
+    });
+    totalLength += segLen;
+  }
+  return {
+    waypoints,
+    closed,
+    totalLength,
+    segments
+  };
+}
+function sampleMotionPath(path, distanceFraction) {
+  const clampedFraction = Math.max(0, Math.min(1, distanceFraction));
+  const targetDistance = clampedFraction * path.totalLength;
+  if (path.totalLength === 0) {
+    const p = toVec3(path.waypoints[0].point);
+    return {
+      position: p,
+      tangent: [1, 0, 0],
+      heading: 0,
+      normal: [0, 1, 0],
+      curvature: 0,
+      distance: 0
+    };
+  }
+  let accumulated = 0;
+  let targetSeg = path.segments[0];
+  let segDistance = targetDistance;
+  for (const seg of path.segments) {
+    if (accumulated + seg.length >= targetDistance || seg === path.segments[path.segments.length - 1]) {
+      targetSeg = seg;
+      segDistance = Math.max(0, Math.min(seg.length, targetDistance - accumulated));
+      break;
+    }
+    accumulated += seg.length;
+  }
+  const samples = targetSeg.samples;
+  let low = 0;
+  let high = samples.length - 1;
+  while (low <= high) {
+    const mid = low + high >> 1;
+    if (samples[mid].s < segDistance) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  const idx = Math.max(0, Math.min(samples.length - 2, high));
+  const s0 = samples[idx];
+  const s1 = samples[idx + 1];
+  const segRange = s1.s - s0.s;
+  const factor = segRange > 1e-7 ? (segDistance - s0.s) / segRange : 0;
+  const t = s0.t + factor * (s1.t - s0.t);
+  const pos = cubicPos(targetSeg.p0, targetSeg.p1, targetSeg.p2, targetSeg.p3, t);
+  const vel = cubicVel(targetSeg.p0, targetSeg.p1, targetSeg.p2, targetSeg.p3, t);
+  const acc = cubicAcc(targetSeg.p0, targetSeg.p1, targetSeg.p2, targetSeg.p3, t);
+  const speed = Math.sqrt(vel[0] * vel[0] + vel[1] * vel[1] + vel[2] * vel[2]);
+  const safeSpeed = speed > 1e-6 ? speed : 1;
+  const tangent = [vel[0] / safeSpeed, vel[1] / safeSpeed, vel[2] / safeSpeed];
+  const heading = Math.atan2(tangent[1], tangent[0]);
+  const normal = [-tangent[1], tangent[0], 0];
+  const cx = vel[1] * acc[2] - vel[2] * acc[1];
+  const cy = vel[2] * acc[0] - vel[0] * acc[2];
+  const cz = vel[0] * acc[1] - vel[1] * acc[0];
+  const crossMag = Math.sqrt(cx * cx + cy * cy + cz * cz);
+  const curvature = crossMag / (safeSpeed * safeSpeed * safeSpeed);
+  return {
+    position: pos,
+    tangent,
+    heading,
+    normal,
+    curvature,
+    distance: targetDistance
+  };
+}
+function sampleMotionPathAtTime(path, time, duration, ease) {
+  const distanceFraction = evaluateKeyframeSegment(
+    0,
+    1,
+    duration,
+    time,
+    ease?.easeOut,
+    ease?.easeIn
+  );
+  return sampleMotionPath(path, distanceFraction);
+}
+
+// src/agent/tools.ts
+var FLAIR_AGENT_TOOLS = [
+  {
+    name: "get_scene",
+    description: "Returns the current scene JSON and any static validation issues.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "write_scene",
+    description: "Overwrites the entire scene with a new specification and validates it.",
+    input_schema: {
+      type: "object",
+      properties: {
+        scene: {
+          type: "object",
+          description: "Full Scene object with name, stage, media, and shots."
+        }
+      },
+      required: ["scene"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "update_shot",
+    description: "Updates fields of a specific shot (1-based index) without rewriting the whole scene.",
+    input_schema: {
+      type: "object",
+      properties: {
+        shot: { type: "integer", minimum: 1, description: "1-based index of the shot to update." },
+        set: { type: "object", description: "Fields to set or replace on this shot." },
+        remove: {
+          type: "array",
+          items: { type: "string" },
+          description: "Field names to delete from this shot."
+        }
+      },
+      required: ["shot"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "insert_shots",
+    description: "Inserts one or more shots at a given position.",
+    input_schema: {
+      type: "object",
+      properties: {
+        after: {
+          type: "integer",
+          minimum: 0,
+          description: "0 to insert at the beginning, or 1-based index of shot to insert after."
+        },
+        shots: {
+          type: "array",
+          items: { type: "object" },
+          description: "Array of Shot objects to insert."
+        }
+      },
+      required: ["after", "shots"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "delete_shots",
+    description: "Deletes one or more shots by 1-based index.",
+    input_schema: {
+      type: "object",
+      properties: {
+        shots: {
+          type: "array",
+          items: { type: "integer", minimum: 1 },
+          description: "1-based shot numbers to delete."
+        }
+      },
+      required: ["shots"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "set_media",
+    description: "Adds, updates, or removes embedded media (e.g. bespoke WebGL shaders) by ID.",
+    input_schema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Media identifier." },
+        media: {
+          type: ["object", "null"],
+          description: 'SceneMedia object (e.g. { type: "shader", source: "..." }), or null to remove.'
+        }
+      },
+      required: ["id", "media"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "preview_scene",
+    description: "Simulates the scene fast and off-screen, returning timing, layout checks, and review report.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "set_rig_widget",
+    description: "Adjusts a high-level creative rig widget (slider, popup, or toggle) and propagates parameters to shaders and elements.",
+    input_schema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Rig widget identifier/name." },
+        value: {
+          type: ["number", "string", "boolean"],
+          description: "New value (number for slider, string for popup, boolean for toggle)."
+        }
+      },
+      required: ["name", "value"],
+      additionalProperties: false
+    }
+  }
+];
+async function applySceneTool(scene, toolName, input = {}) {
+  switch (toolName) {
+    case "get_scene": {
+      return { ok: true, scene, issues: validateScene(scene) };
+    }
+    case "write_scene": {
+      if (!input.scene || typeof input.scene !== "object") {
+        return { ok: false, error: "Expected scene object in arguments." };
+      }
+      const newScene = input.scene;
+      const issues = validateScene(newScene);
+      return { ok: true, scene: newScene, issues };
+    }
+    case "update_shot": {
+      const idx = input.shot - 1;
+      if (idx < 0 || idx >= scene.shots.length) {
+        return { ok: false, error: `Invalid shot number ${input.shot}; scene has ${scene.shots.length} shots.` };
+      }
+      const existing = scene.shots[idx];
+      const updated = { ...existing, ...input.set || {} };
+      if (Array.isArray(input.remove)) {
+        for (const k of input.remove) {
+          delete updated[k];
+        }
+      }
+      const shots = [...scene.shots];
+      shots[idx] = updated;
+      const newScene = { ...scene, shots };
+      return { ok: true, scene: newScene, issues: validateScene(newScene) };
+    }
+    case "insert_shots": {
+      const after = input.after ?? scene.shots.length;
+      if (after < 0 || after > scene.shots.length) {
+        return { ok: false, error: `Invalid after index ${after}.` };
+      }
+      if (!Array.isArray(input.shots) || input.shots.length === 0) {
+        return { ok: false, error: "Expected non-empty shots array to insert." };
+      }
+      const shots = [...scene.shots.slice(0, after), ...input.shots, ...scene.shots.slice(after)];
+      const newScene = { ...scene, shots };
+      return { ok: true, scene: newScene, issues: validateScene(newScene) };
+    }
+    case "delete_shots": {
+      if (!Array.isArray(input.shots) || input.shots.length === 0) {
+        return { ok: false, error: "Expected non-empty shots array to delete." };
+      }
+      const toDelete = new Set(input.shots.map((n) => n - 1));
+      const shots = scene.shots.filter((_, i) => !toDelete.has(i));
+      if (shots.length === 0) {
+        return { ok: false, error: "Cannot delete all shots in scene." };
+      }
+      const newScene = { ...scene, shots };
+      return { ok: true, scene: newScene, issues: validateScene(newScene) };
+    }
+    case "set_media": {
+      if (!input.id || typeof input.id !== "string") {
+        return { ok: false, error: "Expected string media id." };
+      }
+      const media = { ...scene.media || {} };
+      if (input.media === null) {
+        delete media[input.id];
+      } else {
+        media[input.id] = input.media;
+      }
+      const newScene = { ...scene, media };
+      return { ok: true, scene: newScene, issues: validateScene(newScene) };
+    }
+    case "preview_scene": {
+      const { review } = await simulateScene(scene);
+      return { ok: true, scene, issues: validateScene(scene), review };
+    }
+    case "set_rig_widget": {
+      if (!scene.rig || !scene.rig.widgets || !scene.rig.widgets[input.name]) {
+        return { ok: false, error: `Scene does not have a rig widget named "${input.name}".` };
+      }
+      try {
+        const updatedRig = setRigWidget(scene.rig, input.name, input.value);
+        const newScene = applyRig(updatedRig, scene);
+        return { ok: true, scene: newScene, issues: validateScene(newScene) };
+      } catch (err) {
+        return { ok: false, error: err.message || String(err) };
+      }
+    }
+    default:
+      return { ok: false, error: `Unknown tool name: ${toolName}` };
+  }
+}
+
+// src/agent/batch.ts
+function getByPath(obj, path) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const parts = path.replace(/\[(\w+)\]/g, ".$1").split(".");
+  let curr = obj;
+  for (const part of parts) {
+    if (curr === void 0 || curr === null) return void 0;
+    curr = curr[part];
+  }
+  return curr;
+}
+function substituteVariables(value, stepResults) {
+  if (typeof value === "string") {
+    const match = /^\$(\d+)\.(.+)$/.exec(value);
+    if (match) {
+      const stepIdx = parseInt(match[1], 10);
+      const path = match[2];
+      const prevResult = stepResults.get(stepIdx);
+      if (prevResult) {
+        const resolved = getByPath(prevResult, path);
+        if (resolved !== void 0) {
+          return resolved;
+        }
+      }
+    }
+    return value.replace(/\$(\d+)\.([a-zA-Z0-9_.[\]]+)/g, (fullMatch, stepStr, path) => {
+      const stepIdx = parseInt(stepStr, 10);
+      const prevResult = stepResults.get(stepIdx);
+      if (prevResult) {
+        const resolved = getByPath(prevResult, path);
+        if (resolved !== void 0) {
+          return String(resolved);
+        }
+      }
+      return fullMatch;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => substituteVariables(item, stepResults));
+  }
+  if (value !== null && typeof value === "object") {
+    const copy = {};
+    for (const [k, v] of Object.entries(value)) {
+      copy[k] = substituteVariables(v, stepResults);
+    }
+    return copy;
+  }
+  return value;
+}
+async function applySceneBatch(scene, commands) {
+  let currentScene = scene;
+  const stepResults = /* @__PURE__ */ new Map();
+  const executedSteps = [];
+  for (let i = 0; i < commands.length; i++) {
+    const stepNumber = i + 1;
+    const cmd = commands[i];
+    const resolvedParams = substituteVariables(cmd.params || {}, stepResults);
+    if (cmd.tool === "batch_scene_tool") {
+      return {
+        ok: false,
+        scene,
+        // Rollback
+        steps: executedSteps,
+        error: `Nested batch_scene_tool is not allowed at step ${stepNumber}.`,
+        failedStep: stepNumber
+      };
+    }
+    const stepResult = await applySceneTool(currentScene, cmd.tool, resolvedParams);
+    stepResults.set(stepNumber, stepResult);
+    executedSteps.push({
+      step: stepNumber,
+      tool: cmd.tool,
+      result: stepResult
+    });
+    if (!stepResult.ok) {
+      return {
+        ok: false,
+        scene,
+        // Rollback to initial
+        steps: executedSteps,
+        error: `Step ${stepNumber} (${cmd.tool}) failed: ${stepResult.error}`,
+        failedStep: stepNumber
+      };
+    }
+    currentScene = stepResult.scene;
+  }
+  return {
+    ok: true,
+    scene: currentScene,
+    steps: executedSteps
+  };
+}
+export {
+  ALL_BLEND_MODES,
+  ALL_TRANSITION_TYPES,
+  BUILTIN_UNIFORMS,
+  CAMERA_MS,
+  COMMON_FRAME_RATES,
+  DEFAULT_STAGE,
+  EASES,
+  EASY_EASE,
+  EFFECT_FADE_MS,
+  EFFECT_TYPES,
+  FLAIR_AGENT_TOOLS,
+  ImageLoadError,
+  ManualClock,
+  MemorySceneBoard,
+  NO_CHECK,
+  SMALL_TEXT_PX,
+  STEP_MS,
+  SVG_EDGE,
+  SVG_PICTURE,
+  ShaderCompileError,
+  ShaderFrames,
+  ShaderRenderer,
+  SvgPlayer,
+  TextureCache,
+  ThumbnailPool,
+  VERTEX_SOURCE,
+  applyAscCdl,
+  applyLiftGammaGain,
+  applyRig,
+  applySceneBatch,
+  applySceneTool,
+  applyTextureSettings,
+  applyVibrance,
+  areaOf,
+  between,
+  bez1d,
+  bez1dDerivative,
+  blendRgba,
+  blendTransitionPixel,
+  boardHeight,
+  boundsOf,
+  calculateFramingRect,
+  calculateShotTimings,
+  centreOf,
+  checkControlValue,
+  checkShot,
+  coerceControlValue,
+  compileShader,
+  componentCount,
+  controlValue,
+  convertColorSpace,
+  createContext,
+  createFrameRate,
+  createLottieEase,
+  createMotionPath,
+  defaultDataKey,
+  describeValue,
+  drawFrame,
+  easeInOutCubic,
+  easeProgress,
+  effectGone,
+  effectOpacity,
+  evaluateBehavior,
+  evaluateKeyframeSegment,
+  expandReplicator,
+  exportCmx3600Edl,
+  exportFcp7Xml,
+  exportLottie,
+  exportMotn,
+  formatCompileError,
+  formatTimecode,
+  fractalWiggle,
+  frame,
+  framesToSMPTE,
+  framesToTimecode,
+  getColorGradingGLSL,
+  getDropFrameCount,
+  getGlslBlendFunction,
+  getOklabGLSL,
+  getTimecodeBase,
+  getTransitionGLSL,
+  getWhiteBalanceGains,
+  hash64,
+  hexToRgb,
+  holdTime,
+  humanise,
+  imageUrls,
+  interpolateOklab,
+  interpolateOklch,
+  isDeleteCommand,
+  isElementCommand,
+  isImageUrl,
+  isSvgUrl,
+  isUpdateCommand,
+  jitter,
+  lerpAttr,
+  lerpData,
+  linearRgbToSrgb,
+  linearSrgbToOklab,
+  linearToSrgb,
+  loadImage,
+  loopTime,
+  mixSeeds,
+  noise1d,
+  noise3d,
+  oklabToLinearSrgb,
+  oklabToOklch,
+  oklabToSrgb,
+  oklchToOklab,
+  overlapArea,
+  pageHidden,
+  parseCompileLog,
+  parseControls,
+  parseSvg,
+  parseTimecode,
+  pingPongTime,
+  playScene,
+  preloadImages,
+  quinticFade,
+  realClock,
+  recordGif,
+  registerThumbnail,
+  releaseImages,
+  resetGlCaches,
+  reviewScene,
+  rgbToHex,
+  sampleMotionPath,
+  sampleMotionPathAtTime,
+  sampleTransition,
+  setRigWidget,
+  sharedThumbnailPool,
+  simulateScene,
+  sizeSvg,
+  smpteToFrames,
+  solveBezierU,
+  speedRampTime,
+  srgbToLinear,
+  srgbToLinearRgb,
+  srgbToOklab,
+  standaloneHtml,
+  standaloneSceneHtml,
+  stepData,
+  stepProgress,
+  stepStart,
+  strobeTime,
+  substituteVariables,
+  supportsDropFrame,
+  svgDuration,
+  svgFrame,
+  svgMotionIssues,
+  svgOpeningTag,
+  svgView,
+  timecodeToFrames,
+  titleBox,
+  touchedIds,
+  unitFloat,
+  validateScene,
+  viewAt,
+  visibleRect,
+  wrapSource
+};
+//# sourceMappingURL=index.js.map