@pixerate/flair 0.1.1 → 0.3.0

package/dist/chunk-WAMA45G3.js

@@ -0,0 +1,998 @@
+import {
+  ManualClock
+} from "./chunk-WMZQCUFJ.js";
+
+// src/time/noise.ts
+var GOLDEN_GAMMA = 0x9e3779b97f4a7c15n;
+var MULT1 = 0xbf58476d1ce4e5b9n;
+var MULT2 = 0x94d049bb133111ebn;
+var MASK64 = 0xffffffffffffffffn;
+var BASE_MIX = 0x2545f4914f6cdd1dn;
+var POW2_53 = 9007199254740992;
+function hash64(x) {
+  let v = x + GOLDEN_GAMMA & MASK64;
+  v = (v ^ v >> 30n) * MULT1 & MASK64;
+  v = (v ^ v >> 27n) * MULT2 & MASK64;
+  return (v ^ v >> 31n) & MASK64;
+}
+function mixSeeds(parts) {
+  let h = BASE_MIX;
+  for (const p of parts) {
+    const val = typeof p === "bigint" ? p : BigInt(Math.floor(p));
+    h = hash64(h ^ hash64(val & MASK64));
+  }
+  return h;
+}
+function unitFloat(seed) {
+  const s = typeof seed === "bigint" ? seed : BigInt(Math.floor(seed));
+  const hashed = hash64(s);
+  const shifted = Number(hashed >> 11n);
+  return shifted / POW2_53;
+}
+function quinticFade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lattice(seed, i) {
+  const mixed = seed ^ hash64(i & MASK64);
+  return unitFloat(mixed) * 2 - 1;
+}
+function noise1d(seed, x) {
+  if (!Number.isFinite(x)) return 0;
+  const s = typeof seed === "bigint" ? seed : BigInt(Math.floor(seed));
+  const floorX = Math.floor(x);
+  const u = quinticFade(x - floorX);
+  const i = BigInt(Math.floor(floorX));
+  const a = lattice(s, i);
+  const b = lattice(s, i + 1n);
+  return a + (b - a) * u;
+}
+function noise3d(x, y, z, seed = 0) {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
+    return 0;
+  }
+  const s = typeof seed === "bigint" ? seed : BigInt(Math.floor(seed));
+  const fx = Math.floor(x);
+  const fy = Math.floor(y);
+  const fz = Math.floor(z);
+  const u = quinticFade(x - fx);
+  const v = quinticFade(y - fy);
+  const w = quinticFade(z - fz);
+  const ix = BigInt(fx);
+  const iy = BigInt(fy);
+  const iz = BigInt(fz);
+  const g = (dx, dy, dz) => {
+    const combined = mixSeeds([s, ix + dx, iy + dy, iz + dz]);
+    return unitFloat(combined) * 2 - 1;
+  };
+  const lerp = (a, b, t) => a + (b - a) * t;
+  const x00 = lerp(g(0n, 0n, 0n), g(1n, 0n, 0n), u);
+  const x10 = lerp(g(0n, 1n, 0n), g(1n, 1n, 0n), u);
+  const x01 = lerp(g(0n, 0n, 1n), g(1n, 0n, 1n), u);
+  const x11 = lerp(g(0n, 1n, 1n), g(1n, 1n, 1n), u);
+  const y0 = lerp(x00, x10, v);
+  const y1 = lerp(x01, x11, v);
+  return lerp(y0, y1, w);
+}
+function fractalWiggle(freq, amp, octaves = 3, ampMult = 0.5, t = 0, seed = 42, dimension = 0) {
+  const oct = Math.max(1, Math.min(16, Math.floor(octaves)));
+  let currentAmp = amp;
+  let currentFreq = freq;
+  let sum = 0;
+  const baseSeed = BigInt(seed);
+  for (let k = 0; k < oct; k++) {
+    const s = mixSeeds([baseSeed, BigInt(dimension), BigInt(k)]);
+    const phaseOffset = unitFloat(s) * 1e3;
+    sum += currentAmp * noise1d(s, currentFreq * t + phaseOffset);
+    currentAmp *= ampMult;
+    currentFreq *= 2;
+  }
+  return sum;
+}
+
+// src/scene/types.ts
+function isElementCommand(cmd) {
+  return cmd.type === "element" && "element" in cmd && !!cmd.element;
+}
+function isUpdateCommand(cmd) {
+  return cmd.type === "update" && "id" in cmd && typeof cmd.id === "string";
+}
+function isDeleteCommand(cmd) {
+  return cmd.type === "delete" && "id" in cmd && typeof cmd.id === "string";
+}
+
+// src/scene/geometry.ts
+function boundsOf(e) {
+  if (e.points?.length) {
+    const xs = e.points.map((p) => e.x + p[0]);
+    const ys = e.points.map((p) => e.y + p[1]);
+    const x = Math.min(...xs);
+    const y = Math.min(...ys);
+    return {
+      x,
+      y,
+      width: Math.max(1, Math.max(...xs) - x),
+      height: Math.max(1, Math.max(...ys) - y)
+    };
+  }
+  return { x: e.x, y: e.y, width: Math.max(1, e.width), height: Math.max(1, e.height) };
+}
+function overlapArea(a, b) {
+  const w = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
+  const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
+  return w > 0 && h > 0 ? w * h : 0;
+}
+var areaOf = (r) => r.width * r.height;
+
+// src/scene/camera.ts
+var DEFAULT_STAGE = {
+  width: 1920,
+  height: 1080,
+  caption: 0
+};
+var CAMERA_MS = 600;
+var DEFAULT_PERSPECTIVE = 1.2;
+var MAX_TILT = 75;
+var boardHeight = (stage) => stage.height - (stage.caption ?? 0);
+function viewAt(cx, cy, zoom, stage) {
+  return {
+    zoom,
+    scrollX: stage.width / (2 * zoom) - cx,
+    scrollY: boardHeight(stage) / (2 * zoom) - cy
+  };
+}
+function centreOf(view, stage) {
+  return [
+    stage.width / (2 * view.zoom) - view.scrollX,
+    boardHeight(stage) / (2 * view.zoom) - view.scrollY
+  ];
+}
+function frame(rect, stage) {
+  if (!(rect.width > 0 && rect.height > 0)) {
+    throw new Error("A camera rectangle needs a positive width and height");
+  }
+  const zoom = Math.min(stage.width / rect.width, boardHeight(stage) / rect.height);
+  return viewAt(rect.x + rect.width / 2, rect.y + rect.height / 2, zoom, stage);
+}
+function calculateFramingRect(elements, stage, options = {}) {
+  const activeElements = elements.filter((e) => !e.isDeleted);
+  const targetH = boardHeight(stage);
+  const stageAspect = stage.width / Math.max(1, targetH);
+  if (activeElements.length === 0) {
+    return {
+      x: 0,
+      y: 0,
+      width: stage.width,
+      height: targetH
+    };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const el of activeElements) {
+    const b = boundsOf(el);
+    if (b.x < minX) minX = b.x;
+    if (b.y < minY) minY = b.y;
+    if (b.x + b.width > maxX) maxX = b.x + b.width;
+    if (b.y + b.height > maxY) maxY = b.y + b.height;
+  }
+  let width = maxX - minX;
+  let height = maxY - minY;
+  const padding = options.padding ?? 0.15;
+  if (padding > 0) {
+    const padX = width * padding;
+    const padY = height * padding;
+    minX -= padX;
+    minY -= padY;
+    width += padX * 2;
+    height += padY * 2;
+  }
+  if (options.minWidth && width < options.minWidth) {
+    const diff = options.minWidth - width;
+    minX -= diff / 2;
+    width = options.minWidth;
+  }
+  if (options.minHeight && height < options.minHeight) {
+    const diff = options.minHeight - height;
+    minY -= diff / 2;
+    height = options.minHeight;
+  }
+  const currentAspect = width / Math.max(1, height);
+  if (currentAspect < stageAspect) {
+    const targetWidth = height * stageAspect;
+    const diff = targetWidth - width;
+    minX -= diff / 2;
+    width = targetWidth;
+  } else if (currentAspect > stageAspect) {
+    const targetHeight = width / stageAspect;
+    const diff = targetHeight - height;
+    minY -= diff / 2;
+    height = targetHeight;
+  }
+  return {
+    x: minX,
+    y: minY,
+    width,
+    height
+  };
+}
+var ANGLES = ["tilt", "turn", "roll"];
+function isAngled(view) {
+  return ANGLES.some((k) => (view[k] ?? 0) !== 0);
+}
+function cameraAngle(view) {
+  const out = {};
+  const clamp = (v, max) => Math.max(-max, Math.min(max, v));
+  if (view.tilt) out.tilt = clamp(view.tilt, MAX_TILT);
+  if (view.turn) out.turn = clamp(view.turn, MAX_TILT);
+  if (view.roll) out.roll = clamp(view.roll, 180);
+  if (view.perspective !== void 0 && view.perspective !== DEFAULT_PERSPECTIVE) out.perspective = Math.max(0.3, view.perspective);
+  return out;
+}
+function between(from, to, t, stage) {
+  const [x0, y0] = centreOf(from, stage);
+  const [x1, y1] = centreOf(to, stage);
+  const zoom = from.zoom * Math.pow(to.zoom / from.zoom, t);
+  const view = viewAt(x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, zoom, stage);
+  if (!isAngled(from) && !isAngled(to) && from.perspective === to.perspective) return view;
+  const lerp = (a = 0, b = 0) => a + (b - a) * t;
+  return {
+    ...view,
+    ...cameraAngle({
+      tilt: lerp(from.tilt, to.tilt),
+      turn: lerp(from.turn, to.turn),
+      roll: lerp(from.roll, to.roll),
+      perspective: lerp(from.perspective ?? DEFAULT_PERSPECTIVE, to.perspective ?? DEFAULT_PERSPECTIVE)
+    })
+  };
+}
+function cameraTransform(view, stage, width = stage.width) {
+  if (!isAngled(view)) return "none";
+  const a = cameraAngle(view);
+  const distance = (a.perspective ?? DEFAULT_PERSPECTIVE) * width;
+  return `perspective(${round(distance)}px) rotateX(${round(a.tilt ?? 0)}deg) rotateY(${round(a.turn ?? 0)}deg) rotateZ(${round(a.roll ?? 0)}deg)`;
+}
+function cameraBlur(view, stage, width = stage.width) {
+  const blur = (view.blur ?? 0) * (width / stage.width);
+  if (!(blur >= 0.05)) return [0, 0];
+  if (view.blurAngle === void 0) return [round(blur), round(blur)];
+  const a = (view.blurAngle - (cameraAngle(view).roll ?? 0)) * Math.PI / 180;
+  const across = blur * 0.15;
+  return [round(Math.max(across, blur * Math.abs(Math.cos(a)))), round(Math.max(across, blur * Math.abs(Math.sin(a))))];
+}
+function cameraFilter(view, stage, width = stage.width) {
+  const blur = (view.blur ?? 0) * (width / stage.width);
+  return blur >= 0.05 ? `blur(${round(blur)}px)` : "none";
+}
+var round = (n) => Math.round(n * 1e3) / 1e3;
+function projectPoint(view, stage, [x, y]) {
+  const cx = stage.width / 2;
+  const cy = boardHeight(stage) / 2;
+  let px = (x + view.scrollX) * view.zoom - cx;
+  let py = (y + view.scrollY) * view.zoom - cy;
+  if (!isAngled(view)) return [px + cx, py + cy];
+  const a = cameraAngle(view);
+  const rad = Math.PI / 180;
+  const [sr, cr] = [Math.sin((a.roll ?? 0) * rad), Math.cos((a.roll ?? 0) * rad)];
+  [px, py] = [px * cr - py * sr, px * sr + py * cr];
+  const [st, ct] = [Math.sin((a.turn ?? 0) * rad), Math.cos((a.turn ?? 0) * rad)];
+  let pz = -px * st;
+  px = px * ct;
+  const [sx, cx2] = [Math.sin((a.tilt ?? 0) * rad), Math.cos((a.tilt ?? 0) * rad)];
+  [py, pz] = [py * cx2 - pz * sx, py * sx + pz * cx2];
+  const distance = (a.perspective ?? DEFAULT_PERSPECTIVE) * stage.width;
+  if (pz >= distance) return null;
+  const k = distance / (distance - pz);
+  return [cx + px * k, cy + py * k];
+}
+function screenMotion(from, to, stage) {
+  const [x0, y0] = centreOf(from, stage);
+  const [x1, y1] = centreOf(to, stage);
+  const zoom = Math.sqrt(from.zoom * to.zoom);
+  const scale = Math.abs(Math.log(to.zoom / from.zoom)) * stage.width * 0.5;
+  const turn = ANGLES.reduce((sum, k) => sum + Math.abs((to[k] ?? 0) - (from[k] ?? 0)), 0) * (stage.width / 180);
+  return { dx: (x1 - x0) * zoom, dy: (y1 - y0) * zoom, other: scale + turn };
+}
+function motionBlur(from, to, stage, strength) {
+  if (!(strength > 0)) return 0;
+  const { dx, dy, other } = screenMotion(from, to, stage);
+  return round(Math.min(40, (Math.hypot(dx, dy) + other) * 0.35 * strength));
+}
+function motionBlurAngle(from, to, stage) {
+  const { dx, dy, other } = screenMotion(from, to, stage);
+  const pan = Math.hypot(dx, dy);
+  if (!(pan > 0) || pan < 0.6 * (pan + other)) return void 0;
+  const a = Math.atan2(dy, dx) * 180 / Math.PI;
+  return round((a % 180 + 180) % 180);
+}
+function moveBlur(from, to, stage, strength) {
+  const blur = motionBlur(from, to, stage, strength);
+  if (!(blur > 0)) return {};
+  const blurAngle = motionBlurAngle(from, to, stage);
+  return blurAngle === void 0 ? { blur } : { blur, blurAngle };
+}
+function visibleRect(view, stage) {
+  return {
+    x: -view.scrollX,
+    y: -view.scrollY,
+    width: stage.width / view.zoom,
+    height: boardHeight(stage) / view.zoom
+  };
+}
+var easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+
+// src/scene/check.ts
+var NO_CHECK = { framing: [], overlaps: [], edges: [], underTitle: [] };
+var SMALL_TEXT_PX = 24;
+function titleBox(title, stage) {
+  const width = Math.min(stage.width, title.length * 20 + 64);
+  return { x: (stage.width - width) / 2, y: 24, width, height: 60 };
+}
+function touchedIds(shot) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const cmd of shot.run ?? []) {
+    if (isElementCommand(cmd)) {
+      ids.add(cmd.element.id);
+    } else if ("id" in cmd && typeof cmd.id === "string") {
+      ids.add(cmd.id);
+    }
+  }
+  return [...ids];
+}
+var IN_FRAME = 0.95;
+function screenBox(box, view, stage) {
+  const corners = [
+    [box.x, box.y],
+    [box.x + box.width, box.y],
+    [box.x, box.y + box.height],
+    [box.x + box.width, box.y + box.height]
+  ].map(([x2, y2]) => projectPoint(view, stage, [x2, y2]));
+  if (corners.some((c) => !c)) return null;
+  const xs = corners.map((c) => c[0]);
+  const ys = corners.map((c) => c[1]);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+}
+function checkShot(shot, elements, view, stage, title) {
+  const screen = { x: 0, y: 0, width: stage.width, height: boardHeight(stage) };
+  const touched = new Set(touchedIds(shot));
+  const framing = [];
+  const edges = [];
+  const overlaps = [];
+  const activeElements = elements.filter((e) => !e.isDeleted && (e.opacity === void 0 || e.opacity > 0));
+  for (const el of activeElements) {
+    const box = screenBox(boundsOf(el), view, stage);
+    const overlap = box ? overlapArea(box, screen) : 0;
+    const boxArea = box ? areaOf(box) : 0;
+    if (touched.has(el.id)) {
+      if (overlap === 0) {
+        framing.push({ id: el.id, how: "outside" });
+      } else if (boxArea > 0 && overlap / boxArea < IN_FRAME) {
+        framing.push({ id: el.id, how: "cut" });
+      }
+    } else if (overlap > 0 && boxArea > 0 && overlap / boxArea < IN_FRAME) {
+      edges.push(el.id);
+    }
+  }
+  const touchedList = activeElements.filter((e) => touched.has(e.id));
+  for (let i = 0; i < touchedList.length; i++) {
+    for (let j = i + 1; j < touchedList.length; j++) {
+      const a = touchedList[i];
+      const b = touchedList[j];
+      const aBox = boundsOf(a);
+      const bBox = boundsOf(b);
+      const ol = overlapArea(aBox, bBox);
+      const minArea = Math.min(areaOf(aBox), areaOf(bBox));
+      if (minArea > 0 && ol / minArea > 0.3) {
+        overlaps.push([a.id, b.id]);
+      }
+    }
+  }
+  const smallTexts = [];
+  let smallestText;
+  for (const el of activeElements) {
+    if (el.text && el.fontSize) {
+      const b = boundsOf(el);
+      const top = projectPoint(view, stage, [b.x + b.width / 2, b.y + b.height / 2]);
+      const bottom = projectPoint(view, stage, [b.x + b.width / 2, b.y + b.height / 2 + el.fontSize]);
+      if (!top || !bottom) continue;
+      const px = Math.round(Math.hypot(bottom[0] - top[0], bottom[1] - top[1]));
+      const item = { id: el.id, text: el.text, px };
+      if (!smallestText || px < smallestText.px) {
+        smallestText = item;
+      }
+      if (px < SMALL_TEXT_PX) {
+        smallTexts.push(item);
+      }
+    }
+  }
+  const underTitle = [];
+  if (title) {
+    const tBox = titleBox(title, stage);
+    for (const el of activeElements) {
+      const box = screenBox(boundsOf(el), view, stage);
+      if (box && overlapArea(box, tBox) > 0) {
+        underTitle.push(el.id);
+      }
+    }
+  }
+  return {
+    framing,
+    overlaps,
+    smallestText,
+    smallTexts: smallTexts.length ? smallTexts : void 0,
+    edges,
+    underTitle
+  };
+}
+
+// src/scene/effects.ts
+var EFFECT_TYPES = [
+  "gradient",
+  "flow",
+  "glow",
+  "spotlight",
+  "shimmer",
+  "ripple",
+  "timer",
+  "counter",
+  "highlight",
+  "blur",
+  "burst",
+  "media"
+];
+var EFFECT_FADE_MS = 300;
+function effectGone(running, now) {
+  if (running.until !== void 0) {
+    return now >= running.until + EFFECT_FADE_MS;
+  }
+  if (running.effect.duration !== void 0) {
+    return now >= running.from + running.effect.duration + EFFECT_FADE_MS;
+  }
+  return false;
+}
+function effectOpacity(running, now) {
+  if (now < running.from) return 0;
+  const inFade = Math.min(1, (now - running.from) / 150);
+  if (running.until !== void 0) {
+    const out = Math.max(0, 1 - (now - running.until) / EFFECT_FADE_MS);
+    return inFade * out;
+  }
+  if (running.effect.duration !== void 0) {
+    const remaining = running.from + running.effect.duration - now;
+    if (remaining < 0) {
+      const out = Math.max(0, 1 + remaining / EFFECT_FADE_MS);
+      return inFade * out;
+    }
+  }
+  return inFade;
+}
+
+// src/scene/behavior.ts
+function evaluateWriggle(t, freq, amount, octaves = 3, seed = 42) {
+  return fractalWiggle(freq, amount, octaves, 0.5, t, seed, 0);
+}
+function evaluateBehavior(behavior, elapsedSec, durationSec, baseValue = 0) {
+  const t = Math.max(0, elapsedSec);
+  switch (behavior.type) {
+    case "oscillate": {
+      const freq = behavior.frequency;
+      const phase = behavior.phase ?? 0;
+      const angle = 2 * Math.PI * freq * t + phase;
+      let waveVal = 0;
+      switch (behavior.wave) {
+        case "square":
+          waveVal = Math.sin(angle) >= 0 ? 1 : -1;
+          break;
+        case "triangle":
+          waveVal = 2 / Math.PI * Math.asin(Math.sin(angle));
+          break;
+        case "sawtooth": {
+          const norm = angle / (2 * Math.PI) % 1;
+          waveVal = 2 * (norm < 0 ? norm + 1 : norm) - 1;
+          break;
+        }
+        case "sine":
+        default:
+          waveVal = Math.sin(angle);
+          break;
+      }
+      const offset = waveVal * behavior.amplitude;
+      return behavior.center !== void 0 ? behavior.center + offset : baseValue + offset;
+    }
+    case "ramp": {
+      const from = behavior.from ?? baseValue;
+      const to = behavior.to;
+      const p = durationSec > 0 ? Math.min(1, Math.max(0, t / durationSec)) : 1;
+      let eased = p;
+      switch (behavior.ease) {
+        case "easeIn":
+          eased = p * p;
+          break;
+        case "easeOut":
+          eased = p * (2 - p);
+          break;
+        case "easeInOut":
+          eased = p < 0.5 ? 2 * p * p : -1 + (4 - 2 * p) * p;
+          break;
+        case "linear":
+        default:
+          eased = p;
+          break;
+      }
+      return from + (to - from) * eased;
+    }
+    case "rate": {
+      return baseValue + behavior.rate * t;
+    }
+    case "wriggle": {
+      const wander = evaluateWriggle(
+        t,
+        behavior.frequency,
+        behavior.amount,
+        behavior.octaves ?? 3,
+        behavior.seed ?? 42
+      );
+      return baseValue + wander;
+    }
+    case "overshoot": {
+      const from = behavior.startValue ?? baseValue;
+      const target = behavior.targetValue;
+      const cycles = behavior.cycles ?? 3;
+      const damping = behavior.damping ?? 4;
+      if (durationSec <= 0) return target;
+      const p = Math.min(1, t / durationSec);
+      if (p >= 1) return target;
+      const envelope = Math.exp(-damping * p);
+      const oscillation = Math.cos(cycles * Math.PI * p);
+      const progress = 1 - envelope * oscillation;
+      return from + (target - from) * progress;
+    }
+    case "throw": {
+      const v0 = behavior.initialVelocity;
+      const k = Math.max(1e-3, behavior.friction ?? 2);
+      const displacement = v0 / k * (1 - Math.exp(-k * t));
+      return baseValue + displacement;
+    }
+  }
+}
+
+// src/scene/report.ts
+function reviewScene(scene, logs, options = {}) {
+  const warnings = [];
+  const notes = [];
+  const minTextPx = options.minTextPx ?? 18;
+  const totalMs = logs.length > 0 ? logs[logs.length - 1].end : 0;
+  const totalSec = (totalMs / 1e3).toFixed(1);
+  if (scene.target) {
+    const [minS, maxS] = scene.target;
+    const durS = totalMs / 1e3;
+    if (durS < minS) {
+      warnings.push(`Scene is ${totalSec}s, shorter than target minimum (${minS}s).`);
+    } else if (durS > maxS) {
+      warnings.push(`Scene is ${totalSec}s, longer than target maximum (${maxS}s).`);
+    }
+  }
+  for (const log of logs) {
+    const shotPrefix = `Shot ${log.index}:`;
+    if (log.failed.length > 0) {
+      warnings.push(`${shotPrefix} ${log.failed.length} command(s) failed: ${log.failed.join(", ")}`);
+    }
+    for (const f of log.framing) {
+      warnings.push(`${shotPrefix} element "${f.id}" is ${f.how} of the camera frame.`);
+    }
+    for (const [a, b] of log.overlaps) {
+      notes.push(`${shotPrefix} elements "${a}" and "${b}" overlap significantly.`);
+    }
+    if (log.smallTexts) {
+      for (const t of log.smallTexts) {
+        if (t.px < minTextPx) {
+          warnings.push(`${shotPrefix} text "${t.text}" is only ${t.px}px on screen (less than ${minTextPx}px minimum).`);
+        }
+      }
+    }
+    for (const id of log.underTitle) {
+      warnings.push(`${shotPrefix} element "${id}" is partially covered by the title bar.`);
+    }
+  }
+  const lines = [
+    `# Scene Preview Review: ${scene.title || scene.name}`,
+    `**Total Duration:** ${totalSec}s (${logs.length} shots)`,
+    ""
+  ];
+  if (warnings.length > 0) {
+    lines.push("### \u26A0\uFE0F Warnings to Address:");
+    for (const w of warnings) lines.push(`- ${w}`);
+    lines.push("");
+  } else {
+    lines.push("\u2705 No critical layout or framing warnings.");
+    lines.push("");
+  }
+  if (notes.length > 0) {
+    lines.push("### \u2139\uFE0F Layout Notes:");
+    for (const n of notes) lines.push(`- ${n}`);
+    lines.push("");
+  }
+  lines.push("### Shot Breakdown");
+  lines.push("| Shot | Start | End | Duration | Title / Caption |");
+  lines.push("|:---:|:---:|:---:|:---:|:---|");
+  for (const log of logs) {
+    const dur = ((log.end - log.start) / 1e3).toFixed(1);
+    const text = log.title || log.caption || "\u2014";
+    lines.push(`| ${log.index} | ${(log.start / 1e3).toFixed(1)}s | ${(log.end / 1e3).toFixed(1)}s | ${dur}s | ${text.slice(0, 40)} |`);
+  }
+  return {
+    totalMs,
+    warnings,
+    notes,
+    markdown: lines.join("\n")
+  };
+}
+
+// src/scene/player.ts
+var MemorySceneBoard = class {
+  view;
+  elMap = /* @__PURE__ */ new Map();
+  currentTitle = "";
+  currentCaption = "";
+  runningEffects = [];
+  constructor(stage = DEFAULT_STAGE) {
+    this.view = viewAt(stage.width / 2, stage.height / 2, 1, stage);
+  }
+  getView() {
+    return this.view;
+  }
+  setView(view) {
+    this.view = view;
+  }
+  elements() {
+    return Array.from(this.elMap.values());
+  }
+  runCommand(cmd) {
+    if (isElementCommand(cmd)) {
+      this.elMap.set(cmd.element.id, { ...cmd.element });
+    } else if (isUpdateCommand(cmd)) {
+      const existing = this.elMap.get(cmd.id);
+      if (existing) {
+        this.elMap.set(cmd.id, { ...existing, ...cmd.props });
+      }
+    } else if (isDeleteCommand(cmd)) {
+      this.elMap.delete(cmd.id);
+    } else if (cmd.type === "clear") {
+      this.elMap.clear();
+    }
+  }
+  setTitle(text) {
+    this.currentTitle = text;
+  }
+  setCaption(text) {
+    this.currentCaption = text;
+  }
+  setEffects(effects) {
+    this.runningEffects = effects;
+  }
+};
+function shotView(shot, elements, stage, current) {
+  const camera = shot.camera;
+  if (!camera) return void 0;
+  let view = { zoom: current.zoom, scrollX: current.scrollX, scrollY: current.scrollY };
+  let framed;
+  if ("frame" in camera) {
+    const frameIds = new Set(camera.frame);
+    const targetElements = elements.filter((el) => frameIds.has(el.id));
+    if (targetElements.length === 0) {
+      for (const cmd of shot.run ?? []) {
+        if (isElementCommand(cmd) && frameIds.has(cmd.element.id)) targetElements.push(cmd.element);
+      }
+    }
+    framed = calculateFramingRect(targetElements, stage, {
+      padding: camera.padding,
+      minWidth: camera.minWidth,
+      minHeight: camera.minHeight
+    });
+  } else if ("width" in camera) {
+    framed = camera;
+  }
+  if (framed) view = frame(framed, stage);
+  const angle = cameraAngle({
+    tilt: camera.tilt ?? current.tilt,
+    turn: camera.turn ?? current.turn,
+    roll: camera.roll ?? current.roll,
+    perspective: camera.perspective ?? current.perspective
+  });
+  const angled = { ...view, ...angle };
+  return framed && isAngled(angled) ? fitAngled(angled, framed, stage) : angled;
+}
+function fitAngled(view, box, stage) {
+  const [cx, cy] = centreOf(view, stage);
+  const halfW = stage.width / 2;
+  const halfH = boardHeight(stage) / 2;
+  let fitted = view;
+  for (let i = 0; i < 4; i++) {
+    let spread = 0;
+    for (const corner of [[box.x, box.y], [box.x + box.width, box.y], [box.x, box.y + box.height], [box.x + box.width, box.y + box.height]]) {
+      const p = projectPoint(fitted, stage, corner);
+      spread = p ? Math.max(spread, Math.abs(p[0] - halfW) / halfW, Math.abs(p[1] - halfH) / halfH) : Infinity;
+      if (!p) break;
+    }
+    if (spread <= 1.001) break;
+    const zoom = fitted.zoom / (Number.isFinite(spread) ? spread : 2);
+    fitted = { ...fitted, ...viewAt(cx, cy, zoom, stage) };
+  }
+  return fitted;
+}
+async function playScene(scene, board, clock, options = {}) {
+  const stage = {
+    width: scene.stage?.width ?? DEFAULT_STAGE.width,
+    height: scene.stage?.height ?? DEFAULT_STAGE.height,
+    caption: scene.stage?.caption ?? DEFAULT_STAGE.caption
+  };
+  const shots = [];
+  const begin = clock.now();
+  let runningEffects = [];
+  const endsAt = /* @__PURE__ */ new Map();
+  const updateEffects = (next) => {
+    runningEffects = next.filter((r) => !effectGone(r, clock.now()));
+    board.setEffects?.(runningEffects);
+  };
+  for (const [idx, shot] of scene.shots.entries()) {
+    const shotStart = clock.now() - begin;
+    const failedCmds = [];
+    const stopIds = new Set(shot.stopEffects ?? []);
+    if (stopIds.size > 0 || runningEffects.some((r) => endsAt.get(r) === idx)) {
+      const now = clock.now();
+      updateEffects(
+        runningEffects.map(
+          (r) => r.until === void 0 && (stopIds.has(r.effect.id) || endsAt.get(r) === idx) ? { ...r, until: now } : r
+        )
+      );
+    }
+    const targetView = shotView(shot, board.elements(), stage, board.getView());
+    if (targetView) {
+      if (idx === 0) {
+        board.setView(targetView);
+      } else {
+        const fromView = board.getView();
+        const strength = shot.camera?.motionBlur ?? 0;
+        const steps = 15;
+        const stepMs = CAMERA_MS / steps;
+        let last = fromView;
+        for (let s = 1; s <= steps; s++) {
+          const t = easeInOutCubic(s / steps);
+          const view = between(fromView, targetView, t, stage);
+          board.setView(s < steps ? { ...view, ...moveBlur(last, view, stage, strength) } : view);
+          last = view;
+          await clock.sleep(stepMs);
+        }
+      }
+    }
+    if (shot.title !== void 0) {
+      board.setTitle?.(shot.title, 1);
+    }
+    if (shot.caption !== void 0) {
+      board.setCaption?.(shot.caption);
+    }
+    const startEffects = (shot.effects ?? []).filter((e) => e.at === "start");
+    if (startEffects.length > 0) {
+      const now = clock.now();
+      const added = startEffects.map((effect) => ({ effect, from: now }));
+      for (const r of added) if (r.effect.shots) endsAt.set(r, idx + r.effect.shots);
+      updateEffects([...runningEffects, ...added]);
+    }
+    for (const cmd of shot.run ?? []) {
+      try {
+        await board.runCommand(cmd);
+      } catch (err) {
+        failedCmds.push(err.message || String(err));
+      }
+    }
+    const drawnEffects = (shot.effects ?? []).filter((e) => e.at !== "start");
+    if (drawnEffects.length > 0) {
+      const now = clock.now();
+      const added = drawnEffects.map((effect) => ({ effect, from: now }));
+      for (const r of added) if (r.effect.shots) endsAt.set(r, idx + r.effect.shots);
+      updateEffects([...runningEffects, ...added]);
+    }
+    const drawnTime = clock.now() - begin;
+    const check = options.check ? checkShot(shot, board.elements(), board.getView(), stage, shot.title) : { framing: [], overlaps: [], edges: [], underTitle: [] };
+    const holdMs = shot.hold ?? 800;
+    const behaviors = shot.behaviors ?? [];
+    if (behaviors.length > 0) {
+      const initialProps = /* @__PURE__ */ new Map();
+      for (const b of behaviors) {
+        const key = `${b.target}:${b.property}`;
+        const el = board.elements().find((e) => e.id === b.target);
+        if (el && typeof el[b.property] === "number") {
+          initialProps.set(key, el[b.property]);
+        } else {
+          initialProps.set(key, 0);
+        }
+      }
+      const stepMs = 50;
+      const steps = Math.max(1, Math.round(holdMs / stepMs));
+      const actualStepMs = holdMs / steps;
+      const durationSec = holdMs / 1e3;
+      for (let s = 1; s <= steps; s++) {
+        await clock.sleep(actualStepMs);
+        const elapsedSec = s * actualStepMs / 1e3;
+        for (const b of behaviors) {
+          const baseVal = initialProps.get(`${b.target}:${b.property}`) ?? 0;
+          const nextVal = evaluateBehavior(b, elapsedSec, durationSec, baseVal);
+          board.runCommand({
+            type: "update",
+            id: b.target,
+            props: { [b.property]: nextVal }
+          });
+        }
+      }
+    } else {
+      await clock.sleep(holdMs);
+    }
+    const shotEnd = clock.now() - begin;
+    const log = {
+      ...check,
+      index: idx + 1,
+      start: shotStart,
+      drawn: drawnTime,
+      end: shotEnd,
+      caption: shot.caption,
+      title: shot.title,
+      failed: failedCmds,
+      effects: runningEffects.map((r) => r.effect.id)
+    };
+    shots.push(log);
+    if (options.afterShot) {
+      await options.afterShot(log);
+    }
+  }
+  const duration = clock.now() - begin;
+  const ok = shots.every((s) => s.failed.length === 0 && s.framing.every((f) => f.how !== "outside"));
+  return { ok, duration, shots };
+}
+async function simulateScene(scene, options = {}) {
+  const clock = new ManualClock();
+  const board = new MemorySceneBoard();
+  let done = false;
+  let playError = null;
+  const playPromise = playScene(scene, board, clock, { check: true }).then((res) => {
+    done = true;
+    return res;
+  }).catch((err) => {
+    done = true;
+    playError = err;
+    throw err;
+  });
+  for (let i = 0; i < 5e3 && !done; i++) {
+    await clock.advance(50);
+  }
+  if (playError) throw playError;
+  const result = await playPromise;
+  const review = reviewScene(scene, result.shots, {
+    target: scene.target,
+    minTextPx: options.minTextPx
+  });
+  return { result, review };
+}
+
+// src/scene/cameratrack.ts
+function sceneStage(scene) {
+  return {
+    width: scene.stage?.width ?? DEFAULT_STAGE.width,
+    height: scene.stage?.height ?? DEFAULT_STAGE.height,
+    caption: scene.stage?.caption ?? DEFAULT_STAGE.caption
+  };
+}
+function cameraTrack(scene) {
+  const stage = sceneStage(scene);
+  const board = new MemorySceneBoard(stage);
+  let view = viewAt(stage.width / 2, (stage.height - (stage.caption ?? 0)) / 2, 1, stage);
+  let startMs = 0;
+  return scene.shots.map((shot, index) => {
+    const target = shotView(shot, board.elements(), stage, view);
+    const moveMs = index > 0 && shot.camera ? CAMERA_MS : 0;
+    const from = index === 0 && target ? target : view;
+    const to = target ?? view;
+    const holdMs = shot.hold ?? 800;
+    for (const cmd of shot.run ?? []) board.runCommand(cmd);
+    const entry = {
+      shot,
+      index,
+      startMs,
+      moveMs,
+      holdMs,
+      from,
+      to,
+      motionBlur: shot.camera?.motionBlur ?? 0,
+      elements: board.elements().map((e) => ({ ...e }))
+    };
+    view = to;
+    startMs += moveMs + holdMs;
+    return entry;
+  });
+}
+var CAMERA_STEP_MS = CAMERA_MS / 15;
+function cameraAt(entry, ms, stage) {
+  if (!(entry.moveMs > 0) || ms >= entry.moveMs) return entry.to;
+  const u = Math.max(0, ms) / entry.moveMs;
+  const view = between(entry.from, entry.to, easeInOutCubic(u), stage);
+  if (!(entry.motionBlur > 0)) return view;
+  const before = between(entry.from, entry.to, easeInOutCubic(Math.max(0, u - CAMERA_STEP_MS / entry.moveMs)), stage);
+  return { ...view, ...moveBlur(before, view, stage, entry.motionBlur) };
+}
+function cameraSamples(scene, frameRate, every = 2) {
+  const stage = sceneStage(scene);
+  const samples = [];
+  const add = (sample) => {
+    if (samples.at(-1)?.frame === sample.frame) samples.pop();
+    samples.push(sample);
+  };
+  for (const entry of cameraTrack(scene)) {
+    const start = Math.round(entry.startMs / 1e3 * frameRate);
+    const moveFrames = Math.round(entry.moveMs / 1e3 * frameRate);
+    for (let f = 0; f < moveFrames; f += every) {
+      add({ frame: start + f, view: cameraAt(entry, f / frameRate * 1e3, stage), shot: entry.index });
+    }
+    add({ frame: start + moveFrames, view: entry.to, shot: entry.index });
+  }
+  return samples;
+}
+
+export {
+  hash64,
+  mixSeeds,
+  unitFloat,
+  quinticFade,
+  noise1d,
+  noise3d,
+  fractalWiggle,
+  isElementCommand,
+  isUpdateCommand,
+  isDeleteCommand,
+  boundsOf,
+  overlapArea,
+  areaOf,
+  DEFAULT_STAGE,
+  CAMERA_MS,
+  DEFAULT_PERSPECTIVE,
+  MAX_TILT,
+  boardHeight,
+  viewAt,
+  centreOf,
+  frame,
+  calculateFramingRect,
+  isAngled,
+  cameraAngle,
+  between,
+  cameraTransform,
+  cameraBlur,
+  cameraFilter,
+  projectPoint,
+  motionBlur,
+  motionBlurAngle,
+  moveBlur,
+  visibleRect,
+  easeInOutCubic,
+  NO_CHECK,
+  SMALL_TEXT_PX,
+  titleBox,
+  touchedIds,
+  screenBox,
+  checkShot,
+  EFFECT_TYPES,
+  EFFECT_FADE_MS,
+  effectGone,
+  effectOpacity,
+  evaluateBehavior,
+  reviewScene,
+  MemorySceneBoard,
+  shotView,
+  playScene,
+  simulateScene,
+  sceneStage,
+  cameraTrack,
+  CAMERA_STEP_MS,
+  cameraAt,
+  cameraSamples
+};
+//# sourceMappingURL=chunk-WAMA45G3.js.map