@hyperframes/inspector 0.0.0-stage → 0.8.152

package/dist/inspection.js

@@ -0,0 +1,2007 @@
+"use strict";
+(() => {
+  // ../core/src/runtime/timelineValues.ts
+  var unknown = () => ({ kind: "unknown", value: null });
+  function declared(value) {
+    if (typeof value === "number" && Number.isFinite(value)) return { kind: "literal", value };
+    if (typeof value === "string") {
+      const kind = /^[+\-*/]=/.test(value) ? "relative" : value.includes("random(") ? "expression" : "literal";
+      return { kind, value };
+    }
+    return unknown();
+  }
+  function animationValues(vars, properties) {
+    const startAt = vars.startAt && typeof vars.startAt === "object" ? vars.startAt : {};
+    return {
+      basis: "authored-tween",
+      properties: properties.map((property) => ({
+        property,
+        from: declared(vars.runBackwards ? vars[property] : startAt[property]),
+        to: vars.runBackwards ? unknown() : declared(vars[property])
+      })),
+      ease: declared(vars.ease)
+    };
+  }
+
+  // ../core/src/runtime/globals.ts
+  function getDebugSurface() {
+    return globalThis;
+  }
+
+  // ../core/src/runtime/diagnostics.ts
+  function swallow(label, error) {
+    if (typeof window === "undefined") return;
+    const w = getDebugSurface();
+    const handler = w.__hf?.onSwallowed;
+    if (handler) {
+      try {
+        handler({ label, error });
+      } catch (handlerError) {
+        void handlerError;
+      }
+    }
+    if (w.__hfDebug || w.__HYPERFRAMES_DEBUG) {
+      console.debug(`[hyperframes] ${label} swallowed:`, error);
+    }
+  }
+
+  // ../core/src/runtime/timelineDuration.ts
+  function readTimelineDurationSeconds(timeline) {
+    try {
+      if (typeof timeline?.duration !== "function") return null;
+      const seconds = Number(timeline.duration());
+      return Number.isFinite(seconds) ? seconds : null;
+    } catch (err) {
+      swallow("runtime.timelineDuration", err);
+      return null;
+    }
+  }
+
+  // ../core/src/runtime/authoredTiming.ts
+  function finiteNumber(value) {
+    if (value == null) return null;
+    if (typeof value === "string" && value.trim() === "") return null;
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  function resolveAuthoredTimingWindow(values) {
+    const parsedStart = finiteNumber(values.start);
+    if (parsedStart == null) return null;
+    const start = Math.max(0, parsedStart);
+    const publicDuration = finiteNumber(values.duration);
+    const preservedDuration = finiteNumber(values.authoredDuration);
+    const duration = publicDuration != null && publicDuration > 0 ? publicDuration : preservedDuration != null && preservedDuration > 0 ? preservedDuration : null;
+    if (duration != null) return { start, duration, end: start + duration };
+    const publicEnd = finiteNumber(values.end);
+    const preservedEnd = finiteNumber(values.authoredEnd);
+    const end = publicEnd != null && publicEnd > start ? publicEnd : preservedEnd != null && preservedEnd > start ? preservedEnd : null;
+    return { start, duration: end == null ? null : end - start, end };
+  }
+
+  // ../parsers/src/compositionContract.ts
+  var COMPOSITION_ATTRIBUTES = Object.freeze({
+    start: "data-start",
+    duration: "data-duration",
+    trackIndex: "data-track-index",
+    derivedEnd: "data-end",
+    legacyTrack: "data-layer"
+  });
+  var CANONICAL_AUTHORED_TIMING_ATTRIBUTES = Object.freeze([
+    COMPOSITION_ATTRIBUTES.start,
+    COMPOSITION_ATTRIBUTES.duration,
+    COMPOSITION_ATTRIBUTES.trackIndex
+  ]);
+  var DERIVED_TIMING_ATTRIBUTES = Object.freeze([
+    COMPOSITION_ATTRIBUTES.derivedEnd
+  ]);
+  var LEGACY_TIMING_ATTRIBUTES = Object.freeze([
+    COMPOSITION_ATTRIBUTES.derivedEnd,
+    COMPOSITION_ATTRIBUTES.legacyTrack
+  ]);
+  function parseNumeric(value) {
+    if (value == null || value.trim() === "") return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  var REFERENCE_ID_PATTERN = /^[A-Za-z0-9_.:-]+$/;
+  function isAsciiDigitAt(value, index) {
+    const code = value.charCodeAt(index);
+    return code >= 48 && code <= 57;
+  }
+  function skipDigitsLeft(value, start) {
+    let cursor = start;
+    while (cursor >= 0 && isAsciiDigitAt(value, cursor)) cursor--;
+    return cursor;
+  }
+  function skipWhitespaceLeft(value, start) {
+    let cursor = start;
+    while (cursor >= 0 && (value[cursor] ?? "").trim() === "") cursor--;
+    return cursor;
+  }
+  function findMagnitudeStart(value) {
+    const last = value.length - 1;
+    if (!isAsciiDigitAt(value, last)) return null;
+    let cursor = skipDigitsLeft(value, last);
+    if (value[cursor] === ".") cursor = skipDigitsLeft(value, cursor - 1);
+    return cursor + 1;
+  }
+  function parseReferenceOffset(value) {
+    const magnitudeStart = findMagnitudeStart(value);
+    if (magnitudeStart == null) return null;
+    const operatorIndex = skipWhitespaceLeft(value, magnitudeStart - 1);
+    const operator = value[operatorIndex];
+    if (operator !== "+" && operator !== "-") return null;
+    const refId = value.slice(0, operatorIndex).trim();
+    if (!REFERENCE_ID_PATTERN.test(refId)) return null;
+    const magnitude = Number(value.slice(magnitudeStart));
+    if (!Number.isFinite(magnitude)) return null;
+    return { refId, operator, magnitude };
+  }
+  function parseStartExpression(raw) {
+    const normalized = (raw ?? "").trim();
+    if (!normalized) return null;
+    const absolute = parseNumeric(normalized);
+    if (absolute != null) return { kind: "absolute", value: absolute };
+    if (REFERENCE_ID_PATTERN.test(normalized)) {
+      return { kind: "reference", refId: normalized, offset: 0 };
+    }
+    const reference = parseReferenceOffset(normalized);
+    if (!reference) return null;
+    return {
+      kind: "reference",
+      refId: reference.refId,
+      offset: reference.operator === "-" ? -reference.magnitude : reference.magnitude
+    };
+  }
+
+  // ../parsers/src/mediaDuration.ts
+  var nonNegative = (raw) => {
+    const value = parseNumeric(raw);
+    return value !== null && value >= 0 ? value : null;
+  };
+  function readMediaOffsetSeconds(getAttr) {
+    return nonNegative(getAttr("data-playback-start")) ?? nonNegative(getAttr("data-media-start")) ?? 0;
+  }
+  var MIN_PLAYBACK_RATE = 0.1;
+  var MAX_PLAYBACK_RATE = 10;
+  function clampPlaybackRate(raw) {
+    return Number.isFinite(raw) && raw > 0 ? Math.max(MIN_PLAYBACK_RATE, Math.min(MAX_PLAYBACK_RATE, raw)) : 1;
+  }
+  function readPlaybackRate(getAttr, fallback = 1) {
+    const authored = Number.parseFloat(getAttr("data-playback-rate") ?? "");
+    return clampPlaybackRate(Number.isFinite(authored) && authored > 0 ? authored : fallback);
+  }
+  function readDataDurationSeconds(getAttr) {
+    const duration = parseNumeric(getAttr("data-duration"));
+    return duration !== null && duration > 0 ? duration : null;
+  }
+  function readAuthoredDurationSeconds(getAttr, startSeconds) {
+    const duration = readDataDurationSeconds(getAttr);
+    if (duration !== null) return duration;
+    const end = parseNumeric(getAttr("data-end"));
+    return end !== null ? end - startSeconds : null;
+  }
+  var DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS = 3;
+  function resolveNaturalDurationSeconds(sourceDurationSeconds, mediaStartSeconds, playbackRate) {
+    if (!Number.isFinite(sourceDurationSeconds)) return null;
+    const remaining = Math.max(0, sourceDurationSeconds - mediaStartSeconds);
+    return remaining / clampPlaybackRate(playbackRate);
+  }
+  function resolveMediaDuration(input) {
+    const { tag, authoredDurationSeconds, sourceDurationSeconds, mediaStartSeconds, playbackRate } = input;
+    if (authoredDurationSeconds !== null && authoredDurationSeconds > 0) {
+      return { seconds: authoredDurationSeconds, source: "authored" };
+    }
+    if (tag === "img") {
+      return { seconds: DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS, source: "default" };
+    }
+    if (sourceDurationSeconds === null) {
+      return { seconds: null, source: "pending", reason: "source duration not yet probed" };
+    }
+    const seconds = resolveNaturalDurationSeconds(
+      sourceDurationSeconds,
+      mediaStartSeconds,
+      playbackRate
+    );
+    if (seconds === null) {
+      return { seconds: null, source: "pending", reason: "source reported a non-finite duration" };
+    }
+    return { seconds, source: "media" };
+  }
+
+  // ../core/src/audioFx.ts
+  var HF_AUDIO_FX_ATTR = "data-fx-chain";
+  var HF_AUDIO_FX_DATA_KEY = HF_AUDIO_FX_ATTR.slice("data-".length);
+  var freq = (key = "frequency", label = "Frequency", def = 1e3, min = 20, max = 2e4) => ({
+    kind: "number",
+    key,
+    label,
+    unit: "Hz",
+    min,
+    max,
+    step: 1,
+    default: def,
+    scale: "log",
+    automatable: true
+  });
+  var qParam = (def = 0.707, hint = "Bandwidth: higher is narrower.") => ({
+    kind: "number",
+    key: "q",
+    label: "Q",
+    unit: "",
+    min: 0.1,
+    max: 20,
+    step: 0.01,
+    default: def,
+    scale: "log",
+    automatable: true,
+    hint
+  });
+  var gainDb = (min = -40, max = 40, def = 0) => ({
+    kind: "number",
+    key: "gain",
+    label: "Gain",
+    unit: "dB",
+    min,
+    max,
+    step: 0.1,
+    default: def,
+    automatable: true
+  });
+  var poles = {
+    kind: "enum",
+    key: "poles",
+    label: "Slope",
+    options: [
+      { value: "1", label: "6 dB/oct" },
+      { value: "2", label: "12 dB/oct" }
+    ],
+    default: "2",
+    hint: "Two poles is the usual biquad; one pole is gentler."
+  };
+  var HF_AUDIO_FX = [
+    {
+      id: "gain",
+      label: "Gain",
+      group: "dynamics",
+      description: "Raise or lower the whole signal. Automate it to duck under something else.",
+      // Cuts go deep, boosts stay modest: this is a level stage for making room,
+      // and a chain that can add 40 dB clips long before it is useful.
+      params: [gainDb(-60, 12, 0)],
+      web: "gain-node"
+    },
+    {
+      id: "peaking",
+      label: "Peaking EQ",
+      group: "filter",
+      description: "Boost or cut a band, leaving everything either side alone.",
+      params: [freq("frequency", "Frequency", 1e3), gainDb(-40, 40, 0), qParam(1)],
+      web: "biquad-peaking"
+    },
+    {
+      id: "lowshelf",
+      label: "Low Shelf",
+      group: "filter",
+      description: "Lift or drop everything below the corner frequency.",
+      // No Q: the Web Audio spec leaves it unused for shelving filters, so the
+      // control moved nothing — and being automatable, a lane drawn on it would
+      // have been silently inert.
+      params: [freq("frequency", "Frequency", 200, 20, 2e3), gainDb(-40, 40, 0)],
+      web: "biquad-lowshelf"
+    },
+    {
+      id: "highshelf",
+      label: "High Shelf",
+      group: "filter",
+      description: "Lift or drop everything above the corner frequency.",
+      params: [freq("frequency", "Frequency", 4e3, 500, 2e4), gainDb(-40, 40, 0)],
+      web: "biquad-highshelf"
+    },
+    {
+      id: "highpass",
+      label: "High-pass",
+      group: "filter",
+      description: "Remove low frequencies: the usual fix for rumble on a voice.",
+      params: [freq("frequency", "Cutoff", 300, 20, 2e4), qParam(0.707), poles],
+      web: "biquad-highpass"
+    },
+    {
+      id: "lowpass",
+      label: "Low-pass",
+      group: "filter",
+      description: "Remove high frequencies, which darkens or muffles a track.",
+      params: [freq("frequency", "Cutoff", 8e3, 100, 2e4), qParam(0.707), poles],
+      web: "biquad-lowpass"
+    },
+    {
+      id: "compressor",
+      label: "Compressor",
+      group: "dynamics",
+      description: "Pull loud parts down so the quiet ones can come up.",
+      params: [
+        {
+          kind: "number",
+          key: "threshold",
+          label: "Threshold",
+          unit: "dB",
+          min: -60,
+          max: 0,
+          step: 0.5,
+          default: -24,
+          hint: "Level above which the compressor starts working."
+        },
+        {
+          kind: "number",
+          key: "ratio",
+          label: "Ratio",
+          unit: ":1",
+          min: 1,
+          max: 20,
+          step: 0.1,
+          default: 4
+        },
+        {
+          kind: "number",
+          key: "attack",
+          label: "Attack",
+          unit: "ms",
+          min: 0.01,
+          max: 2e3,
+          step: 0.1,
+          default: 20,
+          scale: "log"
+        },
+        {
+          kind: "number",
+          key: "release",
+          label: "Release",
+          unit: "ms",
+          min: 0.01,
+          max: 9e3,
+          step: 1,
+          default: 250,
+          scale: "log"
+        },
+        {
+          kind: "number",
+          key: "knee",
+          label: "Knee",
+          unit: "",
+          min: 1,
+          max: 8,
+          step: 0.01,
+          default: 2.83,
+          hint: "1 is a hard corner; higher eases into it."
+        },
+        {
+          kind: "number",
+          key: "makeup",
+          label: "Makeup",
+          unit: "dB",
+          min: 0,
+          max: 36,
+          step: 0.1,
+          default: 0
+        },
+        {
+          kind: "number",
+          key: "mix",
+          label: "Mix",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 1,
+          hint: "Below 1 blends the dry signal back in."
+        }
+      ],
+      web: "worklet-compressor"
+    },
+    {
+      id: "limiter",
+      label: "Limiter",
+      group: "dynamics",
+      description: "Peak limiter that follows the signal's level. It has no lookahead, so a fast peak or an inter-sample peak can pass the ceiling; use the true-peak limiter for a delivery limit.",
+      params: [
+        {
+          kind: "number",
+          key: "limit",
+          label: "Ceiling",
+          unit: "dB",
+          min: -24,
+          max: 0,
+          step: 0.1,
+          default: -1
+        },
+        {
+          kind: "number",
+          key: "attack",
+          label: "Attack",
+          unit: "ms",
+          min: 0.1,
+          max: 80,
+          step: 0.1,
+          default: 5
+        },
+        {
+          kind: "number",
+          key: "release",
+          label: "Release",
+          unit: "ms",
+          min: 1,
+          max: 8e3,
+          step: 1,
+          default: 50,
+          scale: "log"
+        },
+        {
+          kind: "number",
+          key: "level_out",
+          label: "Output",
+          unit: "dB",
+          min: -24,
+          max: 24,
+          step: 0.1,
+          default: 0
+        }
+      ],
+      web: "worklet-limiter"
+    },
+    {
+      id: "truepeak",
+      label: "True-peak limiter",
+      group: "dynamics",
+      description: "Lookahead limiter that holds a 4x estimate of the inter-sample peak at a dBTP ceiling; full-band noise can land up to about 1.7 dB above it. Adds lookahead plus about 0.3 ms of latency.",
+      params: [
+        {
+          kind: "number",
+          key: "ceiling",
+          label: "Ceiling",
+          unit: "dBTP",
+          min: -24,
+          max: 0,
+          step: 0.1,
+          default: -1,
+          hint: "Target true peak, measured on a 4x oversampled signal. Dense full-band sound can end up to about 1.7 dB above it."
+        },
+        {
+          kind: "number",
+          key: "lookahead",
+          label: "Lookahead",
+          unit: "ms",
+          min: 0.5,
+          max: 10,
+          step: 0.1,
+          default: 3,
+          hint: "How far ahead the gain starts falling. Longer is smoother and adds the same latency."
+        },
+        {
+          kind: "number",
+          key: "release",
+          label: "Release",
+          unit: "ms",
+          min: 10,
+          max: 2e3,
+          step: 1,
+          default: 80,
+          scale: "log"
+        }
+      ],
+      web: "worklet-truepeak"
+    },
+    {
+      id: "gate",
+      label: "Noise Gate",
+      group: "dynamics",
+      description: "Silence the track when it drops below the threshold.",
+      params: [
+        {
+          kind: "number",
+          key: "threshold",
+          label: "Threshold",
+          unit: "dB",
+          min: -80,
+          max: 0,
+          step: 0.5,
+          default: -35
+        },
+        {
+          kind: "number",
+          key: "range",
+          label: "Range",
+          unit: "dB",
+          min: -80,
+          max: 0,
+          step: 0.5,
+          default: -24,
+          hint: "How far down the gate pulls when closed."
+        },
+        {
+          kind: "number",
+          key: "ratio",
+          label: "Ratio",
+          unit: ":1",
+          min: 1,
+          max: 20,
+          step: 0.1,
+          default: 10
+        },
+        {
+          kind: "number",
+          key: "attack",
+          label: "Attack",
+          unit: "ms",
+          min: 0.01,
+          max: 9e3,
+          step: 0.1,
+          default: 1,
+          scale: "log"
+        },
+        {
+          kind: "number",
+          key: "release",
+          label: "Release",
+          unit: "ms",
+          min: 0.01,
+          max: 9e3,
+          step: 1,
+          default: 100,
+          scale: "log"
+        },
+        {
+          kind: "number",
+          key: "knee",
+          label: "Knee",
+          unit: "",
+          min: 1,
+          max: 8,
+          step: 0.01,
+          default: 2.83
+        }
+      ],
+      web: "worklet-gate"
+    },
+    {
+      id: "saturate",
+      label: "Saturation",
+      group: "nonlinear",
+      description: "Soft-clip the waveform for warmth or outright distortion.",
+      params: [
+        {
+          kind: "enum",
+          key: "type",
+          label: "Curve",
+          options: [
+            { value: "tanh", label: "Tanh" },
+            { value: "atan", label: "Arctan" },
+            { value: "cubic", label: "Cubic" },
+            { value: "exp", label: "Exponential" },
+            { value: "alg", label: "Algebraic" },
+            { value: "quintic", label: "Quintic" },
+            { value: "sin", label: "Sine" },
+            { value: "erf", label: "Error function" },
+            { value: "hard", label: "Hard clip" }
+          ],
+          default: "tanh"
+        },
+        {
+          kind: "number",
+          key: "threshold",
+          label: "Threshold",
+          unit: "dB",
+          min: -40,
+          max: 0,
+          step: 0.1,
+          default: -6
+        },
+        {
+          kind: "number",
+          key: "output",
+          automatable: true,
+          label: "Output",
+          unit: "dB",
+          min: -24,
+          max: 24,
+          step: 0.1,
+          default: 0
+        },
+        {
+          kind: "number",
+          key: "oversample",
+          label: "Oversample",
+          unit: "x",
+          min: 1,
+          max: 8,
+          step: 1,
+          default: 4,
+          hint: "Higher costs more but keeps aliasing down."
+        }
+      ],
+      web: "waveshaper"
+    },
+    {
+      id: "bitcrush",
+      label: "Bitcrush",
+      group: "nonlinear",
+      description: "Drop bit depth and sample rate for a lo-fi, digital sound.",
+      params: [
+        {
+          kind: "number",
+          key: "bits",
+          label: "Bit depth",
+          unit: "bit",
+          min: 1,
+          max: 32,
+          step: 0.1,
+          default: 8
+        },
+        {
+          kind: "number",
+          key: "samples",
+          label: "Sample hold",
+          unit: "x",
+          min: 1,
+          max: 250,
+          step: 1,
+          default: 1,
+          hint: "Repeats each sample N times, a crude downsample."
+        },
+        {
+          kind: "number",
+          key: "mix",
+          label: "Mix",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 1
+        }
+      ],
+      web: "worklet-bitcrush"
+    },
+    {
+      id: "pitchshift",
+      label: "Pitch shift",
+      group: "time",
+      // The granular algorithm reads from a 100 ms grain, so its output runs a
+      // constant ~50 ms behind its input and nothing in the graph subtracts that
+      // — there is no latency/pre-roll concept here yet. It is inaudible on its
+      // own and audible against picture or against an unshifted track, so it is
+      // stated rather than hidden. `semitones: 0` bypasses the node entirely.
+      description: "Shifts pitch up or down without changing playback speed. Adds ~50 ms of latency.",
+      params: [
+        {
+          kind: "number",
+          key: "semitones",
+          label: "Semitones",
+          unit: "st",
+          min: -12,
+          max: 12,
+          step: 1,
+          default: 0
+        },
+        {
+          kind: "number",
+          key: "mix",
+          label: "Mix",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 1
+        }
+      ],
+      web: "worklet-pitchshift"
+    },
+    {
+      id: "delay",
+      label: "Delay",
+      group: "time",
+      description: "Repeating echoes behind the dry signal.",
+      params: [
+        {
+          kind: "number",
+          key: "time",
+          automatable: true,
+          label: "Time",
+          unit: "ms",
+          min: 1,
+          max: 5e3,
+          step: 1,
+          default: 250,
+          scale: "log"
+        },
+        // aecho rejects a decay of exactly 0 ("out of allowed range: (0, 1]"),
+        // so the floor is a hair above silence rather than at it.
+        {
+          kind: "number",
+          key: "feedback",
+          automatable: true,
+          label: "Feedback",
+          unit: "",
+          min: 0.01,
+          max: 0.95,
+          step: 0.01,
+          default: 0.35
+        },
+        {
+          kind: "number",
+          key: "mix",
+          automatable: true,
+          label: "Mix",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 0.4
+        }
+      ],
+      web: "delay-feedback"
+    },
+    {
+      id: "chorus",
+      label: "Chorus",
+      group: "time",
+      description: "Detuned copies of the signal for width and thickness.",
+      params: [
+        {
+          kind: "number",
+          key: "delay",
+          automatable: true,
+          label: "Delay",
+          unit: "ms",
+          min: 1,
+          max: 100,
+          step: 0.1,
+          default: 7
+        },
+        {
+          kind: "number",
+          key: "depth",
+          automatable: true,
+          label: "Depth",
+          unit: "ms",
+          min: 0,
+          max: 10,
+          step: 0.01,
+          default: 2
+        },
+        {
+          kind: "number",
+          key: "speed",
+          automatable: true,
+          label: "Rate",
+          unit: "Hz",
+          min: 0.01,
+          max: 10,
+          step: 0.01,
+          default: 1
+        },
+        {
+          kind: "number",
+          key: "mix",
+          automatable: true,
+          label: "Mix",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 0.5
+        }
+      ],
+      web: "chorus-lfo"
+    },
+    {
+      id: "phaser",
+      label: "Phaser",
+      group: "time",
+      description: "Sweeping notches moving through the spectrum.",
+      params: [
+        {
+          kind: "number",
+          key: "in_gain",
+          automatable: true,
+          label: "Input",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 0.4
+        },
+        {
+          kind: "number",
+          key: "out_gain",
+          automatable: true,
+          label: "Output",
+          unit: "",
+          min: 0,
+          max: 2,
+          step: 0.01,
+          default: 0.74
+        },
+        // aphaser advertises a delay range starting at 0 but rejects it at
+        // runtime with "delay is too small"; 0.1 ms is the real floor.
+        {
+          kind: "number",
+          key: "delay",
+          label: "Delay",
+          unit: "ms",
+          min: 0.1,
+          max: 5,
+          step: 0.1,
+          default: 3
+        },
+        {
+          kind: "number",
+          key: "decay",
+          label: "Decay",
+          unit: "",
+          min: 0,
+          max: 0.99,
+          step: 0.01,
+          default: 0.4
+        },
+        {
+          kind: "number",
+          key: "speed",
+          automatable: true,
+          label: "Rate",
+          unit: "Hz",
+          min: 0.1,
+          max: 2,
+          step: 0.01,
+          default: 0.5
+        },
+        {
+          kind: "enum",
+          key: "type",
+          label: "Waveform",
+          options: [
+            { value: "0", label: "Triangular" },
+            { value: "1", label: "Sinusoidal" }
+          ],
+          default: "0"
+        }
+      ],
+      web: "allpass-phaser"
+    },
+    {
+      id: "reverb",
+      label: "Reverb",
+      group: "time",
+      description: "Room tail. Both ends convolve the same generated impulse, so preview matches render.",
+      params: [
+        {
+          kind: "number",
+          key: "size",
+          label: "Room size",
+          unit: "",
+          min: 0.05,
+          max: 1,
+          step: 0.01,
+          default: 0.7
+        },
+        {
+          kind: "number",
+          key: "damping",
+          label: "Damping",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 0.5,
+          hint: "Higher rolls the top off the tail faster."
+        },
+        {
+          kind: "number",
+          key: "wet",
+          automatable: true,
+          label: "Wet",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 0.35
+        },
+        {
+          kind: "number",
+          key: "dry",
+          automatable: true,
+          label: "Dry",
+          unit: "",
+          min: 0,
+          max: 1,
+          step: 0.01,
+          default: 0.7
+        }
+      ],
+      web: "convolver"
+    }
+  ];
+  var BY_ID = new Map(HF_AUDIO_FX.map((d) => [d.id, d]));
+  var HF_AUDIO_FX_IDS = HF_AUDIO_FX.map((d) => d.id);
+
+  // ../core/src/audioGain.ts
+  var MAX_AUDIO_GAIN_DB = 12;
+  function audioDbToGain(db) {
+    return 10 ** (db / 20);
+  }
+  var MAX_AUDIO_GAIN = audioDbToGain(MAX_AUDIO_GAIN_DB);
+
+  // ../core/src/audioAutomation.ts
+  var HF_AUDIO_AUTOMATION_ATTR = "data-automation";
+  var HF_AUDIO_AUTOMATION_DATA_KEY = HF_AUDIO_AUTOMATION_ATTR.slice("data-".length);
+  var HF_AUDIO_AUTOMATION_VERSION = 1;
+  var MAX_AUTOMATION_POINTS = 512;
+  var AudioAutomationError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "AudioAutomationError";
+    }
+  };
+  var VOLUME_TARGET = "volume";
+  var RATE_TARGET = "rate";
+  function parseAutomationTarget(target) {
+    if (target === VOLUME_TARGET) return { kind: "volume" };
+    if (target === RATE_TARGET) return { kind: "rate" };
+    const parts = target.split(".");
+    if (parts.length === 3 && parts[0] === "fx" && parts[1] === PRESET_TARGET_KEY) {
+      const presetId = parts[2];
+      return presetId ? { kind: "preset", presetId } : null;
+    }
+    if (parts.length !== 3 || parts[0] !== "fx") return null;
+    const [, nodeId, param] = parts;
+    if (!nodeId || !param) return null;
+    return { kind: "fx", nodeId, param };
+  }
+  var PRESET_TARGET_KEY = "preset";
+  var VOLUME_RANGE = {
+    min: 0,
+    max: MAX_AUDIO_GAIN,
+    step: 0.01,
+    unit: "",
+    label: "Volume",
+    scale: "linear",
+    default: 1
+  };
+  var RATE_RANGE = {
+    min: MIN_PLAYBACK_RATE,
+    max: MAX_PLAYBACK_RATE,
+    step: 0.05,
+    unit: "x",
+    label: "Speed",
+    scale: "log",
+    default: 1
+  };
+  function numberOrNull(raw) {
+    if (typeof raw === "number") return Number.isFinite(raw) ? raw : null;
+    if (typeof raw === "string" && raw.trim() !== "") {
+      const n = Number(raw);
+      return Number.isFinite(n) ? n : null;
+    }
+    return null;
+  }
+  function clampCurve(v) {
+    const n = numberOrNull(v);
+    if (n === null || n === 0) return 0;
+    return Math.min(1, Math.max(-1, n));
+  }
+  function clampVia(rawX, rawY) {
+    const x = numberOrNull(rawX);
+    const y = numberOrNull(rawY);
+    if (x === null || y === null) return null;
+    const inside = (n) => Math.min(0.999, Math.max(1e-3, n));
+    const cx = inside(x);
+    const cy = inside(y);
+    if (Math.abs(cx - cy) < 1e-6) return null;
+    return { x: cx, y: cy };
+  }
+  function shapeFields(p) {
+    const curve = clampCurve(p?.curve);
+    const via = clampVia(p?.viaX, p?.viaY);
+    return {
+      ...curve ? { curve } : {},
+      ...via ? { viaX: via.x, viaY: via.y } : {}
+    };
+  }
+  function cleanPoint(p, range) {
+    const t = numberOrNull(p?.t);
+    const v = numberOrNull(p?.v);
+    if (t === null || v === null) return null;
+    const clamped = range ? Math.min(range.max, Math.max(range.min, v)) : v;
+    return { t: Math.max(0, t), v: clamped, ...shapeFields(p) };
+  }
+  function normalizePoints(points, range) {
+    const clean = points.map((p) => cleanPoint(p, range)).filter((p) => p !== null).sort((a, b) => a.t - b.t);
+    const out = [];
+    for (const p of clean) {
+      if (out.length > 0 && out[out.length - 1].t === p.t) out[out.length - 1] = p;
+      else out.push(p);
+    }
+    return out.slice(0, MAX_AUTOMATION_POINTS);
+  }
+  function normalizeAutomation(automation) {
+    const lanes = [];
+    for (const lane of automation.lanes) {
+      if (!parseAutomationTarget(lane.target)) continue;
+      const range = lane.target === VOLUME_TARGET ? VOLUME_RANGE : lane.target === RATE_TARGET ? RATE_RANGE : null;
+      const points = normalizePoints(lane.points ?? [], range);
+      if (points.length > 0) lanes.push({ target: lane.target, points });
+    }
+    return { version: HF_AUDIO_AUTOMATION_VERSION, lanes };
+  }
+  function parseAutomation(json) {
+    let raw;
+    try {
+      raw = JSON.parse(json);
+    } catch (err) {
+      throw new AudioAutomationError(`Automation is not valid JSON: ${err.message}`);
+    }
+    if (typeof raw !== "object" || raw === null) {
+      throw new AudioAutomationError("Automation must be a JSON object.");
+    }
+    const obj = raw;
+    if (obj.version !== HF_AUDIO_AUTOMATION_VERSION) {
+      throw new AudioAutomationError(`Unsupported automation version: ${String(obj.version)}`);
+    }
+    if (!Array.isArray(obj.lanes)) {
+      throw new AudioAutomationError("Automation is missing a `lanes` array.");
+    }
+    const lanes = obj.lanes.map((l, i) => {
+      if (typeof l !== "object" || l === null) {
+        throw new AudioAutomationError(`Lane ${i} is not an object.`);
+      }
+      const lane = l;
+      if (typeof lane.target !== "string" || !parseAutomationTarget(lane.target)) {
+        throw new AudioAutomationError(`Lane ${i} has an unreadable target: ${String(lane.target)}`);
+      }
+      if (!Array.isArray(lane.points)) {
+        throw new AudioAutomationError(`Lane ${i} is missing a \`points\` array.`);
+      }
+      return { target: lane.target, points: lane.points };
+    });
+    return normalizeAutomation({ version: HF_AUDIO_AUTOMATION_VERSION, lanes });
+  }
+  function applyCurve(x, curve) {
+    if (!curve) return x;
+    return Math.pow(x, Math.pow(2, 2 * curve));
+  }
+  function viaConic(viaX, viaY) {
+    const dx = viaX - 0.5;
+    const dy = viaY - 0.5;
+    const edge = 0.999;
+    const MAX_WEIGHT = 1e6;
+    const needX = dx > 0 ? dx / (edge - viaX) : dx < 0 ? -dx / (viaX - (1 - edge)) : 0;
+    const needY = dy > 0 ? dy / (edge - viaY) : dy < 0 ? -dy / (viaY - (1 - edge)) : 0;
+    const w = Math.min(MAX_WEIGHT, Math.max(1, needX, needY));
+    return { cx: viaX + dx / w, cy: viaY + dy / w, w };
+  }
+  function shapeVia(x, viaX, viaY) {
+    const { cx, cy, w } = viaConic(viaX, viaY);
+    const spread = 2 - 2 * w;
+    const a = x * spread - 1 + 2 * w * cx;
+    const b = -x * spread - 2 * w * cx;
+    const t = conicParam(a, b, x);
+    const rest = 1 - t;
+    const denominator = rest * rest + 2 * w * t * rest + t * t;
+    if (!(denominator > 0)) return x;
+    return (2 * w * cy * t * rest + t * t) / denominator;
+  }
+  function conicParam(a, b, c) {
+    if (Math.abs(a) < 1e-12) return Math.abs(b) < 1e-12 ? c : -c / b;
+    const root = Math.sqrt(Math.max(0, b * b - 4 * a * c));
+    const first = (-b + root) / (2 * a);
+    const second = (-b - root) / (2 * a);
+    const onArc = (t) => t >= -1e-9 && t <= 1 + 1e-9;
+    if (onArc(first)) return Math.min(1, Math.max(0, first));
+    if (onArc(second)) return Math.min(1, Math.max(0, second));
+    return c;
+  }
+  function shapeProgress(x, point) {
+    const via = clampVia(point.viaX, point.viaY);
+    if (via) return shapeVia(Math.min(1, Math.max(0, x)), via.x, via.y);
+    return applyCurve(x, point.curve);
+  }
+  function lerpValue(a, b, x, scale) {
+    if (scale === "log" && a > 0 && b > 0) {
+      return Math.exp(Math.log(a) + (Math.log(b) - Math.log(a)) * x);
+    }
+    return a + (b - a) * x;
+  }
+  function sampleAutomationLane(lane, t, scale = "linear") {
+    const pts = lane.points;
+    if (pts.length === 0) return 0;
+    const first = pts[0];
+    if (t <= first.t) return first.v;
+    const last = pts[pts.length - 1];
+    if (t >= last.t) return last.v;
+    let lo = 0;
+    let hi = pts.length - 1;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (pts[mid].t <= t) lo = mid;
+      else hi = mid;
+    }
+    const a = pts[lo];
+    const b = pts[hi];
+    const span = b.t - a.t;
+    if (span <= 0) return b.v;
+    return lerpValue(a.v, b.v, shapeProgress((t - a.t) / span, a), scale);
+  }
+
+  // ../core/src/runtime/audioAutomationVolume.ts
+  var cache = /* @__PURE__ */ new Map();
+  var CACHE_LIMIT = 64;
+  function laneFromAttr(raw, target = VOLUME_TARGET) {
+    const key = `${target}\0${raw}`;
+    const hit = cache.get(key);
+    if (hit !== void 0) return hit;
+    let lane = null;
+    try {
+      lane = parseAutomation(raw).lanes.find((l) => l.target === target) ?? null;
+    } catch {
+      lane = null;
+    }
+    if (cache.size > CACHE_LIMIT) cache.clear();
+    cache.set(key, lane);
+    return lane;
+  }
+
+  // ../core/src/speedRamp.ts
+  var CELLS_PER_SEGMENT = 48;
+  var tables = /* @__PURE__ */ new WeakMap();
+  function buildTable(lane) {
+    const pts = lane.points;
+    const firstRate = pts[0].v;
+    const lastRate = pts[pts.length - 1].v;
+    const ts = [0];
+    const ss = [0];
+    const push = (t) => {
+      const prevT = ts[ts.length - 1];
+      if (t <= prevT) return;
+      const prevRate = sampleAutomationLane(lane, prevT, "log");
+      ts.push(t);
+      ss.push(
+        ss[ss.length - 1] + (prevRate + sampleAutomationLane(lane, t, "log")) / 2 * (t - prevT)
+      );
+    };
+    const first = Math.max(0, pts[0].t);
+    push(first);
+    for (let i = 1; i < pts.length; i += 1) {
+      const a = pts[i - 1].t;
+      const b = pts[i].t;
+      if (b <= 0) continue;
+      for (let k = 1; k <= CELLS_PER_SEGMENT; k += 1)
+        push(Math.max(a, 0) + (b - a) * k / CELLS_PER_SEGMENT);
+    }
+    return { ts: Float64Array.from(ts), ss: Float64Array.from(ss), firstRate, lastRate };
+  }
+  function tableFor(lane) {
+    let table = tables.get(lane);
+    if (!table) {
+      table = buildTable(lane);
+      tables.set(lane, table);
+    }
+    return table;
+  }
+  function usable(spec) {
+    return typeof spec !== "number" && spec.points.length > 0;
+  }
+  function interpolate(xs, ys, x) {
+    let lo = 0;
+    let hi = xs.length - 1;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (xs[mid] <= x) lo = mid;
+      else hi = mid;
+    }
+    return ys[lo] + (ys[hi] - ys[lo]) * (x - xs[lo]) / (xs[hi] - xs[lo]);
+  }
+  function timeAtSourceTime(spec, source) {
+    if (typeof spec === "number") return source / spec;
+    if (!usable(spec)) return source;
+    const { ts, ss, firstRate, lastRate } = tableFor(spec);
+    const last = ts.length - 1;
+    if (source <= 0) return source / firstRate;
+    if (source >= ss[last]) return ts[last] + (source - ss[last]) / lastRate;
+    return interpolate(ss, ts, source);
+  }
+  function parseRateLane(raw) {
+    return raw ? laneFromAttr(raw, RATE_TARGET) : null;
+  }
+  function resolveRateSpec(automationAttr, constant) {
+    return parseRateLane(automationAttr) ?? constant;
+  }
+  var SPEED_PRESETS = [
+    {
+      id: "montage",
+      label: "Montage",
+      points: [
+        [0, 0.9],
+        [0.15, 0.3],
+        [0.5, 2.5],
+        [0.85, 0.3],
+        [1, 0.9]
+      ]
+    },
+    {
+      id: "hero",
+      label: "Hero",
+      points: [
+        [0, 1],
+        [0.25, 1.6],
+        [0.5, 0.25],
+        [0.75, 1.6],
+        [1, 1]
+      ]
+    },
+    {
+      id: "bullet",
+      label: "Bullet",
+      points: [
+        [0, 3],
+        [0.4, 3],
+        [0.5, 0.15],
+        [0.6, 3],
+        [1, 3]
+      ]
+    },
+    {
+      id: "jump-cut",
+      label: "Jump cut",
+      points: [
+        [0, 0.5],
+        [0.24, 0.5],
+        [0.26, 3],
+        [0.5, 3],
+        [0.52, 0.5],
+        [0.74, 0.5],
+        [0.76, 3],
+        [1, 3]
+      ]
+    },
+    {
+      id: "flash-in",
+      label: "Flash in",
+      points: [
+        [0, 0.3],
+        [0.6, 0.6],
+        [1, 5]
+      ]
+    },
+    {
+      id: "flash-out",
+      label: "Flash out",
+      points: [
+        [0, 5],
+        [0.4, 0.6],
+        [1, 0.3]
+      ]
+    },
+    {
+      id: "ramp-in",
+      label: "Ramp in",
+      points: [
+        [0, 0.5],
+        [1, 1]
+      ]
+    },
+    {
+      id: "ramp-out",
+      label: "Ramp out",
+      points: [
+        [0, 1],
+        [1, 0.5]
+      ]
+    },
+    {
+      id: "slowmo-middle",
+      label: "Slow-mo middle",
+      points: [
+        [0, 1],
+        [1 / 3, 0.35],
+        [2 / 3, 0.35],
+        [1, 1]
+      ]
+    }
+  ];
+
+  // ../core/src/runtime/domRealm.ts
+  var XHTML_NS = "http://www.w3.org/1999/xhtml";
+  function isElementNode(value) {
+    return value != null && value.nodeType === 1;
+  }
+  function isHtmlElement(value) {
+    return isElementNode(value) && value.namespaceURI === XHTML_NS;
+  }
+  function isHtmlTag(value, tag) {
+    return isHtmlElement(value) && value.localName === tag;
+  }
+  function isVideoElement(value) {
+    return isHtmlTag(value, "video");
+  }
+  function isAudioElement(value) {
+    return isHtmlTag(value, "audio");
+  }
+  function isMediaElement(value) {
+    return isVideoElement(value) || isAudioElement(value);
+  }
+  function isImageElement(value) {
+    return isHtmlTag(value, "img");
+  }
+
+  // ../core/src/runtime/playbackRate.ts
+  function parseStrictFiniteTimingNumber(raw) {
+    return parseNumeric(raw);
+  }
+  function readElementPlaybackRate(el) {
+    return readPlaybackRate(
+      (name) => el.getAttribute(name),
+      isMediaElement(el) ? el.defaultPlaybackRate : 1
+    );
+  }
+  function readElementRateSpec(el) {
+    return resolveRateSpec(el.getAttribute("data-automation"), readElementPlaybackRate(el));
+  }
+  function readMediaStart(el) {
+    return readMediaOffsetSeconds((name) => el.getAttribute(name));
+  }
+  function resolveNaturalMediaTimelineDuration(el, sourceDuration) {
+    return resolveNaturalMediaTimelineDurationFromValues(
+      sourceDuration,
+      readMediaStart(el),
+      readElementRateSpec(el)
+    );
+  }
+  function resolveTimedImageDurationSeconds(el, startSeconds = 0) {
+    if (!isImageElement(el)) return null;
+    if (!el.hasAttribute("data-start") && !el.hasAttribute("data-track-index")) return null;
+    return resolveMediaDuration({
+      tag: "img",
+      authoredDurationSeconds: readAuthoredDurationSeconds(
+        (name) => el.getAttribute(name),
+        startSeconds
+      ),
+      sourceDurationSeconds: null,
+      mediaStartSeconds: 0,
+      playbackRate: 1
+    }).seconds;
+  }
+  function resolveNaturalMediaTimelineDurationFromValues(sourceDuration, mediaStart, playbackRate) {
+    if (typeof playbackRate === "number") {
+      return resolveNaturalDurationSeconds(sourceDuration, mediaStart, playbackRate);
+    }
+    if (!Number.isFinite(sourceDuration)) return null;
+    return timeAtSourceTime(playbackRate, Math.max(0, sourceDuration - mediaStart));
+  }
+
+  // ../core/src/mediaTiming.ts
+  var MEDIA_START_BASIS_ATTR = "data-hf-media-start-basis";
+  function readMediaStartBasis(value) {
+    return value?.trim().toLowerCase() === "global" ? "global" : "local";
+  }
+  function resolveAbsoluteMediaStartSeconds(input) {
+    return readMediaStartBasis(input.basis) === "global" ? input.authoredStart : input.hostStart + input.authoredStart;
+  }
+  function resolveMediaStartSeconds(input) {
+    if (!hasLiteralNestedStart(input)) return input.ordinaryStart();
+    return resolveAbsoluteMediaStartSeconds({
+      authoredStart: input.authoredStart,
+      hostStart: input.hostStart,
+      basis: input.basis
+    });
+  }
+  function isRootGlobalMediaStart(input) {
+    return hasLiteralNestedStart(input) && readMediaStartBasis(input.basis) === "global";
+  }
+  function hasLiteralNestedStart(input) {
+    return !input.hasAutoStart && input.authoredStart != null && input.hostStart !== 0;
+  }
+  function hostInPointSeconds(host) {
+    return readMediaOffsetSeconds((name) => host.getAttribute(name));
+  }
+  function compositionOriginSeconds(hostStart, host) {
+    return hostStart - hostInPointSeconds(host);
+  }
+
+  // ../core/src/runtime/startResolver.ts
+  function createRuntimeStartTimeResolver(params) {
+    const timelineRegistry = params.timelineRegistry ?? {};
+    const includeAuthoredTimingAttrs = params.includeAuthoredTimingAttrs ?? false;
+    const doc = params.documentRef ?? document;
+    const startCache = /* @__PURE__ */ new WeakMap();
+    const durationCache = /* @__PURE__ */ new WeakMap();
+    const visiting = /* @__PURE__ */ new Set();
+    const findReferenceTarget = (refId) => {
+      const byId = doc.getElementById(refId);
+      if (byId) return byId;
+      return Array.from(doc.querySelectorAll("[data-composition-id]")).find(
+        (element) => element.getAttribute("data-composition-id") === refId
+      ) ?? null;
+    };
+    const authoredAttr = (element, name) => includeAuthoredTimingAttrs ? element.getAttribute(name) : null;
+    const resolveAuthoredDuration = (element) => resolveAuthoredTimingWindow({
+      start: 0,
+      duration: element.getAttribute("data-duration"),
+      authoredDuration: authoredAttr(element, "data-hf-authored-duration")
+    })?.duration ?? resolveAuthoredTimingWindow({
+      start: resolveStartForElementInternal(element, 0),
+      end: element.getAttribute("data-end"),
+      authoredEnd: authoredAttr(element, "data-hf-authored-end")
+    })?.duration ?? null;
+    const positive = (value) => value != null && Number.isFinite(value) && value > 0 ? value : null;
+    const resolveRegisteredTimelineDuration = (element) => {
+      const compositionId = element.getAttribute("data-composition-id");
+      return compositionId ? positive(readTimelineDurationSeconds(timelineRegistry[compositionId])) : null;
+    };
+    const resolveDurationForElement = (element) => {
+      const cached = durationCache.get(element);
+      if (cached !== void 0) return cached;
+      const resolved = resolveAuthoredDuration(element) ?? positive(
+        isMediaElement(element) ? resolveNaturalMediaTimelineDuration(element, element.duration) : null
+      ) ?? positive(resolveTimedImageDurationSeconds(element)) ?? resolveRegisteredTimelineDuration(element);
+      durationCache.set(element, resolved);
+      return resolved;
+    };
+    const isCompositionHost = (element) => element.hasAttribute("data-composition-src") || element.hasAttribute("data-composition-id") || element.hasAttribute("data-composition-file");
+    const inheritedTimingHost = (element) => {
+      const parent = element.parentElement;
+      if (!parent || !element.hasAttribute("data-composition-id")) return null;
+      if (parseStartExpression(element.getAttribute("data-start"))) return null;
+      return isCompositionHost(parent) ? parent : null;
+    };
+    const resolveCompositionOrigin = (compositionRoot, fallback) => compositionOriginSeconds(
+      resolveStartForElementInternal(compositionRoot, fallback),
+      inheritedTimingHost(compositionRoot) ?? compositionRoot
+    );
+    const resolveHostOffsetForElement = (element, fallback) => {
+      const compositionRoot = element.hasAttribute("data-composition-id") ? element.parentElement?.closest("[data-composition-id]") : element.closest("[data-composition-id]");
+      return compositionRoot ? resolveCompositionOrigin(compositionRoot, fallback) : 0;
+    };
+    const computeStart = (element, fallback) => {
+      const expression = parseStartExpression(element.getAttribute("data-start"));
+      if (!expression) {
+        const host = inheritedTimingHost(element);
+        return host ? resolveStartForElementInternal(host, fallback) : fallback;
+      }
+      if (expression.kind === "absolute") {
+        return resolveHostOffsetForElement(element, fallback) + Math.max(0, expression.value);
+      }
+      const target = findReferenceTarget(expression.refId);
+      if (!target) return fallback;
+      const targetStart = resolveStartForElementInternal(target, 0);
+      const targetDuration = resolveDurationForElement(target) ?? 0;
+      const floor = Math.min(0, resolveHostOffsetForElement(element, 0));
+      return Math.max(floor, targetStart + targetDuration + expression.offset);
+    };
+    const resolveStartForElementInternal = (element, fallback) => {
+      const cached = startCache.get(element);
+      if (cached !== void 0) {
+        return cached == null ? fallback : cached;
+      }
+      if (visiting.has(element)) {
+        return fallback;
+      }
+      visiting.add(element);
+      try {
+        const resolved = computeStart(element, fallback);
+        startCache.set(element, resolved);
+        return resolved;
+      } finally {
+        visiting.delete(element);
+      }
+    };
+    const mediaStartInput = (element) => {
+      const compositionRoot = element.closest("[data-composition-id]");
+      return {
+        authoredStart: parseStrictFiniteTimingNumber(element.getAttribute("data-start")),
+        hostStart: compositionRoot ? resolveCompositionOrigin(compositionRoot, 0) : 0,
+        hasAutoStart: element.hasAttribute("data-hf-auto-start"),
+        basis: element.getAttribute(MEDIA_START_BASIS_ATTR)
+      };
+    };
+    const resolveMediaStartForElement = (element) => {
+      const input = mediaStartInput(element);
+      return resolveMediaStartSeconds({
+        ...input,
+        ordinaryStart: () => resolveStartForElementInternal(element, input.hostStart)
+      });
+    };
+    const resolveHostSlotsForElement = (element) => {
+      const slots = [];
+      for (let node = element.parentElement; node; node = node.parentElement) {
+        if (!isCompositionHost(node) || inheritedTimingHost(node)) continue;
+        if (hostInPointSeconds(node) <= 0) continue;
+        const start = resolveStartForElementInternal(node, 0);
+        const duration = resolveAuthoredDuration(node);
+        slots.push({ start, end: duration ? start + duration : Infinity });
+      }
+      return slots;
+    };
+    const isRootGlobalMediaStartForElement = (element) => isMediaElement(element) && isRootGlobalMediaStart(mediaStartInput(element));
+    return {
+      resolveStartForElement: (element, fallback = 0) => resolveStartForElementInternal(element, Math.max(0, fallback)),
+      resolveDurationForElement: (element) => resolveDurationForElement(element),
+      resolveMediaStartForElement,
+      resolveHostStartForElement: (element) => resolveHostOffsetForElement(element, 0),
+      resolveHostSlotsForElement,
+      isRootGlobalMediaStartForElement
+    };
+  }
+
+  // ../core/src/runtime/compositionDimension.ts
+  function findRootCompositionElement(doc = document) {
+    const explicitRoot = doc.querySelector('[data-composition-id][data-root="true"]');
+    if (isHtmlElement(explicitRoot)) return explicitRoot;
+    return doc.querySelector("[data-composition-id]");
+  }
+
+  // ../core/src/runtime/timelineInspection.ts
+  function classify(interval, q) {
+    const { start, end } = interval;
+    const near = (a, b) => Math.abs(a - b) <= 1e-7;
+    const before = (a, b) => a < b && !near(a, b);
+    const beforeOrAt = (a, b) => a < b || near(a, b);
+    if (q.boundary != null) {
+      const t = q.boundary;
+      if (near(start, end) && near(start, t)) return "instant";
+      if (near(start, t)) return "starts";
+      if (near(end, t)) return "ends";
+      return start < t && end > t ? "crosses" : null;
+    }
+    if (q.at != null)
+      return near(start, end) ? near(start, q.at) ? "instant" : null : beforeOrAt(start, q.at) && before(q.at, end) ? "active" : null;
+    if (q.range)
+      return near(start, end) ? beforeOrAt(q.range[0], start) && before(start, q.range[1]) ? "instant" : null : before(start, q.range[1]) && before(q.range[0], end) ? "intersects" : null;
+    return near(start, end) ? "instant" : "scheduled";
+  }
+  function cycles(a, input, warnings) {
+    const d = a.duration(), repeat = a.repeat?.() ?? 0, gap = a.repeatDelay?.() ?? 0;
+    if (repeat < 0 || repeat > 1e3) {
+      warnings.add("Infinite or >1000 repeats are not expanded; timing incomplete.");
+      return [];
+    }
+    const result = [];
+    for (let cycle = 0; cycle <= repeat; cycle++)
+      for (const interval of input) {
+        const start = Math.max(0, interval.start), end = Math.min(d, interval.end);
+        if (end < start) continue;
+        const reverse = !!a.yoyo?.() && cycle % 2 === 1;
+        result.push({
+          start: cycle * (d + gap) + (reverse ? d - end : start),
+          end: cycle * (d + gap) + (reverse ? d - start : end)
+        });
+        if (result.length >= 1e4) {
+          warnings.add("Occurrence expansion limit reached; timing incomplete.");
+          return result;
+        }
+      }
+    return result;
+  }
+  function globalIntervals(a, root, warnings, activity = [{ start: 0, end: a.duration() }]) {
+    let intervals = cycles(a, activity, warnings);
+    let node = a;
+    const seen = /* @__PURE__ */ new Set();
+    while (node !== root) {
+      if (seen.has(node) || !node.parent) {
+        warnings.add("Animation is not attached to a registered root; global time unknown.");
+        return [];
+      }
+      seen.add(node);
+      const scale = node.timeScale?.() ?? 1;
+      if (node.paused?.() || !scale) {
+        warnings.add("Paused or zero-speed nested animation excluded; activation is unknown.");
+        return [];
+      }
+      const total = node.totalDuration?.() ?? node.duration();
+      intervals = intervals.map((i) => {
+        const x = node.startTime() + (scale < 0 ? (total - i.end) / -scale : i.start / scale);
+        const y = node.startTime() + (scale < 0 ? (total - i.start) / -scale : i.end / scale);
+        return { start: x, end: y };
+      });
+      node = node.parent;
+      intervals = cycles(node, intervals, warnings);
+    }
+    return intervals;
+  }
+  function inspectTimelineRuntime(q, roots, scope, describe, origin, reserved2, registry) {
+    const warnings = /* @__PURE__ */ new Set();
+    const events = [];
+    const seen = /* @__PURE__ */ new Set();
+    const resolver = createRuntimeStartTimeResolver({
+      timelineRegistry: registry,
+      documentRef: scope.ownerDocument
+    });
+    const rootElement = findRootCompositionElement(scope.ownerDocument);
+    const clocks = /* @__PURE__ */ new Map();
+    for (const [id, timeline] of Object.entries(registry)) {
+      const host = scope.ownerDocument.querySelector(`[data-composition-id="${CSS.escape(id)}"]`);
+      if (host) clocks.set(timeline, host);
+    }
+    const clockFor = (animation2, fallback) => {
+      const visited = /* @__PURE__ */ new Set();
+      let node = animation2;
+      while (node && !visited.has(node)) {
+        if (clocks.has(node)) return node;
+        visited.add(node);
+        node = node.parent;
+      }
+      return fallback;
+    };
+    const toProjectTime = (clock, intervals) => {
+      const host = clocks.get(clock);
+      if (!host || host === rootElement) return intervals;
+      const start = resolver.resolveStartForElement(host, 0);
+      const offset = readMediaStart(host);
+      const rate = readElementRateSpec(host);
+      if (!Number.isFinite(start)) {
+        warnings.add("Composition start could not be resolved; timing incomplete.");
+        return [];
+      }
+      return intervals.filter((interval) => interval.end >= offset).map((interval) => ({
+        start: start + timeAtSourceTime(rate, Math.max(0, interval.start - offset)),
+        end: start + timeAtSourceTime(rate, interval.end - offset)
+      }));
+    };
+    const component = (el) => describe(q.component ? scope : el.closest("[data-composition-id]") ?? scope);
+    for (const root of roots)
+      for (const a of root.getChildren?.(true, true, false) ?? []) {
+        if (events.length >= 1e4) {
+          warnings.add("Global event limit reached; narrow component/time query. Timing incomplete.");
+          break;
+        }
+        if (seen.has(a)) continue;
+        seen.add(a);
+        const clock = clockFor(a, root);
+        const internal = a.timeline;
+        if (internal && a._ease && [0, 0.25, 0.5, 0.75, 1].some((t) => Math.abs(a._ease(t) - t) > 1e-7)) {
+          warnings.add("Nonlinear internal timeline easing is not mapped; timing incomplete.");
+          continue;
+        }
+        const pieces = internal?.getChildren?.(true, true, false) ?? [a];
+        for (const piece of pieces) {
+          const targets = (piece.targets?.() ?? []).filter(isElementNode);
+          if (!targets.some((el) => scope === el || scope.contains(el))) continue;
+          const properties = Object.keys(piece.vars ?? {}).filter(
+            (k) => !reserved2.has(k) && !k.startsWith("on")
+          );
+          const values = animationValues(piece.vars ?? {}, properties);
+          const localIntervals = internal ? globalIntervals(
+            a,
+            clock,
+            warnings,
+            globalIntervals(piece, internal, warnings).map((i) => {
+              const scale = internal.duration() ? a.duration() / internal.duration() : 1;
+              return { start: i.start * scale, end: i.end * scale };
+            })
+          ) : globalIntervals(a, clock, warnings);
+          const intervals = toProjectTime(clock, localIntervals);
+          for (const interval of intervals) {
+            if (events.length >= 1e4) {
+              warnings.add("Global event limit reached; timing incomplete.");
+              break;
+            }
+            const relation = classify(interval, q);
+            if (!relation) continue;
+            for (const owner of new Set(
+              targets.filter((el) => scope === el || scope.contains(el)).map((el) => q.component ? scope : el.closest("[data-composition-id]") ?? scope)
+            )) {
+              const stack = origin(a);
+              const existing = events.find(
+                (e) => e.kind === "animation" && e.stack === stack && stack !== null && e.start === interval.start && e.end === interval.end && e.component?.ref === describe(owner).ref && e.properties.join() === properties.join() && JSON.stringify(e.values) === JSON.stringify(values)
+              );
+              if (existing) {
+                for (const target of targets.map(describe))
+                  if (!existing.targets.some((t) => t.ref === target.ref))
+                    existing.targets.push(target);
+              } else
+                events.push({
+                  ...interval,
+                  kind: "animation",
+                  relation,
+                  component: describe(owner),
+                  targets: targets.map(describe),
+                  properties,
+                  values,
+                  stack
+                });
+            }
+          }
+        }
+      }
+    for (const el of [
+      scope,
+      ...scope.querySelectorAll("[data-start],[data-duration],[data-end],[data-composition-id]")
+    ]) {
+      if (!el.matches("[data-start],[data-duration],[data-end],[data-composition-id]")) continue;
+      const media = el.tagName === "AUDIO" || el.tagName === "VIDEO";
+      const start = media ? resolver.resolveMediaStartForElement(el) : resolver.resolveStartForElement(el, Number.NaN);
+      const duration = resolver.resolveDurationForElement(el);
+      if (!Number.isFinite(start) || duration == null || !Number.isFinite(duration) || duration < 0) {
+        warnings.add("Some HF item timing could not be resolved.");
+        continue;
+      }
+      const interval = { start, end: start + duration };
+      const relation = classify(interval, q);
+      if (!relation) continue;
+      events.push({
+        ...interval,
+        kind: "item",
+        relation,
+        component: component(el),
+        targets: [describe(el)],
+        properties: [],
+        stack: null
+      });
+    }
+    events.sort((a, b) => a.start - b.start || a.end - b.end);
+    return { status: "found", candidates: [describe(scope)], events, warnings: [...warnings] };
+  }
+
+  // ../core/src/runtime/inspection.ts
+  var animation = (value) => !!value && typeof value === "object" && "duration" in value && typeof value.duration === "function" && "startTime" in value && typeof value.startTime === "function";
+  var reserved = /* @__PURE__ */ new Set([
+    "duration",
+    "ease",
+    "delay",
+    "repeat",
+    "repeatDelay",
+    "yoyo",
+    "stagger",
+    "paused",
+    "immediateRender",
+    "overwrite",
+    "lazy",
+    "parent",
+    "data",
+    "id",
+    "inherit",
+    "runBackwards",
+    "startAt",
+    "keyframes",
+    "reversed",
+    "defaults"
+  ]);
+  function installInspection(win, generation, limit = 2e4) {
+    const records = /* @__PURE__ */ new WeakMap();
+    const attachments = /* @__PURE__ */ new WeakMap();
+    const refs = /* @__PURE__ */ new Map();
+    const elementRefs = /* @__PURE__ */ new WeakMap();
+    const restorers = [];
+    const hooked = /* @__PURE__ */ new WeakSet();
+    let count = 0;
+    let depth = 0;
+    let gsap;
+    let disposed = false;
+    const ref = (el) => {
+      let value2 = elementRefs.get(el);
+      if (!value2) {
+        value2 = `hfi:${generation}:${refs.size + 1}`;
+        refs.set(value2, new WeakRef(el));
+        elementRefs.set(el, value2);
+      }
+      return value2;
+    };
+    const describe = (el) => ({
+      ref: ref(el),
+      tag: el.tagName.toLowerCase(),
+      id: el.id,
+      hfId: el.getAttribute("data-hf-id"),
+      classes: [...el.classList],
+      composition: el.closest("[data-composition-id]")?.getAttribute("data-composition-id") ?? null
+    });
+    function record(value2, stack) {
+      if (animation(value2) && !records.has(value2) && count < limit) {
+        records.set(value2, stack);
+        count++;
+      }
+    }
+    function wrap(owner, name, timeline) {
+      const original = owner[name];
+      if (typeof original !== "function") return;
+      const method = original;
+      const wrapped = function(...args) {
+        const outer = depth === 0;
+        const stack = outer ? new Error().stack ?? "" : "";
+        const self = animation(this) ? this : void 0;
+        const before = outer && timeline ? new Set(self?.getChildren?.(false, true, true) ?? []) : void 0;
+        depth++;
+        let result;
+        try {
+          result = method.apply(this, args);
+        } finally {
+          depth--;
+        }
+        if (outer) {
+          if (name === "add" && animation(args[0])) attachments.set(args[0], stack);
+          else if (before) {
+            for (const child of self?.getChildren?.(false, true, true) ?? [])
+              if (!before.has(child)) record(child, stack);
+          } else record(result, stack);
+        }
+        return result;
+      };
+      owner[name] = wrapped;
+      restorers.push(() => {
+        if (owner[name] === wrapped) owner[name] = original;
+      });
+    }
+    function hook(value2) {
+      if (disposed || hooked.has(value2) || !value2.core?.Timeline || !value2.getTweensOf) return;
+      hooked.add(value2);
+      gsap = value2;
+      for (const name of ["to", "from", "fromTo", "set", "timeline", "delayedCall"])
+        wrap(value2, name, false);
+      for (const name of ["to", "from", "fromTo", "set", "call", "add"])
+        wrap(value2.core.Timeline.prototype, name, true);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(win, "gsap");
+    let value = win.gsap;
+    if (value) hook(value);
+    if (!descriptor || descriptor.configurable) {
+      Object.defineProperty(win, "gsap", {
+        configurable: true,
+        enumerable: true,
+        get: () => value,
+        set: (next) => {
+          value = next;
+          hook(next);
+        }
+      });
+      restorers.push(() => {
+        if (descriptor)
+          Object.defineProperty(win, "gsap", { ...descriptor, ...descriptor.get ? {} : { value } });
+        else
+          Object.defineProperty(win, "gsap", {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value
+          });
+      });
+    }
+    const api = {
+      query(q) {
+        if (value) hook(value);
+        const results = q.targets.map((target) => {
+          const base = {
+            target,
+            status: "missing",
+            candidates: [],
+            elements: [],
+            animations: [],
+            css: [],
+            truncated: false
+          };
+          let elements;
+          try {
+            if ("ref" in target) {
+              const el = refs.get(target.ref)?.deref();
+              if (!el?.isConnected) return { ...base, status: "stale-ref" };
+              elements = [el];
+            } else {
+              const roots = target.within ? [...document.querySelectorAll(target.within)] : [document];
+              const selector = "selector" in target ? target.selector : `[data-hf-id="${CSS.escape(target.hfId)}"]`;
+              elements = [
+                ...new Set(
+                  roots.flatMap((root) => [
+                    ...isElementNode(root) && root.matches(selector) ? [root] : [],
+                    ...root.querySelectorAll(selector)
+                  ])
+                )
+              ];
+            }
+          } catch {
+            return { ...base, status: "invalid-selector" };
+          }
+          if (elements.length === 0)
+            return {
+              ...base,
+              status: "missing",
+              candidates: elements.slice(0, 20).map(describe),
+              truncated: elements.length > 20
+            };
+          const selected = /* @__PURE__ */ new Set();
+          let truncated = false;
+          const add = (el) => {
+            if (selected.has(el)) return;
+            if (selected.size >= 1001) {
+              truncated = true;
+              return;
+            }
+            selected.add(el);
+          };
+          for (const element of elements) {
+            add(element);
+            if (q.descendants) {
+              for (const child of element.querySelectorAll("*")) {
+                add(child);
+                if (truncated) break;
+              }
+            }
+            if (truncated) break;
+          }
+          const scope = [...selected];
+          const animations = (gsap?.getTweensOf?.(scope) ?? []).map((tw) => {
+            const attachmentStacks = [];
+            const visited = /* @__PURE__ */ new Set();
+            for (let parent = tw; parent && !visited.has(parent); parent = parent.parent) {
+              visited.add(parent);
+              const stack = attachments.get(parent);
+              if (stack) attachmentStacks.push(stack);
+            }
+            return {
+              stack: records.get(tw) ?? null,
+              properties: Object.keys(tw.vars ?? {}).filter(
+                (key) => !reserved.has(key) && !key.startsWith("on")
+              ),
+              targets: (tw.targets?.() ?? []).filter(isElementNode).slice(0, 50).map(describe),
+              localStart: tw.startTime(),
+              duration: tw.duration(),
+              attachmentStacks
+            };
+          });
+          const css = q.cssRules.filter((rule) => {
+            try {
+              return scope.some((el) => el.matches(rule.selector));
+            } catch {
+              return false;
+            }
+          }).map((rule) => rule.id);
+          return {
+            ...base,
+            status: "found",
+            candidates: elements.slice(0, 1001).map(describe),
+            elements: scope.map(describe),
+            animations,
+            css,
+            truncated
+          };
+        });
+        return { results, recorded: count, recordLimitReached: count >= limit, hooked: !!gsap };
+      },
+      timeline(q) {
+        let scope = document.documentElement;
+        if (q.component) {
+          const found = api.query({ targets: [q.component], descendants: false, cssRules: [] }).results[0];
+          if (!found) return { status: "missing", candidates: [], events: [], warnings: [] };
+          if (found.status !== "found")
+            return { status: found.status, candidates: found.candidates, events: [], warnings: [] };
+          const [only, ...others] = found.candidates;
+          if (!only || others.length > 0)
+            return { status: "ambiguous", candidates: found.candidates, events: [], warnings: [] };
+          const el = refs.get(only.ref)?.deref();
+          if (!el) return { status: "stale-ref", candidates: [], events: [], warnings: [] };
+          scope = el;
+        }
+        const registered = Object.values(win.__timelines ?? {});
+        const roots = registered.filter(
+          (root) => !registered.some(
+            (other) => other !== root && (other.getChildren?.(true, false, true) ?? []).includes(root)
+          )
+        );
+        return inspectTimelineRuntime(
+          q,
+          roots,
+          scope,
+          describe,
+          (a) => records.get(a) ?? null,
+          reserved,
+          win.__timelines ?? {}
+        );
+      },
+      dispose() {
+        disposed = true;
+        for (const restore of restorers.reverse()) restore();
+        refs.clear();
+        delete win.__hfInspection;
+      }
+    };
+    win.__hfInspection = api;
+    return api;
+  }
+
+  // src/liveRuntime.ts
+  var live = window.__hfLiveInspection;
+  installInspection(window, live.generation);
+})();