@joewinke/jatui 0.11.0 → 0.13.0

package/dist/components/VideoPlayer.svelte.d.ts

@@ -2,10 +2,14 @@ export type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookm
 export type { BandAxis, BandState } from '../video/band/axis';
 export type { VideoLumaTrack } from '../video/band/luma';
 export type { VideoMarker } from '../video/band/markers';
+export type { NightMode, NightWindow } from '../video/night/clock';
+export type { AudioState, AudioStatus, AudioBrokenReason } from '../video/audio/graph';
 import type { VideoBookmark, VideoChapter, VideoSpeakerTalkTime, VideoSpeakerTurn, VideoTranscriptSegment, VideoWaveform } from '../video/types';
 import { type BandState } from '../video/band/axis';
 import { type VideoLumaTrack } from '../video/band/luma';
 import { type VideoMarker } from '../video/band/markers';
+import { type NightMode, type NightWindow } from '../video/night/clock';
+import { type AudioBrokenReason, type AudioState } from '../video/audio';
 type $$ComponentProps = {
     src: string;
     poster?: string | null;
@@ -97,10 +101,89 @@ type $$ComponentProps = {
     onAddBookmark?: (playbackSec: number, label: string) => void;
     /** Right-click on the band. The host owns the panel; this only hit-tests. */
     onBookmarkContext?: (sec: number, existing: VideoBookmark | null, clientX: number, clientY: number) => void;
+    /**
+     * Night dimming (mos-5lzns.33) — a METER, not a preference: ~1×/s while
+     * playing it reads the frame's actual brightness (32×18 canvas) and pulls
+     * the picture down in proportion, warming it through multiply layers so
+     * blacks stay black. A dark scene passes through untouched.
+     *
+     * `'auto'` arms it from the local clock (20:00–07:00; 18:00–08:00 when the
+     * OS prefers dark), `'on'` always, `'off'` never. Omitted (default) ⇒ the
+     * feature does not exist on this player: no N key, no button, no layers.
+     * Bindable — `N` and the moon button cycle it; `onNightModeChange` reports.
+     *
+     * Frame reading needs a CORS-clean load: pass `crossorigin="anonymous"`
+     * for cross-origin media. A tainted canvas runs night on a fixed level
+     * (no meter, no bias light) and calls `onNightBlind`.
+     */
+    night?: NightMode;
+    /** How far night goes, 0.2–1 (default 0.7). Bindable — scrolling the moon button sets it. */
+    nightDepth?: number;
+    /** Override the auto window, local hours `{ from, to }` (wraps midnight when from > to). */
+    nightWindow?: NightWindow | null;
+    /** While night acts, spill the frame's own colours, blurred, behind the player. */
+    biasLight?: boolean;
+    /** Read the `luma` track ~1s ahead so dimming starts BEFORE a bright cut. Only ever adds dimming. */
+    predictive?: boolean;
+    /**
+     * Photosensitivity guard: across the `luma` track's flash intervals,
+     * drop the picture to about 55% brightness (instant in, released per
+     * tick — never a jump back up). Always at full strength: it does NOT
+     * follow `nightDepth`, and it acts whether night is on, off or absent,
+     * whenever the track carries `flashes`. `false` to disable.
+     *
+     * It REDUCES flashes; it does not make content WCAG 2.3.1-safe. Flash
+     * DETECTION is the host's job — the player guards only the intervals the
+     * host supplies in `luma.flashes`.
+     */
+    strobeGuard?: boolean;
+    onNightModeChange?: (mode: NightMode) => void;
+    /** Frame readback was refused (CORS-tainted canvas) — night fell back to a fixed level. */
+    onNightBlind?: () => void;
+    /**
+     * Audio graph (mos-5lzns.31) — all three default OFF (absent = the
+     * feature does not exist on this player and nothing is ever routed).
+     *
+     * `loudness`: a gated RMS meter rides the gain slowly toward
+     * `loudnessTarget` (dBFS, −30…−12, default −20) so a whispered video and
+     * a blaring one arrive at the same level; clamped 0.3–1.35×, it rescues a
+     * quiet mix by a few dB and never becomes an amplifier.
+     * `quietListening`: loudness-compensated tone that rises as the volume
+     * drops (and sits a little on while night is armed).
+     * `limiter`: catches peaks above −3 dBFS that the slow rider can't.
+     *
+     * ⚠ Routing into WebAudio is permanent for the element, and a source
+     * that isn't CORS-clean routes to SILENCE. So the player routes only
+     * when the src is blob:/data: or `crossorigin` is set ("anonymous" /
+     * "use-credentials", with the server answering Access-Control-Allow-
+     * Origin) — a same-origin URL is NOT enough, since it may redirect to
+     * storage on another origin. Anything else is refused and plays
+     * unprocessed (`status: 'cors'`). It also waits for the AudioContext to
+     * be `running` (a user gesture); until then native audio plays.
+     *
+     * After routing it cannot be undone, so the player reports
+     * `status: 'broken'` and calls `onAudioBroken(reason)`:
+     * · 'unsafe-src' — the src later changed to one that isn't route-safe
+     *   (or `crossorigin` was removed). Remount the player (a fresh element)
+     *   for that source.
+     * · 'silent' — bit-exact silence for 4s while the video plays audibly
+     *   AND the browser shows decoded audio flowing (a video with no audio
+     *   track never fires). Show a notice and/or turn the audio features
+     *   off for that src — do NOT remount; it would loop.
+     * · 'build-failed' — construction threw: plain audio for the session.
+     */
+    loudness?: boolean;
+    loudnessTarget?: number;
+    quietListening?: boolean;
+    limiter?: boolean;
+    /** Graph status + the rider's live gain (≤5×/s while matching acts). */
+    onAudioState?: (state: AudioState) => void;
+    /** Entered `broken`: 'build-failed' | 'unsafe-src' | 'silent' (see above). */
+    onAudioBroken?: (reason: AudioBrokenReason) => void;
     class?: string;
 };
 declare const VideoPlayer: import("svelte").Component<$$ComponentProps, {
     bandState: () => BandState;
-}, "">;
+}, "night" | "nightDepth">;
 type VideoPlayer = ReturnType<typeof VideoPlayer>;
 export default VideoPlayer;

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export type { ChapterBlock } from './components/replay/ChapterTimeline.svelte';
 export { default as TranscriptPlayer } from './components/TranscriptPlayer.svelte';
 export type { TranscriptSegment, TranscriptBookmark, TranscriptChapter, TranscriptSpeakerTalkTime, } from './components/TranscriptPlayer.svelte';
 export { default as VideoPlayer } from './components/VideoPlayer.svelte';
