odori 0.0.1 → 0.0.2

package/dist/chunk-2SROZSZM.js

@@ -0,0 +1,953 @@
+"use client";
+import {
+  framesFromDuration,
+  hashValue
+} from "./chunk-PXG45HYV.js";
+
+// src/context.ts
+import { createContext, useContext } from "react";
+var FrameContext = createContext(null);
+var SceneContext = createContext(null);
+var BrandContext = createContext(null);
+var LayoutContext = createContext(null);
+var AssetContext = createContext(null);
+var AudioSinkContext = createContext(null);
+var ForceMountContext = createContext(false);
+var ReadinessContext = createContext(null);
+var useReadiness = () => {
+  const readiness = useContext(ReadinessContext);
+  return readiness ?? { hold: () => () => void 0 };
+};
+var required = (value, hook) => {
+  if (value === null) throw new Error(`${hook} must be called inside a <Video> tree.`);
+  return value;
+};
+var useFrame = () => required(useContext(FrameContext), "useFrame()").frame;
+var useVideo = () => {
+  const state = required(useContext(FrameContext), "useVideo()");
+  return {
+    fps: state.fps,
+    width: state.width,
+    height: state.height,
+    durationInFrames: state.durationInFrames
+  };
+};
+var useDesignScale = (reference = 1080) => {
+  const state = required(useContext(FrameContext), "useDesignScale()");
+  return Math.min(state.width, state.height) / reference;
+};
+var useBrand = () => required(useContext(BrandContext), "useBrand()");
+var useLayout = () => required(useContext(LayoutContext), "useLayout()");
+var useScene = () => required(useContext(SceneContext), "useScene()");
+var useAssets = () => {
+  const registry = useContext(AssetContext);
+  return registry ?? { resolve: (reference) => reference, list: () => [], ready: true };
+};
+var createAssetRegistry = (entries) => {
+  const table = new Map(entries.map((entry) => [entry.reference, entry.url]));
+  return {
+    ready: true,
+    list: () => entries,
+    resolve(reference) {
+      const url = table.get(reference);
+      if (!url) throw new Error(`Unknown asset reference: ${reference}. Declare it in prepare.ts or odori.config.ts.`);
+      return url;
+    }
+  };
+};
+
+// src/audio.ts
+var cueId = (src, fromFrame) => `${src}@${fromFrame}`;
+var isAssetReference = (src) => !/^(https?:\/\/|\/|\.\/|\.\.\/|data:|blob:)/.test(src);
+var sortCues = (cues) => [...cues].sort((left, right) => left.fromFrame - right.fromFrame || left.id.localeCompare(right.id));
+var trackDuration = (cues) => cues.reduce((total, cue) => Math.max(total, cue.fromFrame + cue.durationInFrames), 0);
+var gainAtFrame = (cue, frame) => {
+  const local = frame - cue.fromFrame;
+  if (local < 0 || local >= cue.durationInFrames) return 0;
+  const fadeIn = cue.fadeInFrames > 0 ? Math.min(1, local / cue.fadeInFrames) : 1;
+  const remaining = cue.durationInFrames - local;
+  const fadeOut = cue.fadeOutFrames > 0 ? Math.min(1, remaining / cue.fadeOutFrames) : 1;
+  const authored = cue.gainPoints ? envelopeAtFrame(cue.gainPoints, frame) : 1;
+  return cue.gain * authored * fadeIn * fadeOut;
+};
+var sampleGainCurve = (curve, fromFrame, durationInFrames, tolerance = 0.01) => {
+  const raw = [];
+  for (let frame = fromFrame; frame < fromFrame + durationInFrames; frame += 1) {
+    const value = curve(frame - fromFrame);
+    raw.push({ frame, value: Number.isFinite(value) ? value : 1 });
+  }
+  if (raw.length <= 2) return raw;
+  const kept = [raw[0]];
+  for (let index = 1; index < raw.length - 1; index += 1) {
+    const previous = kept[kept.length - 1];
+    const next = raw[index + 1];
+    const span = next.frame - previous.frame;
+    const predicted = span === 0 ? previous.value : previous.value + (next.value - previous.value) * (raw[index].frame - previous.frame) / span;
+    if (Math.abs(raw[index].value - predicted) > tolerance) kept.push(raw[index]);
+  }
+  kept.push(raw[raw.length - 1]);
+  return kept;
+};
+var DUCK_GAIN = 0.35;
+var DUCK_RAMP_FRAMES = 6;
+var clampFrame = (frame, durationInFrames) => Math.max(0, Math.min(durationInFrames, frame));
+var duckEnvelope = (cue, cues) => {
+  const end = cue.fromFrame + cue.durationInFrames;
+  if (!cue.duckUnder) return [{ frame: cue.fromFrame, value: 1 }, { frame: end, value: 1 }];
+  const windows = cues.filter((other) => other.id !== cue.id && !other.duckUnder).map((other) => ({
+    start: Math.max(cue.fromFrame, other.fromFrame),
+    end: Math.min(end, other.fromFrame + other.durationInFrames)
+  })).filter((window2) => window2.end > window2.start).sort((left, right) => left.start - right.start);
+  const merged = [];
+  for (const window2 of windows) {
+    const last = merged[merged.length - 1];
+    if (last && window2.start <= last.end) last.end = Math.max(last.end, window2.end);
+    else merged.push({ ...window2 });
+  }
+  const points = [{ frame: cue.fromFrame, value: 1 }];
+  for (const window2 of merged) {
+    points.push(
+      { frame: clampFrame(window2.start - DUCK_RAMP_FRAMES, end), value: 1 },
+      { frame: clampFrame(window2.start, end), value: DUCK_GAIN },
+      { frame: clampFrame(window2.end, end), value: DUCK_GAIN },
+      { frame: clampFrame(window2.end + DUCK_RAMP_FRAMES, end), value: 1 }
+    );
+  }
+  points.push({ frame: end, value: 1 });
+  return simplify(points.sort((left, right) => left.frame - right.frame));
+};
+var simplify = (points) => {
+  const stepped = [];
+  for (const point of points) {
+    const last = stepped[stepped.length - 1];
+    if (last && last.frame === point.frame) stepped[stepped.length - 1] = point;
+    else stepped.push(point);
+  }
+  return stepped.filter((point, index) => {
+    const previous = stepped[index - 1];
+    const next = stepped[index + 1];
+    return !previous || !next || previous.value !== point.value || next.value !== point.value;
+  });
+};
+var envelopeAtFrame = (points, frame) => {
+  if (points.length === 0) return 1;
+  if (frame <= points[0].frame) return points[0].value;
+  for (let index = 1; index < points.length; index += 1) {
+    const previous = points[index - 1];
+    const current = points[index];
+    if (frame > current.frame) continue;
+    const span = current.frame - previous.frame;
+    if (span <= 0) return current.value;
+    return previous.value + (current.value - previous.value) * (frame - previous.frame) / span;
+  }
+  return points[points.length - 1].value;
+};
+var trackGainAtFrame = (cue, cues, frame) => gainAtFrame(cue, frame) * envelopeAtFrame(duckEnvelope(cue, cues), frame);
+
+// src/synth.ts
+var SAMPLE_RATE = 48e3;
+var clamp = (value, low, high) => Math.max(low, Math.min(high, value));
+var seeded = (seed) => {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 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 silence = (samples, channels = 1) => ({
+  channels: Array.from({ length: channels }, () => new Float32Array(samples)),
+  sampleRate: SAMPLE_RATE
+});
+var sine = (samples, frequency, phase = 0) => {
+  const data = new Float32Array(samples);
+  const increment = Math.PI * 2 * frequency / SAMPLE_RATE;
+  for (let index = 0; index < samples; index += 1) data[index] = Math.sin(phase + increment * index);
+  return { channels: [data], sampleRate: SAMPLE_RATE };
+};
+var triangle = (samples, frequency) => {
+  const data = new Float32Array(samples);
+  const period = SAMPLE_RATE / frequency;
+  for (let index = 0; index < samples; index += 1) {
+    const position = index % period / period;
+    data[index] = 4 * Math.abs(position - 0.5) - 1;
+  }
+  return { channels: [data], sampleRate: SAMPLE_RATE };
+};
+var noise = (samples, seed = 1) => {
+  const random = seeded(seed);
+  const data = new Float32Array(samples);
+  for (let index = 0; index < samples; index += 1) data[index] = random() * 2 - 1;
+  return { channels: [data], sampleRate: SAMPLE_RATE };
+};
+var sweep = (samples, from, to) => {
+  const data = new Float32Array(samples);
+  let phase = 0;
+  for (let index = 0; index < samples; index += 1) {
+    const position = samples <= 1 ? 1 : index / (samples - 1);
+    const frequency = from + (to - from) * position;
+    phase += Math.PI * 2 * frequency / SAMPLE_RATE;
+    data[index] = Math.sin(phase);
+  }
+  return { channels: [data], sampleRate: SAMPLE_RATE };
+};
+var shape = (signal, envelope) => {
+  const { attack = 0, decay = 0, sustain = 1, release = 0 } = envelope;
+  const length = signal.channels[0]?.length ?? 0;
+  const attackEnd = Math.round(attack * SAMPLE_RATE);
+  const decayEnd = attackEnd + Math.round(decay * SAMPLE_RATE);
+  const releaseStart = Math.max(decayEnd, length - Math.round(release * SAMPLE_RATE));
+  const level = (index) => {
+    if (index < attackEnd) return attackEnd === 0 ? 1 : index / attackEnd;
+    if (index < decayEnd) {
+      const position = (index - attackEnd) / Math.max(1, decayEnd - attackEnd);
+      return 1 + (sustain - 1) * position;
+    }
+    if (index < releaseStart) return sustain;
+    const remaining = length - releaseStart;
+    return remaining <= 0 ? 0 : sustain * (1 - (index - releaseStart) / remaining);
+  };
+  return {
+    sampleRate: signal.sampleRate,
+    channels: signal.channels.map((channel) => {
+      const out = new Float32Array(channel.length);
+      for (let index = 0; index < channel.length; index += 1) out[index] = channel[index] * level(index);
+      return out;
+    })
+  };
+};
+var gain = (signal, amount) => ({
+  sampleRate: signal.sampleRate,
+  channels: signal.channels.map((channel) => {
+    const out = new Float32Array(channel.length);
+    for (let index = 0; index < channel.length; index += 1) out[index] = channel[index] * amount;
+    return out;
+  })
+});
+var mix = (...signals) => {
+  const length = Math.max(0, ...signals.map((signal) => signal.channels[0]?.length ?? 0));
+  const width = Math.max(1, ...signals.map((signal) => signal.channels.length));
+  const channels = Array.from({ length: width }, () => new Float32Array(length));
+  for (const signal of signals) {
+    for (let channel = 0; channel < width; channel += 1) {
+      const source = signal.channels[channel] ?? signal.channels[0];
+      if (!source) continue;
+      const target = channels[channel];
+      for (let index = 0; index < source.length; index += 1) target[index] += source[index];
+    }
+  }
+  return { channels, sampleRate: SAMPLE_RATE };
+};
+var lowPass = (signal, frequency) => {
+  const coefficient = clamp(1 - Math.exp(-2 * Math.PI * frequency / SAMPLE_RATE), 0, 1);
+  return {
+    sampleRate: signal.sampleRate,
+    channels: signal.channels.map((channel) => {
+      const out = new Float32Array(channel.length);
+      let previous = 0;
+      for (let index = 0; index < channel.length; index += 1) {
+        previous += coefficient * (channel[index] - previous);
+        out[index] = previous;
+      }
+      return out;
+    })
+  };
+};
+var highPass = (signal, frequency) => {
+  const low = lowPass(signal, frequency);
+  return {
+    sampleRate: signal.sampleRate,
+    channels: signal.channels.map((channel, index) => {
+      const out = new Float32Array(channel.length);
+      const removed = low.channels[index];
+      for (let sample = 0; sample < channel.length; sample += 1) out[sample] = channel[sample] - removed[sample];
+      return out;
+    })
+  };
+};
+var declick = (signal, milliseconds = 3) => {
+  const ramp = Math.max(1, Math.round(milliseconds / 1e3 * SAMPLE_RATE));
+  return {
+    sampleRate: signal.sampleRate,
+    channels: signal.channels.map((channel) => {
+      const out = Float32Array.from(channel);
+      const span = Math.min(ramp, Math.floor(out.length / 2));
+      for (let index = 0; index < span; index += 1) {
+        const level = index / span;
+        out[index] *= level;
+        out[out.length - 1 - index] *= level;
+      }
+      return out;
+    })
+  };
+};
+var seamless = (signal, milliseconds = 12) => {
+  const fade = Math.max(1, Math.round(milliseconds / 1e3 * SAMPLE_RATE));
+  return {
+    sampleRate: signal.sampleRate,
+    channels: signal.channels.map((channel) => {
+      const span = Math.min(fade, Math.floor(channel.length / 2));
+      if (span <= 1) return Float32Array.from(channel);
+      const out = Float32Array.from(channel.subarray(0, channel.length - span));
+      for (let index = 0; index < span; index += 1) {
+        const level = index / span;
+        out[index] = out[index] * level + channel[channel.length - span + index] * (1 - level);
+      }
+      return out;
+    })
+  };
+};
+var normalize = (signal, peak = 0.9) => {
+  let highest = 0;
+  for (const channel of signal.channels) {
+    for (let index = 0; index < channel.length; index += 1) {
+      const value = Math.abs(channel[index]);
+      if (value > highest) highest = value;
+    }
+  }
+  return highest === 0 ? signal : gain(signal, peak / highest);
+};
+var loop = (signal, samples) => ({
+  sampleRate: signal.sampleRate,
+  channels: signal.channels.map((channel) => {
+    const out = new Float32Array(samples);
+    if (channel.length === 0) return out;
+    for (let index = 0; index < samples; index += 1) out[index] = channel[index % channel.length];
+    return out;
+  })
+});
+var seconds = (value) => Math.max(0, Math.round(value * SAMPLE_RATE));
+var SEMITONES = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
+var note = (name) => {
+  const match = /^([a-gA-G])([#b]?)(-?\d+)$/.exec(name.trim());
+  if (!match) throw new Error(`Not a note name: "${name}". Use scientific pitch, for example "a4" or "c#3".`);
+  const [, letter, accidental, octave] = match;
+  const semitone = SEMITONES[letter.toLowerCase()] + (accidental === "#" ? 1 : accidental === "b" ? -1 : 0) + (Number(octave) + 1) * 12;
+  return 440 * 2 ** ((semitone - 69) / 12);
+};
+var step = (bpm, division = 4) => Math.max(1, Math.round(60 / bpm / (division / 4) * SAMPLE_RATE));
+var sequence = (steps, options) => {
+  const { bpm, division = 4, swing = 0, samples } = options;
+  const width = step(bpm, division);
+  const placed = steps.map((item) => {
+    const length = Math.max(1, Math.round((item.length ?? 1) * width));
+    const shuffle = swing > 0 && Math.round(item.at) % 2 === 1 ? swing * width : 0;
+    const offset = Math.round(item.at * width + shuffle);
+    return { offset, signal: item.gain === void 0 ? item.play(length) : gain(item.play(length), item.gain) };
+  });
+  const total = samples ?? Math.max(0, ...placed.map(({ offset, signal }) => offset + (signal.channels[0]?.length ?? 0)));
+  const channelCount = Math.max(1, ...placed.map(({ signal }) => signal.channels.length));
+  const channels = Array.from({ length: channelCount }, () => new Float32Array(total));
+  for (const { offset, signal } of placed) {
+    for (let channel = 0; channel < channelCount; channel += 1) {
+      const source = signal.channels[channel] ?? signal.channels[0];
+      if (!source) continue;
+      const target = channels[channel];
+      for (let index = 0; index < source.length && offset + index < total; index += 1) {
+        target[offset + index] += source[index];
+      }
+    }
+  }
+  return { channels, sampleRate: SAMPLE_RATE };
+};
+var QUALITIES = {
+  major: [0, 4, 7],
+  minor: [0, 3, 7],
+  sus2: [0, 2, 7],
+  sus4: [0, 5, 7],
+  major7: [0, 4, 7, 11],
+  minor7: [0, 3, 7, 10],
+  add9: [0, 4, 7, 14]
+};
+var chord = (root, quality = "major") => {
+  const base = typeof root === "number" ? root : note(root);
+  return QUALITIES[quality].map((interval) => base * 2 ** (interval / 12));
+};
+var pad = (frequencies, samples, options = {}) => {
+  const { envelope = { attack: 0.4, sustain: 1, release: 0.6 }, detuneCents = 4, level = 1 / Math.max(1, frequencies.length) } = options;
+  const voices = frequencies.flatMap((frequency, index) => {
+    const detune = 2 ** (detuneCents * (index % 2 === 0 ? 1 : -1) / 1200);
+    return [gain(sine(samples, frequency), level), gain(sine(samples, frequency * detune), level * 0.6)];
+  });
+  return shape(mix(...voices), envelope);
+};
+
+// src/cue.ts
+var defineCue = (input) => ({
+  kind: "odori-cue",
+  loops: false,
+  params: {},
+  ...input,
+  // A score is about the sound, not about remembering what a buffer does at
+  // its edges. A one shot is declicked, because a buffer that stops
+  // mid-waveform is a click. A loop is made seamless instead, because
+  // declicking it would put that same silence at every seam.
+  render: (context) => input.loops ? seamless(input.render(context)) : declick(input.render(context))
+});
+var isCueDefinition = (value) => typeof value === "object" && value !== null && value.kind === "odori-cue";
+var cueSignature = (cue) => hashValue({
+  name: cue.name,
+  durationInFrames: cue.durationInFrames,
+  loops: cue.loops,
+  params: cue.params
+}).slice(0, 16);
+var cueSamples = (cue, fps) => Math.max(1, Math.round(cue.durationInFrames / fps * SAMPLE_RATE));
+var cueUrl = (cue) => `/__odori/cue/${cue.name}-${cueSignature(cue)}.wav`;
+
+// src/easing.ts
+var solveBezierCoordinate = (time, a1, a2) => {
+  const inverse = 1 - time;
+  return 3 * inverse * inverse * time * a1 + 3 * inverse * time * time * a2 + time ** 3;
+};
+var solveBezierSlope = (time, a1, a2) => 3 * (1 - time) ** 2 * a1 + 6 * (1 - time) * time * (a2 - a1) + 3 * time ** 2 * (1 - a2);
+var cubicBezier = (x1, y1, x2, y2) => (value) => {
+  if (value <= 0 || value >= 1) return value;
+  let time = value;
+  for (let index = 0; index < 8; index += 1) {
+    const error = solveBezierCoordinate(time, x1, x2) - value;
+    const slope = solveBezierSlope(time, x1, x2);
+    if (Math.abs(error) < 1e-6 || Math.abs(slope) < 1e-6) break;
+    time -= error / slope;
+  }
+  return solveBezierCoordinate(Math.min(1, Math.max(0, time)), y1, y2);
+};
+var Easing = {
+  linear: (value) => value,
+  bezier: cubicBezier,
+  standard: cubicBezier(0.16, 1, 0.3, 1),
+  quad: (value) => value * value,
+  cubic: (value) => value ** 3,
+  in: (easing) => easing,
+  out: (easing) => (value) => 1 - easing(1 - value),
+  inOut: (easing) => (value) => value < 0.5 ? easing(value * 2) / 2 : 1 - easing((1 - value) * 2) / 2
+};
+function interpolate(value, input, output, options = {}) {
+  if (input.length !== output.length || input.length < 2) {
+    throw new Error("interpolate() requires matching input and output ranges.");
+  }
+  let resolved = value;
+  if (options.extrapolateLeft !== "extend") resolved = Math.max(input[0], resolved);
+  if (options.extrapolateRight !== "extend") resolved = Math.min(input[input.length - 1], resolved);
+  let rangeIndex = input.length - 2;
+  for (let index = 0; index < input.length - 1; index += 1) {
+    if (resolved <= input[index + 1]) {
+      rangeIndex = index;
+      break;
+    }
+  }
+  const inputStart = input[rangeIndex];
+  const inputEnd = input[rangeIndex + 1];
+  const progress = inputEnd === inputStart ? 0 : (resolved - inputStart) / (inputEnd - inputStart);
+  const eased = (options.easing ?? Easing.linear)(progress);
+  const startValue = output[rangeIndex];
+  const endValue = output[rangeIndex + 1];
+  if (typeof startValue === "number" && typeof endValue === "number") {
+    return startValue + (endValue - startValue) * eased;
+  }
+  if (typeof startValue === "string" && typeof endValue === "string") {
+    const startNumbers = startValue.match(/-?\d*\.?\d+/g)?.map(Number) ?? [];
+    const endNumbers = endValue.match(/-?\d*\.?\d+/g)?.map(Number) ?? [];
+    if (startNumbers.length !== endNumbers.length) {
+      throw new Error("String interpolation requires matching numeric segments.");
+    }
+    let segment = 0;
+    return startValue.replace(/-?\d*\.?\d+/g, () => {
+      const result = startNumbers[segment] + (endNumbers[segment] - startNumbers[segment]) * eased;
+      segment += 1;
+      return Number(result.toFixed(4)).toString();
+    });
+  }
+  throw new Error("interpolate() output values must share a type.");
+}
+var spring = ({
+  frame,
+  fps,
+  from = 0,
+  to = 1,
+  stiffness = 120,
+  damping = 20,
+  mass = 1,
+  delayInFrames = 0
+}) => {
+  const elapsed = Math.max(0, frame - delayInFrames);
+  const step2 = 1 / fps;
+  let position = 0;
+  let velocity = 0;
+  for (let index = 0; index < elapsed; index += 1) {
+    const force = -stiffness * (position - 1) - damping * velocity;
+    velocity += force / mass * step2;
+    position += velocity * step2;
+  }
+  return from + (to - from) * position;
+};
+
+// src/brand.ts
+var defaultBrand = {
+  kind: "odori-brand",
+  name: "odori",
+  colors: {
+    background: "#000000",
+    surface: "#0a0a0a",
+    foreground: "#ededed",
+    muted: "#a1a1a1",
+    accent: "#ffffff",
+    border: "#1f1f1f"
+  },
+  /**
+   * System faces, deliberately.
+   *
+   * A default that leads with a licensed family it does not ship is a default
+   * that renders through a fallback on every machine while claiming not to —
+   * and `odori test` is right to fail it, which meant a freshly scaffolded
+   * project failed its own contract check the first time it installed a
+   * component. A brand that wants Geist names it and adds the file, and the
+   * check then protects that choice instead of punishing the default.
+   */
+  typography: {
+    sans: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+    mono: 'ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace'
+  },
+  fonts: [],
+  logos: {},
+  motion: { standard: [0.16, 1, 0.3, 1], staggerFrames: 4 },
+  audio: { cues: {}, targetLufs: -14 }
+};
+var defineBrand = (input) => ({
+  kind: "odori-brand",
+  name: input.name ?? defaultBrand.name,
+  colors: { ...defaultBrand.colors, ...input.colors },
+  typography: { ...defaultBrand.typography, ...input.typography },
+  fonts: input.fonts ?? [],
+  logos: { ...input.logos },
+  motion: { ...defaultBrand.motion, ...input.motion },
+  audio: { ...defaultBrand.audio, ...input.audio, cues: { ...defaultBrand.audio.cues, ...input.audio?.cues } }
+});
+var brandCssVariables = (brand) => ({
+  "--odori-background": brand.colors.background,
+  "--odori-surface": brand.colors.surface,
+  "--odori-foreground": brand.colors.foreground,
+  "--odori-muted": brand.colors.muted,
+  "--odori-accent": brand.colors.accent,
+  "--odori-border": brand.colors.border,
+  "--odori-font-sans": brand.typography.sans,
+  "--odori-font-mono": brand.typography.mono
+});
+
+// src/layout.ts
+var defaultLayout = {
+  kind: "odori-layout",
+  format: { width: 1920, height: 1080, fps: 30 },
+  brand: defaultBrand,
+  safeArea: { x: 96, y: 72 },
+  motion: { enter: [0.16, 1, 0.3, 1], staggerFrames: 4 },
+  audio: { palette: "product-cinematic", targetLufs: -14 },
+  transition: { crossfadeFrames: 8 }
+};
+var defineVideoLayout = (input = {}) => {
+  const base = input.extends ?? defaultLayout;
+  return {
+    kind: "odori-layout",
+    format: { ...base.format, ...input.format },
+    brand: input.brand ?? base.brand,
+    safeArea: input.safeArea ?? base.safeArea,
+    motion: { ...base.motion, ...input.motion },
+    audio: { ...base.audio, ...input.audio },
+    transition: input.transition ?? base.transition
+  };
+};
+
+// src/runtime.tsx
+import {
+  Children,
+  cloneElement,
+  createContext as createContext2,
+  isValidElement,
+  useContext as useContext2,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var TimelineContext = createContext2(null);
+var Fill = ({ style, ...props }) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    ...props,
+    style: {
+      position: "absolute",
+      inset: 0,
+      width: "100%",
+      height: "100%",
+      display: "flex",
+      flexDirection: "column",
+      overflow: "hidden",
+      ...style
+    }
+  }
+);
+var SafeArea = ({ children, style }) => {
+  const layout = useContext2(LayoutContext) ?? defaultLayout;
+  return /* @__PURE__ */ jsx(Fill, { style: { padding: `${layout.safeArea.y}px ${layout.safeArea.x}px`, ...style }, children });
+};
+var SceneTransitionContext = createContext2({
+  entering: 1,
+  leaving: 0,
+  enterFrames: 0,
+  exitFrames: 0
+});
+var useSceneTransition = () => useContext2(SceneTransitionContext);
+var SceneEnvelope = ({ children, durationInFrames }) => {
+  const frame = useFrame();
+  const edge = Math.max(1, Math.min(10, Math.floor(durationInFrames / 6)));
+  const opacity = interpolate(
+    frame,
+    [0, edge, Math.max(edge + 1, durationInFrames - edge), Math.max(edge + 2, durationInFrames - 1)],
+    [0, 1, 1, 0],
+    { easing: Easing.standard }
+  );
+  return /* @__PURE__ */ jsx(Fill, { style: { opacity }, children });
+};
+var Scene = ({
+  children,
+  id,
+  name,
+  __start = 0,
+  __index = 0,
+  __durationInFrames = 1,
+  __enterOverlap = 0,
+  __exitOverlap = 0,
+  __videoFrame = 0
+}) => {
+  const config = useVideo();
+  const forceMount = useContext2(ForceMountContext);
+  const sceneId = id ?? `scene-${__index + 1}`;
+  const localFrame = __videoFrame - __start;
+  const active = localFrame >= 0 && localFrame < __durationInFrames;
+  if (!active && !forceMount) return null;
+  const joined = __enterOverlap > 0 || __exitOverlap > 0;
+  const transition = {
+    entering: __enterOverlap > 0 ? Math.min(1, Math.max(0, localFrame / __enterOverlap)) : 1,
+    leaving: __exitOverlap > 0 ? Math.min(1, Math.max(0, (localFrame - (__durationInFrames - __exitOverlap)) / __exitOverlap)) : 0,
+    enterFrames: __enterOverlap,
+    exitFrames: __exitOverlap
+  };
+  return /* @__PURE__ */ jsx(SceneContext.Provider, { value: { id: sceneId, name, index: __index, start: __start, durationInFrames: __durationInFrames }, children: /* @__PURE__ */ jsx(
+    FrameContext.Provider,
+    {
+      value: {
+        frame: Math.max(0, Math.min(__durationInFrames - 1, localFrame)),
+        fps: config.fps,
+        width: config.width,
+        height: config.height,
+        durationInFrames: __durationInFrames
+      },
+      children: /* @__PURE__ */ jsx(SceneTransitionContext.Provider, { value: transition, children: /* @__PURE__ */ jsx(Fill, { "data-odori-scene": sceneId, children: joined ? /* @__PURE__ */ jsx(Fill, { children }) : /* @__PURE__ */ jsx(SceneEnvelope, { durationInFrames: __durationInFrames, children }) }) })
+    }
+  ) });
+};
+Scene.__odoriScene = true;
+var Stagger = ({ children, from = 0, duration }) => {
+  const config = useVideo();
+  const frame = useFrame();
+  const start = typeof from === "number" && Number.isInteger(from) && from > 1 ? from : framesFromDuration(from, config.fps);
+  const window2 = duration === void 0 ? config.durationInFrames : framesFromDuration(duration, config.fps);
+  const local = frame - start;
+  if (local < 0 || local >= window2) return null;
+  return /* @__PURE__ */ jsx(FrameContext.Provider, { value: { ...config, frame: local, durationInFrames: window2 }, children: /* @__PURE__ */ jsx(Fill, { children }) });
+};
+var Loop = ({
+  children,
+  duration,
+  times
+}) => {
+  const config = useVideo();
+  const frame = useFrame();
+  const window2 = Math.max(1, framesFromDuration(duration, config.fps));
+  const pass = Math.floor(frame / window2);
+  if (times !== void 0 && pass >= times) return null;
+  return /* @__PURE__ */ jsx(FrameContext.Provider, { value: { ...config, frame: frame % window2, durationInFrames: window2 }, children: /* @__PURE__ */ jsx(Fill, { children }) });
+};
+var Freeze = ({ children, at = 0 }) => {
+  const config = useVideo();
+  const held = framesFromDuration(at, config.fps);
+  return /* @__PURE__ */ jsx(FrameContext.Provider, { value: { ...config, frame: Math.max(0, held) }, children: /* @__PURE__ */ jsx(Fill, { children }) });
+};
+var Audio = ({
+  src,
+  from = 0,
+  duration,
+  gain: gain2 = 1,
+  fadeIn = 0,
+  fadeOut = 0,
+  trimStart = 0,
+  loop: loop2,
+  duckUnder = false
+}) => {
+  const config = useVideo();
+  const sink = useContext2(AudioSinkContext);
+  const scene = useContext2(SceneContext);
+  const assets = useAssets();
+  const brand = useContext2(BrandContext) ?? defaultBrand;
+  const frames = (value) => framesFromDuration(value, config.fps);
+  const named = brand.audio.cues[src];
+  const source = isCueDefinition(named) ? cueUrl(named) : named ?? src;
+  const url = isAssetReference(source) ? assets.resolve(source) : source;
+  const repeats = loop2 ?? (isCueDefinition(named) ? named.loops : false);
+  if (sink) {
+    const offset = (from === 0 ? 0 : frames(from)) + (scene?.start ?? 0);
+    const window2 = duration === void 0 ? scene?.durationInFrames ?? config.durationInFrames : frames(duration);
+    sink.register({
+      id: cueId(url, offset),
+      src: url,
+      fromFrame: offset,
+      durationInFrames: window2,
+      // A curve is sampled here, once, where the window is known. Downstream
+      // only ever sees points.
+      gain: typeof gain2 === "function" ? 1 : gain2,
+      gainPoints: typeof gain2 === "function" ? sampleGainCurve(gain2, offset, window2) : void 0,
+      fadeInFrames: fadeIn === 0 ? 0 : frames(fadeIn),
+      fadeOutFrames: fadeOut === 0 ? 0 : frames(fadeOut),
+      trimStartSeconds: trimStart === 0 ? 0 : frames(trimStart) / config.fps,
+      loop: repeats,
+      duckUnder
+    });
+  }
+  return null;
+};
+Audio.__odoriAudio = true;
+var isSceneElement = (node) => isValidElement(node) && node.type?.__odoriScene === true;
+var Video = ({ children, style }) => {
+  const config = useVideo();
+  const frame = useFrame();
+  const sink = useContext2(TimelineContext);
+  const reported = useRef("");
+  const nodes = Children.toArray(children);
+  const { laidOut, timeline } = useMemo(() => {
+    let cursor = 0;
+    let sceneIndex = 0;
+    const scenes = [];
+    const overlaps = [];
+    const placed = nodes.map((node) => {
+      if (!isSceneElement(node)) return null;
+      const durationInFrames = Math.max(1, framesFromDuration(node.props.duration, config.fps));
+      const requested = node.props.overlap === void 0 ? 0 : framesFromDuration(node.props.overlap, config.fps);
+      const previous = scenes[scenes.length - 1];
+      const overlap = sceneIndex === 0 ? 0 : Math.max(0, Math.min(requested, durationInFrames, previous?.durationInFrames ?? 0));
+      const start = Math.max(0, cursor - overlap);
+      const index = sceneIndex;
+      scenes.push({ id: node.props.id ?? `scene-${index + 1}`, name: node.props.name, index, start, durationInFrames, overlap });
+      overlaps.push(overlap);
+      cursor = start + durationInFrames;
+      sceneIndex += 1;
+      return { start, index, durationInFrames };
+    });
+    let placedIndex = 0;
+    const output = nodes.map((node, key) => {
+      if (!isSceneElement(node)) return node;
+      const entry = placed[key] ?? placed.find((item) => item !== null);
+      const index = placedIndex;
+      placedIndex += 1;
+      if (!entry) return node;
+      return cloneElement(node, {
+        key: `odori-scene-${key}`,
+        __start: entry.start,
+        __index: entry.index,
+        __durationInFrames: entry.durationInFrames,
+        __enterOverlap: overlaps[index] ?? 0,
+        __exitOverlap: overlaps[index + 1] ?? 0
+      });
+    });
+    return { laidOut: output, timeline: { scenes, durationInFrames: cursor } };
+  }, [children, config.fps]);
+  const publish = () => {
+    const signature = JSON.stringify(timeline);
+    if (signature === reported.current) return;
+    reported.current = signature;
+    sink?.report(timeline);
+  };
+  if (typeof window === "undefined") publish();
+  useEffect(publish);
+  return /* @__PURE__ */ jsx(Fill, { "data-odori-video": true, style, children: laidOut.map(
+    (node) => isSceneElement(node) ? cloneElement(node, { __videoFrame: frame }) : node
+  ) });
+};
+var resolveEntryLayout = (entry, override) => override ?? entry.metadata.layout ?? defaultLayout;
+var entryDurationInFrames = (entry, layout) => entry.metadata.duration === void 0 ? 0 : framesFromDuration(entry.metadata.duration, layout.format.fps);
+var fontFaceCss = (fonts) => fonts.map(
+  (font) => `@font-face{font-family:"${font.family}";src:url("${font.url}") format("woff2");font-weight:${font.weight ?? "100 900"};font-display:block;font-style:normal;}`
+).join("");
+var installedFonts = /* @__PURE__ */ new Set();
+var FontFaces = ({ fonts }) => {
+  const css = useMemo(() => fontFaceCss(fonts), [fonts]);
+  useEffect(() => {
+    if (!css || installedFonts.has(css)) return;
+    installedFonts.add(css);
+    const style = document.createElement("style");
+    style.dataset.odoriFonts = "";
+    style.textContent = css;
+    document.head.append(style);
+  }, [css]);
+  return typeof window === "undefined" && css ? /* @__PURE__ */ jsx("style", { "data-odori-fonts": true, children: css }) : null;
+};
+var AudioPass = ({
+  children,
+  onAudio,
+  durationInFrames
+}) => {
+  const collected = useRef(/* @__PURE__ */ new Map());
+  const reported = useRef("");
+  const sink = useMemo(
+    () => ({
+      register: (cue) => {
+        collected.current.set(cue.id, cue);
+      }
+    }),
+    []
+  );
+  collected.current.clear();
+  const tree = /* @__PURE__ */ jsx(AudioSinkContext.Provider, { value: sink, children: /* @__PURE__ */ jsx(ForceMountContext.Provider, { value: true, children }) });
+  const publish = () => {
+    const cues = sortCues([...collected.current.values()]);
+    const signature = JSON.stringify(cues);
+    if (signature === reported.current) return;
+    reported.current = signature;
+    onAudio({ cues, durationInFrames: Math.max(durationInFrames, trackDuration(cues)) });
+  };
+  useEffect(publish);
+  return /* @__PURE__ */ jsxs("div", { "aria-hidden": true, "data-odori-audio-pass": true, style: { display: "none" }, children: [
+    tree,
+    /* @__PURE__ */ jsx(Publisher, { publish })
+  ] });
+};
+var Publisher = ({ publish }) => {
+  if (typeof window === "undefined") publish();
+  return null;
+};
+var OdoriRuntime = ({ entry, frame, input, prepared, assets, layout, onTimeline, onAudio }) => {
+  const resolvedLayout = resolveEntryLayout(entry, layout);
+  const { format, brand } = resolvedLayout;
+  const registry = useMemo(() => createAssetRegistry(assets ?? []), [assets]);
+  const sink = useMemo(() => ({ report: (timeline) => onTimeline?.(timeline) }), [onTimeline]);
+  const props = useMemo(() => {
+    const merged = { ...entry.metadata.defaultProps, ...input };
+    return entry.metadata.schema ? entry.metadata.schema.parse(merged) : merged;
+  }, [entry, input]);
+  const durationInFrames = entryDurationInFrames(entry, resolvedLayout);
+  const Composition = entry.component;
+  const [pending, setPending] = useState(0);
+  const readiness = useMemo(
+    () => ({
+      hold: () => {
+        setPending((count) => count + 1);
+        let released = false;
+        return () => {
+          if (released) return;
+          released = true;
+          setPending((count) => Math.max(0, count - 1));
+        };
+      }
+    }),
+    []
+  );
+  return /* @__PURE__ */ jsx(LayoutContext.Provider, { value: resolvedLayout, children: /* @__PURE__ */ jsx(BrandContext.Provider, { value: brand, children: /* @__PURE__ */ jsx(AssetContext.Provider, { value: registry, children: /* @__PURE__ */ jsx(ReadinessContext.Provider, { value: readiness, children: /* @__PURE__ */ jsx(TimelineContext.Provider, { value: sink, children: /* @__PURE__ */ jsx(
+    FrameContext.Provider,
+    {
+      value: {
+        frame,
+        fps: format.fps,
+        width: format.width,
+        height: format.height,
+        durationInFrames: durationInFrames || 1
+      },
+      children: /* @__PURE__ */ jsxs(
+        Fill,
+        {
+          "data-odori-frame": pending === 0 ? frame : void 0,
+          style: {
+            backgroundColor: brand.colors.background,
+            color: brand.colors.foreground,
+            fontFamily: brand.typography.sans,
+            ...brandCssVariables(brand)
+          },
+          children: [
+            /* @__PURE__ */ jsx(FontFaces, { fonts: brand.fonts }),
+            /* @__PURE__ */ jsx(Composition, { ...props, prepared }),
+            onAudio ? /* @__PURE__ */ jsx(AudioPass, { onAudio, durationInFrames, children: /* @__PURE__ */ jsx(Composition, { ...props, prepared }) }, entry.metadata.id) : null
+          ]
+        }
+      )
+    }
+  ) }) }) }) }) });
+};
+
+export {
+  useReadiness,
+  useFrame,
+  useVideo,
+  useDesignScale,
+  useBrand,
+  useLayout,
+  useScene,
+  useAssets,
+  createAssetRegistry,
+  cueId,
+  isAssetReference,
+  sortCues,
+  trackDuration,
+  gainAtFrame,
+  sampleGainCurve,
+  DUCK_GAIN,
+  DUCK_RAMP_FRAMES,
+  duckEnvelope,
+  envelopeAtFrame,
+  trackGainAtFrame,
+  SAMPLE_RATE,
+  seeded,
+  silence,
+  sine,
+  triangle,
+  noise,
+  sweep,
+  shape,
+  gain,
+  mix,
+  lowPass,
+  highPass,
+  seamless,
+  normalize,
+  loop,
+  seconds,
+  note,
+  step,
+  sequence,
+  chord,
+  pad,
+  defineCue,
+  isCueDefinition,
+  cueSignature,
+  cueSamples,
+  cueUrl,
+  Easing,
+  interpolate,
+  spring,
+  defaultBrand,
+  defineBrand,
+  brandCssVariables,
+  defaultLayout,
+  defineVideoLayout,
+  Fill,
+  SafeArea,
+  useSceneTransition,
+  Scene,
+  Stagger,
+  Loop,
+  Freeze,
+  Audio,
+  Video,
+  resolveEntryLayout,
+  entryDurationInFrames,
+  OdoriRuntime
+};
+//# sourceMappingURL=chunk-2SROZSZM.js.map