@motionscript/browser 0.1.0-alpha.8 → 0.1.0

package/dist/audio/filter-graph.js

@@ -1,241 +0,0 @@
-import { isCurve, sourceTimeAtClipElapsed } from "@motionscript/core";
-/**
- * How many sample points per second to bake an eased curve segment into for
- * `setValueCurveAtTime`. 200/s (≈ every 5ms) is smooth to the ear and cheap.
- */
-const CURVE_SAMPLES_PER_SECOND = 200;
-/**
- * Apply a (possibly time-varying) {@link Param} to a Web Audio {@link AudioParam}.
- *
- * - **number** → set once (today's behavior; zero scheduling overhead).
- * - **Curve** → resolve against `clipDuration` and schedule each segment:
- *   - linear segments via `setValueAtTime` + `linearRampToValueAtTime`,
- *   - eased segments baked into a `Float32Array` via `setValueCurveAtTime`.
- *
- * `elapsed` (clip-seconds already played when a mid-clip seek starts the source)
- * shifts the schedule back by `elapsed` so "now" reads the curve's value at the
- * clip's *current* position, not its start. A `clamp(v)` hook lets a param keep a
- * valid range (e.g. echo mix 0–1) at every sampled point.
- */
-function applyParam(ctx, audioParam, param, startTime, clipDuration, elapsed, clamp = (v) => v) {
-    // Coerce to a finite value before touching an AudioParam — the platform throws
-    // on NaN/Infinity. Falls back to the current param value (never undefined here).
-    const finite = (v) => {
-        const c = clamp(v);
-        return Number.isFinite(c) ? c : audioParam.value;
-    };
-    if (!isCurve(param)) {
-        audioParam.value = finite(param);
-        return;
-    }
-    // A non-finite clip length yields no usable schedule; hold the curve's start value.
-    if (!Number.isFinite(clipDuration) || clipDuration <= 0) {
-        audioParam.value = finite(param.staticValue(audioParam.value));
-        return;
-    }
-    const base = startTime - elapsed; // map curve t=0 to here so seeks line up
-    const resolved = param.resolve(clipDuration, audioParam.value);
-    if (resolved.length === 0)
-        return;
-    // Anchor the starting value at `startTime` (the seek point) so there is no
-    // jump from the param's default before the first scheduled segment runs.
-    const startValue = param.sampleAt(Math.max(0, elapsed), clipDuration, audioParam.value);
-    audioParam.setValueAtTime(finite(startValue), startTime);
-    for (const seg of resolved) {
-        const segStart = base + seg.startTime;
-        const segEnd = base + seg.endTime;
-        // Skip segments wholly in the past relative to the seek point, or any with a
-        // non-finite boundary (degenerate resolve) that would throw on schedule.
-        if (segEnd <= startTime || !Number.isFinite(segStart) || !Number.isFinite(segEnd))
-            continue;
-        const span = seg.endTime - seg.startTime;
-        if (span <= 0) {
-            audioParam.setValueAtTime(finite(seg.to), Math.max(segStart, startTime));
-            continue;
-        }
-        // How far through this segment the seek lands. A segment already under way
-        // carries on from the anchor rather than starting over from its `from` —
-        // the case a bus hits whenever its first clip enters partway through it.
-        const done = Math.max(0, (startTime - segStart) / span);
-        const curveStart = Math.max(segStart, startTime);
-        if (seg.isLinear) {
-            if (done === 0)
-                audioParam.setValueAtTime(finite(seg.from), curveStart);
-            audioParam.linearRampToValueAtTime(finite(seg.to), segEnd);
-        }
-        else {
-            const curveDur = segEnd - curveStart;
-            if (curveDur <= 0)
-                continue;
-            const count = Math.max(2, Math.ceil(curveDur * CURVE_SAMPLES_PER_SECOND));
-            const samples = new Float32Array(count);
-            for (let i = 0; i < count; i++) {
-                const local = done + (1 - done) * (i / (count - 1));
-                samples[i] = finite(seg.from + (seg.to - seg.from) * seg.ease(local));
-            }
-            audioParam.setValueCurveAtTime(samples, curveStart, curveDur);
-        }
-    }
-}
-/**
- * Builds the Web Audio graph for a clip's filter chain, returning the node to
- * connect downstream. Shared by live playback ({@link WebAudioSink}) and
- * offline export (`mixAudio`) so both paths sound identical.
- *
- * Filters apply in array order (index 0 closest to the source). `speed` filters
- * are intentionally ignored here — they're realized via `source.playbackRate`
- * by the caller (and affect timeline scheduling), not as a graph node.
- *
- * `startTime` is the AudioContext time the source starts; `clipDuration` is the
- * clip-time length the curves run over (a clip's, or a bus's span); `elapsed` is
- * clip-seconds already played at a mid-clip seek (0 for a clean start, negative
- * before the span begins). These let curve-valued params schedule and align.
- *
- * Pass the already-created `source` so its `playbackRate` can be set by the
- * caller; this function only wires nodes *after* the source.
- */
-export function buildAudioFilterGraph(ctx, source, filters, startTime = ctx.currentTime, clipDuration = 0, elapsed = 0) {
-    const nodes = [];
-    const oscillators = [];
-    let cursor = source;
-    const series = (node) => {
-        cursor.connect(node);
-        nodes.push(node);
-        cursor = node;
-    };
-    const apply = (p, v, clamp) => applyParam(ctx, p, v, startTime, clipDuration, elapsed, clamp);
-    for (const filter of filters) {
-        switch (filter.type) {
-            case "gain": {
-                const gain = ctx.createGain();
-                apply(gain.gain, filter.value);
-                series(gain);
-                break;
-            }
-            case "highpass":
-            case "lowpass": {
-                const biquad = ctx.createBiquadFilter();
-                biquad.type = filter.type === "highpass" ? "highpass" : "lowpass";
-                apply(biquad.frequency, filter.frequency);
-                if (filter.q !== undefined)
-                    apply(biquad.Q, filter.q);
-                series(biquad);
-                break;
-            }
-            case "tremolo": {
-                // Carrier gain whose value is modulated by an LFO. With depth d the
-                // carrier base = (1 - d/2) and the LFO swing gain = d/2. The clamp
-                // hook applies these transforms whether depth is scalar or a curve.
-                const carrier = ctx.createGain();
-                const lfo = ctx.createOscillator();
-                const lfoDepth = ctx.createGain();
-                apply(carrier.gain, filter.depth, (d) => 1 - clamp01(d) / 2);
-                apply(lfoDepth.gain, filter.depth, (d) => clamp01(d) / 2);
-                apply(lfo.frequency, filter.rate);
-                lfo.connect(lfoDepth);
-                lfoDepth.connect(carrier.gain);
-                nodes.push(lfoDepth);
-                oscillators.push(lfo);
-                series(carrier);
-                break;
-            }
-            case "echo": {
-                // Dry + wet split. The wet path is a delay with feedback; both sum
-                // into a merge node that becomes the new cursor.
-                const split = cursor;
-                const merge = ctx.createGain();
-                const dry = ctx.createGain();
-                apply(dry.gain, filter.mix ?? 0.5, (m) => 1 - clamp01(m));
-                split.connect(dry);
-                dry.connect(merge);
-                // Delay buffer must accommodate the max delay; size from the static value.
-                const maxDelay = staticOf(filter.delay);
-                const delay = ctx.createDelay(Math.max(1, maxDelay + 1));
-                apply(delay.delayTime, filter.delay);
-                const feedbackGain = ctx.createGain();
-                apply(feedbackGain.gain, filter.feedback, (f) => Math.max(0, Math.min(0.99, f)));
-                const wet = ctx.createGain();
-                apply(wet.gain, filter.mix ?? 0.5, (m) => clamp01(m));
-                split.connect(delay);
-                delay.connect(feedbackGain);
-                feedbackGain.connect(delay); // feedback loop
-                delay.connect(wet);
-                wet.connect(merge);
-                nodes.push(dry, delay, feedbackGain, wet, merge);
-                cursor = merge;
-                break;
-            }
-            case "speed":
-                // Realized via source.playbackRate by the caller; no graph node.
-                break;
-        }
-    }
-    return { output: cursor, nodes, oscillators };
-}
-/** Clamp to [0, 1]. */
-function clamp01(v) {
-    return Math.max(0, Math.min(1, v));
-}
-/** The static/representative number of a param (number itself, or curve's t=0 value). */
-function staticOf(p) {
-    return isCurve(p) ? p.staticValue(0) : p;
-}
-/**
- * Net *constant* playback-rate multiplier from any scalar `speed` filters in the
- * chain (product of all), defaulting to 1. Curve-valued speeds contribute 1 here
- * and are scheduled separately by {@link applySpeedToPlaybackRate}. Mirrors
- * `Sound.effectiveSpeed()` so the renderer applies the same rate the core timeline
- * reserved time for.
- */
-export function effectiveSpeed(filters) {
-    if (!filters)
-        return 1;
-    let speed = 1;
-    for (const f of filters) {
-        if (f.type === "speed" && !isCurve(f.value) && f.value > 0)
-            speed *= f.value;
-    }
-    return speed;
-}
-/** The first curve-valued `speed` filter in the chain, if any. */
-export function speedCurveOf(filters) {
-    if (!filters)
-        return undefined;
-    for (const f of filters) {
-        if (f.type === "speed" && isCurve(f.value))
-            return f.value;
-    }
-    return undefined;
-}
-/**
- * Schedule a time-varying speed curve onto an `AudioBufferSourceNode.playbackRate`.
- *
- * The curve is authored over **source time** (rate as a function of how far through
- * the source we've played). `setValueAtTime`/`linearRampToValueAtTime` schedule in
- * **context time**, so we walk clip-time forward in small steps, convert each to a
- * source-time offset via the integral inverse, read the curve there, and lay down a
- * value point at the matching context time. `scalar` folds in any constant speed
- * filters (they scale the whole rate uniformly).
- *
- * `elapsed` is clip-seconds already played at a mid-clip seek, so the schedule
- * starts at the seek point and aligns the playbackRate to the clip's true position.
- */
-export function applySpeedToPlaybackRate(rate, curve, sourceLength, clipDuration, scalar, startTime, elapsed) {
-    if (!curve)
-        return;
-    const step = 1 / CURVE_SAMPLES_PER_SECOND; // clip-time sampling step
-    const seekAt = Math.max(0, elapsed);
-    // Seed the value exactly at the seek point.
-    const seedSrc = sourceTimeAtClipElapsed(curve, sourceLength, seekAt);
-    rate.setValueAtTime(Math.max(1e-4, curve.sampleAt(seedSrc, sourceLength, 1) * scalar), startTime);
-    for (let s = seekAt + step; s <= clipDuration + step; s += step) {
-        const clampedElapsed = Math.min(s, clipDuration);
-        const srcT = sourceTimeAtClipElapsed(curve, sourceLength, clampedElapsed);
-        const value = Math.max(1e-4, curve.sampleAt(srcT, sourceLength, 1) * scalar);
-        const ctxTime = startTime + (clampedElapsed - seekAt);
-        rate.linearRampToValueAtTime(value, ctxTime);
-        if (clampedElapsed >= clipDuration)
-            break;
-    }
-}
-//# sourceMappingURL=filter-graph.js.map

