reframe-video 0.1.0

package/dist/index.js

@@ -0,0 +1,889 @@
+// ../core/src/ir.ts
+var DEFAULT_TO_DURATION = 0.5;
+var DEFAULT_TWEEN_DURATION = 0.5;
+var DEFAULT_FPS = 30;
+
+// ../core/src/compile.ts
+var key = (target, prop) => `${target}.${prop}`;
+function compileScene(ir) {
+  const nodeById = /* @__PURE__ */ new Map();
+  const nodeOrder = [];
+  const collect = (nodes) => {
+    for (const node of nodes) {
+      nodeById.set(node.id, node);
+      nodeOrder.push(node.id);
+      if (node.type === "group") collect(node.children);
+    }
+  };
+  collect(ir.nodes);
+  const initialValues = /* @__PURE__ */ new Map();
+  for (const [id, node] of nodeById) {
+    for (const [prop, value] of Object.entries(node.props)) {
+      if (typeof value === "number" || typeof value === "string") {
+        initialValues.set(key(id, prop), value);
+      }
+    }
+  }
+  if (ir.initial !== void 0) {
+    const override = ir.states?.[ir.initial] ?? {};
+    for (const [id, props] of Object.entries(override)) {
+      for (const [prop, value] of Object.entries(props)) {
+        initialValues.set(key(id, prop), value);
+      }
+    }
+  }
+  const segments = /* @__PURE__ */ new Map();
+  const current = new Map(initialValues);
+  const pushSegment = (seg) => {
+    const k = key(seg.target, seg.prop);
+    let list = segments.get(k);
+    if (!list) segments.set(k, list = []);
+    list.push(seg);
+    current.set(k, seg.to);
+  };
+  const currentValue = (target, prop) => {
+    const v = current.get(key(target, prop));
+    if (v !== void 0) return v;
+    if (prop === "opacity" || prop === "scale" || prop === "progress") return 1;
+    if (prop === "rotation") return 0;
+    throw new Error(`cannot animate "${prop}" of "${target}": no base value to start from`);
+  };
+  const labelTimes = /* @__PURE__ */ new Map();
+  const walk = (tl, start) => {
+    const end = walkInner(tl, start);
+    if ("label" in tl && tl.label !== void 0) labelTimes.set(tl.label, { t0: start, t1: end });
+    return end;
+  };
+  const walkInner = (tl, start) => {
+    switch (tl.kind) {
+      case "seq": {
+        let t = start;
+        for (const child of tl.children) t = walk(child, t);
+        return t;
+      }
+      case "par": {
+        let end = start;
+        for (const child of tl.children) end = Math.max(end, walk(child, start));
+        return end;
+      }
+      case "stagger": {
+        let end = start;
+        tl.children.forEach((child, i) => {
+          end = Math.max(end, walk(child, start + i * tl.interval));
+        });
+        return end;
+      }
+      case "wait":
+        return start + tl.duration;
+      case "tween": {
+        const duration = tl.duration ?? DEFAULT_TWEEN_DURATION;
+        for (const [prop, toValue] of Object.entries(tl.props)) {
+          pushSegment({
+            target: tl.target,
+            prop,
+            t0: start,
+            t1: start + duration,
+            from: currentValue(tl.target, prop),
+            to: toValue,
+            ...tl.ease !== void 0 && { ease: tl.ease }
+          });
+        }
+        return start + duration;
+      }
+      case "to": {
+        const override = ir.states?.[tl.state] ?? {};
+        const duration = tl.duration ?? DEFAULT_TO_DURATION;
+        const staggerInterval = tl.stagger ?? 0;
+        const targets = nodeOrder.filter(
+          (id) => id in override && (tl.filter === void 0 || tl.filter.includes(id))
+        );
+        targets.forEach((id, i) => {
+          const t0 = start + i * staggerInterval;
+          for (const [prop, toValue] of Object.entries(override[id])) {
+            pushSegment({
+              target: id,
+              prop,
+              t0,
+              t1: t0 + duration,
+              from: currentValue(id, prop),
+              to: toValue,
+              ...tl.ease !== void 0 && { ease: tl.ease }
+            });
+          }
+        });
+        const last = Math.max(0, targets.length - 1);
+        return start + duration + last * staggerInterval;
+      }
+    }
+  };
+  const inferredEnd = ir.timeline ? walk(ir.timeline, 0) : 0;
+  for (const list of segments.values()) list.sort((a, b) => a.t0 - b.t0);
+  return {
+    ir,
+    duration: ir.duration ?? inferredEnd,
+    segments,
+    initialValues,
+    nodeById,
+    nodeOrder,
+    labelTimes
+  };
+}
+
+// ../core/src/validate.ts
+var COMMON_PROPS = ["x", "y", "opacity", "rotation", "scale", "anchor"];
+var PROPS_BY_TYPE = {
+  rect: [...COMMON_PROPS, "width", "height", "fill", "stroke", "strokeWidth", "radius"],
+  ellipse: [...COMMON_PROPS, "width", "height", "fill", "stroke", "strokeWidth"],
+  line: ["x1", "y1", "x2", "y2", "stroke", "strokeWidth", "opacity", "progress"],
+  text: [...COMMON_PROPS, "content", "contentDecimals", "fontFamily", "fontSize", "fontWeight", "fill", "letterSpacing"],
+  group: COMMON_PROPS
+};
+var SceneValidationError = class extends Error {
+  constructor(problems) {
+    super(`Scene validation failed:
+${problems.map((p) => `  - ${p}`).join("\n")}`);
+    this.problems = problems;
+    this.name = "SceneValidationError";
+  }
+  problems;
+};
+function validateScene(ir) {
+  const problems = [];
+  const nodeById = /* @__PURE__ */ new Map();
+  const collect = (nodes) => {
+    for (const node of nodes) {
+      if (nodeById.has(node.id)) {
+        problems.push(`duplicate node id "${node.id}" \u2014 every node id must be unique`);
+      }
+      nodeById.set(node.id, node);
+      if (node.type === "group") collect(node.children);
+    }
+  };
+  collect(ir.nodes);
+  const checkProps = (where, nodeId, props) => {
+    const node = nodeById.get(nodeId);
+    if (!node) {
+      problems.push(
+        `${where} targets unknown node "${nodeId}" \u2014 known ids: ${[...nodeById.keys()].join(", ")}`
+      );
+      return;
+    }
+    const allowed = PROPS_BY_TYPE[node.type];
+    for (const key2 of Object.keys(props)) {
+      if (!allowed.includes(key2)) {
+        problems.push(
+          `${where}: "${key2}" is not a prop of ${node.type} "${nodeId}" \u2014 valid props: ${allowed.join(", ")}`
+        );
+      }
+    }
+  };
+  const states = ir.states ?? {};
+  for (const [stateName, overrides] of Object.entries(states)) {
+    for (const [nodeId, props] of Object.entries(overrides)) {
+      checkProps(`state "${stateName}"`, nodeId, props);
+    }
+  }
+  if (ir.initial !== void 0 && !(ir.initial in states)) {
+    problems.push(
+      `initial state "${ir.initial}" is not defined \u2014 defined states: ${Object.keys(states).join(", ") || "(none)"}`
+    );
+  }
+  const labels = /* @__PURE__ */ new Set();
+  const checkTimeline = (tl, path) => {
+    if ("label" in tl && tl.label !== void 0) {
+      if (labels.has(tl.label)) {
+        problems.push(
+          `${path}: duplicate timeline label "${tl.label}" \u2014 labels are overlay addresses and must be unique`
+        );
+      }
+      labels.add(tl.label);
+    }
+    switch (tl.kind) {
+      case "seq":
+      case "par":
+        tl.children.forEach((c, i) => checkTimeline(c, `${path}.${tl.kind}[${i}]`));
+        break;
+      case "stagger":
+        if (tl.interval < 0) problems.push(`${path}: stagger interval must be >= 0`);
+        tl.children.forEach((c, i) => checkTimeline(c, `${path}.stagger[${i}]`));
+        break;
+      case "to":
+        if (!(tl.state in states)) {
+          problems.push(
+            `${path}: to("${tl.state}") references an undefined state \u2014 defined states: ${Object.keys(states).join(", ") || "(none)"}`
+          );
+        }
+        if (tl.duration !== void 0 && tl.duration <= 0) {
+          problems.push(`${path}: to("${tl.state}") duration must be > 0`);
+        }
+        for (const id of tl.filter ?? []) {
+          if (!nodeById.has(id)) problems.push(`${path}: filter contains unknown node "${id}"`);
+        }
+        break;
+      case "tween":
+        checkProps(path, tl.target, tl.props);
+        if (tl.duration !== void 0 && tl.duration <= 0) {
+          problems.push(`${path}: tween duration must be > 0`);
+        }
+        break;
+      case "wait":
+        if (tl.duration < 0) problems.push(`${path}: wait duration must be >= 0`);
+        break;
+    }
+  };
+  if (ir.timeline) checkTimeline(ir.timeline, "timeline");
+  for (const [i, b] of (ir.behaviors ?? []).entries()) {
+    checkProps(`behaviors[${i}]`, b.target, { [b.prop]: 0 });
+  }
+  if (ir.duration !== void 0 && ir.duration <= 0) {
+    problems.push("scene duration must be > 0");
+  }
+  const SFX_NAMES = ["whoosh", "pop", "tick", "rise", "shimmer", "thud"];
+  for (const [i, cue] of (ir.audio?.cues ?? []).entries()) {
+    if (typeof cue.at === "string" && !labels.has(cue.at)) {
+      problems.push(
+        `audio.cues[${i}]: unknown timeline label "${cue.at}" \u2014 known labels: ${[...labels].join(", ") || "(none)"}`
+      );
+    }
+    if (typeof cue.at === "number" && cue.at < 0) {
+      problems.push(`audio.cues[${i}]: "at" must be >= 0`);
+    }
+    if (cue.sfx === void 0 === (cue.file === void 0)) {
+      problems.push(`audio.cues[${i}]: exactly one of "sfx" or "file" is required`);
+    }
+    if (cue.sfx !== void 0 && !SFX_NAMES.includes(cue.sfx)) {
+      problems.push(`audio.cues[${i}]: unknown sfx "${cue.sfx}" \u2014 valid: ${SFX_NAMES.join(", ")}`);
+    }
+    if (cue.gain !== void 0 && cue.gain < 0) {
+      problems.push(`audio.cues[${i}]: gain must be >= 0`);
+    }
+  }
+  const duck = ir.audio?.bgm?.duck;
+  if (typeof duck === "object" && duck !== null && duck.depth !== void 0 && (duck.depth < 0 || duck.depth > 1)) {
+    problems.push("audio.bgm.duck.depth must be in [0, 1]");
+  }
+  if (ir.audio?.bgm?.file !== void 0 && ir.audio.bgm.synth !== void 0) {
+    problems.push('audio.bgm: use either "file" or "synth", not both');
+  }
+  if (problems.length > 0) throw new SceneValidationError(problems);
+}
+
+// ../core/src/dsl.ts
+function scene(input) {
+  const ir = { version: 1, ...input };
+  validateScene(ir);
+  if (ir.duration === void 0 && ir.timeline) {
+    ir.duration = compileScene(ir).duration;
+  }
+  return ir;
+}
+function rect(props) {
+  const { id, ...rest } = props;
+  return { type: "rect", id, props: rest };
+}
+function ellipse(props) {
+  const { id, ...rest } = props;
+  return { type: "ellipse", id, props: rest };
+}
+function line(props) {
+  const { id, ...rest } = props;
+  return { type: "line", id, props: rest };
+}
+function text(props) {
+  const { id, ...rest } = props;
+  return { type: "text", id, props: rest };
+}
+function group(props, children) {
+  const { id, ...rest } = props;
+  return { type: "group", id, props: rest, children };
+}
+function seq(...children) {
+  return { kind: "seq", children };
+}
+function par(...children) {
+  return { kind: "par", children };
+}
+function stagger(interval, ...children) {
+  return { kind: "stagger", interval, children };
+}
+function to(state, opts = {}) {
+  return { kind: "to", state, ...opts };
+}
+function tween(target, props, opts = {}) {
+  return { kind: "tween", target, props, ...opts };
+}
+function wait(duration, label) {
+  return { kind: "wait", duration, ...label !== void 0 && { label } };
+}
+function oscillate(target, prop, params, window = {}) {
+  return { target, prop, ...window, behavior: { kind: "named", name: "oscillate", params } };
+}
+function wiggle(target, prop, params, window = {}) {
+  return { target, prop, ...window, behavior: { kind: "named", name: "wiggle", params } };
+}
+
+// ../core/src/compose.ts
+var SCENE_PATCHABLE = ["background", "duration", "fps"];
+function composeScene(base, ...overlays) {
+  const ir = structuredClone(base);
+  const report = { applied: [], orphans: [], warnings: [] };
+  overlays.forEach((overlay, index) => {
+    const layer = overlay.name ?? `overlay-${index}`;
+    if (overlay.target !== void 0 && overlay.target !== ir.id) {
+      report.warnings.push(
+        `${layer}: authored against scene "${overlay.target}" but composing onto "${ir.id}"`
+      );
+    }
+    applyOverlay(ir, overlay, layer, report);
+  });
+  validateScene(ir);
+  return { ir, report };
+}
+function applyOverlay(ir, overlay, layer, report) {
+  const nodeById = /* @__PURE__ */ new Map();
+  const collect = (nodes) => {
+    for (const node of nodes) {
+      nodeById.set(node.id, node);
+      if (node.type === "group") collect(node.children);
+    }
+  };
+  collect(ir.nodes);
+  const knownIds = () => [...nodeById.keys()].join(", ");
+  const orphan = (address, reason) => report.orphans.push({ layer, address, reason });
+  const applied = (address, action) => report.applied.push({ layer, address, action });
+  const patchProps = (address, node, target, patch) => {
+    const allowed = PROPS_BY_TYPE[node.type];
+    for (const [prop, value] of Object.entries(patch)) {
+      if (!allowed.includes(prop)) {
+        orphan(
+          `${address}.${prop}`,
+          `"${prop}" is not a prop of ${node.type} "${node.id}" \u2014 the base may have changed this node's type; valid props: ${allowed.join(", ")}`
+        );
+        continue;
+      }
+      if (value === null) {
+        delete target[prop];
+        applied(`${address}.${prop}`, "unset");
+      } else {
+        target[prop] = value;
+        applied(`${address}.${prop}`, "set");
+      }
+    }
+  };
+  if (overlay.scene) {
+    for (const key2 of SCENE_PATCHABLE) {
+      const value = overlay.scene[key2];
+      if (value !== void 0) {
+        ir[key2] = value;
+        applied(`scene.${key2}`, "set");
+      }
+    }
+  }
+  for (const [id, patch] of Object.entries(overlay.nodes ?? {})) {
+    const node = nodeById.get(id);
+    if (!node) {
+      orphan(
+        `nodes.${id}`,
+        `unknown node "${id}" \u2014 known ids: ${knownIds()}; did the base regeneration rename it?`
+      );
+      continue;
+    }
+    patchProps(`nodes.${id}`, node, node.props, patch);
+  }
+  for (const [stateName, statePatch] of Object.entries(overlay.states ?? {})) {
+    const state = ir.states?.[stateName];
+    if (!state) {
+      orphan(
+        `states.${stateName}`,
+        `unknown state "${stateName}" \u2014 defined states: ${Object.keys(ir.states ?? {}).join(", ") || "(none)"}`
+      );
+      continue;
+    }
+    for (const [id, patch] of Object.entries(statePatch)) {
+      const node = nodeById.get(id);
+      if (!node) {
+        orphan(
+          `states.${stateName}.${id}`,
+          `unknown node "${id}" \u2014 known ids: ${knownIds()}; did the base regeneration rename it?`
+        );
+        continue;
+      }
+      const target = state[id] ??= {};
+      patchProps(`states.${stateName}.${id}`, node, target, patch);
+    }
+  }
+  if (overlay.behaviors?.remove || overlay.behaviors?.set) {
+    ir.behaviors ??= [];
+    for (const { target, prop } of overlay.behaviors.remove ?? []) {
+      const index = ir.behaviors.findIndex((b) => b.target === target && b.prop === prop);
+      if (index < 0) {
+        orphan(
+          `behaviors.remove.${target}.${prop}`,
+          `no behavior on "${target}.${prop}" to remove`
+        );
+        continue;
+      }
+      ir.behaviors.splice(index, 1);
+      applied(`behaviors.${target}.${prop}`, "behavior-remove");
+    }
+    for (const behavior of overlay.behaviors.set ?? []) {
+      if (!nodeById.has(behavior.target)) {
+        orphan(
+          `behaviors.set.${behavior.target}.${behavior.prop}`,
+          `unknown node "${behavior.target}" \u2014 known ids: ${knownIds()}`
+        );
+        continue;
+      }
+      const index = ir.behaviors.findIndex(
+        (b) => b.target === behavior.target && b.prop === behavior.prop
+      );
+      if (index >= 0) ir.behaviors[index] = structuredClone(behavior);
+      else ir.behaviors.push(structuredClone(behavior));
+      applied(`behaviors.${behavior.target}.${behavior.prop}`, "behavior-set");
+    }
+  }
+  if (overlay.timeline) {
+    const byLabel = /* @__PURE__ */ new Map();
+    const walkTimeline = (tl) => {
+      if ("label" in tl && tl.label !== void 0) byLabel.set(tl.label, tl);
+      if ("children" in tl) tl.children.forEach(walkTimeline);
+    };
+    if (ir.timeline) walkTimeline(ir.timeline);
+    const PATCHABLE = {
+      to: ["duration", "ease", "stagger"],
+      tween: ["duration", "ease"],
+      wait: ["duration"]
+    };
+    let timingPatched = false;
+    for (const [label, patch] of Object.entries(overlay.timeline)) {
+      const step = byLabel.get(label);
+      if (!step) {
+        orphan(
+          `timeline.${label}`,
+          `unknown timeline label "${label}" \u2014 known labels: ${[...byLabel.keys()].join(", ") || "(none)"}; did the base regeneration drop it?`
+        );
+        continue;
+      }
+      const allowed = PATCHABLE[step.kind] ?? [];
+      for (const [key2, value] of Object.entries(patch)) {
+        if (value === void 0) continue;
+        if (!allowed.includes(key2)) {
+          orphan(
+            `timeline.${label}.${key2}`,
+            `"${key2}" is not patchable on a ${step.kind} step \u2014 patchable: ${allowed.join(", ")}`
+          );
+          continue;
+        }
+        step[key2] = value;
+        applied(`timeline.${label}.${key2}`, "set");
+        if (key2 === "duration" || key2 === "stagger") timingPatched = true;
+      }
+    }
+    if (timingPatched && overlay.scene?.duration === void 0) {
+      delete ir.duration;
+      ir.duration = compileScene(ir).duration;
+    }
+  }
+  for (const node of overlay.addNodes ?? []) {
+    ir.nodes.push(structuredClone(node));
+    nodeById.set(node.id, node);
+    applied(`addNodes.${node.id}`, "add-node");
+  }
+}
+function formatComposeReport(report) {
+  const lines = [];
+  lines.push(
+    `compose: ${report.applied.length} applied, ${report.orphans.length} orphaned, ${report.warnings.length} warnings`
+  );
+  for (const a of report.applied) lines.push(`  \u2713 [${a.layer}] ${a.address} (${a.action})`);
+  for (const o of report.orphans) lines.push(`  \u2717 [${o.layer}] ${o.address}: ${o.reason}`);
+  for (const w of report.warnings) lines.push(`  ! ${w}`);
+  return lines.join("\n");
+}
+
+// ../core/src/audio.ts
+var SFX_DURATION = {
+  whoosh: 0.35,
+  pop: 0.12,
+  tick: 0.03,
+  rise: 0.5,
+  shimmer: 0.9,
+  thud: 0.25
+};
+var FILE_CUE_DURATION = 0.4;
+function resolveAudioPlan(compiled) {
+  const audio = compiled.ir.audio;
+  if (!audio || !audio.bgm && (audio.cues ?? []).length === 0) return null;
+  const warnings = [];
+  const duration = compiled.duration;
+  const cues = [];
+  for (const [index, cue] of (audio.cues ?? []).entries()) {
+    let anchor;
+    if (typeof cue.at === "number") {
+      anchor = cue.at;
+    } else {
+      const span = compiled.labelTimes.get(cue.at);
+      if (!span) {
+        warnings.push(`cue[${index}]: unknown label "${cue.at}" \u2014 cue dropped`);
+        continue;
+      }
+      anchor = span.t0;
+    }
+    const t = Math.max(0, anchor + (cue.offset ?? 0));
+    const cueDuration = cue.sfx ? SFX_DURATION[cue.sfx] : FILE_CUE_DURATION;
+    if (t >= duration) {
+      warnings.push(`cue[${index}] at ${t.toFixed(2)}s starts past the scene end (${duration.toFixed(2)}s) \u2014 dropped`);
+      continue;
+    }
+    if (t + cueDuration > duration) {
+      warnings.push(`cue[${index}] at ${t.toFixed(2)}s extends past the scene end \u2014 it will be truncated`);
+    }
+    cues.push({
+      t,
+      gain: cue.gain ?? 1,
+      duration: cueDuration,
+      source: cue.sfx ? { kind: "sfx", name: cue.sfx, params: cue.params ?? {} } : { kind: "file", path: cue.file }
+    });
+  }
+  cues.sort((a, b) => a.t - b.t);
+  const duckWindows = [];
+  for (const cue of cues) {
+    const window = { t0: cue.t, t1: Math.min(duration, cue.t + cue.duration) };
+    const last = duckWindows[duckWindows.length - 1];
+    if (last && window.t0 <= last.t1 + 0.1) last.t1 = Math.max(last.t1, window.t1);
+    else duckWindows.push(window);
+  }
+  let bgm = null;
+  if (audio.bgm) {
+    const b = audio.bgm;
+    const duck = b.duck === false ? null : {
+      depth: b.duck?.depth ?? 0.5,
+      attack: b.duck?.attack ?? 0.05,
+      release: b.duck?.release ?? 0.25
+    };
+    bgm = {
+      source: b.file ? { kind: "file", path: b.file } : { kind: "synth", name: b.synth ?? "ambient-pad" },
+      gain: b.gain ?? 0.5,
+      fadeIn: b.fadeIn ?? 0,
+      fadeOut: b.fadeOut ?? 0,
+      duck
+    };
+  }
+  return { duration, bgm, cues, duckWindows, warnings };
+}
+
+// ../core/src/behaviors.ts
+function sampleBehavior(b, t) {
+  switch (b.name) {
+    case "oscillate": {
+      const { amplitude, frequency, phase = 0 } = b.params;
+      return amplitude * Math.sin(2 * Math.PI * frequency * t + phase);
+    }
+    case "wiggle": {
+      const { amplitude, frequency, seed } = b.params;
+      return amplitude * valueNoise(t * frequency, seed);
+    }
+  }
+}
+function valueNoise(x, seed) {
+  const i = Math.floor(x);
+  const f = x - i;
+  const u = f * f * (3 - 2 * f);
+  const a = hash01(i, seed) * 2 - 1;
+  const b = hash01(i + 1, seed) * 2 - 1;
+  return a + (b - a) * u;
+}
+function hash01(n, seed) {
+  let h = n * 374761393 + seed * 668265263 | 0;
+  h = h ^ h >>> 13 | 0;
+  h = Math.imul(h, 1274126177);
+  h = (h ^ h >>> 16) >>> 0;
+  return h / 4294967295;
+}
+
+// ../core/src/interpolate.ts
+var EASE_TABLE = {
+  linear: (u) => u,
+  easeInQuad: (u) => u * u,
+  easeOutQuad: (u) => 1 - (1 - u) * (1 - u),
+  easeInOutQuad: (u) => u < 0.5 ? 2 * u * u : 1 - (-2 * u + 2) ** 2 / 2,
+  easeInCubic: (u) => u ** 3,
+  easeOutCubic: (u) => 1 - (1 - u) ** 3,
+  easeInOutCubic: (u) => u < 0.5 ? 4 * u ** 3 : 1 - (-2 * u + 2) ** 3 / 2,
+  easeInQuart: (u) => u ** 4,
+  easeOutQuart: (u) => 1 - (1 - u) ** 4,
+  easeInOutQuart: (u) => u < 0.5 ? 8 * u ** 4 : 1 - (-2 * u + 2) ** 4 / 2,
+  easeInExpo: (u) => u === 0 ? 0 : 2 ** (10 * u - 10),
+  easeOutExpo: (u) => u === 1 ? 1 : 1 - 2 ** (-10 * u),
+  easeInOutExpo: (u) => u === 0 ? 0 : u === 1 ? 1 : u < 0.5 ? 2 ** (20 * u - 10) / 2 : (2 - 2 ** (-20 * u + 10)) / 2
+};
+var EASE_NAMES = Object.keys(EASE_TABLE);
+function resolveEase(ease) {
+  if (ease === void 0) return EASE_TABLE.linear;
+  if (typeof ease === "string") {
+    const fn = EASE_TABLE[ease];
+    if (!fn) throw new Error(`unknown ease "${ease}" \u2014 valid: ${Object.keys(EASE_TABLE).join(", ")}`);
+    return fn;
+  }
+  return cubicBezierEase(...ease.cubicBezier);
+}
+function cubicBezierEase(x1, y1, x2, y2) {
+  const bez = (a, b) => (t) => 3 * a * t * (1 - t) ** 2 + 3 * b * t * t * (1 - t) + t ** 3;
+  const bx = bez(x1, x2);
+  const by = bez(y1, y2);
+  const dbx = (t) => 3 * x1 * (1 - t) * (1 - 3 * t) + 3 * x2 * t * (2 - 3 * t) + 3 * t * t;
+  return (u) => {
+    if (u <= 0) return 0;
+    if (u >= 1) return 1;
+    let t = u;
+    for (let i = 0; i < 8; i++) {
+      const err = bx(t) - u;
+      if (Math.abs(err) < 1e-6) return by(t);
+      const d = dbx(t);
+      if (Math.abs(d) < 1e-6) break;
+      t -= err / d;
+    }
+    let lo = 0;
+    let hi = 1;
+    t = u;
+    while (hi - lo > 1e-6) {
+      if (bx(t) < u) lo = t;
+      else hi = t;
+      t = (lo + hi) / 2;
+    }
+    return by(t);
+  };
+}
+var HEX_COLOR = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function isColor(v) {
+  return typeof v === "string" && HEX_COLOR.test(v);
+}
+function parseColor(hex) {
+  let h = hex.slice(1);
+  if (h.length <= 4) h = [...h].map((c) => c + c).join("");
+  const n = parseInt(h.padEnd(8, "f"), 16);
+  return [n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255];
+}
+function formatColor([r, g, b, a]) {
+  const hex = (v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
+  return a >= 255 ? `#${hex(r)}${hex(g)}${hex(b)}` : `#${hex(r)}${hex(g)}${hex(b)}${hex(a)}`;
+}
+function lerpValue(from, to2, u) {
+  if (typeof from === "number" && typeof to2 === "number") {
+    return from + (to2 - from) * u;
+  }
+  if (isColor(from) && isColor(to2)) {
+    const a = parseColor(from);
+    const b = parseColor(to2);
+    return formatColor([
+      a[0] + (b[0] - a[0]) * u,
+      a[1] + (b[1] - a[1]) * u,
+      a[2] + (b[2] - a[2]) * u,
+      a[3] + (b[3] - a[3]) * u
+    ]);
+  }
+  return to2;
+}
+
+// ../core/src/evaluate.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function multiply(m, n) {
+  return [
+    m[0] * n[0] + m[2] * n[1],
+    m[1] * n[0] + m[3] * n[1],
+    m[0] * n[2] + m[2] * n[3],
+    m[1] * n[2] + m[3] * n[3],
+    m[0] * n[4] + m[2] * n[5] + m[4],
+    m[1] * n[4] + m[3] * n[5] + m[5]
+  ];
+}
+function localMatrix(x, y, rotationDeg, scale) {
+  const r = rotationDeg * Math.PI / 180;
+  const cos = Math.cos(r) * scale;
+  const sin = Math.sin(r) * scale;
+  return [cos, sin, -sin, cos, x, y];
+}
+var ANCHOR_FACTORS = {
+  "top-left": [0, 0],
+  "top-center": [0.5, 0],
+  "top-right": [1, 0],
+  "center-left": [0, 0.5],
+  center: [0.5, 0.5],
+  "center-right": [1, 0.5],
+  "bottom-left": [0, 1],
+  "bottom-center": [0.5, 1],
+  "bottom-right": [1, 1]
+};
+var TEXT_ALIGN = { 0: "left", 0.5: "center", 1: "right" };
+var TEXT_BASELINE = { 0: "top", 0.5: "middle", 1: "bottom" };
+function behaviorEnvelope(b, t) {
+  const from = b.from ?? Number.NEGATIVE_INFINITY;
+  const until = b.until ?? Number.POSITIVE_INFINITY;
+  if (t < from || t > until) return 0;
+  const ramp = b.ramp ?? 0.2;
+  let envelope = 1;
+  if (Number.isFinite(from) && ramp > 0) envelope = Math.min(envelope, (t - from) / ramp);
+  if (Number.isFinite(until) && ramp > 0) envelope = Math.min(envelope, (until - t) / ramp);
+  return Math.max(0, Math.min(1, envelope));
+}
+function evaluate(compiled, t) {
+  const ops = [];
+  const valueAt = (target, prop, fallback) => {
+    let value = compiled.initialValues.get(`${target}.${prop}`) ?? fallback;
+    const segs = compiled.segments.get(`${target}.${prop}`);
+    if (segs) {
+      let active;
+      for (const seg of segs) {
+        if (seg.t0 <= t) active = seg;
+        else break;
+      }
+      if (active) {
+        if (t >= active.t1) {
+          value = active.to;
+        } else {
+          const u = resolveEase(active.ease)((t - active.t0) / (active.t1 - active.t0));
+          value = lerpValue(active.from, active.to, u);
+        }
+      }
+    }
+    for (const b of compiled.ir.behaviors ?? []) {
+      if (b.target === target && b.prop === prop && typeof value === "number") {
+        const envelope = behaviorEnvelope(b, t);
+        if (envelope > 0) value = value + envelope * sampleBehavior(b.behavior, t);
+      }
+    }
+    return value;
+  };
+  const num = (target, prop, fallback) => {
+    const v = valueAt(target, prop, fallback);
+    return typeof v === "number" ? v : fallback;
+  };
+  const str = (target, prop, fallback) => {
+    const v = valueAt(target, prop, fallback);
+    return typeof v === "string" ? v : String(v);
+  };
+  const opt = (target, prop, base) => {
+    const v = valueAt(target, prop, base ?? "");
+    return v === "" && base === void 0 ? void 0 : String(v);
+  };
+  const walk = (node, parent, parentOpacity) => {
+    const id = node.id;
+    if (node.type === "line") {
+      const opacity2 = parentOpacity * num(id, "opacity", node.props.opacity ?? 1);
+      if (opacity2 <= 0) return;
+      const progress = Math.max(0, Math.min(1, num(id, "progress", node.props.progress ?? 1)));
+      const x1 = num(id, "x1", node.props.x1);
+      const y1 = num(id, "y1", node.props.y1);
+      ops.push({
+        type: "line",
+        id,
+        transform: parent,
+        opacity: opacity2,
+        x1,
+        y1,
+        x2: x1 + (num(id, "x2", node.props.x2) - x1) * progress,
+        y2: y1 + (num(id, "y2", node.props.y2) - y1) * progress,
+        stroke: str(id, "stroke", node.props.stroke),
+        strokeWidth: num(id, "strokeWidth", node.props.strokeWidth ?? 1)
+      });
+      return;
+    }
+    const opacity = parentOpacity * num(id, "opacity", node.props.opacity ?? 1);
+    if (opacity <= 0) return;
+    const matrix = multiply(
+      parent,
+      localMatrix(
+        num(id, "x", node.props.x),
+        num(id, "y", node.props.y),
+        num(id, "rotation", node.props.rotation ?? 0),
+        num(id, "scale", node.props.scale ?? 1)
+      )
+    );
+    switch (node.type) {
+      case "group":
+        for (const child of node.children) walk(child, matrix, opacity);
+        return;
+      case "rect":
+      case "ellipse": {
+        const width = num(id, "width", node.props.width);
+        const height = num(id, "height", node.props.height);
+        const [ax, ay] = ANCHOR_FACTORS[node.props.anchor ?? "top-left"];
+        const strokeWidth = num(id, "strokeWidth", node.props.strokeWidth ?? 1);
+        const fill = opt(id, "fill", node.props.fill);
+        const stroke = opt(id, "stroke", node.props.stroke);
+        ops.push({
+          type: node.type,
+          id,
+          transform: matrix,
+          opacity,
+          width,
+          height,
+          offsetX: -width * ax,
+          offsetY: -height * ay,
+          ...fill !== void 0 && { fill },
+          ...stroke !== void 0 && { stroke, strokeWidth },
+          ...node.type === "rect" && { radius: num(id, "radius", node.props.radius ?? 0) }
+        });
+        return;
+      }
+      case "text": {
+        const [ax, ay] = ANCHOR_FACTORS[node.props.anchor ?? "top-left"];
+        const raw = valueAt(id, "content", node.props.content);
+        const decimals = Math.max(
+          0,
+          Math.round(num(id, "contentDecimals", node.props.contentDecimals ?? 0))
+        );
+        ops.push({
+          type: "text",
+          id,
+          transform: matrix,
+          opacity,
+          content: typeof raw === "number" ? raw.toFixed(decimals) : raw,
+          fontFamily: str(id, "fontFamily", node.props.fontFamily),
+          fontSize: num(id, "fontSize", node.props.fontSize),
+          fontWeight: num(id, "fontWeight", node.props.fontWeight ?? 400),
+          fill: str(id, "fill", node.props.fill ?? "#ffffff"),
+          letterSpacing: num(id, "letterSpacing", node.props.letterSpacing ?? 0),
+          align: TEXT_ALIGN[ax] ?? "left",
+          baseline: TEXT_BASELINE[ay] ?? "top"
+        });
+        return;
+      }
+    }
+  };
+  for (const node of compiled.ir.nodes) walk(node, IDENTITY, 1);
+  return ops;
+}
+export {
+  DEFAULT_FPS,
+  DEFAULT_TO_DURATION,
+  DEFAULT_TWEEN_DURATION,
+  EASE_NAMES,
+  PROPS_BY_TYPE,
+  SFX_DURATION,
+  SceneValidationError,
+  compileScene,
+  composeScene,
+  ellipse,
+  evaluate,
+  formatComposeReport,
+  group,
+  isColor,
+  lerpValue,
+  line,
+  oscillate,
+  par,
+  rect,
+  resolveAudioPlan,
+  resolveEase,
+  sampleBehavior,
+  scene,
+  seq,
+  stagger,
+  text,
+  to,
+  tween,
+  validateScene,
+  wait,
+  wiggle
+};