-export type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookmark, VideoWaveform, VideoSpeakerTalkTime, VideoLumaTrack, VideoMarker, BandState, BandAxis, } from './components/VideoPlayer.svelte';
+export type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookmark, VideoWaveform, VideoSpeakerTalkTime, VideoLumaTrack, VideoMarker, BandState, BandAxis, NightMode, NightWindow, AudioState, AudioStatus, AudioBrokenReason, } from './components/VideoPlayer.svelte';
 export { buildSilenceMap, boostAt, estimateSaving, type SilenceMap, type SilenceWave, type SilenceOpts, type BoostOpts } from './video/advisors/smart-speed';
 export { speakerPace, suggestRates, rateAt, describeRates, type SpeakerPace, type SpeakerPaceRow, type RateMap, type RateTurn, type RateSegment, type SuggestOpts } from './video/advisors/speaker-rate';
 export { snapResume, resumeLabel, type ResumePoint, type ResumeReason, type ResumeCtx, type ResumeOpts } from './video/advisors/resume-point';

package/dist/video/README.md

@@ -20,8 +20,8 @@ props + callback surfaces.
 | `rate.ts` | .28 (done) — filled by **.32** | The rate composer contract (`composeRate`, deadband, clamp), the `SPEED_STEPS` staircase, `formatSpeedLabel`. .32 adds the speaker-pace and silence-map advisors — they never write `playbackRate`; they advise. |
 | `deepLink.ts` | .28 (done) | `?t=` parse/format/read/write (replaceState, throttled, other params preserved). |
 | `settings.ts` | shared — knobs added by .30–.34 | `coerce` (never throws, never junk) + `VIDEO_SETTINGS` registry. A knob lands WITH its reader. |