package/dist/audio/filter-graph.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter-graph.js","sourceRoot":"","sources":["../../src/audio/filter-graph.ts"],"names":[],"mappings":"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","sourcesContent":["import { AudioFilterItem, Param, isCurve, sourceTimeAtClipElapsed } from \"@motionscript/core\";\r\n\r\n/**\r\n * Result of building an audio-filter graph for one source.\r\n *\r\n * - `output` is the last node in the chain; connect it downstream (e.g. to the\r\n *   per-request gain node).\r\n * - `nodes` are every intermediate node, so callers can `disconnect()` them on\r\n *   teardown.\r\n * - `oscillators` are LFOs (from `tremolo`) the caller must `start()` — and may\r\n *   `stop()` — alongside the source, since oscillators need an explicit start.\r\n */\r\nexport interface AudioFilterGraph {\r\n    output: AudioNode;\r\n    nodes: AudioNode[];\r\n    oscillators: OscillatorNode[];\r\n}\r\n\r\n/**\r\n * How many sample points per second to bake an eased curve segment into for\r\n * `setValueCurveAtTime`. 200/s (≈ every 5ms) is smooth to the ear and cheap.\r\n */\r\nconst CURVE_SAMPLES_PER_SECOND = 200;\r\n\r\n/**\r\n * Apply a (possibly time-varying) {@link Param} to a Web Audio {@link AudioParam}.\r\n *\r\n * - **number** → set once (today's behavior; zero scheduling overhead).\r\n * - **Curve** → resolve against `clipDuration` and schedule each segment:\r\n *   - linear segments via `setValueAtTime` + `linearRampToValueAtTime`,\r\n *   - eased segments baked into a `Float32Array` via `setValueCurveAtTime`.\r\n *\r\n * `elapsed` (clip-seconds already played when a mid-clip seek starts the source)\r\n * shifts the schedule back by `elapsed` so \"now\" reads the curve's value at the\r\n * clip's *current* position, not its start. A `clamp(v)` hook lets a param keep a\r\n * valid range (e.g. echo mix 0–1) at every sampled point.\r\n */\r\nfunction applyParam(\r\n    ctx: BaseAudioContext,\r\n    audioParam: AudioParam,\r\n    param: Param,\r\n    startTime: number,\r\n    clipDuration: number,\r\n    elapsed: number,\r\n    clamp: (v: number) => number = (v) => v,\r\n): void {\r\n    // Coerce to a finite value before touching an AudioParam — the platform throws\r\n    // on NaN/Infinity. Falls back to the current param value (never undefined here).\r\n    const finite = (v: number): number => {\r\n        const c = clamp(v);\r\n        return Number.isFinite(c) ? c : audioParam.value;\r\n    };\r\n\r\n    if (!isCurve(param)) {\r\n        audioParam.value = finite(param);\r\n        return;\r\n    }\r\n\r\n    // A non-finite clip length yields no usable schedule; hold the curve's start value.\r\n    if (!Number.isFinite(clipDuration) || clipDuration <= 0) {\r\n        audioParam.value = finite(param.staticValue(audioParam.value));\r\n        return;\r\n    }\r\n\r\n    const base = startTime - elapsed; // map curve t=0 to here so seeks line up\r\n    const resolved = param.resolve(clipDuration, audioParam.value);\r\n    if (resolved.length === 0) return;\r\n\r\n    // Anchor the starting value at `startTime` (the seek point) so there is no\r\n    // jump from the param's default before the first scheduled segment runs.\r\n    const startValue = param.sampleAt(Math.max(0, elapsed), clipDuration, audioParam.value);\r\n    audioParam.setValueAtTime(finite(startValue), startTime);\r\n\r\n    for (const seg of resolved) {\r\n        const segStart = base + seg.startTime;\r\n        const segEnd = base + seg.endTime;\r\n        // Skip segments wholly in the past relative to the seek point, or any with a\r\n        // non-finite boundary (degenerate resolve) that would throw on schedule.\r\n        if (segEnd <= startTime || !Number.isFinite(segStart) || !Number.isFinite(segEnd)) continue;\r\n\r\n        const span = seg.endTime - seg.startTime;\r\n\r\n        if (span <= 0) {\r\n            audioParam.setValueAtTime(finite(seg.to), Math.max(segStart, startTime));\r\n            continue;\r\n        }\r\n\r\n        // How far through this segment the seek lands. A segment already under way\r\n        // carries on from the anchor rather than starting over from its `from` —\r\n        // the case a bus hits whenever its first clip enters partway through it.\r\n        const done = Math.max(0, (startTime - segStart) / span);\r\n        const curveStart = Math.max(segStart, startTime);\r\n\r\n        if (seg.isLinear) {\r\n            if (done === 0) audioParam.setValueAtTime(finite(seg.from), curveStart);\r\n            audioParam.linearRampToValueAtTime(finite(seg.to), segEnd);\r\n        } else {\r\n            const curveDur = segEnd - curveStart;\r\n            if (curveDur <= 0) continue;\r\n            const count = Math.max(2, Math.ceil(curveDur * CURVE_SAMPLES_PER_SECOND));\r\n            const samples = new Float32Array(count);\r\n            for (let i = 0; i < count; i++) {\r\n                const local = done + (1 - done) * (i / (count - 1));\r\n                samples[i] = finite(seg.from + (seg.to - seg.from) * seg.ease(local));\r\n            }\r\n            audioParam.setValueCurveAtTime(samples, curveStart, curveDur);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Builds the Web Audio graph for a clip's filter chain, returning the node to\r\n * connect downstream. Shared by live playback ({@link WebAudioSink}) and\r\n * offline export (`mixAudio`) so both paths sound identical.\r\n *\r\n * Filters apply in array order (index 0 closest to the source). `speed` filters\r\n * are intentionally ignored here — they're realized via `source.playbackRate`\r\n * by the caller (and affect timeline scheduling), not as a graph node.\r\n *\r\n * `startTime` is the AudioContext time the source starts; `clipDuration` is the\r\n * clip-time length the curves run over (a clip's, or a bus's span); `elapsed` is\r\n * clip-seconds already played at a mid-clip seek (0 for a clean start, negative\r\n * before the span begins). These let curve-valued params schedule and align.\r\n *\r\n * Pass the already-created `source` so its `playbackRate` can be set by the\r\n * caller; this function only wires nodes *after* the source.\r\n */\r\nexport function buildAudioFilterGraph(\r\n    ctx: BaseAudioContext,\r\n    source: AudioNode,\r\n    filters: readonly AudioFilterItem[],\r\n    startTime: number = ctx.currentTime,\r\n    clipDuration: number = 0,\r\n    elapsed: number = 0,\r\n): AudioFilterGraph {\r\n    const nodes: AudioNode[] = [];\r\n    const oscillators: OscillatorNode[] = [];\r\n    let cursor: AudioNode = source;\r\n\r\n    const series = (node: AudioNode): void => {\r\n        cursor.connect(node);\r\n        nodes.push(node);\r\n        cursor = node;\r\n    };\r\n\r\n    const apply = (p: AudioParam, v: Param, clamp?: (n: number) => number): void =>\r\n        applyParam(ctx, p, v, startTime, clipDuration, elapsed, clamp);\r\n\r\n    for (const filter of filters) {\r\n        switch (filter.type) {\r\n            case \"gain\": {\r\n                const gain = ctx.createGain();\r\n                apply(gain.gain, filter.value);\r\n                series(gain);\r\n                break;\r\n            }\r\n            case \"highpass\":\r\n            case \"lowpass\": {\r\n                const biquad = ctx.createBiquadFilter();\r\n                biquad.type = filter.type === \"highpass\" ? \"highpass\" : \"lowpass\";\r\n                apply(biquad.frequency, filter.frequency);\r\n                if (filter.q !== undefined) apply(biquad.Q, filter.q);\r\n                series(biquad);\r\n                break;\r\n            }\r\n            case \"tremolo\": {\r\n                // Carrier gain whose value is modulated by an LFO. With depth d the\r\n                // carrier base = (1 - d/2) and the LFO swing gain = d/2. The clamp\r\n                // hook applies these transforms whether depth is scalar or a curve.\r\n                const carrier = ctx.createGain();\r\n                const lfo = ctx.createOscillator();\r\n                const lfoDepth = ctx.createGain();\r\n\r\n                apply(carrier.gain, filter.depth, (d) => 1 - clamp01(d) / 2);\r\n                apply(lfoDepth.gain, filter.depth, (d) => clamp01(d) / 2);\r\n                apply(lfo.frequency, filter.rate);\r\n\r\n                lfo.connect(lfoDepth);\r\n                lfoDepth.connect(carrier.gain);\r\n\r\n                nodes.push(lfoDepth);\r\n                oscillators.push(lfo);\r\n                series(carrier);\r\n                break;\r\n            }\r\n            case \"echo\": {\r\n                // Dry + wet split. The wet path is a delay with feedback; both sum\r\n                // into a merge node that becomes the new cursor.\r\n                const split = cursor;\r\n                const merge = ctx.createGain();\r\n\r\n                const dry = ctx.createGain();\r\n                apply(dry.gain, filter.mix ?? 0.5, (m) => 1 - clamp01(m));\r\n                split.connect(dry);\r\n                dry.connect(merge);\r\n\r\n                // Delay buffer must accommodate the max delay; size from the static value.\r\n                const maxDelay = staticOf(filter.delay);\r\n                const delay = ctx.createDelay(Math.max(1, maxDelay + 1));\r\n                apply(delay.delayTime, filter.delay);\r\n                const feedbackGain = ctx.createGain();\r\n                apply(feedbackGain.gain, filter.feedback, (f) => Math.max(0, Math.min(0.99, f)));\r\n                const wet = ctx.createGain();\r\n                apply(wet.gain, filter.mix ?? 0.5, (m) => clamp01(m));\r\n\r\n                split.connect(delay);\r\n                delay.connect(feedbackGain);\r\n                feedbackGain.connect(delay); // feedback loop\r\n                delay.connect(wet);\r\n                wet.connect(merge);\r\n\r\n                nodes.push(dry, delay, feedbackGain, wet, merge);\r\n                cursor = merge;\r\n                break;\r\n            }\r\n            case \"speed\":\r\n                // Realized via source.playbackRate by the caller; no graph node.\r\n                break;\r\n        }\r\n    }\r\n\r\n    return { output: cursor, nodes, oscillators };\r\n}\r\n\r\n/** Clamp to [0, 1]. */\r\nfunction clamp01(v: number): number {\r\n    return Math.max(0, Math.min(1, v));\r\n}\r\n\r\n/** The static/representative number of a param (number itself, or curve's t=0 value). */\r\nfunction staticOf(p: Param): number {\r\n    return isCurve(p) ? p.staticValue(0) : p;\r\n}\r\n\r\n/**\r\n * Net *constant* playback-rate multiplier from any scalar `speed` filters in the\r\n * chain (product of all), defaulting to 1. Curve-valued speeds contribute 1 here\r\n * and are scheduled separately by {@link applySpeedToPlaybackRate}. Mirrors\r\n * `Sound.effectiveSpeed()` so the renderer applies the same rate the core timeline\r\n * reserved time for.\r\n */\r\nexport function effectiveSpeed(filters: readonly AudioFilterItem[] | undefined): number {\r\n    if (!filters) return 1;\r\n    let speed = 1;\r\n    for (const f of filters) {\r\n        if (f.type === \"speed\" && !isCurve(f.value) && f.value > 0) speed *= f.value;\r\n    }\r\n    return speed;\r\n}\r\n\r\n/** The first curve-valued `speed` filter in the chain, if any. */\r\nexport function speedCurveOf(filters: readonly AudioFilterItem[] | undefined) {\r\n    if (!filters) return undefined;\r\n    for (const f of filters) {\r\n        if (f.type === \"speed\" && isCurve(f.value)) return f.value;\r\n    }\r\n    return undefined;\r\n}\r\n\r\n/**\r\n * Schedule a time-varying speed curve onto an `AudioBufferSourceNode.playbackRate`.\r\n *\r\n * The curve is authored over **source time** (rate as a function of how far through\r\n * the source we've played). `setValueAtTime`/`linearRampToValueAtTime` schedule in\r\n * **context time**, so we walk clip-time forward in small steps, convert each to a\r\n * source-time offset via the integral inverse, read the curve there, and lay down a\r\n * value point at the matching context time. `scalar` folds in any constant speed\r\n * filters (they scale the whole rate uniformly).\r\n *\r\n * `elapsed` is clip-seconds already played at a mid-clip seek, so the schedule\r\n * starts at the seek point and aligns the playbackRate to the clip's true position.\r\n */\r\nexport function applySpeedToPlaybackRate(\r\n    rate: AudioParam,\r\n    curve: ReturnType<typeof speedCurveOf>,\r\n    sourceLength: number,\r\n    clipDuration: number,\r\n    scalar: number,\r\n    startTime: number,\r\n    elapsed: number,\r\n): void {\r\n    if (!curve) return;\r\n    const step = 1 / CURVE_SAMPLES_PER_SECOND; // clip-time sampling step\r\n    const seekAt = Math.max(0, elapsed);\r\n    // Seed the value exactly at the seek point.\r\n    const seedSrc = sourceTimeAtClipElapsed(curve, sourceLength, seekAt);\r\n    rate.setValueAtTime(Math.max(1e-4, curve.sampleAt(seedSrc, sourceLength, 1) * scalar), startTime);\r\n\r\n    for (let s = seekAt + step; s <= clipDuration + step; s += step) {\r\n        const clampedElapsed = Math.min(s, clipDuration);\r\n        const srcT = sourceTimeAtClipElapsed(curve, sourceLength, clampedElapsed);\r\n        const value = Math.max(1e-4, curve.sampleAt(srcT, sourceLength, 1) * scalar);\r\n        const ctxTime = startTime + (clampedElapsed - seekAt);\r\n        rate.linearRampToValueAtTime(value, ctxTime);\r\n        if (clampedElapsed >= clipDuration) break;\r\n    }\r\n}\r\n"]}

