odori 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,889 @@
+"use client";
+import {
+  Audio,
+  DUCK_GAIN,
+  DUCK_RAMP_FRAMES,
+  Easing,
+  Fill,
+  Freeze,
+  Loop,
+  OdoriRuntime,
+  SAMPLE_RATE,
+  SafeArea,
+  Scene,
+  Stagger,
+  Video,
+  brandCssVariables,
+  chord,
+  createAssetRegistry,
+  cueId,
+  cueSamples,
+  cueSignature,
+  cueUrl,
+  defaultBrand,
+  defaultLayout,
+  defineBrand,
+  defineCue,
+  defineVideoLayout,
+  duckEnvelope,
+  entryDurationInFrames,
+  envelopeAtFrame,
+  gain,
+  gainAtFrame,
+  highPass,
+  interpolate,
+  isAssetReference,
+  isCueDefinition,
+  loop,
+  lowPass,
+  mix,
+  noise,
+  normalize,
+  note,
+  pad,
+  resolveEntryLayout,
+  sampleGainCurve,
+  seamless,
+  seconds,
+  seeded,
+  sequence,
+  shape,
+  silence,
+  sine,
+  sortCues,
+  spring,
+  step,
+  sweep,
+  trackDuration,
+  trackGainAtFrame,
+  triangle,
+  useAssets,
+  useBrand,
+  useDesignScale,
+  useFrame,
+  useLayout,
+  useReadiness,
+  useScene,
+  useSceneTransition,
+  useVideo
+} from "./chunk-2SROZSZM.js";
+import {
+  createRenderManifest
+} from "./chunk-VQLDJUK4.js";
+import {
+  canonicalJson,
+  formatTimecode,
+  framesFromDuration,
+  hashString,
+  hashValue,
+  secondsFromFrames
+} from "./chunk-PXG45HYV.js";
+
+// src/loudness.ts
+var SHELF = { frequency: 1681.974450955533, gainDb: 3.999843853973347, q: 0.7071752369554196 };
+var HIGH_PASS = { frequency: 38.13547087602444, q: 0.5003270373238773 };
+var shelfCoefficients = (sampleRate) => {
+  const amplitude = 10 ** (SHELF.gainDb / 40);
+  const omega = 2 * Math.PI * SHELF.frequency / sampleRate;
+  const alpha = Math.sin(omega) / (2 * SHELF.q);
+  const cos = Math.cos(omega);
+  const shared = 2 * Math.sqrt(amplitude) * alpha;
+  const a0 = amplitude + 1 - (amplitude - 1) * cos + shared;
+  return {
+    b0: amplitude * (amplitude + 1 + (amplitude - 1) * cos + shared) / a0,
+    b1: -2 * amplitude * (amplitude - 1 + (amplitude + 1) * cos) / a0,
+    b2: amplitude * (amplitude + 1 + (amplitude - 1) * cos - shared) / a0,
+    a1: 2 * (amplitude - 1 - (amplitude + 1) * cos) / a0,
+    a2: (amplitude + 1 - (amplitude - 1) * cos - shared) / a0
+  };
+};
+var highPassCoefficients = (sampleRate) => {
+  const omega = 2 * Math.PI * HIGH_PASS.frequency / sampleRate;
+  const alpha = Math.sin(omega) / (2 * HIGH_PASS.q);
+  const cos = Math.cos(omega);
+  const a0 = 1 + alpha;
+  return {
+    b0: (1 + cos) / 2 / a0,
+    b1: -(1 + cos) / a0,
+    b2: (1 + cos) / 2 / a0,
+    a1: -2 * cos / a0,
+    a2: (1 - alpha) / a0
+  };
+};
+var filter = (samples, { b0, b1, b2, a1, a2 }) => {
+  const output = new Float32Array(samples.length);
+  let x1 = 0;
+  let x2 = 0;
+  let y1 = 0;
+  let y2 = 0;
+  for (let index = 0; index < samples.length; index += 1) {
+    const x0 = samples[index];
+    const y0 = b0 * x0 + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+    output[index] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+  return output;
+};
+var BLOCK_SECONDS = 0.4;
+var STEP = 0.25;
+var ABSOLUTE_GATE = -70;
+var RELATIVE_GATE = -10;
+var OFFSET = -0.691;
+var loudnessOf = (meanSquares) => OFFSET + 10 * Math.log10(meanSquares.reduce((total, value) => total + value, 0) || Number.MIN_VALUE);
+var integratedLufs = (channels, sampleRate) => {
+  if (channels.length === 0 || channels[0].length === 0) return null;
+  const weighted = channels.map((channel) => filter(filter(channel, shelfCoefficients(sampleRate)), highPassCoefficients(sampleRate)));
+  const blockSize = Math.round(BLOCK_SECONDS * sampleRate);
+  const hop = Math.round(BLOCK_SECONDS * STEP * sampleRate);
+  if (weighted[0].length < blockSize) return null;
+  const blocks = [];
+  for (let start = 0; start + blockSize <= weighted[0].length; start += hop) {
+    blocks.push(
+      weighted.map((channel) => {
+        let sum = 0;
+        for (let index = start; index < start + blockSize; index += 1) sum += channel[index] * channel[index];
+        return sum / blockSize;
+      })
+    );
+  }
+  if (blocks.length === 0) return null;
+  const above = blocks.filter((block) => loudnessOf(block) > ABSOLUTE_GATE);
+  if (above.length === 0) return null;
+  const mean = above[0].map((_, channel) => above.reduce((total, block) => total + block[channel], 0) / above.length);
+  const threshold = loudnessOf(mean) + RELATIVE_GATE;
+  const gated = above.filter((block) => loudnessOf(block) > threshold);
+  if (gated.length === 0) return null;
+  const integrated = gated[0].map((_, channel) => gated.reduce((total, block) => total + block[channel], 0) / gated.length);
+  return loudnessOf(integrated);
+};
+
+// src/player.tsx
+import { useCallback as useCallback2, useMemo, useState as useState2 } from "react";
+
+// src/playback.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+var advanceFrames = (fractional, deltaMs, fps, rate = 1) => fractional + deltaMs / 1e3 * fps * rate;
+var usePlayback = ({
+  fps,
+  durationInFrames,
+  initialFrame = 0,
+  autoPlay = false,
+  loop: loop2 = true,
+  rate = 1,
+  onFrame
+}) => {
+  const [frame, setFrame] = useState(initialFrame);
+  const [playing, setPlaying] = useState(autoPlay);
+  const animation = useRef(null);
+  const previousTime = useRef(null);
+  const fractional = useRef(initialFrame);
+  const frameRef = useRef(initialFrame);
+  const commit = useCallback(
+    (next) => {
+      const clamped = Math.max(0, Math.min(Math.round(next), Math.max(0, durationInFrames - 1)));
+      frameRef.current = clamped;
+      setFrame(clamped);
+      onFrame?.(clamped);
+    },
+    [durationInFrames, onFrame]
+  );
+  useEffect(() => {
+    if (!playing) {
+      previousTime.current = null;
+      fractional.current = frameRef.current;
+      return;
+    }
+    const tick = (now) => {
+      const previous = previousTime.current ?? now;
+      previousTime.current = now;
+      fractional.current = advanceFrames(fractional.current, now - previous, fps, rate);
+      if (fractional.current >= durationInFrames) {
+        if (!loop2) {
+          commit(durationInFrames - 1);
+          setPlaying(false);
+          return;
+        }
+        fractional.current %= durationInFrames;
+      }
+      commit(Math.floor(fractional.current));
+      animation.current = requestAnimationFrame(tick);
+    };
+    animation.current = requestAnimationFrame(tick);
+    return () => {
+      if (animation.current !== null) cancelAnimationFrame(animation.current);
+    };
+  }, [commit, durationInFrames, fps, loop2, playing, rate]);
+  const seek = useCallback(
+    (next) => {
+      fractional.current = next;
+      commit(next);
+    },
+    [commit]
+  );
+  return {
+    frame,
+    playing,
+    rate,
+    play: () => setPlaying(true),
+    pause: () => setPlaying(false),
+    toggle: () => setPlaying((value) => !value),
+    seek,
+    step: (delta) => {
+      setPlaying(false);
+      seek(frameRef.current + delta);
+    },
+    restart: () => {
+      seek(0);
+      setPlaying(true);
+    }
+  };
+};
+
+// src/audio-playback.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+var useAudioPlayback = ({
+  track,
+  frame,
+  fps,
+  playing,
+  muted = false,
+  masterGain = 1,
+  soloCue = null,
+  scrubbing = false,
+  rate = 1,
+  onBlocked,
+  onFailed
+}) => {
+  const elements = useRef2(/* @__PURE__ */ new Map());
+  const sync = useRef2(() => {
+  });
+  const failed = useRef2(/* @__PURE__ */ new Set());
+  useEffect2(() => {
+    const table = elements.current;
+    const live = new Set((track?.cues ?? []).map((cue) => cue.id));
+    for (const [id, element] of table) {
+      if (live.has(id)) continue;
+      element.pause();
+      table.delete(id);
+    }
+    return () => {
+      for (const element of table.values()) element.pause();
+    };
+  }, [track]);
+  useEffect2(() => {
+    if (typeof window === "undefined") return;
+    const table = elements.current;
+    const onTimeUpdate = () => run();
+    const run = () => {
+      const audible = playing || scrubbing;
+      for (const cue of track?.cues ?? []) {
+        let element = table.get(cue.id);
+        if (!element) {
+          element = new window.Audio(cue.src);
+          element.preload = "auto";
+          element.loop = cue.loop;
+          element.addEventListener("timeupdate", onTimeUpdate);
+          element.addEventListener("error", () => {
+            failed.current.add(cue.src);
+            onFailed?.([...failed.current]);
+          });
+          table.set(cue.id, element);
+        }
+        const local = frame - cue.fromFrame;
+        const inside = local >= 0 && local < cue.durationInFrames;
+        const span = element.duration;
+        const elapsed = local / fps;
+        const position = cue.loop && Number.isFinite(span) && span > 0 ? elapsed % span : elapsed;
+        if (element.loop !== cue.loop) element.loop = cue.loop;
+        element.volume = Math.max(0, Math.min(1, trackGainAtFrame(cue, track?.cues ?? [], frame) * masterGain));
+        element.muted = muted || soloCue !== null && soloCue !== cue.id;
+        if (!inside || !audible) {
+          if (!element.paused) element.pause();
+          if (inside && !audible) {
+            const target2 = cue.trimStartSeconds + position;
+            if (Math.abs(element.currentTime - target2) > 1 / fps) element.currentTime = target2;
+          }
+          continue;
+        }
+        const target = cue.trimStartSeconds + position;
+        if (element.playbackRate !== rate) element.playbackRate = rate;
+        if (Math.abs(element.currentTime - target) > 2 / fps * Math.max(1, rate)) element.currentTime = target;
+        if (element.paused) {
+          void element.play().then(
+            () => onBlocked?.(false),
+            (error) => onBlocked?.(error?.name === "NotAllowedError")
+          );
+        }
+      }
+    };
+    sync.current = run;
+    run();
+    return () => {
+      for (const element of table.values()) element.removeEventListener("timeupdate", onTimeUpdate);
+    };
+  }, [fps, frame, masterGain, muted, onBlocked, onFailed, playing, rate, scrubbing, soloCue, track]);
+  useEffect2(() => {
+    if (typeof document === "undefined") return;
+    const onVisibility = () => {
+      if (document.hidden) {
+        for (const element of elements.current.values()) element.pause();
+        return;
+      }
+      sync.current();
+    };
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => document.removeEventListener("visibilitychange", onVisibility);
+  }, []);
+};
+
+// src/player.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var Player = ({
+  entry,
+  input,
+  prepared,
+  assets,
+  layout,
+  initialFrame = 0,
+  autoPlay = false,
+  loop: loop2 = true,
+  controls = true,
+  muted = false,
+  style,
+  onFrame,
+  onTimeline,
+  onAudio
+}) => {
+  const resolvedLayout = resolveEntryLayout(entry, layout);
+  const { fps, width, height } = resolvedLayout.format;
+  const [timeline, setTimeline] = useState2(null);
+  const [track, setTrack] = useState2(null);
+  const declared = entryDurationInFrames(entry, resolvedLayout);
+  const durationInFrames = Math.max(1, declared || timeline?.durationInFrames || fps);
+  const playback = usePlayback({ fps, durationInFrames, initialFrame, autoPlay, loop: loop2, onFrame });
+  const { frame } = playback;
+  useAudioPlayback({ track, frame: playback.frame, fps, playing: playback.playing, muted });
+  const handleAudio = useCallback2(
+    (next) => {
+      setTrack(next);
+      onAudio?.(next);
+    },
+    [onAudio]
+  );
+  const handleTimeline = useCallback2(
+    (next) => {
+      setTimeline((current) => JSON.stringify(current) === JSON.stringify(next) ? current : next);
+      onTimeline?.(next);
+    },
+    [onTimeline]
+  );
+  const aspectRatio = useMemo(() => `${width} / ${height}`, [height, width]);
+  const activeScene = timeline?.scenes.find(
+    (scene) => frame >= scene.start && frame < scene.start + scene.durationInFrames
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "odori-player", style: { display: "grid", gap: 12, width: "100%", ...style }, children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-odori-player": true,
+        style: {
+          aspectRatio,
+          background: resolvedLayout.brand.colors.background,
+          borderRadius: 10,
+          overflow: "hidden",
+          position: "relative",
+          width: "100%"
+        },
+        children: /* @__PURE__ */ jsx(
+          OdoriRuntime,
+          {
+            entry,
+            frame,
+            input,
+            prepared,
+            assets,
+            layout,
+            onTimeline: handleTimeline,
+            onAudio: handleAudio
+          }
+        )
+      }
+    ),
+    controls ? /* @__PURE__ */ jsxs("div", { className: "odori-player-controls", style: { alignItems: "center", display: "flex", gap: 10 }, children: [
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: playback.toggle, children: playback.playing ? "Pause" : "Play" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => playback.step(-1), "aria-label": "Previous frame", children: "\u2039" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => playback.step(1), "aria-label": "Next frame", children: "\u203A" }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          "aria-label": "Timeline",
+          type: "range",
+          min: 0,
+          max: durationInFrames - 1,
+          value: frame,
+          onChange: (event) => {
+            playback.pause();
+            playback.seek(Number(event.currentTarget.value));
+          },
+          style: { flex: 1 }
+        }
+      ),
+      /* @__PURE__ */ jsxs("output", { style: { fontVariantNumeric: "tabular-nums", minWidth: 132, textAlign: "right" }, children: [
+        formatTimecode(frame, fps),
+        " ",
+        "\xB7",
+        " ",
+        frame,
+        "/",
+        durationInFrames - 1,
+        activeScene ? ` \xB7 ${activeScene.name ?? activeScene.id}` : ""
+      ] })
+    ] }) : null
+  ] });
+};
+
+// src/render-surface.tsx
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var RenderSurface = ({
+  entry,
+  initialFrame = 0,
+  input,
+  prepared,
+  assets,
+  layout
+}) => {
+  const [frame, setFrame] = useState3(initialFrame);
+  useEffect3(() => {
+    window.__ODORI_SET_FRAME__ = setFrame;
+    window.__ODORI_READY__ = true;
+    return () => {
+      delete window.__ODORI_SET_FRAME__;
+      delete window.__ODORI_READY__;
+    };
+  }, []);
+  return /* @__PURE__ */ jsx2(
+    OdoriRuntime,
+    {
+      entry,
+      frame,
+      input,
+      prepared,
+      assets,
+      layout,
+      onTimeline: (timeline) => {
+        window.__ODORI_TIMELINE__ = timeline;
+      },
+      onAudio: (track) => {
+        window.__ODORI_AUDIO__ = track;
+      }
+    }
+  );
+};
+
+// src/wav.ts
+var encodeWav = (signal) => {
+  const channels = signal.channels.length || 1;
+  const frames = signal.channels[0]?.length ?? 0;
+  const bytesPerSample = 2;
+  const dataBytes = frames * channels * bytesPerSample;
+  const buffer = new ArrayBuffer(44 + dataBytes);
+  const view = new DataView(buffer);
+  const ascii = (offset2, text) => {
+    for (let index = 0; index < text.length; index += 1) view.setUint8(offset2 + index, text.charCodeAt(index));
+  };
+  ascii(0, "RIFF");
+  view.setUint32(4, 36 + dataBytes, true);
+  ascii(8, "WAVE");
+  ascii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, signal.sampleRate, true);
+  view.setUint32(28, signal.sampleRate * channels * bytesPerSample, true);
+  view.setUint16(32, channels * bytesPerSample, true);
+  view.setUint16(34, 8 * bytesPerSample, true);
+  ascii(36, "data");
+  view.setUint32(40, dataBytes, true);
+  let offset = 44;
+  for (let frame = 0; frame < frames; frame += 1) {
+    for (let channel = 0; channel < channels; channel += 1) {
+      const sample = signal.channels[channel]?.[frame] ?? 0;
+      const clamped = Math.max(-1, Math.min(1, sample));
+      view.setInt16(offset, Math.round(clamped * 32767), true);
+      offset += bytesPerSample;
+    }
+  }
+  return new Uint8Array(buffer);
+};
+
+// src/cursor.ts
+var PRESS_FRAMES = 9;
+var cursorAt = (stops, frame) => {
+  if (stops.length === 0) return { x: 0, y: 0, visible: 0, pressed: 0, clicking: false };
+  const timed = [];
+  let shift = 0;
+  for (const stop of stops) {
+    const start = stop.frame + shift;
+    timed.push({ ...stop, frame: start });
+    if (stop.hold) {
+      timed.push({ ...stop, frame: start + stop.hold, click: false });
+      shift += stop.hold;
+    }
+  }
+  const first = timed[0];
+  const last = timed[timed.length - 1];
+  if (frame <= first.frame) return { x: first.x, y: first.y, visible: 0, pressed: 0, clicking: false };
+  const frames = timed.map((stop) => stop.frame);
+  const x = interpolate(frame, frames, timed.map((stop) => stop.x), { easing: Easing.standard });
+  const y = interpolate(frame, frames, timed.map((stop) => stop.y), { easing: Easing.standard });
+  let pressed = 0;
+  for (const stop of timed) {
+    if (!stop.click || stop.frame > frame) continue;
+    const age = frame - stop.frame;
+    if (age <= PRESS_FRAMES) pressed = Math.max(pressed, 1 - age / PRESS_FRAMES);
+  }
+  return {
+    x,
+    y,
+    // Fade in as it arrives and out after the last stop, so a pointer never
+    // pops onto a frame it was not part of.
+    visible: interpolate(
+      frame,
+      [first.frame, first.frame + 6, last.frame + 12, last.frame + 20],
+      [0, 1, 1, 0],
+      { easing: Easing.standard }
+    ),
+    pressed,
+    clicking: pressed > 0
+  };
+};
+var cursorDuration = (stops) => {
+  const hold = stops.reduce((total, stop) => total + (stop.hold ?? 0), 0);
+  return (stops[stops.length - 1]?.frame ?? 0) + hold + 20;
+};
+
+// src/random.ts
+var hashSeed = (value) => {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var toSeed = (seed) => typeof seed === "number" ? Math.floor(seed) >>> 0 : hashSeed(seed);
+var random = (seed) => {
+  const key = Array.isArray(seed) ? seed.join(":") : seed;
+  let state = toSeed(key) + 1831565813 >>> 0;
+  let t = Math.imul(state ^ state >>> 15, 1 | state);
+  t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+  return ((t ^ t >>> 14) >>> 0) / 4294967296;
+};
+var randomBetween = (seed, min, max) => min + random(seed) * (max - min);
+var randomPick = (seed, items) => items.length === 0 ? void 0 : items[Math.floor(random(seed) * items.length)];
+var randomOrder = (seed, items) => {
+  const key = Array.isArray(seed) ? seed.join(":") : String(seed);
+  const out = [...items];
+  for (let index = out.length - 1; index > 0; index -= 1) {
+    const swap = Math.floor(random(`${key}:${index}`) * (index + 1));
+    [out[index], out[swap]] = [out[swap], out[index]];
+  }
+  return out;
+};
+
+// src/canvas.ts
+import { useEffect as useEffect4, useLayoutEffect, useRef as useRef3 } from "react";
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect4 : useLayoutEffect;
+var useCanvas = (draw, dependencies = []) => {
+  const canvas = useRef3(null);
+  const frame = useFrame();
+  const { width, height } = useVideo();
+  const readiness = useReadiness();
+  const latest = useRef3(draw);
+  latest.current = draw;
+  useIsomorphicLayoutEffect(() => {
+    const element = canvas.current;
+    if (!element) return;
+    const release = readiness.hold();
+    try {
+      const context = element.getContext("2d", { alpha: true });
+      if (!context) return;
+      context.setTransform(1, 0, 0, 1, 0, 0);
+      context.clearRect(0, 0, element.width, element.height);
+      latest.current(context, { frame, width: element.width, height: element.height });
+    } finally {
+      release();
+    }
+  }, [frame, width, height, ...dependencies]);
+  return canvas;
+};
+var drawHtml = async (context, html, options) => {
+  const { width, height, style = "" } = options;
+  if (typeof document !== "undefined" && document.fonts?.ready) await document.fonts.ready;
+  const svg = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">`,
+    `<foreignObject width="100%" height="100%">`,
+    `<div xmlns="http://www.w3.org/1999/xhtml" style="width:${width}px;height:${height}px;${style}">`,
+    html,
+    `</div></foreignObject></svg>`
+  ].join("");
+  const encoded = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+  await new Promise((done, fail) => {
+    const image = new Image();
+    image.onload = () => {
+      context.drawImage(image, 0, 0, width, height);
+      done();
+    };
+    image.onerror = () => fail(
+      new Error(
+        "The HTML could not be rasterized. Every element inside must carry inline styles, and images must be data URLs: an SVG foreignObject cannot reach outside itself."
+      )
+    );
+    image.src = encoded;
+  });
+};
+
+// src/placeholder.ts
+var placeholderSvg = ({
+  width = 1600,
+  height = 900,
+  label,
+  from = "#1a1a1a",
+  to = "#0a0a0a",
+  seed = "placeholder"
+} = {}) => {
+  const shapes = Array.from({ length: 14 }, (_, index) => {
+    const x = random([seed, "x", index]) * width;
+    const y = random([seed, "y", index]) * height;
+    const radius = (random([seed, "r", index]) * 0.16 + 0.03) * Math.min(width, height);
+    const opacity = (random([seed, "o", index]) * 0.06 + 0.02).toFixed(3);
+    return `<circle cx="${x.toFixed(1)}" cy="${y.toFixed(1)}" r="${radius.toFixed(1)}" fill="#ffffff" opacity="${opacity}"/>`;
+  }).join("");
+  const caption = label ? `<text x="50%" y="50%" fill="#ffffff" fill-opacity="0.42" font-family="ui-monospace, monospace" font-size="${Math.round(
+    Math.min(width, height) * 0.06
+  )}" text-anchor="middle" dominant-baseline="middle">${label.replace(/[<>&]/g, "")}</text>` : "";
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`,
+    `<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1">`,
+    `<stop offset="0" stop-color="${from}"/><stop offset="1" stop-color="${to}"/>`,
+    `</linearGradient></defs>`,
+    `<rect width="${width}" height="${height}" fill="url(#g)"/>`,
+    shapes,
+    `<rect x="1" y="1" width="${width - 2}" height="${height - 2}" fill="none" stroke="#ffffff" stroke-opacity="0.08"/>`,
+    caption,
+    `</svg>`
+  ].join("");
+};
+var placeholderImage = (options = {}) => `data:image/svg+xml;charset=utf-8,${encodeURIComponent(placeholderSvg(options))}`;
+var placeholderFrame = (frame, options = {}) => {
+  const { width = 1600, height = 900, fps = 30, ...rest } = options;
+  const seconds2 = frame / fps;
+  const timecode = `${String(Math.floor(seconds2 / 60)).padStart(2, "0")}:${String(Math.floor(seconds2 % 60)).padStart(2, "0")}:${String(
+    frame % fps
+  ).padStart(2, "0")}`;
+  const base = placeholderSvg({ ...rest, width, height, label: void 0 });
+  const progress = frame % (fps * 4) / (fps * 4);
+  const marker = [
+    `<rect x="0" y="${height - 12}" width="${(width * progress).toFixed(1)}" height="12" fill="#ffffff" fill-opacity="0.5"/>`,
+    `<text x="${width / 2}" y="${height / 2}" fill="#ffffff" fill-opacity="0.5" font-family="ui-monospace, monospace" font-size="${Math.round(
+      Math.min(width, height) * 0.08
+    )}" text-anchor="middle" dominant-baseline="middle">${timecode}</text>`
+  ].join("");
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(base.replace("</svg>", `${marker}</svg>`))}`;
+};
+
+// src/metadata.ts
+var SEGMENT = /^[a-z0-9][a-z0-9-]*$/i;
+var isValidVideoId = (id) => id.length > 0 && id.split("/").every((segment) => SEGMENT.test(segment));
+var resolveVideoId = (id, pathId) => id || pathId;
+var defineVideoMetadata = (metadata) => {
+  if (metadata.id !== void 0 && !isValidVideoId(metadata.id)) {
+    throw new Error(`Video id must be alphanumeric path segments with dashes: ${metadata.id}`);
+  }
+  return { kind: "odori-video-metadata", ...metadata, id: metadata.id ?? "" };
+};
+var definePrepare = (run, options = {}) => ({
+  kind: "odori-prepare",
+  version: options.version ?? "1",
+  run
+});
+
+// src/schema.ts
+var validateField = (name, field, value, issues) => {
+  if (value === void 0) return field.defaultValue;
+  switch (field.type) {
+    case "text":
+    case "color": {
+      if (typeof value !== "string") {
+        issues.push(`${name} must be a string`);
+        return field.defaultValue;
+      }
+      if (field.type === "text" && field.maxLength !== void 0 && value.length > field.maxLength) {
+        issues.push(`${name} exceeds ${field.maxLength} characters`);
+      }
+      return value;
+    }
+    case "number": {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        issues.push(`${name} must be a finite number`);
+        return field.defaultValue;
+      }
+      if (field.min !== void 0 && value < field.min) issues.push(`${name} is below ${field.min}`);
+      if (field.max !== void 0 && value > field.max) issues.push(`${name} is above ${field.max}`);
+      return value;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        issues.push(`${name} must be a boolean`);
+        return field.defaultValue;
+      }
+      return value;
+    }
+    case "select": {
+      if (typeof value !== "string" || !field.options.includes(value)) {
+        issues.push(`${name} must be one of ${field.options.join(", ")}`);
+        return field.defaultValue;
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+};
+var defineInputSchema = (fields) => {
+  const defaults = () => Object.fromEntries(Object.entries(fields).map(([name, field]) => [name, field.defaultValue]));
+  const safeParse = (input) => {
+    if (input !== void 0 && input !== null && typeof input !== "object") {
+      return { success: false, issues: ["input must be an object"] };
+    }
+    const source = input ?? {};
+    const issues = [];
+    const data = {};
+    for (const [name, field] of Object.entries(fields)) {
+      data[name] = validateField(name, field, source[name], issues);
+    }
+    for (const key of Object.keys(source)) {
+      if (!(key in fields)) data[key] = source[key];
+    }
+    return issues.length > 0 ? { success: false, issues } : { success: true, data };
+  };
+  return {
+    kind: "odori-schema",
+    fields,
+    defaults,
+    describe: () => fields,
+    safeParse,
+    parse(input) {
+      const result = safeParse(input);
+      if (!result.success) throw new Error(`Invalid video input: ${result.issues.join("; ")}`);
+      return result.data;
+    }
+  };
+};
+var isOdoriSchema = (schema) => typeof schema === "object" && schema !== null && schema.kind === "odori-schema";
+var parseWithSchema = (schema, input) => schema ? schema.parse(input) : input ?? {};
+export {
+  Audio,
+  DUCK_GAIN,
+  DUCK_RAMP_FRAMES,
+  Easing,
+  Fill,
+  Freeze,
+  Loop,
+  OdoriRuntime,
+  Player,
+  RenderSurface,
+  SAMPLE_RATE,
+  SafeArea,
+  Scene,
+  Stagger,
+  Video,
+  advanceFrames,
+  brandCssVariables,
+  canonicalJson,
+  chord,
+  createAssetRegistry,
+  createRenderManifest,
+  cueId,
+  cueSamples,
+  cueSignature,
+  cueUrl,
+  cursorAt,
+  cursorDuration,
+  defaultBrand,
+  defaultLayout,
+  defineBrand,
+  defineCue,
+  defineInputSchema,
+  definePrepare,
+  defineVideoLayout,
+  defineVideoMetadata,
+  drawHtml,
+  duckEnvelope,
+  encodeWav,
+  entryDurationInFrames,
+  envelopeAtFrame,
+  formatTimecode,
+  framesFromDuration,
+  gain,
+  gainAtFrame,
+  hashString,
+  hashValue,
+  highPass,
+  integratedLufs,
+  interpolate,
+  isAssetReference,
+  isCueDefinition,
+  isOdoriSchema,
+  isValidVideoId,
+  loop,
+  lowPass,
+  mix,
+  noise,
+  normalize,
+  note,
+  pad,
+  parseWithSchema,
+  placeholderFrame,
+  placeholderImage,
+  placeholderSvg,
+  random,
+  randomBetween,
+  randomOrder,
+  randomPick,
+  resolveEntryLayout,
+  resolveVideoId,
+  sampleGainCurve,
+  seamless,
+  seconds,
+  secondsFromFrames,
+  seeded,
+  sequence,
+  shape,
+  silence,
+  sine,
+  sortCues,
+  spring,
+  step,
+  sweep,
+  trackDuration,
+  trackGainAtFrame,
+  triangle,
+  useAssets,
+  useAudioPlayback,
+  useBrand,
+  useCanvas,
+  useDesignScale,
+  useFrame,
+  useLayout,
+  usePlayback,
+  useReadiness,
+  useScene,
+  useSceneTransition,
+  useVideo
+};
+//# sourceMappingURL=index.js.map