-| `audio.ts` | **.31** | Loudness matching, quiet listening, limiter — audio-graph contract is in the file header. |
-| `night.ts` | **.33** | Night dimming, bias light, predictive dimming (luma track), strobe guard. |
+| `audio.ts` + `audio/` | **.31** (done) | `audio.ts` is the barrel. `rider.ts` — pure: RMS dBFS (silence → null), the 12 dB relative-gated loud estimate (rise 0.08 / forget 0.01), want-gain clamped 0.3–1.35, the asymmetric ride (down 0.15 / up 0.02), limiter constants + `compressorMakeupDb`/`limiterTrim` (DynamicsCompressor's automatic makeup, cancelled by a trim node), `routeSafety` (only blob:/data: or a `crossorigin` load — a same-origin URL may redirect cross-origin and route to SILENCE). `graph.ts` — `createAudioSession`: source → gain → quiet chain → limiter → trim → destination, analyser on the source. Context first, route last: the element is taken only when a feature is on, the source is route-safe and `ctx.state === 'running'` (gestures resume + retry; never navigator.userActivation). After routing it watches: an unsafe src or bit-exact zeros while audibly playing ⇒ `broken` (`unsafe-src` / `silent`) via `onBroken`. A construction throw is a permanent `build-failed` (context closed if the element wasn't taken; kept with source → destination if it was). Level off cancels before it sets; limiter moves are ramped. The element never enters the module — the component passes a `route` closure. |
+| `night.ts` + `night/` | **.33** (done) | `night.ts` is the barrel. `meter.ts` — 32×18 frame bytes → Rec.709 luma + blown share, asymmetric smoothing, bias-light cells from the same bytes. `levels.ts` — luma → brightness/saturation/warmth/vignette off `NIGHT_FLOOR` 0.34, blind fixed level, the light-theme surround. `clock.ts` — local-clock `auto` window + the `N` auto/on/off cycle (no hyprsunset). `track.ts` — prediction (only ever adds dimming), flash intervals, `composeNight` (darker at once, brighter released per tick — never a jump). |
 | `presence.ts` | **.34** | Wind-down (Idle Detection), resume-at-sentence, FLIP open. |
 | `advisors/` | **.27 (done)** | The five extension-library pure advisors, ported verbatim: `smart-speed` (silence map + boost), `speaker-rate` (measured wpm + suggested rates), `resume-point` (sentence-snapping + the label), `quiet-listening` (tone-only chain + `amountFor`), `qr` (ISO 18004 encoder v1–10). Each has its own README row in `advisors/README.md`; the `--self-test` suites live on as vitest in `tests/unit/advisors/` (`npm run test:advisors`). |
 
@@ -44,8 +44,9 @@ feature task.
    the prompt).
 3. **Measuring code is an advisor; the component decides and applies.**
    Modules under `src/lib/video/` read no settings and touch no `<video>`