package/dist/browser/chunks/chunk-IILVN4SK.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/asset-bytes.ts", "../../../src/audio/bus-graph.ts", "../../../src/audio/effect-graph.ts", "../../../src/audio/loop-region.ts", "../../../src/audio/mixer.ts", "../../../src/audio/player.ts"],
-  "sourcesContent": ["/**\r\n * Where a source URL's bytes come from: a host's local store, then the network.\r\n * The renderer's storage adapter reads every asset through it (`loadBytes`).\r\n *\r\n * ## Why the web adapter needs this at all\r\n *\r\n * The storage adapter addresses every asset by URL and fetches it. That is\r\n * right for an asset that lives somewhere, and wrong for one whose bytes the\r\n * host already has in hand — a file the user has just chosen, a render a local\r\n * model has just produced, a picture whose upload has not finished or cannot\r\n * start because there is no network. In all three the adapter downloads bytes\r\n * that never needed to travel.\r\n *\r\n * `NodeStorageAdapter` has had the answer since it was written: an injected\r\n * `AssetLoader`, with an `inline` map consulted ahead of the disk. This is the\r\n * same seam for the browser.\r\n *\r\n * ## Why it is module-level\r\n *\r\n * The storage adapter is constructed at several sites *inside* this package —\r\n * sessions, the exporter, the audio mixer and the still renderer — none of\r\n * which a host can reach. A constructor argument would\r\n * therefore cover the preview and leave export and stills on the network,\r\n * which is the worst of both: the picture a user sees would come from local\r\n * bytes and the one they render would not.\r\n *\r\n * So this is an *injection point*, not a cache. The adapter still owns every\r\n * decode, every cache, every size ceiling and every eviction rule; all this\r\n * changes is where the compressed bytes came from. A source that answers `null`\r\n * — which is what an unregistered URL, an evicted entry or a host with no local\r\n * store does — leaves the adapter exactly as it was.\r\n */\r\n\r\n/** Local bytes for a source URL, or `null` to go to the network. */\r\nexport type AssetByteSource = (src: string) => Promise<Blob | null>;\r\n\r\nlet source: AssetByteSource | null = null;\r\n\r\n/**\r\n * Installs the byte source for this browsing context, or clears it with `null`.\r\n *\r\n * Called once per window that renders. Later calls replace the previous source\r\n * rather than stacking, because two sources disagreeing about one URL has no\r\n * sensible answer.\r\n */\r\nexport function setAssetByteSource(next: AssetByteSource | null): void {\r\n    source = next;\r\n}\r\n\r\n/**\r\n * The bytes for `src`, or `null`.\r\n *\r\n * Swallows a throwing source on purpose. A host's local store failing is a\r\n * cache miss, not a render failure — the caller falls through to `fetch`, which\r\n * is what it would have done had the source never been installed.\r\n */\r\nexport async function localAssetBytes(src: string): Promise<Blob | null> {\r\n    if (!source) return null;\r\n    try {\r\n        return await source(src);\r\n    } catch {\r\n        return null;\r\n    }\r\n}\r\n\r\n/**\r\n * The network's bytes for `url`. A response that is not OK is a failed load,\r\n * never bytes: a 404 page handed to the font manager marked a family loaded\r\n * with no face in it.\r\n */\r\nexport async function fetchAssetBytes(url: string): Promise<Blob> {\r\n    const response = await fetch(url);\r\n    if (!response.ok) {\r\n        const status = response.statusText ? `${response.status} ${response.statusText}` : `${response.status}`;\r\n        throw new Error(`Fetching \"${url}\" failed: HTTP ${status}`);\r\n    }\r\n    return response.blob();\r\n}\r\n\r\n/** The bytes for `src`: the host's local store first, then the network. */\r\nexport async function loadAssetBytes(src: string): Promise<Blob> {\r\n    return (await localAssetBytes(src)) ?? fetchAssetBytes(src);\r\n}\r\n", "import { busStopKey, type AudioBusStop, type AudioEffect } from \"@motionscript/core\";\r\nimport { applyTransitions, buildAudioEffectGraph } from \"./effect-graph\";\r\n\r\n/**\r\n * The live chains for one audio context's buses.\r\n *\r\n * Held per context rather than per clip, because that is the whole difference\r\n * between a bus and per-clip processing: every clip naming a bus connects into\r\n * the *same* nodes, so a reverb on a bus is one tail the group shares rather\r\n * than one tail each. Flattening the levels into per-clip gain would sound\r\n * right; flattening the effects would not.\r\n */\r\nexport class AudioBusGraph {\r\n    constructor(\r\n        private readonly ctx: BaseAudioContext,\r\n        /** Where the last bus in a chain connects — the master, or the destination. */\r\n        private readonly destination: AudioNode,\r\n    ) { }\r\n\r\n    /**\r\n     * The input node a clip on `bus` should connect to, building the chain the\r\n     * first time it is asked for.\r\n     *\r\n     * `bus` is source-adjacent first, so `bus[0]` is the one the clip feeds and\r\n     * each stop after it is that bus's own parent. An empty or absent chain\r\n     * returns the destination, which is what every clip did before buses\r\n     * existed.\r\n     *\r\n     * `startTime` is the context time a new chain's schedule starts from, and\r\n     * `clipTime` the same instant in the stops' own seconds. A curve on a stop\r\n     * runs over its `startAt`–`endAt`, so the two are what place it.\r\n     */\r\n    inputFor(bus: readonly AudioBusStop[] | undefined, startTime: number, clipTime: number): AudioNode {\r\n        if (!bus || bus.length === 0) return this.destination;\r\n        return this.chainFrom(bus, 0, startTime, clipTime);\r\n    }\r\n\r\n    /** Disconnect every live bus node, so the next {@link inputFor} builds afresh. Safe to call more than once. */\r\n    dispose(): void {\r\n        for (const node of this.nodes) {\r\n            try { node.disconnect(); } catch { /* already torn down */ }\r\n        }\r\n        for (const osc of this.oscillators) {\r\n            try { osc.stop(); } catch { /* never started, or already stopped */ }\r\n        }\r\n        this.nodes.length = 0;\r\n        this.oscillators.length = 0;\r\n        this.inputs.clear();\r\n    }\r\n\r\n    private readonly inputs = new Map<string, AudioNode>();\r\n    private readonly nodes: AudioNode[] = [];\r\n    private readonly oscillators: OscillatorNode[] = [];\r\n\r\n    /**\r\n     * Build (or reuse) the chain for `bus[index]`, connected to whatever\r\n     * `bus[index + 1]` resolves to.\r\n     *\r\n     * Recursive rather than iterative because a bus's *output* has to exist\r\n     * before its own nodes can connect to it, and the outermost bus is the last\r\n     * entry.\r\n     *\r\n     * Reused by everything that changes what it sounds like, down to the master,\r\n     * not by id alone: a bus edited under a playing device, or one id on two\r\n     * tracks, is a different chain, and one built for the first would play the\r\n     * second through stale levels and a curve anchored to the wrong span.\r\n     */\r\n    private chainFrom(bus: readonly AudioBusStop[], index: number, startTime: number, clipTime: number): AudioNode {\r\n        if (index >= bus.length) return this.destination;\r\n\r\n        const stop = bus[index];\r\n        const key = bus.slice(index).map(busStopKey).join(\">\");\r\n        const existing = this.inputs.get(key);\r\n        if (existing) return existing;\r\n\r\n        const output = this.chainFrom(bus, index + 1, startTime, clipTime);\r\n\r\n        // A pass-through head every clip connects to, so the bus has one input\r\n        // whatever its effects turn out to be.\r\n        const input = this.ctx.createGain();\r\n        input.gain.value = 1;\r\n\r\n        // The level is a gain after the effects, as a sound's own level is, so a\r\n        // ramp on it is scheduled exactly as one in `effects` is.\r\n        const level: AudioEffect = { type: \"gain\", value: stop.mute ? 0 : stop.volume };\r\n        const span = stop.endAt - stop.startAt;\r\n        const graph = buildAudioEffectGraph(\r\n            this.ctx, input, [...(stop.effects ?? []), level], startTime, span, clipTime - stop.startAt,\r\n        );\r\n        let tail = graph.output;\r\n        if (stop.transitionIn || stop.transitionOut) {\r\n            const transition = this.ctx.createGain();\r\n            applyTransitions(transition.gain, span, stop.transitionIn, stop.transitionOut, startTime, clipTime - stop.startAt);\r\n            tail.connect(transition);\r\n            this.nodes.push(transition);\r\n            tail = transition;\r\n        }\r\n        tail.connect(output);\r\n\r\n        this.nodes.push(input, ...graph.nodes);\r\n        this.oscillators.push(...graph.oscillators);\r\n        for (const osc of graph.oscillators) osc.start(startTime);\r\n\r\n        this.inputs.set(key, input);\r\n        return input;\r\n    }\r\n}\r\n", "import {\r\n    clipTimeAtSource,\r\n    isRamp,\r\n    resolveRamp,\r\n    sampleRamp,\r\n    sourceTimeAtClip,\r\n    staticValue,\r\n    transitionGainAt,\r\n    transitionSpans,\r\n    type AudioEffect,\r\n    type AudioRequest,\r\n    type AudioTransition,\r\n    type Param,\r\n    type Ramp,\r\n} from \"@motionscript/core\";\r\n\r\n/**\r\n * The Web Audio graph for one source's effect chain.\r\n *\r\n * `output` is the last node, to connect downstream; `nodes` are every node to\r\n * `disconnect()` on teardown; `oscillators` are tremolo LFOs the caller starts\r\n * and stops alongside the source.\r\n */\r\nexport interface AudioEffectGraph {\r\n    output: AudioNode;\r\n    nodes: AudioNode[];\r\n    oscillators: OscillatorNode[];\r\n}\r\n\r\n/** Sample points per second an eased segment or a transition is baked into: about every 5 ms. */\r\nconst CURVE_SAMPLES_PER_SECOND = 200;\r\n\r\n/**\r\n * Apply a {@link Param} to a Web Audio {@link AudioParam}: a number once, a\r\n * ramp as a schedule — linear segments as `linearRampToValueAtTime`, eased\r\n * ones baked into `setValueCurveAtTime`.\r\n *\r\n * `elapsed` is the clip seconds already played when a mid-clip seek starts the\r\n * source, so \"now\" reads the ramp at the clip's current position. `clamp` keeps\r\n * every scheduled value in a param's valid range.\r\n */\r\nfunction applyParam(\r\n    audioParam: AudioParam,\r\n    param: Param,\r\n    startTime: number,\r\n    clipDuration: number,\r\n    elapsed: number,\r\n    clamp: (v: number) => number = (v) => v,\r\n): void {\r\n    // The platform throws on a non-finite value.\r\n    const finite = (v: number): number => {\r\n        const c = clamp(v);\r\n        return Number.isFinite(c) ? c : audioParam.value;\r\n    };\r\n\r\n    if (!isRamp(param)) {\r\n        audioParam.value = finite(param);\r\n        return;\r\n    }\r\n    if (!Number.isFinite(clipDuration) || clipDuration <= 0) {\r\n        audioParam.value = finite(staticValue(param, audioParam.value));\r\n        return;\r\n    }\r\n\r\n    const keys = resolveRamp(param, clipDuration);\r\n    if (keys.length === 0) return;\r\n    const base = startTime - elapsed;\r\n    audioParam.setValueAtTime(finite(sampleRamp(param, Math.max(0, elapsed), clipDuration, audioParam.value)), startTime);\r\n\r\n    for (let i = 1; i < keys.length; i++) {\r\n        const previous = keys[i - 1];\r\n        const key = keys[i];\r\n        const segStart = base + previous.time;\r\n        const segEnd = base + key.time;\r\n        if (segEnd <= startTime) continue;\r\n\r\n        const span = key.time - previous.time;\r\n        if (span <= 0) {\r\n            audioParam.setValueAtTime(finite(key.value), Math.max(segEnd, startTime));\r\n            continue;\r\n        }\r\n\r\n        // A segment already under way when the source starts carries on from\r\n        // the value set at `startTime` rather than restarting from its own.\r\n        const done = Math.max(0, (startTime - segStart) / span);\r\n        const curveStart = Math.max(segStart, startTime);\r\n        if (key.linear) {\r\n            if (done === 0) audioParam.setValueAtTime(finite(previous.value), curveStart);\r\n            audioParam.linearRampToValueAtTime(finite(key.value), segEnd);\r\n        } else {\r\n            const curveDur = segEnd - curveStart;\r\n            const count = Math.max(2, Math.ceil(curveDur * CURVE_SAMPLES_PER_SECOND));\r\n            const samples = new Float32Array(count);\r\n            for (let n = 0; n < count; n++) {\r\n                const local = done + (1 - done) * (n / (count - 1));\r\n                samples[n] = finite(previous.value + (key.value - previous.value) * key.ease(local));\r\n            }\r\n            audioParam.setValueCurveAtTime(samples, curveStart, curveDur);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Builds the Web Audio graph for a clip's effect chain, after an\r\n * already-created `source`. Shared by live playback ({@link WebAudioSink}) and\r\n * offline export (`mixAudio`) so both sound identical.\r\n *\r\n * `startTime` is the context time the source starts; `clipDuration` the clip\r\n * seconds ramps run over (a clip's, or a bus's span); `elapsed` the clip seconds\r\n * already played at a mid-clip seek (0 for a clean start, negative before the\r\n * span begins).\r\n */\r\nexport function buildAudioEffectGraph(\r\n    ctx: BaseAudioContext,\r\n    source: AudioNode,\r\n    effects: readonly AudioEffect[],\r\n    startTime: number = ctx.currentTime,\r\n    clipDuration: number = 0,\r\n    elapsed: number = 0,\r\n): AudioEffectGraph {\r\n    const nodes: AudioNode[] = [];\r\n    const oscillators: OscillatorNode[] = [];\r\n    let cursor: AudioNode = source;\r\n\r\n    const series = (node: AudioNode): void => {\r\n        cursor.connect(node);\r\n        nodes.push(node);\r\n        cursor = node;\r\n    };\r\n\r\n    const apply = (p: AudioParam, v: Param, clamp?: (n: number) => number): void =>\r\n        applyParam(p, v, startTime, clipDuration, elapsed, clamp);\r\n\r\n    for (const effect of effects) {\r\n        switch (effect.type) {\r\n            case \"gain\": {\r\n                const gain = ctx.createGain();\r\n                apply(gain.gain, effect.value);\r\n                series(gain);\r\n                break;\r\n            }\r\n            case \"highpass\":\r\n            case \"lowpass\": {\r\n                const biquad = ctx.createBiquadFilter();\r\n                biquad.type = effect.type;\r\n                apply(biquad.frequency, effect.frequency);\r\n                if (effect.q !== undefined) apply(biquad.Q, effect.q);\r\n                series(biquad);\r\n                break;\r\n            }\r\n            case \"tremolo\": {\r\n                // A carrier gain an LFO swings: with depth d the carrier sits at\r\n                // 1 - d/2 and the swing is d/2.\r\n                const carrier = ctx.createGain();\r\n                const lfo = ctx.createOscillator();\r\n                const lfoDepth = ctx.createGain();\r\n\r\n                apply(carrier.gain, effect.depth, (d) => 1 - clamp01(d) / 2);\r\n                apply(lfoDepth.gain, effect.depth, (d) => clamp01(d) / 2);\r\n                apply(lfo.frequency, effect.rate);\r\n\r\n                lfo.connect(lfoDepth);\r\n                lfoDepth.connect(carrier.gain);\r\n\r\n                nodes.push(lfoDepth);\r\n                oscillators.push(lfo);\r\n                series(carrier);\r\n                break;\r\n            }\r\n            case \"echo\": {\r\n                const split = cursor;\r\n                const merge = ctx.createGain();\r\n\r\n                const dry = ctx.createGain();\r\n                apply(dry.gain, effect.mix ?? 0.5, (m) => 1 - clamp01(m));\r\n                split.connect(dry);\r\n                dry.connect(merge);\r\n\r\n                // The delay line is sized once, so it has to hold the ramp's longest delay.\r\n                const delay = ctx.createDelay(Math.max(1, maxOf(effect.delay) + 1));\r\n                apply(delay.delayTime, effect.delay);\r\n                const feedbackGain = ctx.createGain();\r\n                apply(feedbackGain.gain, effect.feedback, (f) => Math.max(0, Math.min(0.99, f)));\r\n                const wet = ctx.createGain();\r\n                apply(wet.gain, effect.mix ?? 0.5, (m) => clamp01(m));\r\n\r\n                split.connect(delay);\r\n                delay.connect(feedbackGain);\r\n                feedbackGain.connect(delay);\r\n                delay.connect(wet);\r\n                wet.connect(merge);\r\n\r\n                nodes.push(dry, delay, feedbackGain, wet, merge);\r\n                cursor = merge;\r\n                break;\r\n            }\r\n        }\r\n    }\r\n\r\n    return { output: cursor, nodes, oscillators };\r\n}\r\n\r\nfunction clamp01(v: number): number {\r\n    return Math.max(0, Math.min(1, v));\r\n}\r\n\r\nfunction maxOf(p: Param): number {\r\n    return isRamp(p) ? Math.max(0, ...p.keys.map((k) => k.value)) : p;\r\n}\r\n\r\n/**\r\n * Schedule `transitionIn`/`transitionOut` onto a gain over a span `length`\r\n * seconds long, baked like an eased ramp. Between the two it holds at 1.\r\n */\r\nexport function applyTransitions(\r\n    gain: AudioParam,\r\n    length: number,\r\n    transitionIn: AudioTransition | undefined,\r\n    transitionOut: AudioTransition | undefined,\r\n    startTime: number,\r\n    elapsed: number,\r\n): void {\r\n    if (!transitionIn && !transitionOut) return;\r\n    const seek = Math.max(0, elapsed);\r\n    const at = (t: number): number => transitionGainAt(t, length, transitionIn, transitionOut);\r\n    gain.setValueAtTime(at(seek), startTime);\r\n\r\n    const spans = transitionSpans(length, transitionIn, transitionOut);\r\n    const windows: [number, number][] = [];\r\n    if (spans.in > 0) windows.push([0, spans.in]);\r\n    if (spans.out > 0 && Number.isFinite(length)) windows.push([length - spans.out, length]);\r\n    const base = startTime - elapsed;\r\n    for (const [from, to] of windows) {\r\n        const begin = Math.max(from, seek);\r\n        const duration = to - begin;\r\n        if (duration <= 0) continue;\r\n        const count = Math.max(2, Math.ceil(duration * CURVE_SAMPLES_PER_SECOND));\r\n        const samples = new Float32Array(count);\r\n        for (let n = 0; n < count; n++) samples[n] = at(begin + duration * (n / (count - 1)));\r\n        gain.setValueCurveAtTime(samples, base + begin, duration);\r\n    }\r\n}\r\n\r\n/** How one request plays its source: the rate, and the lengths its ramps and transitions run over. */\r\nexport interface Playback {\r\n    /** The constant `playbackRate`; 1 under a ramp, which is scheduled instead. */\r\n    rate: number;\r\n    speedRamp?: Ramp;\r\n    /** Source seconds a speed ramp is placed on. */\r\n    sourceLength: number;\r\n    /** Clip seconds the volume and effect ramps run over. */\r\n    clipDuration: number;\r\n    /** What the transitions run over: the clip's length, unknown for an open one. */\r\n    transitionLength: number;\r\n}\r\n\r\nexport function playbackOf(req: AudioRequest, bufferDuration: number): Playback {\r\n    const speed = req.speed ?? 1;\r\n    const speedRamp = isRamp(speed) ? speed : undefined;\r\n    const rate = speedRamp || !(Number.isFinite(speed) && (speed as number) > 0) ? 1 : (speed as number);\r\n    // Placed on the same length core sized the request with, not the decoded buffer.\r\n    const sourceLength = req.sourceLength ?? Math.max(0, bufferDuration - req.trimStart);\r\n    const bounded = Number.isFinite(req.endAt);\r\n    const clipDuration = bounded ? Math.max(0, req.endAt - req.startAt) : clipTimeAtSource(speed, sourceLength);\r\n    return { rate, speedRamp, sourceLength, clipDuration, transitionLength: bounded ? clipDuration : Infinity };\r\n}\r\n\r\n/** Source seconds after `trimStart` that `clipElapsed` clip seconds have played. */\r\nexport function sourceOffsetOf(playback: Playback, clipElapsed: number): number {\r\n    return playback.speedRamp\r\n        ? sourceTimeAtClip(playback.speedRamp, playback.sourceLength, clipElapsed)\r\n        : clipElapsed * playback.rate;\r\n}\r\n\r\n/**\r\n * A request's level, then its transitions, after `from`: the gains every\r\n * request plays through on its way to its bus.\r\n */\r\nexport function buildLevel(\r\n    ctx: BaseAudioContext,\r\n    from: AudioNode,\r\n    req: AudioRequest,\r\n    playback: Playback,\r\n    startTime: number,\r\n    elapsed: number,\r\n): { output: AudioNode; nodes: AudioNode[] } {\r\n    const level = ctx.createGain();\r\n    applyParam(level.gain, req.volume ?? 1, startTime, playback.clipDuration, elapsed);\r\n    from.connect(level);\r\n    if (!req.transitionIn && !req.transitionOut) return { output: level, nodes: [level] };\r\n    const transition = ctx.createGain();\r\n    applyTransitions(transition.gain, playback.transitionLength, req.transitionIn, req.transitionOut, startTime, elapsed);\r\n    level.connect(transition);\r\n    return { output: transition, nodes: [level, transition] };\r\n}\r\n\r\n/**\r\n * Schedule a speed ramp onto an `AudioBufferSourceNode.playbackRate`.\r\n *\r\n * The ramp runs over **source** seconds and Web Audio schedules in context\r\n * seconds, so this walks clip time in small steps, converts each to a source\r\n * offset through the integral inverse, and lays down the rate there. `elapsed`\r\n * is clip seconds already played at a mid-clip seek.\r\n */\r\nexport function applySpeedToPlaybackRate(\r\n    rate: AudioParam,\r\n    speed: Ramp | undefined,\r\n    sourceLength: number,\r\n    clipDuration: number,\r\n    startTime: number,\r\n    elapsed: number,\r\n): void {\r\n    if (!speed) return;\r\n    const step = 1 / CURVE_SAMPLES_PER_SECOND;\r\n    const seekAt = Math.max(0, elapsed);\r\n    const valueAt = (clipElapsed: number): number =>\r\n        Math.max(1e-4, sampleRamp(speed, sourceTimeAtClip(speed, sourceLength, clipElapsed), sourceLength, 1));\r\n    rate.setValueAtTime(valueAt(seekAt), startTime);\r\n\r\n    for (let s = seekAt + step; s <= clipDuration + step; s += step) {\r\n        const clamped = Math.min(s, clipDuration);\r\n        rate.linearRampToValueAtTime(valueAt(clamped), startTime + (clamped - seekAt));\r\n        if (clamped >= clipDuration) break;\r\n    }\r\n}\r\n", "import type { AudioRequest } from \"@motionscript/core\";\r\n\r\n/** The span of a decoded buffer a looping request repeats, in source seconds. */\r\nexport interface LoopRegion {\r\n    start: number;\r\n    end: number;\r\n}\r\n\r\n/**\r\n * The region a looping request repeats: from its in-point to its out-point, or to\r\n * the end of the buffer when it has none. `null` for a request that does not loop,\r\n * and for a degenerate region (an out-point at or before the in-point), where the\r\n * device falls back to wrapping the whole buffer.\r\n *\r\n * Shared by the live device and the offline mixer so a preview and an export loop\r\n * the same samples.\r\n */\r\nexport function loopRegionOf(request: AudioRequest, bufferDuration: number): LoopRegion | null {\r\n    if (!request.loop) return null;\r\n    const start = Math.min(Math.max(0, request.trimStart), bufferDuration);\r\n    const end = Math.min(request.trimEnd ?? bufferDuration, bufferDuration);\r\n    return end > start ? { start, end } : null;\r\n}\r\n\r\n/**\r\n * Configure `source` to play `request`'s loop: on or off, and over the trimmed\r\n * region rather than the whole buffer (`loopStart`/`loopEnd` default to the\r\n * whole buffer, which is how a trim used to be lost).\r\n */\r\nexport function applyLoop(source: AudioBufferSourceNode, request: AudioRequest): LoopRegion | null {\r\n    source.loop = request.loop;\r\n    const region = source.buffer ? loopRegionOf(request, source.buffer.duration) : null;\r\n    if (region) {\r\n        source.loopStart = region.start;\r\n        source.loopEnd = region.end;\r\n    }\r\n    return region;\r\n}\r\n\r\n/**\r\n * Fold a source offset into a loop region.\r\n *\r\n * A seek into the middle of a looping clip lands at `trimStart + elapsed`, which\r\n * can be many passes past the region's end; the device would not wrap an offset\r\n * that starts outside the region, so it is wrapped here.\r\n */\r\nexport function wrapIntoRegion(region: LoopRegion | null, offset: number): number {\r\n    if (!region || offset < region.end) return offset;\r\n    return region.start + ((offset - region.start) % (region.end - region.start));\r\n}\r\n", "import type { AssetCatalog } from \"@motionscript/core\";\r\nimport type { AudioMixer, ScheduledAudioRequest } from \"../frame-loop\";\r\nimport { fetchAssetBytes, localAssetBytes } from \"../asset-bytes\";\r\nimport { AudioBusGraph } from \"./bus-graph\";\r\nimport { applyLoop } from \"./loop-region\";\r\nimport { applySpeedToPlaybackRate, buildAudioEffectGraph, buildLevel, playbackOf, sourceOffsetOf } from \"./effect-graph\";\r\n\r\n/** Sample rate used when the caller doesn't pick one. */\r\nexport const DEFAULT_SAMPLE_RATE = 44100;\r\n\r\nexport interface MixAudioOptions {\r\n    /** Defaults to {@link DEFAULT_SAMPLE_RATE}. */\r\n    sampleRate?: number;\r\n    /**\r\n     * Resolves a request's `src` to the address its bytes live at, as the storage\r\n     * adapter does for the live paths. Omitted, a `src` is\r\n     * fetched as written — right only while the host keys its manifest by URL.\r\n     */\r\n    catalog?: AssetCatalog;\r\n}\r\n\r\n/** Audio first, then video: a clip's own soundtrack is requested under the video's key. */\r\nfunction audioUrl(src: string, catalog: AssetCatalog | undefined): string {\r\n    if (!catalog) return src;\r\n    try {\r\n        return catalog.getAudioMeta(src).src || src;\r\n    } catch {\r\n        try {\r\n            return catalog.getVideoMeta(src).src || src;\r\n        } catch {\r\n            return src;\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Reads and decodes an audio source against a scratch `OfflineAudioContext`\r\n * (decoding requires a context but doesn't render through it). The host's byte\r\n * source is asked first, as for every other asset read: a mix that went to the\r\n * network would fail where the preview played, offline or for bytes not yet\r\n * uploaded.\r\n */\r\nasync function fetchAudioBuffer(src: string, ctx: OfflineAudioContext): Promise<AudioBuffer> {\r\n    const blob = (await localAssetBytes(src)) ?? (await fetchAssetBytes(src));\r\n    return ctx.decodeAudioData(await blob.arrayBuffer());\r\n}\r\n\r\n/**\r\n * Render every scheduled request into one timeline-length buffer.\r\n *\r\n * An `OfflineAudioContext` graph — gain per request, looping/trimming, and the\r\n * same filter chain the live {@link WebAudioSink} builds — rendered in one\r\n * pass rather than scheduled per frame.\r\n *\r\n * Shared by the video exporter and by `mixTimelineAudio`, deliberately: a split\r\n * export and a whole one have to be the same mix, and two implementations of\r\n * \"stack these clips\" would eventually disagree.\r\n *\r\n * Curve-valued filter params and `speed` curves schedule here exactly as they do\r\n * in {@link WebAudioSink.playBuffer}, which is the reference implementation —\r\n * the two must be read side by side when either changes.\r\n *\r\n * One deliberate difference: this schedules at absolute context times, so clip\r\n * starts are sample-accurate here and quantized to `1/fps` in live playback,\r\n * which starts sources at `currentTime` on a clock tick.\r\n */\r\nexport async function mixAudio(\r\n    requests: readonly ScheduledAudioRequest[],\r\n    totalDuration: number,\r\n    options: MixAudioOptions = {},\r\n): Promise<AudioBuffer | null> {\r\n    if (requests.length === 0) return null;\r\n    const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;\r\n    const frames = Math.ceil(totalDuration * sampleRate);\r\n    if (frames <= 0) return null;\r\n\r\n    const uniqueSrcs = [...new Set(requests.map(r => r.request.src))];\r\n    const scratchCtx = new OfflineAudioContext(2, frames, sampleRate);\r\n\r\n    // A source only a picture's own sound wants may hold no audio at all, which\r\n    // is silence rather than a failed mix — see `AudioRequest.optional`.\r\n    const asked = new Set(requests.filter(r => !r.request.optional).map(r => r.request.src));\r\n    const decoded = new Map<string, AudioBuffer>();\r\n    await Promise.all(uniqueSrcs.map(async (src) => {\r\n        try {\r\n            decoded.set(src, await fetchAudioBuffer(audioUrl(src, options.catalog), scratchCtx));\r\n        } catch (cause) {\r\n            if (asked.has(src)) throw cause;\r\n        }\r\n    }));\r\n\r\n    const mixCtx = new OfflineAudioContext(2, frames, sampleRate);\r\n    // The same shared-chain rule the live device uses, for the same reason: an\r\n    // export that flattened buses into per-clip processing would not match what\r\n    // the preview sounded like.\r\n    const buses = new AudioBusGraph(mixCtx, mixCtx.destination);\r\n\r\n    for (const { request: req, globalOffset } of requests) {\r\n        const srcBuffer = decoded.get(req.src);\r\n        if (!srcBuffer) continue;\r\n\r\n        const globalStart = globalOffset + req.startAt;\r\n        // `endAt` is `Infinity` for an open clip; either way the timeline bounds it.\r\n        const globalEnd = Math.min(globalOffset + req.endAt, totalDuration);\r\n        const playDuration = globalEnd - globalStart;\r\n        if (playDuration <= 0) continue;\r\n\r\n        const source = mixCtx.createBufferSource();\r\n        source.buffer = srcBuffer;\r\n        applyLoop(source, req);\r\n\r\n        // Ramps resolve against the clip's own length, deliberately *not*\r\n        // `playDuration`, which is that length truncated by the timeline end:\r\n        // resolving against the truncated value would squeeze the whole ramp\r\n        // into the surviving part instead of cutting it off. `elapsed` is 0:\r\n        // unlike a live seek, the mix always starts a clip at its beginning.\r\n        const playback = playbackOf(req, srcBuffer.duration);\r\n        if (playback.rate !== 1) source.playbackRate.value = playback.rate;\r\n        applySpeedToPlaybackRate(\r\n            source.playbackRate, playback.speedRamp, playback.sourceLength, playback.clipDuration, globalStart, 0,\r\n        );\r\n\r\n        // The same chain as the live WebAudioSink graph, so exports sound like the preview.\r\n        const graph = buildAudioEffectGraph(mixCtx, source, req.effects ?? [], globalStart, playback.clipDuration, 0);\r\n        const level = buildLevel(mixCtx, graph.output, req, playback, globalStart, 0);\r\n        // From the mix's start, whichever clip asks first: a bus's chain is shared,\r\n        // so its schedule cannot begin at one clip's start. Context time 0 is\r\n        // `-globalOffset` in this request's seconds, which are its stops' too.\r\n        level.output.connect(buses.inputFor(req.bus, 0, -globalOffset));\r\n\r\n        // start()'s 3rd arg is a source-buffer duration: under a speed ramp the\r\n        // buffer consumed over a span of clip time is the integral of the rate,\r\n        // not a multiple of it.\r\n        const consumed = sourceOffsetOf(playback, playDuration);\r\n\r\n        source.start(globalStart, req.trimStart, consumed);\r\n        for (const osc of graph.oscillators) osc.start(globalStart);\r\n    }\r\n\r\n    return mixCtx.startRendering();\r\n}\r\n\r\n/**\r\n * Adapter presenting {@link mixAudio} as the exporter's injected mixer seam.\r\n *\r\n * The sample rate is a constructor argument rather than a third `mix` parameter\r\n * because {@link AudioMixer} — the seam `renderTimeline` calls through — takes\r\n * exactly two, so anything passed as a third would be silently dropped. Fixing\r\n * it here rather than widening the interface keeps the rate a property of *this*\r\n * mixer, which is whose business it is.\r\n */\r\nexport class WebAudioMixer implements AudioMixer<AudioBuffer> {\r\n    constructor(\r\n        private readonly sampleRate: number = DEFAULT_SAMPLE_RATE,\r\n        private readonly catalog?: AssetCatalog,\r\n    ) { }\r\n\r\n    mix(\r\n        requests: readonly ScheduledAudioRequest[],\r\n        totalDuration: number,\r\n    ): Promise<AudioBuffer | null> {\r\n        return mixAudio(requests, totalDuration, {\r\n            sampleRate: this.sampleRate,\r\n            catalog: this.catalog,\r\n        });\r\n    }\r\n}\r\n\r\n/**\r\n * Encode an `AudioBuffer` as a 16-bit PCM WAV.\r\n *\r\n * The only other encoder in this package is the AAC track inside the mp4 muxer,\r\n * which is reachable solely by exporting a video — so without this a mixdown has\r\n * no file representation at all. WAV because it needs no codec support and is\r\n * lossless; a host wanting mp3/aac can re-encode from here.\r\n */\r\nexport function encodeWav(buffer: AudioBuffer): Uint8Array<ArrayBuffer> {\r\n    const channelCount = buffer.numberOfChannels;\r\n    const frameCount = buffer.length;\r\n    const bytesPerSample = 2;\r\n    const blockAlign = channelCount * bytesPerSample;\r\n    const dataBytes = frameCount * blockAlign;\r\n\r\n    const out = new ArrayBuffer(44 + dataBytes);\r\n    const view = new DataView(out);\r\n\r\n    const ascii = (offset: number, text: string) => {\r\n        for (let i = 0; i < text.length; i++) view.setUint8(offset + i, text.charCodeAt(i));\r\n    };\r\n\r\n    ascii(0, \"RIFF\");\r\n    view.setUint32(4, 36 + dataBytes, true);\r\n    ascii(8, \"WAVE\");\r\n    ascii(12, \"fmt \");\r\n    view.setUint32(16, 16, true);            // PCM header length\r\n    view.setUint16(20, 1, true);             // format: PCM\r\n    view.setUint16(22, channelCount, true);\r\n    view.setUint32(24, buffer.sampleRate, true);\r\n    view.setUint32(28, buffer.sampleRate * blockAlign, true);\r\n    view.setUint16(32, blockAlign, true);\r\n    view.setUint16(34, 8 * bytesPerSample, true);\r\n    ascii(36, \"data\");\r\n    view.setUint32(40, dataBytes, true);\r\n\r\n    // Pull each channel out once — getChannelData is a live view, but calling it\r\n    // per sample inside the interleave loop is measurably slower.\r\n    const channels: Float32Array[] = [];\r\n    for (let c = 0; c < channelCount; c++) channels.push(buffer.getChannelData(c));\r\n\r\n    let offset = 44;\r\n    for (let frame = 0; frame < frameCount; frame++) {\r\n        for (let c = 0; c < channelCount; c++) {\r\n            // Clamp before scaling: the mix bus can exceed [-1,1] where clips\r\n            // overlap, and letting that wrap turns a loud passage into noise.\r\n            const sample = Math.max(-1, Math.min(1, channels[c][frame]));\r\n            view.setInt16(offset, sample < 0 ? sample * 0x8000 : sample * 0x7fff, true);\r\n            offset += bytesPerSample;\r\n        }\r\n    }\r\n\r\n    return new Uint8Array(out);\r\n}\r\n", "import { AudioSink, AudioRequest } from \"@motionscript/core\";\r\nimport { AudioBusGraph } from \"./bus-graph\";\r\nimport { applyLoop, wrapIntoRegion } from \"./loop-region\";\r\nimport { applySpeedToPlaybackRate, buildAudioEffectGraph, buildLevel, playbackOf, sourceOffsetOf } from \"./effect-graph\";\r\n\r\ntype ActiveSource = {\r\n    source: AudioBufferSourceNode;\r\n    request: AudioRequest;\r\n    /** Effect and level nodes to disconnect on teardown. */\r\n    nodes: AudioNode[];\r\n    /** Tremolo LFOs to stop on teardown. */\r\n    oscillators: OscillatorNode[];\r\n};\r\n\r\n/**\r\n * Web Audio implementation of {@link AudioSink} — decodes and caches source\r\n * buffers, then schedules/plays {@link AudioRequest}s as `AudioBufferSourceNode`s\r\n * through a shared master gain (global mute and volume). `schedule` registers the\r\n * active set of requests for the current frame; `syncTo` then starts/stops\r\n * sources to match `clipTime`, so playback follows scrubbing and seeks.\r\n */\r\nexport class WebAudioSink extends AudioSink {\r\n    private readonly borrowed: AudioContext | undefined;\r\n    private _context: AudioContext | null = null;\r\n    private bufferCache = new Map<string, AudioBuffer>();\r\n    private decoding = new Map<string, Promise<void>>();\r\n    private active = new Map<string, ActiveSource>();\r\n    private scheduled: AudioRequest[] = [];\r\n    private disposed: boolean = false;\r\n    /** The master gain and the live bus chains (shared across every clip that names one), built with the context. */\r\n    private _graph: { master: GainNode; buses: AudioBusGraph } | null = null;\r\n    private muted = false;\r\n    private volume = 1;\r\n\r\n    constructor(context?: AudioContext) {\r\n        super();\r\n        this.borrowed = context;\r\n    }\r\n\r\n    /**\r\n     * The context, created on first use rather than with the sink: a new\r\n     * AudioContext opens the audio device (50–65 ms on a desktop), and a\r\n     * session that never plays or decodes sound never needs one.\r\n     */\r\n    getContext(): AudioContext {\r\n        this._context ??= this.borrowed ?? new AudioContext();\r\n        return this._context;\r\n    }\r\n\r\n    private get context(): AudioContext {\r\n        return this.getContext();\r\n    }\r\n\r\n    private get graph(): { master: GainNode; buses: AudioBusGraph } {\r\n        if (!this._graph) {\r\n            const master = this.context.createGain();\r\n            master.connect(this.context.destination);\r\n            this._graph = { master, buses: new AudioBusGraph(this.context, master) };\r\n            this.applyMasterGain();\r\n        }\r\n        return this._graph;\r\n    }\r\n\r\n    /**\r\n     * Resume the AudioContext. Must be called from within a user gesture\r\n     * (e.g. a click handler) the first time, or browsers keep the context\r\n     * suspended and no audio is heard.\r\n     */\r\n    unlock(): void {\r\n        if (this.context.state === \"suspended\") {\r\n            this.context.resume();\r\n        }\r\n    }\r\n\r\n    has(src: string): boolean {\r\n        return this.bufferCache.has(src);\r\n    }\r\n\r\n    async append(src: string, data: ArrayBuffer): Promise<void> {\r\n        if (this.bufferCache.has(src)) return;\r\n        const existing = this.decoding.get(src);\r\n        if (existing) return existing;\r\n\r\n        // decodeAudioData detaches `data` — that's fine, the caller in\r\n        // AssetManager.fetchAudio discards its reference immediately after\r\n        // awaiting append. Skipping the defensive .slice(0) saves a multi-MB\r\n        // allocation per audio source.\r\n        const job = this.context.decodeAudioData(data).then((buffer) => {\r\n            this.bufferCache.set(src, buffer);\r\n        }).finally(() => {\r\n            this.decoding.delete(src);\r\n        });\r\n        this.decoding.set(src, job);\r\n        await job;\r\n    }\r\n\r\n    /** Drops cached buffers and stops active sources for srcs/requests no longer referenced — called when the asset set changes (e.g. seeking across scene boundaries). */\r\n    retain(keep: ReadonlySet<string>): void {\r\n        for (const src of [...this.bufferCache.keys()]) {\r\n            if (!keep.has(src)) this.bufferCache.delete(src);\r\n        }\r\n        for (const [id, active] of this.active) {\r\n            if (!keep.has(active.request.src)) this.stopSource(id, active);\r\n        }\r\n    }\r\n\r\n    /** Replaces the active request set; stops any currently-playing source whose request is no longer scheduled. Actual start/stop-to-match-time happens in `syncTo`. */\r\n    schedule(requests: readonly AudioRequest[]): void {\r\n        const next = new Set(requests.map(r => r.id));\r\n        for (const [id, active] of this.active) {\r\n            if (!next.has(id)) this.stopSource(id, active);\r\n        }\r\n        this.scheduled = requests.slice();\r\n    }\r\n\r\n    /** Starts sources whose `[startAt, endAt)` window now contains `clipTime` (computing the correct buffer offset for the seek point) and stops any that have fallen outside it. */\r\n    syncTo(clipTime: number): void {\r\n        const liveIds = new Set<string>();\r\n\r\n        for (const req of this.scheduled) {\r\n            // `endAt` is `Infinity` for an open clip, so the comparison needs no\r\n            // nullish fallback — see AudioRequest.endAt.\r\n            const isInWindow = clipTime >= req.startAt && clipTime < req.endAt;\r\n            if (!isInWindow) continue;\r\n\r\n            liveIds.add(req.id);\r\n            if (!this.active.has(req.id)) {\r\n                const buffer = this.bufferCache.get(req.src);\r\n                if (buffer) this.playBuffer(buffer, req, clipTime);\r\n            }\r\n        }\r\n\r\n        for (const [id, active] of this.active) {\r\n            if (!liveIds.has(id)) this.stopSource(id, active);\r\n        }\r\n    }\r\n\r\n    async play(time: number, _speed: number, _reverse: boolean): Promise<void> {\r\n        if (this.context.state === \"suspended\") {\r\n            await this.context.resume();\r\n        }\r\n        this.syncTo(time);\r\n    }\r\n\r\n    stop(): void {\r\n        for (const [id, active] of this.active) {\r\n            this.stopSource(id, active);\r\n        }\r\n        // A bus's curves are scheduled against the clock of the run that built\r\n        // it, so the next play, from wherever it lands, builds them again.\r\n        this._graph?.buses.dispose();\r\n    }\r\n\r\n    setMuted(muted: boolean): void {\r\n        this.muted = muted;\r\n        this.applyMasterGain();\r\n    }\r\n\r\n    setVolume(volume: number): void {\r\n        this.volume = Math.max(0, volume);\r\n        this.applyMasterGain();\r\n    }\r\n\r\n    /** Mute and volume are held separately so unmuting restores the set level. */\r\n    private applyMasterGain(): void {\r\n        if (this._graph) this._graph.master.gain.value = this.muted ? 0 : this.volume;\r\n    }\r\n\r\n    /** Starts a buffer source mid-clip if `clipTime` lands after the request's start — the offset accounts for the request's trim, the elapsed time since `startAt`, and its speed. */\r\n    private playBuffer(buffer: AudioBuffer, req: AudioRequest, clipTime: number): void {\r\n        const startTime = this.context.currentTime;\r\n        const playback = playbackOf(req, buffer.duration);\r\n        const elapsed = Math.max(0, clipTime - req.startAt);\r\n\r\n        const source = this.context.createBufferSource();\r\n        source.buffer = buffer;\r\n        const loopRegion = applyLoop(source, req);\r\n        if (playback.rate !== 1) source.playbackRate.value = playback.rate;\r\n        applySpeedToPlaybackRate(\r\n            source.playbackRate, playback.speedRamp, playback.sourceLength, playback.clipDuration, startTime, elapsed,\r\n        );\r\n\r\n        const graph = buildAudioEffectGraph(\r\n            this.context, source, req.effects ?? [], startTime, playback.clipDuration, elapsed,\r\n        );\r\n        const level = buildLevel(this.context, graph.output, req, playback, startTime, elapsed);\r\n        // Into this clip's bus chain, or straight to the master when it has none.\r\n        // The chain is shared: two clips on one bus reach the same nodes, which is\r\n        // what makes a bus effect one tail rather than one per clip.\r\n        level.output.connect(this.graph.buses.inputFor(req.bus, startTime, clipTime));\r\n\r\n        const audioOffset = req.trimStart + sourceOffsetOf(playback, elapsed);\r\n        source.start(startTime, wrapIntoRegion(loopRegion, audioOffset));\r\n        for (const osc of graph.oscillators) osc.start(startTime);\r\n\r\n        source.onended = () => {\r\n            if (this.active.get(req.id)?.source === source) {\r\n                this.active.delete(req.id);\r\n            }\r\n        };\r\n\r\n        this.active.set(req.id, {\r\n            source,\r\n            request: req,\r\n            nodes: [...graph.nodes, ...level.nodes],\r\n            oscillators: graph.oscillators,\r\n        });\r\n    }\r\n\r\n    private stopSource(id: string, active: ActiveSource): void {\r\n        try {\r\n            active.source.onended = null;\r\n            active.source.stop();\r\n            for (const osc of active.oscillators) osc.stop();\r\n            active.source.disconnect();\r\n            for (const node of active.nodes) node.disconnect();\r\n        } catch {\r\n            // already stopped\r\n        }\r\n        this.active.delete(id);\r\n    }\r\n\r\n    dispose(): void {\r\n        if (this.disposed) return;\r\n        this.disposed = true;\r\n        super.dispose();\r\n        this.bufferCache.clear();\r\n        this.decoding.clear();\r\n        this.scheduled.length = 0;\r\n        this._graph?.buses.dispose();\r\n        try {\r\n            this._graph?.master.disconnect();\r\n        } catch {\r\n            // already disconnected\r\n        }\r\n        const owned = this.borrowed ? null : this._context;\r\n        if (owned && owned.state !== \"closed\") {\r\n            owned.close();\r\n        }\r\n    }\r\n}\r\n"],
-  "mappings": "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",
-  "names": ["source", "setAssetByteSource", "next", "localAssetBytes", "src", "fetchAssetBytes", "url", "response", "status", "loadAssetBytes", "busStopKey", "clipTimeAtSource", "isRamp", "resolveRamp", "sampleRamp", "sourceTimeAtClip", "staticValue", "transitionGainAt", "transitionSpans", "CURVE_SAMPLES_PER_SECOND", "applyParam", "audioParam", "param", "startTime", "clipDuration", "elapsed", "clamp", "v", "finite", "c", "keys", "base", "i", "previous", "key", "segStart", "segEnd", "span", "done", "curveStart", "curveDur", "count", "samples", "n", "local", "buildAudioEffectGraph", "ctx", "source", "effects", "nodes", "oscillators", "cursor", "series", "node", "apply", "p", "effect", "gain", "biquad", "carrier", "lfo", "lfoDepth", "d", "clamp01", "split", "merge", "dry", "m", "delay", "maxOf", "feedbackGain", "f", "wet", "k", "applyTransitions", "length", "transitionIn", "transitionOut", "seek", "at", "t", "spans", "windows", "from", "to", "begin", "duration", "playbackOf", "req", "bufferDuration", "speed", "speedRamp", "rate", "sourceLength", "bounded", "sourceOffsetOf", "playback", "clipElapsed", "buildLevel", "level", "transition", "applySpeedToPlaybackRate", "step", "seekAt", "valueAt", "s", "clamped", "AudioBusGraph", "ctx", "destination", "bus", "startTime", "clipTime", "node", "osc", "index", "stop", "key", "busStopKey", "existing", "output", "input", "level", "span", "graph", "buildAudioEffectGraph", "tail", "transition", "applyTransitions", "loopRegionOf", "request", "bufferDuration", "start", "end", "applyLoop", "source", "region", "wrapIntoRegion", "offset", "DEFAULT_SAMPLE_RATE", "audioUrl", "src", "catalog", "fetchAudioBuffer", "ctx", "blob", "localAssetBytes", "fetchAssetBytes", "mixAudio", "requests", "totalDuration", "options", "sampleRate", "frames", "uniqueSrcs", "r", "scratchCtx", "asked", "decoded", "cause", "mixCtx", "buses", "AudioBusGraph", "req", "globalOffset", "srcBuffer", "globalStart", "playDuration", "source", "applyLoop", "playback", "playbackOf", "applySpeedToPlaybackRate", "graph", "buildAudioEffectGraph", "buildLevel", "consumed", "sourceOffsetOf", "osc", "WebAudioMixer", "encodeWav", "buffer", "channelCount", "frameCount", "bytesPerSample", "blockAlign", "dataBytes", "out", "view", "ascii", "offset", "text", "i", "channels", "c", "frame", "sample", "AudioSink", "WebAudioSink", "AudioSink", "context", "master", "AudioBusGraph", "src", "data", "existing", "job", "buffer", "keep", "id", "active", "requests", "next", "r", "clipTime", "liveIds", "req", "time", "_speed", "_reverse", "muted", "volume", "startTime", "playback", "playbackOf", "elapsed", "source", "loopRegion", "applyLoop", "applySpeedToPlaybackRate", "graph", "buildAudioEffectGraph", "level", "buildLevel", "audioOffset", "sourceOffsetOf", "wrapIntoRegion", "osc", "node", "owned"]
-}

package/dist/canvaskit-renderer.d.ts

@@ -1,8 +0,0 @@
-import type { BrowserRenderer } from "./engine";
-import { getCanvasKit } from "./getter";
-import { WebStorageAdapter } from "./storage-adapter";
-/** The default backend: CanvasKit over WebGL. */
-export declare function canvasKitRenderer(canvasKit: Awaited<ReturnType<typeof getCanvasKit>>): BrowserRenderer<WebStorageAdapter>;
-/** `renderer` when a host gave one; else CanvasKit, loaded only now. */
-export declare function resolveRenderer(renderer: BrowserRenderer | undefined, wasmUrl?: string): Promise<BrowserRenderer>;
-//# sourceMappingURL=canvaskit-renderer.d.ts.map

package/dist/canvaskit-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvaskit-renderer.d.ts","sourceRoot":"","sources":["../src/canvaskit-renderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,iDAAiD;AACjD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,GAAG,eAAe,CAAC,iBAAiB,CAAC,CAYzH;AAED,wEAAwE;AACxE,wBAAsB,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAEvH"}

package/dist/canvaskit-renderer.js

@@ -1,23 +0,0 @@
-import { getCanvasKit } from "./getter";
-import { WebMeasureContext } from "./measure-context";
-import { WebRenderContext } from "./render-context";
-import { WebStorageAdapter } from "./storage-adapter";
-/** The default backend: CanvasKit over WebGL. */
-export function canvasKitRenderer(canvasKit) {
-    return {
-        createStorageAdapter({ catalog, viewport, fps }) {
-            return new WebStorageAdapter(canvasKit, catalog, viewport, fps);
-        },
-        createRenderContext(storage) {
-            return new WebRenderContext(canvasKit, storage);
-        },
-        createMeasureContext(storage) {
-            return new WebMeasureContext(storage);
-        },
-    };
-}
-/** `renderer` when a host gave one; else CanvasKit, loaded only now. */
-export async function resolveRenderer(renderer, wasmUrl) {
-    return renderer ?? canvasKitRenderer(await getCanvasKit(wasmUrl));
-}
-//# sourceMappingURL=canvaskit-renderer.js.map