-   (the audio graph builder is the one exception, and it takes a
-   MediaElementAudioSourceNode, never the element). Knobs arrive as an
+   (the audio graph builder is the one exception: it touches AudioContext,
+   but takes the element only through a `route` closure the component owns
+   — never the element itself). Knobs arrive as an
    `opts` argument; a bad argument returns a safe neutral value rather than
    throwing. This is what keeps every module node-testable under
    `npm run test:unit` (the advisor vitest suites run under

package/dist/video/audio/graph.d.ts

@@ -0,0 +1,115 @@
+/** What the host asks for. Booleans are "feature on"; volume/muted/night feed quiet listening's amount. */
+export interface AudioOpts {
+    level: boolean;
+    target?: number;
+    limiter: boolean;
+    quiet: boolean;
+    volume?: number;
+    muted?: boolean;
+    night?: boolean;
+}
+/**
+ * · 'off'    — nothing routed (no feature on, no source yet, or the context is
+ *              still waiting for a gesture to start). Native audio plays.
+ * · 'live'   — routed and processing.
+ * · 'cors'   — a feature is on but the source isn't route-safe: refused,
+ *              audio plays unprocessed. Clears when the source does.
+ * · 'broken' — see `reason`.
+ */
+export type AudioStatus = 'off' | 'live' | 'cors' | 'broken';
+/**
+ * · 'build-failed' — construction threw; plain audio for the session (permanent).
+ * · 'unsafe-src'   — routed, then the src/crossorigin changed to one that is
+ *                    not route-safe: this element may now be SILENT.
+ * · 'silent'       — routed, playing audibly, clock advancing, decoded audio
+ *                    evidently flowing, and the analyser reads bit-exact
+ *                    zeros for SILENT_AFTER_MS. Show a notice / disable the
+ *                    features for this src — do NOT remount (it would loop).
+ */
+export type AudioBrokenReason = 'build-failed' | 'unsafe-src' | 'silent';
+export interface AudioState {
+    status: AudioStatus;
+    /** Why `status` is 'broken'; null otherwise. */
+    reason: AudioBrokenReason | null;
+    /** The rider's current gain, dB (0 when level matching is off or unmeasured). */
+    gainDb: number;
+    /** The gated loud-level estimate, dBFS — null until something has been heard. */
+    loudDb: number | null;
+    /** Quiet listening's current amount, 0..1. */
+    quiet: number;
+}
+interface ParamLike {
+    value: number;
+    setTargetAtTime?(v: number, t: number, tau: number): unknown;
+    setValueAtTime?(v: number, t: number): unknown;
+    cancelScheduledValues?(t: number): unknown;
+}
+interface NodeLike {
+    connect(dest: unknown): unknown;
+    disconnect?(): unknown;
+    gain?: ParamLike;
+    threshold?: ParamLike;
+    knee?: ParamLike;
+    ratio?: ParamLike;
+    attack?: ParamLike;
+    release?: ParamLike;
+    fftSize?: number;
+    getFloatTimeDomainData?(buf: Float32Array): void;
+}
+export interface AudioContextLike {
+    currentTime: number;
+    destination: unknown;
+    /** 'suspended' | 'running' | 'closed' — absent (a test double) reads as running. */
+    state?: string;
+    createGain(): NodeLike;
+    createDynamicsCompressor(): NodeLike;
+    createAnalyser(): NodeLike;
+    createBiquadFilter?(): unknown;
+    resume?(): unknown;
+    close?(): unknown;
+    addEventListener?(type: string, fn: () => void): void;
+}
+export interface AudioPlayback {
+    /** Not paused and not ended. */
+    playing: boolean;
+    /** Tab hidden — the rider holds its estimate. */
+    hidden: boolean;
+    /** Not muted and volume > 0 — silence would be a fault, not a choice. */
+    audible: boolean;
+    /** currentTime, seconds. */
+    time: number;
+    /**
+     * Evidence that the element HAS decoded audio. `audioDecoded`: Chromium's
+     * webkitAudioDecodedByteCount (must be RISING to count); `audioPresent`:
+     * Gecko's mozHasAudio or WebKit's audioTracks.length > 0. null = unknown.
+     * With no positive evidence the silence watchdog never fires.
+     */
+    audioDecoded?: number | null;
+    audioPresent?: boolean | null;
+}
+export interface AudioSessionDeps {
+    /** Is the element's current source route-safe? (rider.ts `routeSafety`) */
+    routable(): 'ok' | 'wait' | 'cors';
+    /** Create the AudioContext. Does NOT touch the element. */
+    context(): AudioContextLike;
+    /** Take the element: createMediaElementSource. The one-way door — called at most once. */
+    route(ctx: AudioContextLike): NodeLike;
+    playback(): AudioPlayback;
+    /** State changes + each rider tick. */
+    onState?(state: AudioState): void;
+    /** Entered `broken` (or its reason changed). */
+    onBroken?(reason: AudioBrokenReason): void;
+    /** Timer seam (tests). Defaults to setInterval/clearInterval. */
+    every?(ms: number, fn: () => void): () => void;
+}
+export interface AudioSession {
+    apply(opts: AudioOpts): void;
+    /** A user gesture (or play): resume the context, retry a pending route. */
+    gesture(): void;
+    /** One watchdog + rider step (the session's own timer calls this; exposed for tests). */
+    tick(): void;
+    state(): AudioState;
+    dispose(): void;
+}
+export declare function createAudioSession(deps: AudioSessionDeps): AudioSession;
+export {};

package/dist/video/audio/graph.js

@@ -0,0 +1,400 @@
+/**
+ * The audio graph (mos-5lzns.31) — the one module under src/lib/video/ that
+ * touches WebAudio. Ported from extension-library `library.js`
+ * (audioEnsure / audioTick / applyAudioSettings / applyQuietAmount).
+ *
+ *   source ─┬─► gain ─► quiet.input … quiet.output ─► limiter ─► trim ─► destination
+ *           └─► analyser   (taps the SOURCE: measure the material, not our
+ *                           own correction, or the loop chases its own tail)
+ *
+ * Quiet listening sits between level and limiter: it shapes TONE, so it acts
+ * on the signal at the level you'll hear, and the limiter is last by
+ * definition. `trim` cancels the limiter's automatic makeup gain (rider.ts
+ * `compressorMakeupDb`), so toggling the limiter moves no level. If the quiet
+ * chain can't build, the graph splices around it — tone is optional; sound
+ * is not.
+ *
+ * `createMediaElementSource` is a ONE-WAY DOOR — the spec has no way back once
+ * an element is routed. The contract is "never a silent player":
+ *
+ * 1. CONTEXT FIRST, ROUTE LAST. The context is created when a feature is on,
+ *    `resume()`d on every gesture, and the element is routed only once
+ *    `ctx.state === 'running'`. A suspended context on a routed element is
+ *    silence; a suspended context on an UNrouted element is nothing at all —
+ *    native audio keeps playing, and the next gesture retries. We never
+ *    consult navigator.userActivation: the context's own state is the truth.
+ * 2. ROUTE ONLY A CORS-CLEAN SOURCE (rider.ts `routeSafety`): blob:/data:, or
+ *    the element has `crossorigin`. A same-origin URL may 302 to storage on
+ *    another origin, and an opaque response routes to zeros.
+ * 3. AFTER ROUTING, WATCH. A later src that is not route-safe, or an analyser
+ *    reading bit-exact zeros for SILENT_AFTER_MS while the element plays
+ *    audibly AND there is positive evidence decoded audio is flowing (a
+ *    rising webkitAudioDecodedByteCount, mozHasAudio, audioTracks), is
+ *    reported as `broken` (`unsafe-src` / `silent`) via `onBroken`. A video
+ *    with no audio track never reads as silent. Both clear if the condition
+ *    clears. Remounting is right for `unsafe-src` (a fresh element); for
+ *    `silent` the host should show a notice and/or turn the audio features
+ *    off for that src — remounting would just loop.
+ * 4. A construction throw is a permanent `broken` (`build-failed`). If it
+ *    happened before the element was taken, the context is closed; if after,
+ *    the source is wired straight to the destination and the context KEPT —
+ *    closing it would silence the routed element.
+ *
+ * Disabled leaves no trace: level off CANCELS scheduled values before setting
+ * 1; the limiter's threshold ramps back to 0 dBFS with its trim to unity; the
+ * quiet chain rests at the identity (amount 0). A graph is never built just
+ * to neutralise it.
+ *
+ * The element itself never enters this module: the component passes `route`,
+ * a closure that calls createMediaElementSource on it.
+ */
+import { amountFor, createQuietChain } from '../advisors/quiet-listening';
+import { AUDIO_FFT_SIZE, AUDIO_TICK_MS, LIMITER, LIMITER_OFF_THRESHOLD, LIMITER_TAU, RIDE_TAU, SILENT_AFTER_MS, clampTarget, gainDb, gateLoud, limiterTrim, rideStep, rmsDb, wantGain } from './rider';
+const defaultEvery = (ms, fn) => {
+    const id = setInterval(fn, ms);
+    return () => clearInterval(id);
+};
+const safely = (fn) => {
+    try {
+        fn();
+    }
+    catch {
+        /* never throw out of the audio path */
+    }
+};
+export function createAudioSession(deps) {
+    let ctx = null;
+    let routed = false;
+    let buildFailed = false;
+    let unsafeSrc = false;
+    let silent = false;
+    let refusedCors = false;
+    let gain = null;
+    let limiter = null;
+    let trim = null;
+    let analyser = null;
+    let quiet = null;
+    let buf = null;
+    let ride = 1;
+    let loud = null;
+    let amount = 0;
+    let levelOn = false;
+    let limiterOn = false;
+    let target = clampTarget(undefined);
+    let stopTimer = null;
+    let lastOpts = null;
+    let anyOnLast = false;
+    let zeroMs = 0;
+    let lastDecoded = null;
+    let lastTime = Number.NaN;
+    let disposed = false;
+    let lastSent = '';
+    let lastBroken = null;
+    const reason = () => buildFailed ? 'build-failed' : routed && unsafeSrc ? 'unsafe-src' : routed && silent ? 'silent' : null;
+    const status = () => reason() ? 'broken' : routed ? 'live' : refusedCors ? 'cors' : 'off';
+    const state = () => ({
+        status: status(),
+        reason: reason(),
+        gainDb: levelOn ? gainDb(ride) : 0,
+        loudDb: loud,
+        quiet: amount
+    });
+    const emit = () => {
+        const s = state();
+        if (s.reason !== lastBroken) {
+            lastBroken = s.reason;
+            if (s.reason)
+                safely(() => deps.onBroken?.(s.reason));
+        }
+        const key = `${s.status}|${s.reason}|${s.gainDb.toFixed(2)}|${s.loudDb?.toFixed(1)}|${s.quiet.toFixed(2)}`;
+        if (key === lastSent)
+            return;
+        lastSent = key;
+        safely(() => deps.onState?.(s));
+    };
+    const now = () => (ctx && Number.isFinite(ctx.currentTime) ? ctx.currentTime : 0);
+    const running = () => !!ctx && (ctx.state === undefined || ctx.state === 'running');
+    const routable = () => {
+        try {
+            return deps.routable();
+        }
+        catch {
+            return 'wait';
+        }
+    };
+    /** Ask the context to start; on success retry whatever is pending. Never loops. */
+    function kick() {
+        if (!ctx || running())
+            return;
+        try {
+            const p = ctx.resume?.();
+            p?.then?.(() => {
+                if (!disposed && running() && lastOpts)
+                    apply(lastOpts);
+            }, () => { });
+        }
+        catch {
+            /* a refused resume just waits for the next gesture */
+        }
+    }
+    function closeCtx() {
+        const c = ctx;
+        ctx = null;
+        safely(() => {
+            const r = c?.close?.();
+            r?.catch?.(() => { });
+        });
+    }
+    /** Route the element and wire the graph. Only ever called with a running context. */
+    function build() {
+        const c = ctx;
+        let source = null;
+        try {
+            source = deps.route(c);
+            routed = true;
+            gain = c.createGain();
+            limiter = c.createDynamicsCompressor();
+            // Built at rest: threshold 0 dBFS, trim unity. configure() ramps them in.
+            limiter.threshold.value = LIMITER_OFF_THRESHOLD;
+            limiter.knee.value = LIMITER.knee;
+            limiter.ratio.value = LIMITER.ratio;
+            limiter.attack.value = LIMITER.attack;
+            limiter.release.value = LIMITER.release;
+            trim = c.createGain();
+            trim.gain.value = 1;
+            analyser = c.createAnalyser();
+            analyser.fftSize = AUDIO_FFT_SIZE;
+            buf = new Float32Array(AUDIO_FFT_SIZE);
+            // The quiet chain degrades to a unity wire or {input:null} on a context
+            // it doesn't recognise — splice around the null case instead of throwing
+            // into the catch below, where the element is already taken.
+            const q = createQuietChain(c);
+            quiet = q.input && q.output ? q : null;
+            source.connect(analyser);
+            source.connect(gain);
+            if (quiet) {
+                gain.connect(quiet.input);
+                quiet.output.connect(limiter);
+            }
+            else {
+                gain.connect(limiter);
+            }
+            limiter.connect(trim);
+            trim.connect(c.destination);
+            stopTimer = (deps.every ?? defaultEvery)(AUDIO_TICK_MS, tick);
+            return true;
+        }
+        catch {
+            buildFailed = true;
+            for (const n of [gain, limiter, trim, analyser])
+                safely(() => n?.disconnect?.());
+            quiet?.dispose();
+            quiet = gain = limiter = trim = analyser = null;
+            if (source) {
+                // The door closed behind us: a partly-built graph is silence. Wire the
+                // source straight out and KEEP the context — plain audio is all
+                // "broken" may mean.
+                safely(() => {
+                    source.disconnect?.();
+                    source.connect(c.destination);
+                });
+            }
+            else {
+                // Never took the element: nothing depends on this context.
+                routed = false;
+                closeCtx();
+            }
+            return false;
+        }
+    }
+    function setLevel(on) {
+        if (on === levelOn)
+            return;
+        levelOn = on;
+        if (on)
+            return;
+        // Hand the level back exactly as it was — cancel first, then set. A ramp
+        // toward 1 would leave a half-faded trace on the param timeline. The
+        // estimate resets too, so re-enabling starts clean, not stale.
+        ride = 1;
+        loud = null;
+        const p = gain?.gain;
+        if (!p)
+            return;
+        try {
+            p.cancelScheduledValues?.(now());
+            if (p.setValueAtTime)
+                p.setValueAtTime(1, now());
+            else
+                p.value = 1;
+        }
+        catch {
+            p.value = 1;
+        }
+    }
+    function setLimiter(on) {
+        if (on === limiterOn || !limiter?.threshold)
+            return;
+        limiterOn = on;
+        const th = on ? LIMITER.threshold : LIMITER_OFF_THRESHOLD;
+        // Ramped, never a .value write, and the trim moves with it so the
+        // compressor's makeup gain never reaches the output.
+        const ramp = (p, v) => {
+            if (!p)
+                return;
+            try {
+                if (p.setTargetAtTime)
+                    p.setTargetAtTime(v, now(), LIMITER_TAU);
+                else
+                    p.value = v;
+            }
+            catch {
+                p.value = v;
+            }
+        };
+        ramp(limiter.threshold, th);
+        ramp(trim?.gain, limiterTrim(th));
+    }
+    function tick() {
+        if (disposed || !routed || buildFailed || !analyser)
+            return;
+        let pb;
+        try {
+            pb = deps.playback();
+        }
+        catch {
+            return;
+        }
+        if (!pb.playing) {
+            lastTime = Number.NaN;
+            return;
+        }
+        try {
+            analyser.getFloatTimeDomainData?.(buf);
+        }
+        catch {
+            return;
+        }
+        // Watchdog: bit-exact zeros while audible, the clock advances AND there is
+        // positive evidence that decoded audio exists and is flowing. A video
+        // with no audio track reads zeros forever and must never be called
+        // "silent" — no evidence, no verdict.
+        const advanced = Number.isFinite(lastTime) && pb.time > lastTime;
+        lastTime = pb.time;
+        const decoded = Number.isFinite(pb.audioDecoded) ? pb.audioDecoded : null;
+        const flowing = decoded !== null
+            ? lastDecoded !== null && decoded > lastDecoded // Chromium: bytes still decoding
+            : pb.audioPresent === true; // Gecko mozHasAudio / WebKit audioTracks
+        lastDecoded = decoded;
+        if (!flowing) {
+            zeroMs = 0;
+            if (silent) {
+                silent = false;
+                emit();
+            }
+        }
+        else if (pb.audible && advanced) {
+            let zero = true;
+            for (let i = 0; i < buf.length; i++) {
+                if (buf[i] !== 0) {
+                    zero = false;
+                    break;
+                }
+            }
+            zeroMs = zero ? zeroMs + AUDIO_TICK_MS : 0;
+            const s = zeroMs >= SILENT_AFTER_MS;
+            if (s !== silent) {
+                silent = s;
+                emit();
+            }
+        }
+        // Rider. Hidden: the estimate holds.
+        if (!levelOn || pb.hidden || !gain?.gain)
+            return;
+        const level = rmsDb(buf);
+        if (level == null)
+            return; // silence carries no vote
+        loud = gateLoud(loud, level);
+        ride = rideStep(ride, wantGain(loud, target));
+        safely(() => gain.gain.setTargetAtTime?.(ride, now(), RIDE_TAU));
+        emit();
+    }
+    function configure(o, q) {
+        setLevel(o.level === true);
+        setLimiter(o.limiter === true);
+        amount = q && quiet ? amountFor(o.muted ? 0 : o.volume, !!o.night, {}) : 0;
+        quiet?.setAmount(amount);
+    }
+    function apply(opts) {
+        if (disposed)
+            return;
+        const o = opts ?? {};
+        lastOpts = o;
+        target = clampTarget(o.target);
+        const q = o.quiet === true;
+        const anyOn = o.level === true || o.limiter === true || q;
+        anyOnLast = anyOn;
+        if (buildFailed)
+            return emit();
+        if (routed) {
+            // The door is shut behind us; all we can do is watch and report.
+            unsafeSrc = routable() === 'cors';
+            configure(o, q);
+            return emit();
+        }
+        // Never create a context — let alone route — just to neutralise it.
+        if (!anyOn) {
+            refusedCors = false;
+            return emit();
+        }
+        const r = routable();
+        refusedCors = r === 'cors';
+        if (r !== 'ok')
+            return emit();
+        if (!ctx) {
+            try {
+                ctx = deps.context();
+                const c = ctx;
+                c.addEventListener?.('statechange', () => {
+                    if (!disposed && ctx === c && running() && !routed && lastOpts)
+                        apply(lastOpts);
+                });
+            }
+            catch {
+                ctx = null;
+                buildFailed = true;
+                return emit();
+            }
+        }
+        if (!running()) {
+            // Suspended: do NOT route. Native audio keeps playing; the resume below
+            // (or the next gesture's) retries.
+            kick();
+            return emit();
+        }
+        if (!build())
+            return emit();
+        configure(o, q);
+        emit();
+    }
+    function gesture() {
+        // All features off: a click is not our business (no context, no apply).
+        if (disposed || buildFailed || !anyOnLast)
+            return;
+        if (ctx && !running())
+            kick();
+        if (!routed && lastOpts)
+            apply(lastOpts);
+    }
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        stopTimer?.();
+        stopTimer = null;
+        quiet?.dispose();
+        closeCtx();
+        gain = limiter = trim = analyser = quiet = null;
+    }
+    return { apply, gesture, tick, state, dispose };
+}