package/dist/canvaskit-renderer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvaskit-renderer.js","sourceRoot":"","sources":["../src/canvaskit-renderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,iDAAiD;AACjD,MAAM,UAAU,iBAAiB,CAAC,SAAmD;IACjF,OAAO;QACH,oBAAoB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAgB;YACzD,OAAO,IAAI,iBAAiB,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QACpE,CAAC;QACD,mBAAmB,CAAC,OAA0B;YAC1C,OAAO,IAAI,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACpD,CAAC;QACD,oBAAoB,CAAC,OAA0B;YAC3C,OAAO,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;KACJ,CAAC;AACN,CAAC;AAED,wEAAwE;AACxE,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,QAAqC,EAAE,OAAgB;IACzF,OAAO,QAAQ,IAAI,iBAAiB,CAAC,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AACtE,CAAC","sourcesContent":["import type { MeasureContext2D, PlatformDeps } from \"@motionscript/core\";\r\nimport type { BrowserRenderer } from \"./engine\";\r\nimport { getCanvasKit } from \"./getter\";\r\nimport { WebMeasureContext } from \"./measure-context\";\r\nimport { WebRenderContext } from \"./render-context\";\r\nimport { WebStorageAdapter } from \"./storage-adapter\";\r\n\r\n/** The default backend: CanvasKit over WebGL. */\r\nexport function canvasKitRenderer(canvasKit: Awaited<ReturnType<typeof getCanvasKit>>): BrowserRenderer<WebStorageAdapter> {\r\n    return {\r\n        createStorageAdapter({ catalog, viewport, fps }: PlatformDeps): WebStorageAdapter {\r\n            return new WebStorageAdapter(canvasKit, catalog, viewport, fps);\r\n        },\r\n        createRenderContext(storage: WebStorageAdapter): WebRenderContext {\r\n            return new WebRenderContext(canvasKit, storage);\r\n        },\r\n        createMeasureContext(storage: WebStorageAdapter): MeasureContext2D {\r\n            return new WebMeasureContext(storage);\r\n        },\r\n    };\r\n}\r\n\r\n/** `renderer` when a host gave one; else CanvasKit, loaded only now. */\r\nexport async function resolveRenderer(renderer: BrowserRenderer | undefined, wasmUrl?: string): Promise<BrowserRenderer> {\r\n    return renderer ?? canvasKitRenderer(await getCanvasKit(wasmUrl));\r\n}\r\n"]}

package/dist/decode/image-levels.d.ts

@@ -1,137 +0,0 @@
-import { type PixelSize } from "./levels";
-/**
- * Which level a draw is served, and when levels are decoded and released.
- *
- * Browser-free: decoding, uploading and fetching are the host's, so every
- * decision here runs under a plain test runner with a fake clock.
- */
-/** Mirrors core's `DecodePolicy`, which its barrel does not export yet. */
-export type DecodePolicy = "exact" | "interactive";
-export declare const IMAGE_DECODE_BUDGET_BYTES: number;
-/** Unselected levels older than this go, whatever the budget — bar a {@link RETAINED_LEVEL_BYTES} largest level. */
-export declare const LEVEL_AGE_OUT_MS = 2000;
-/** A preview drawing a level at twice what it needs for this long decodes the smaller one. */
-export declare const DOWNGRADE_AFTER_MS = 5000;
-export declare const IDLE_TO_FLOOR_MS = 30000;
-export declare const IDLE_DROP_SOURCE_MS = 60000;
-export declare const MAX_CONCURRENT_DECODES = 3;
-/** An interactive decode covers this multiple of the demand, so a growing draw re-decodes per octave, not per rung. */
-export declare const UPGRADE_HEADROOM = 2;
-/**
- * A largest level no bigger than this is neither aged out nor downgraded until
- * the budget needs the room: decoding it again the next time a draw grows costs
- * more, in main-thread copies and a blurry frame, than holding it.
- */
-export declare const RETAINED_LEVEL_BYTES: number;
-export interface ImageLevel<G = unknown> {
-    /** The ladder rung this level was decoded for. */
-    readonly edge: number;
-    readonly width: number;
-    readonly height: number;
-    readonly pixels: Uint8Array;
-    /** The host's GPU copy, counted against the budget alongside the pixels. */
-    gpu: G | null;
-    lastSelected: number;
-    /** The pass that last selected it — "unselected" is judged by pass, since several can share a clock tick. */
-    selectedPass: number;
-}
-export interface DecodedImage {
-    pixels: Uint8Array;
-    width: number;
-    height: number;
-    intrinsic: PixelSize;
-    vector: boolean;
-}
-export interface ImageLevelHost<G> {
-    now(): number;
-    /**
-     * Decode `src` at the rung `chooseEdge` picks once the source's intrinsic
-     * size is known — the host may have to fetch or even decode the source to
-     * learn it, which is why the choice is a callback rather than an argument.
-     */
-    decode(src: string, chooseEdge: (intrinsic: PixelSize, vector: boolean) => number): Promise<DecodedImage & {
-        edge: number;
-    }>;
-    /** A level left the cache. Free what was built from it. */
-    released(src: string, level: ImageLevel<G>): void;
-    /** Kept compressed bytes for `src`, so an upgrade needs no refetch; 0 when none. */
-    sourceBytes(src: string): number;
-    dropSource(src: string): void;
-    /** Long edge of the surface in device px, for sizing a first interactive load. */
-    surfaceEdge(): number;
-    onError?(src: string, error: unknown): void;
-}
-export declare class ImageLevelCache<G = unknown> {
-    private readonly _host;
-    private readonly _budget;
-    private _policy;
-    private readonly _entries;
-    private _pass;
-    private _inflight;
-    constructor(_host: ImageLevelHost<G>, _budget?: number);
-    get policy(): DecodePolicy;
-    setPolicy(policy: DecodePolicy): void;
-    has(src: string): boolean;
-    intrinsicSize(src: string): PixelSize | null;
-    /** Make sure `src` has a level to draw with. First loads pick their rung by policy. */
-    load(src: string): Promise<void>;
-    beginPass(): void;
-    /**
-     * The level one draw paints with. `footprint` is the long edge in device px
-     * the draw needs; absent means the source's own resolution.
-     */
-    select(src: string, footprint?: number): ImageLevel<G> | null;
-    /** Decide this pass's level changes, now that every draw has reported. */
-    endPass(): void;
-    /**
-     * What a settling caller must wait for before the frame is right: under
-     * `exact`, every decode queued or running; under `interactive`, only a source
-     * the last pass asked for with nothing resident. An upgrade is {@link hasUpgrades}.
-     */
-    hasPending(): boolean;
-    /** Await what {@link hasPending} reports, and report whether there was any. */
-    warm(): Promise<boolean>;
-    /** Whether, under `interactive`, a source the last pass drew below demand has a better level on its way. */
-    hasUpgrades(): boolean;
-    /** Await the upgrades {@link hasUpgrades} reports; whether one landed. */
-    warmUpgrades(): Promise<boolean>;
-    stats(): {
-        sources: number;
-        levels: number;
-        levelBytes: number;
-        sourceBytes: number;
-        inflight: number;
-    };
-    /** Every level held for `src`, ascending — for tests and stats. */
-    levelsOf(src: string): readonly ImageLevel<G>[];
-    dispose(): void;
-    private _entry;
-    private _blocks;
-    private _upgrading;
-    /** The rung an interactive decode for `demand` asks for: with headroom, capped at the source. */
-    private _interactiveEdge;
-    private _learn;
-    private _add;
-    /**
-     * Queue a decode of `edge`. An interactive request replaces what is queued,
-     * since only the latest demand matters; exact requests accumulate, since a
-     * frame may need several rungs of one source.
-     */
-    private _request;
-    private _pump;
-    /**
-     * The next queued rung worth decoding. Under `interactive` never one below the
-     * latest demand, and no upgrade once what landed meanwhile already covers it.
-     */
-    private _nextEdge;
-    private _ageOut;
-    private _total;
-    /**
-     * Cheapest loss first: levels nothing drew this pass, then levels a preview
-     * holds bigger than it needs, then sources nobody has looked at in a while,
-     * then their compressed bytes. A source's last level is never evicted — a
-     * draw finding nothing would throw rather than degrade.
-     */
-    private _enforceBudget;
-}
-//# sourceMappingURL=image-levels.d.ts.map