5f:I[8513,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"ScrollBar"] 6a:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 51:"var(--destructive)" 52:["$","div","channel-solo",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-solo",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":["$","div",null,{"className":"flex items-center gap-2","children":[["$","div",null,{"className":"size-4 flex-shrink-0","style":{"backgroundColor":"oklch(0.795 0.184 86.047)"}}],["$","p",null,{"children":"oklch(0.795 0.184 86.047)"}]]}]}]]}] 53:["$","div","channel-monitor",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-monitor",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":["$","div",null,{"className":"flex items-center gap-2","children":[["$","div",null,{"className":"size-4 flex-shrink-0","style":{"backgroundColor":"oklch(0.623 0.214 259.815)"}}],["$","p",null,{"children":"oklch(0.623 0.214 259.815)"}]]}]}]]}] 54:["$","div","meter-ok-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-ok-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"color-mix(in oklch, var(--meter-ok), black 40%)"}]]}] 55:["$","div","meter-warn-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-warn-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"color-mix(in oklch, var(--meter-warn), black 40%)"}]]}] 56:["$","div","meter-clip-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-clip-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"color-mix(in oklch, var(--meter-clip), black 40%)"}]]}] 57:["$","div","channel-mute-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-mute-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"color-mix(in oklch, var(--channel-mute), black 40%)"}]]}] 58:["$","div","channel-solo-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-solo-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"color-mix(in oklch, var(--channel-solo), black 40%)"}]]}] 59:["$","div","channel-monitor-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-monitor-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"color-mix(in oklch, var(--channel-monitor), black 40%)"}]]}] 5a:["$","$L5f",null,{"orientation":"horizontal"}] 5b:["$","div",null,{"className":"flex flex-col border rounded-md","children":[["$","p",null,{"className":"text-sm font-medium border-b p-2","children":"Dark Mode"}],["$","div",null,{"children":["$","$L50",null,{"type":"always","className":"h-80 px-2","children":[["$","div",null,{"className":"gap-2 pb-8 flex flex-col pt-4","children":[["$","div","meter-ok",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-ok",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":["$","div",null,{"className":"flex items-center gap-2","children":[["$","div",null,{"className":"size-4 flex-shrink-0","style":{"backgroundColor":"oklch(0.765 0.177 163.223)"}}],["$","p",null,{"children":"oklch(0.765 0.177 163.223)"}]]}]}]]}],["$","div","meter-warn",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-warn",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":["$","div",null,{"className":"flex items-center gap-2","children":[["$","div",null,{"className":"size-4 flex-shrink-0","style":{"backgroundColor":"oklch(0.852 0.199 91.936)"}}],["$","p",null,{"children":"oklch(0.852 0.199 91.936)"}]]}]}]]}],["$","div","meter-clip",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-clip",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--destructive)"}]]}],["$","div","channel-mute",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-mute",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--destructive)"}]]}],["$","div","channel-solo",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-solo",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":["$","div",null,{"className":"flex items-center gap-2","children":[["$","div",null,{"className":"size-4 flex-shrink-0","style":{"backgroundColor":"oklch(0.852 0.199 91.936)"}}],["$","p",null,{"children":"oklch(0.852 0.199 91.936)"}]]}]}]]}],["$","div","channel-monitor",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","channel-monitor",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":["$","div",null,{"className":"flex items-center gap-2","children":[["$","div",null,{"className":"size-4 flex-shrink-0","style":{"backgroundColor":"oklch(0.707 0.165 254.624)"}}],["$","p",null,{"children":"oklch(0.707 0.165 254.624)"}]]}]}]]}],["$","div","meter-ok-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-ok-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-ok)"}]]}],["$","div","meter-warn-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","meter-warn-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-warn)"}]]}],["$","div","meter-clip-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":"$L60"}],"$L61"]}],"$L62","$L63","$L64"]}],"$L65"]}]}]]}] 5c:["$","div",null,{"className":"flex flex-col border rounded-md","children":[["$","p",null,{"className":"text-sm font-medium border-b p-2","children":"Theme"}],["$","div",null,{"children":["$","$L50",null,{"type":"always","className":"h-80 px-2","children":[["$","div",null,{"className":"gap-2 pb-8 flex flex-col pt-4","children":[["$","div","color-meter-ok",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-meter-ok",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-ok)"}]]}],["$","div","color-meter-warn",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-meter-warn",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-warn)"}]]}],["$","div","color-meter-clip",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-meter-clip",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-clip)"}]]}],["$","div","color-channel-mute",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-channel-mute",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--channel-mute)"}]]}],["$","div","color-channel-solo",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-channel-solo",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--channel-solo)"}]]}],["$","div","color-channel-monitor",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-channel-monitor",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--channel-monitor)"}]]}],["$","div","color-meter-ok-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-meter-ok-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-ok-foreground)"}]]}],["$","div","color-meter-warn-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-meter-warn-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-warn-foreground)"}]]}],["$","div","color-meter-clip-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-meter-clip-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"var(--meter-clip-foreground)"}]]}],["$","div","color-channel-mute-foreground",{"className":"items-start gap-1 grid grid-cols-2 text-sm","children":[["$","div",null,{"className":"hover:bg-muted/50 py-2","children":["$","p",null,{"className":"text-foreground/80 text-sm","children":["--","color-channel-mute-foreground",":"]}]}],["$","div",null,{"className":"hover:bg-muted/50 py-2 px-1 rounded-md w-full","children":"$L66"}]]}],"$L67","$L68"]}],"$L69"]}]}]]}] 5d:null 6b:T746,/** A level reading for one audio channel, in dBFS. */ export interface ChannelLevel { /** Sample peak in dBFS. `-Infinity` is digital silence. */ peakDb: number; /** RMS level in dBFS, when the source measures it. */ rmsDb?: number; } /** One metering update: one entry per channel (1 = mono, 2 = stereo). */ export interface MeterFrame { channels: ChannelLevel[]; } /** One visualisation update from an analyser. */ export interface VisualFrame { /** Frequency bands, 0..1 each, low to high. */ bands: Float32Array; /** Ring buffer of recent broadband levels, 0..1 each. */ history: Float32Array; /** Index of the oldest entry in `history`. */ historyStart: number; /** Number of valid entries in `history`. */ historyLength: number; /** Time of the newest history entry, in the requestAnimationFrame clock. */ historyUpdatedAt?: number; /** Minimum time between entries, used for playback delay. 0 disables smoothing. */ historyIntervalMs?: number; /** Last entry removed from a full history ring, for its scrolling edge. */ historyPreviousLevel?: number; /** Raw time-domain samples, −1..1, for line and scope drawing. */ timeDomain?: Float32Array; /** Sample peak of this frame in dBFS. */ peakDb: number; } /** Anything that can push frames to subscribers. */ export interface FrameSource { subscribe: (listener: (frame: T) => void) => () => void; } export type MeterZoneName = "ok" | "warn" | "clip"; /** A colour zone of a meter, starting at `fromDb` and running to the next zone. */ export interface MeterZone { fromDb: number; zone: MeterZoneName; } /** Maps a value (usually dB) to a 0..1 position on a control, and back. */ export interface Taper { toPosition: (value: number) => number; toValue: (position: number) => number; } export type Orientation = "horizontal" | "vertical"; 6c:Tecd,/** Default bottom of a meter's range, in dBFS. */ export const DEFAULT_MIN_DB = -60; /** Default top of a meter's range, in dBFS. */ export const DEFAULT_MAX_DB = 0; /** Digital silence. */ export const SILENCE_DB = Number.NEGATIVE_INFINITY; const AMPLITUDE_DB_FACTOR = 20; const MINUS_SIGN = "−"; const INFINITY_SIGN = "∞"; export const clamp = (value: number, min: number, max: number): number => Math.min(max, Math.max(min, value)); /** Decibels to linear gain. `-Infinity` gives 0. */ export const dbToGain = (db: number): number => { if (db === SILENCE_DB) { return 0; } return 10 ** (db / AMPLITUDE_DB_FACTOR); }; /** Linear gain to decibels. 0 (or less) gives `-Infinity`. */ export const gainToDb = (gain: number): number => { if (gain <= 0) { return SILENCE_DB; } return AMPLITUDE_DB_FACTOR * Math.log10(gain); }; /** dBFS to a 0..1 level, linear in dB over `minDb..maxDb`, clamped. */ export const dbToLevel = ( db: number, minDb: number = DEFAULT_MIN_DB, maxDb: number = DEFAULT_MAX_DB ): number => { if (!(db > minDb)) { return 0; } return clamp((db - minDb) / (maxDb - minDb), 0, 1); }; /** A 0..1 level back to dBFS over `minDb..maxDb`. The inverse of `dbToLevel`. */ export const levelToDb = ( level: number, minDb: number = DEFAULT_MIN_DB, maxDb: number = DEFAULT_MAX_DB ): number => minDb + clamp(level, 0, 1) * (maxDb - minDb); /** * Clamps a dB value to a range. With `allowSilence`, `-Infinity` passes * through instead of becoming `minDb`. */ export const clampDb = ( db: number, minDb: number, maxDb: number, options: { allowSilence?: boolean } = {} ): number => { if (db === SILENCE_DB && options.allowSilence) { return SILENCE_DB; } if (Number.isNaN(db)) { return minDb; } return clamp(db, minDb, maxDb); }; export interface FormatDbOptions { /** Digits after the decimal point. Default 1. */ decimals?: number; /** Append " dB". Default true. */ unit?: boolean; /** * `auto` shows "+" for positive values and "−" for negative ones, * `negative` only shows "−", `never` shows no sign. Default `auto`. */ sign?: "auto" | "negative" | "never"; /** At or below this value, show "−∞". Default `-Infinity`. */ floorDb?: number; } /** Formats decibels for display: "−12.3 dB", "+3.0 dB", "−∞ dB". */ export const formatDb = (db: number, options: FormatDbOptions = {}): string => { const { decimals = 1, unit = true, sign = "auto", floorDb = SILENCE_DB, } = options; const suffix = unit ? " dB" : ""; if (Number.isNaN(db)) { return `--${suffix}`; } if (db === SILENCE_DB || db <= floorDb) { const prefix = sign === "never" ? "" : MINUS_SIGN; return `${prefix}${INFINITY_SIGN}${suffix}`; } const rounded = Number(db.toFixed(decimals)); const magnitude = Math.abs(rounded).toFixed(decimals); if (rounded === 0 || sign === "never") { return `${magnitude}${suffix}`; } if (rounded < 0) { return `${MINUS_SIGN}${magnitude}${suffix}`; } const plus = sign === "auto" ? "+" : ""; return `${plus}${magnitude}${suffix}`; }; /** Sample peak of a block of samples, in dBFS. */ export const peakDb = (samples: Iterable): number => { let peak = 0; for (const sample of samples) { const magnitude = Math.abs(sample); if (magnitude > peak) { peak = magnitude; } } return gainToDb(peak); }; /** RMS level of a block of samples, in dBFS. */ export const rmsDb = (samples: Iterable): number => { let sumOfSquares = 0; let count = 0; for (const sample of samples) { sumOfSquares += sample * sample; count += 1; } if (count === 0) { return SILENCE_DB; } return gainToDb(Math.sqrt(sumOfSquares / count)); }; 6d:Tcb5,import { dbToGain, gainToDb } from "@/lib/audio/decibels"; /** How a meter moves between readings. All times are in milliseconds. */ export interface BallisticsOptions { /** Time constant for rising levels. 0 jumps instantly. */ attackMs: number; /** Time constant for falling levels. 0 drops instantly. */ releaseMs: number; /** How long the peak-hold marker stays before it starts to fall. 0 disables it. */ peakHoldMs: number; /** Time constant for the peak-hold marker's fall. */ peakReleaseMs: number; } export const BALLISTICS = { instant: { attackMs: 0, peakHoldMs: 0, peakReleaseMs: 0, releaseMs: 0 }, peak: { attackMs: 15, peakHoldMs: 1200, peakReleaseMs: 600, releaseMs: 350 }, vu: { attackMs: 300, peakHoldMs: 0, peakReleaseMs: 300, releaseMs: 300 }, } as const satisfies Record; export type BallisticsPreset = keyof typeof BALLISTICS; export type BallisticsInput = BallisticsPreset | Partial; const isBallisticsPreset = ( input: BallisticsInput ): input is BallisticsPreset => typeof input === "string"; export const resolveBallistics = ( input: BallisticsInput = "peak" ): BallisticsOptions => { if (isBallisticsPreset(input)) { return BALLISTICS[input]; } return { ...BALLISTICS.peak, ...input }; }; export interface BallisticsState { /** The smoothed level in dBFS. */ db: number; /** The peak-hold level in dBFS. */ holdDb: number; } export interface Ballistics { step: (inputDb: number, nowMs: number) => BallisticsState; reset: () => void; } const smoothingFactor = (elapsedMs: number, timeConstantMs: number): number => { if (timeConstantMs <= 0) { return 1; } return 1 - Math.exp(-elapsedMs / timeConstantMs); }; /** * Creates a meter ballistics integrator. Smoothing runs on linear amplitude, * so a falling level drops at a steady rate in dB, like a hardware meter. */ export const createBallistics = (input?: BallisticsInput): Ballistics => { const options = resolveBallistics(input); let amplitude = 0; let holdAmplitude = 0; let holdUntilMs = 0; let lastMs: number | null = null; const reset = () => { amplitude = 0; holdAmplitude = 0; holdUntilMs = 0; lastMs = null; }; const step = (inputDb: number, nowMs: number): BallisticsState => { const target = dbToGain(inputDb); if (lastMs === null) { amplitude = target; } else { const elapsedMs = Math.max(0, nowMs - lastMs); const timeConstant = target > amplitude ? options.attackMs : options.releaseMs; amplitude += (target - amplitude) * smoothingFactor(elapsedMs, timeConstant); } if (options.peakHoldMs <= 0) { holdAmplitude = amplitude; } else if (amplitude >= holdAmplitude) { holdAmplitude = amplitude; holdUntilMs = nowMs + options.peakHoldMs; } else if (nowMs > holdUntilMs && lastMs !== null) { const elapsedMs = Math.max(0, nowMs - Math.max(lastMs, holdUntilMs)); holdAmplitude -= (holdAmplitude - amplitude) * smoothingFactor(elapsedMs, options.peakReleaseMs); } lastMs = nowMs; return { db: gainToDb(amplitude), holdDb: gainToDb(holdAmplitude) }; }; return { reset, step }; }; 6e:Tb85,import { clamp, DEFAULT_MIN_DB } from "@/lib/audio/decibels"; import type { Taper } from "@/lib/audio/types"; const DEFAULT_FADER_MAX_DB = 6; const DEFAULT_UNITY_POSITION = 0.75; const AUDIO_CURVE_EXPONENT = 2; /** Equal distance per unit across the range. */ export const linearTaper = (min: number, max: number): Taper => ({ toPosition: (value) => { if (!(value > min)) { return 0; } return clamp((value - min) / (max - min), 0, 1); }, toValue: (position) => min + clamp(position, 0, 1) * (max - min), }); export interface AudioTaperOptions { minDb?: number; maxDb?: number; /** Where 0 dB sits on the travel, 0..1. Default 0.75. */ unityPosition?: number; } /** * A console-style fader law: more travel around 0 dB, a fast fall to the * bottom of the range, and linear headroom above 0 dB. */ export const audioTaper = ({ minDb = DEFAULT_MIN_DB, maxDb = DEFAULT_FADER_MAX_DB, unityPosition = DEFAULT_UNITY_POSITION, }: AudioTaperOptions = {}): Taper => { const anchorDb = Math.min(0, maxDb); const unity = maxDb > 0 ? clamp(unityPosition, 0, 1) : 1; const toPosition = (db: number): number => { if (!(db > minDb)) { return 0; } if (db >= maxDb) { return 1; } if (db >= anchorDb) { return unity + ((db - anchorDb) / (maxDb - anchorDb)) * (1 - unity); } const ratio = (db - anchorDb) / (minDb - anchorDb); const travel = 1 - ratio ** (1 / AUDIO_CURVE_EXPONENT); return travel * unity; }; const toValue = (position: number): number => { const clamped = clamp(position, 0, 1); if (clamped >= unity) { if (unity >= 1) { return anchorDb; } return anchorDb + ((clamped - unity) / (1 - unity)) * (maxDb - anchorDb); } const travel = unity > 0 ? clamped / unity : 0; return anchorDb + (minDb - anchorDb) * (1 - travel) ** AUDIO_CURVE_EXPONENT; }; return { toPosition, toValue }; }; /** Logarithmic law for frequency and time parameters. `min` must be above 0. */ export const logTaper = (min: number, max: number): Taper => { const span = Math.log(max / min); return { toPosition: (value) => { if (!(value > min)) { return 0; } return clamp(Math.log(value / min) / span, 0, 1); }, toValue: (position) => min * Math.exp(clamp(position, 0, 1) * span), }; }; export type TaperInput = "linear" | "audio" | "log" | Taper; type TaperName = Exclude; const isTaperName = (taper: TaperInput): taper is TaperName => typeof taper === "string"; /** Resolves a taper name or object for a range. */ export const resolveTaper = ( taper: TaperInput, min: number, max: number ): Taper => { if (!isTaperName(taper)) { return taper; } if (taper === "audio") { return audioTaper({ maxDb: max, minDb: min }); } if (taper === "log") { return logTaper(min, max); } return linearTaper(min, max); }; 6f:Ta98,import { clamp } from "@/lib/audio/decibels"; /** `AnalyserNode.minDecibels` default. */ export const SPECTRUM_MIN_DB = -100; /** `AnalyserNode.maxDecibels` default. */ export const SPECTRUM_MAX_DB = -30; const POWER_DB_FACTOR = 10; /** `count + 1` band edges in Hz, spaced evenly on a log scale. */ export const logBandEdges = ( count: number, minHz: number, maxHz: number ): Float32Array => { const edges = new Float32Array(count + 1); const ratio = maxHz / minHz; for (let index = 0; index <= count; index += 1) { edges[index] = minHz * ratio ** (index / count); } return edges; }; export interface BandsFromSpectrumOptions { minDb?: number; maxDb?: number; } /** * Reduces analyser frequency data (dB per bin) to 0..1 bands between the given * edges. Writes into `out` and returns it. */ export const bandsFromSpectrum = ( spectrumDb: Float32Array, sampleRate: number, edges: Float32Array, out: Float32Array, { minDb = SPECTRUM_MIN_DB, maxDb = SPECTRUM_MAX_DB, }: BandsFromSpectrumOptions = {} ): Float32Array => { const binCount = spectrumDb.length; const hzPerBin = sampleRate / 2 / binCount; const bandCount = Math.min(out.length, edges.length - 1); for (let band = 0; band < bandCount; band += 1) { const low = Math.floor((edges[band] ?? 0) / hzPerBin); const high = Math.max( low + 1, Math.ceil((edges[band + 1] ?? 0) / hzPerBin) ); const first = clamp(low, 0, binCount - 1); const last = clamp(high, first + 1, binCount); let power = 0; for (let bin = first; bin < last; bin += 1) { power += 10 ** ((spectrumDb[bin] ?? minDb) / POWER_DB_FACTOR); } const meanDb = POWER_DB_FACTOR * Math.log10(power / (last - first)); out[band] = clamp((meanDb - minDb) / (maxDb - minDb), 0, 1); } return out; }; /** * Fits `length` values from a ring buffer, starting at `start`, into * `out.length` values. Each output takes the loudest value in its span. */ export const resampleLevels = ( source: ArrayLike, start: number, length: number, out: Float32Array ): Float32Array => { const size = source.length; const count = out.length; if (size === 0 || length <= 0 || count === 0) { out.fill(0); return out; } for (let index = 0; index < count; index += 1) { const from = Math.floor((index * length) / count); const to = Math.max(from + 1, Math.floor(((index + 1) * length) / count)); let loudest = 0; for (let offset = from; offset < to; offset += 1) { const value = source[(start + offset) % size] ?? 0; if (value > loudest) { loudest = value; } } out[index] = loudest; } return out; }; 70:T1168,import { resampleLevels } from "@/lib/audio/bands"; import { clamp } from "@/lib/audio/decibels"; const RELEASE_PER_FRAME = 0.86; const FRAME_MS = 16.67; const SIGNAL_THRESHOLD = 0.02; const MS_PER_SECOND = 1000; /** Bars this close to their target have nothing left to animate. */ const SETTLE_EPSILON = 0.002; /** What bars do with no signal. */ export type BarIdle = "static" | "pulse" | "wave"; export interface BarLevelsOptions { barCount: number; idle: BarIdle; /** Runs a sweep, for connecting or thinking states. */ loading: boolean; /** Resting bar size, 0..1. */ minLevel: number; /** Symmetric around the middle bar, lows in the centre. */ mirrored: boolean; /** No release smoothing, idle animation or sweep. */ reducedMotion: boolean; } export interface BarLevels { /** The level each bar shows, 0..1, never below `minLevel`. */ levels: Float32Array; /** * Advances to `nowMs` with the latest input levels (resampled to the bar * count). Returns true when the input is above the signal floor. */ step: (nowMs: number, input: ArrayLike | null) => boolean; /** * True after a step that left nothing to animate: every bar is at its * target, and no idle animation or loading sweep is running. */ readonly settled: boolean; } const idleLevel = (idle: BarIdle, index: number, seconds: number) => { if (idle === "pulse") { return 0.1 * (0.5 + 0.5 * Math.sin(seconds * Math.PI * 1.6)); } if (idle === "wave") { return 0.16 * (0.5 + 0.5 * Math.sin(seconds * 4 - index * 0.55)); } return 0; }; const sweepLevel = (index: number, count: number, seconds: number) => { const span = count + 6; const position = ((seconds * count * 0.9) % span) - 3; return 0.55 * Math.exp(-((index - position) ** 2) / 3); }; const targetIndexFor = ( index: number, count: number, half: number, mirrored: boolean ) => { if (!mirrored) { return index; } return Math.min(half - 1, Math.floor(Math.abs(index - (count - 1) / 2))); }; const loudestOf = (values: Float32Array) => { let loudest = 0; for (const value of values) { loudest = Math.max(loudest, value); } return loudest; }; /** * Bar levels shared by the bar visualizers: input resampled to the bar count, * instant attack with a smooth release, mirroring, idle animations and the * loading sweep. */ export const createBarLevels = ({ barCount, idle, loading, minLevel, mirrored, reducedMotion, }: BarLevelsOptions): BarLevels => { const half = mirrored ? Math.ceil(barCount / 2) : barCount; const targets = new Float32Array(half); const current = new Float32Array(barCount); const levels = new Float32Array(barCount).fill(minLevel); let lastMs = 0; let settled = false; const extraLevel = (index: number, seconds: number, quiet: boolean) => { if (loading && !reducedMotion) { return sweepLevel(index, barCount, seconds); } return quiet ? idleLevel(idle, index, seconds) : 0; }; const readInput = (input: ArrayLike | null) => { if (input && input.length > 0) { resampleLevels(input, 0, input.length, targets); } else { targets.fill(0); } }; const step = (nowMs: number, input: ArrayLike | null) => { const elapsed = lastMs === 0 ? FRAME_MS : nowMs - lastMs; lastMs = nowMs; const release = reducedMotion ? 0 : RELEASE_PER_FRAME ** (elapsed / FRAME_MS); const seconds = nowMs / MS_PER_SECOND; readInput(input); const active = loudestOf(targets) >= SIGNAL_THRESHOLD; const quiet = !(reducedMotion || active); const animating = (loading && !reducedMotion) || (quiet && idle !== "static"); let converged = true; for (let index = 0; index < barCount; index += 1) { const target = Math.max( targets[targetIndexFor(index, barCount, half, mirrored)] ?? 0, extraLevel(index, seconds, quiet) ); const previous = current[index] ?? 0; const next = target >= previous ? target : previous * release + target * (1 - release); current[index] = next; levels[index] = clamp(Math.max(minLevel, next), 0, 1); if (Math.abs(next - target) > SETTLE_EPSILON) { converged = false; } } settled = converged && !animating; return active; }; return { levels, get settled() { return settled; }, step, }; }; 71:T1d79,import { createBarLevels } from "@/lib/audio/bar-levels"; import { clamp } from "@/lib/audio/decibels"; import type { VisualFrame } from "@/lib/audio/types"; const MS_PER_SECOND = 1000; const FRAME_MS = 16.67; const MAX_STEP_SECONDS = 0.05; const TWO_PI = Math.PI * 2; /** Below this the line counts as silent. */ const SIGNAL_THRESHOLD = 0.02; /** Share of the distance to the new shape still left after one frame. */ const EASE_PER_FRAME = 0.45; /** Loudness left after one frame of silence. */ const LOUDNESS_RELEASE = 0.92; /** Cycles across the width, drift in radians per second and weight of each band group, lows first. */ const WAVE_PARTIALS = [ { cycles: 1.5, drift: 0.8, weight: 0.6 }, { cycles: 2.5, drift: -1.3, weight: 0.4 }, { cycles: 4, drift: 2.1, weight: 0.25 }, { cycles: 6.5, drift: -3.2, weight: 0.16 }, ] as const; /** Scope mode lifts quiet signals by at most this much. */ const SCOPE_MAX_GAIN = 4; /** Scope mode scales its running peak to this height. */ const SCOPE_TARGET = 0.9; /** Share of the scope's running peak left after one frame. */ const SCOPE_PEAK_RELEASE = 0.985; /** Widths per second the loading pulse travels. */ const LOADING_SPEED = 0.55; /** Where the loading pulse rests with reduced motion: the middle. */ const LOADING_REST_SECONDS = 0.7 / LOADING_SPEED; /** Most points a line can have. */ export const WAVE_LINE_MAX_POINTS = 513; /** * `wave` is a smooth wave shaped by the frequency bands. `scope` is the * signal itself, like an oscilloscope. */ export type WaveLineMode = "wave" | "scope"; export interface WaveLineOptions { mode: WaveLineMode; /** Runs a pulse along the line instead of following the signal. */ loading: boolean; /** Visual gain. */ sensitivity: number; /** No drift or easing: the line jumps to each new shape. */ reducedMotion: boolean; } export interface WaveLine { /** Points in use, left to right. */ count: number; /** Height at each point, −1..1, up positive, eased toward the latest shape. */ heights: Float32Array; /** Highest point of the latest shape before easing, 0..1. It jumps on sudden rises. */ peak: number; /** How loud the line is, 0..1: its highest point, released slowly. */ loudness: number; /** * Advances to `nowMs` with the latest frame, over `count` points. Returns * true when there is a signal. */ step: (nowMs: number, frame: VisualFrame | null, count: number) => boolean; } /** * Where the signal first rises through zero in its first quarter, between * samples, so a steady tone stands still. 0 when it never does. */ export const triggerIndex = (samples: ArrayLike): number => { const limit = Math.floor(samples.length / 4); for (let index = 1; index <= limit; index += 1) { const before = samples[index - 1] ?? 0; const after = samples[index] ?? 0; if (before < 0 && after >= 0) { return index - 1 + -before / (after - before); } } return 0; }; const peakOf = (values: ArrayLike, count: number) => { let peak = 0; for (let index = 0; index < count; index += 1) { peak = Math.max(peak, Math.abs(values[index] ?? 0)); } return peak; }; /** Fits three quarters of the samples, from the trigger, into `count` heights. */ const fillScope = ( samples: ArrayLike, out: Float32Array, count: number, gain: number ) => { const start = triggerIndex(samples); const span = Math.floor(samples.length * 0.75) - 1; for (let point = 0; point < count; point += 1) { const position = start + (span * point) / (count - 1); const index = Math.floor(position); const before = samples[index] ?? 0; const after = samples[Math.min(samples.length - 1, index + 1)] ?? before; const value = before + (after - before) * (position - index); out[point] = clamp(value * gain, -1, 1); } }; /** A short wave packet that travels left to right. */ const loadingPulse = (position: number, seconds: number) => { const center = ((seconds * LOADING_SPEED) % 1.4) - 0.2; const envelope = Math.exp(-((position - center) ** 2) / 0.012); return 0.6 * envelope * Math.sin(TWO_PI * (position * 7 - seconds * 2.5)); }; /** * The shape of a single line across the width, shared by the line * visualizers: a drifting wave shaped by the frequency bands, a triggered * oscilloscope trace, or a loading pulse, eased from frame to frame. */ export const createWaveLine = ({ loading, mode, reducedMotion, sensitivity, }: WaveLineOptions): WaveLine => { const targets = new Float32Array(WAVE_LINE_MAX_POINTS); const bands = createBarLevels({ barCount: WAVE_PARTIALS.length, idle: "static", loading: false, minLevel: 0, mirrored: false, reducedMotion, }); const phases = new Float32Array(WAVE_PARTIALS.length); const state = { count: 2, heights: new Float32Array(WAVE_LINE_MAX_POINTS), loudness: 0, peak: 0, }; let lastMs = 0; let scopePeak = 0; const fillWave = (frame: VisualFrame | null, nowMs: number) => { bands.step(nowMs, frame?.bands ?? null); for (let point = 0; point < state.count; point += 1) { const position = point / (state.count - 1); let height = 0; for (const [index, partial] of WAVE_PARTIALS.entries()) { height += partial.weight * (bands.levels[index] ?? 0) * Math.sin(TWO_PI * partial.cycles * position + (phases[index] ?? 0)); } targets[point] = clamp(height * sensitivity, -1, 1); } }; const fillTargets = (nowMs: number, frame: VisualFrame | null) => { const { count } = state; if (loading) { const seconds = reducedMotion ? LOADING_REST_SECONDS : nowMs / MS_PER_SECOND; for (let point = 0; point < count; point += 1) { targets[point] = loadingPulse(point / (count - 1), seconds); } return; } const samples = frame?.timeDomain; if (mode === "scope" && samples && samples.length > 1) { scopePeak = Math.max( peakOf(samples, samples.length), scopePeak * SCOPE_PEAK_RELEASE ); const gain = sensitivity * Math.min(SCOPE_MAX_GAIN, SCOPE_TARGET / (scopePeak || 1)); fillScope(samples, targets, count, gain); return; } fillWave(frame, nowMs); }; const ease = (elapsedMs: number) => { const share = reducedMotion ? 1 : 1 - EASE_PER_FRAME ** (elapsedMs / FRAME_MS); for (let point = 0; point < state.count; point += 1) { const height = state.heights[point] ?? 0; state.heights[point] = height + ((targets[point] ?? 0) - height) * share; } const release = LOUDNESS_RELEASE ** (elapsedMs / FRAME_MS); state.loudness = Math.max( peakOf(state.heights, state.count), state.loudness * release ); }; const step = (nowMs: number, frame: VisualFrame | null, count: number) => { const elapsedMs = lastMs === 0 ? FRAME_MS : nowMs - lastMs; lastMs = nowMs; state.count = clamp(Math.round(count), 2, WAVE_LINE_MAX_POINTS); if (!reducedMotion) { const seconds = clamp(elapsedMs / MS_PER_SECOND, 0, MAX_STEP_SECONDS); for (const [index, partial] of WAVE_PARTIALS.entries()) { phases[index] = ((phases[index] ?? 0) + partial.drift * seconds) % TWO_PI; } } fillTargets(nowMs, frame); state.peak = peakOf(targets, state.count); ease(elapsedMs); return !loading && state.peak >= SIGNAL_THRESHOLD; }; return Object.assign(state, { step }); }; 72:Tc3e,type FrameListener = (nowMs: number) => void; type FramePhase = "update" | "paint"; const listeners = { paint: new Set(), update: new Set(), }; let handle: number | null = null; let ticking = false; const hasListeners = () => listeners.update.size + listeners.paint.size > 0; const tick = (nowMs: number) => { handle = null; ticking = true; for (const phase of [listeners.update, listeners.paint]) { for (const listener of phase) { try { listener(nowMs); } catch (error) { queueMicrotask(() => { throw error; }); } } } ticking = false; if (hasListeners() && handle === null) { handle = requestAnimationFrame(tick); } }; /** * Runs sources in the update phase, then renderers in the default paint phase. * One loop serves the whole page and stops when nothing is subscribed. * The browser pauses it while the tab is hidden. */ export const subscribeFrame = ( listener: FrameListener, phase: FramePhase = "paint" ): (() => void) => { listeners[phase].add(listener); if (handle === null && !ticking && "requestAnimationFrame" in globalThis) { handle = requestAnimationFrame(tick); } return () => { listeners[phase].delete(listener); if (!hasListeners() && handle !== null) { cancelAnimationFrame(handle); handle = null; } }; }; /** One frame of a task. Return true while the task needs another frame. */ export type FrameTaskStep = (nowMs: number) => boolean; export interface FrameTask { /** Runs the step again from the next frame, if the task is asleep. */ wake: () => void; /** Stops the task for good. A stopped task ignores `wake`. */ stop: () => void; } /** * Runs `step` on the shared loop for as long as it returns true. When it * returns false the task sleeps and requests no frames until `wake()`, so a * settled, silent or hidden painter costs nothing. The task starts awake. */ export const createFrameTask = (step: FrameTaskStep): FrameTask => { let stopped = false; let unsubscribe: (() => void) | null = null; const sleep = () => { unsubscribe?.(); unsubscribe = null; }; const run = (nowMs: number) => { if (!step(nowMs)) { sleep(); } }; const wake = () => { if (!stopped && unsubscribe === null) { unsubscribe = subscribeFrame(run); } }; wake(); return { stop: () => { stopped = true; sleep(); }, wake, }; }; /** The longest step a painter clock takes, so waking never jumps. */ export const MAX_FRAME_GAP_MS = 100; /** * A clock that follows the frames but never advances more than * `MAX_FRAME_GAP_MS` at once. A painter that slept, or ran in a hidden tab, * resumes its ballistics where they were instead of jumping to the end. */ export const createPainterClock = (): ((nowMs: number) => number) => { let lastMs: number | null = null; let clockMs = 0; return (nowMs) => { if (lastMs !== null) { clockMs += Math.min(Math.max(0, nowMs - lastMs), MAX_FRAME_GAP_MS); } lastMs = nowMs; return clockMs; }; }; 73:T82e,import type { FrameSource } from "@/lib/audio/types"; export interface FrameEmitter extends FrameSource { /** Sends a frame to every subscriber. */ emit: (frame: T) => void; /** The last frame emitted, if any. */ readonly latest: T | undefined; } /** * Creates a frame source you push to yourself: from a WebSocket, a worker, a * native bridge or a test. */ export const createFrameEmitter = (): FrameEmitter => { const subscribers = new Set<(frame: T) => void>(); let latest: T | undefined; return { emit: (frame) => { latest = frame; for (const subscriber of subscribers) { subscriber(frame); } }, get latest() { return latest; }, subscribe: (listener) => { subscribers.add(listener); return () => { subscribers.delete(listener); }; }, }; }; export interface FrameRelay extends FrameSource { /** Forwards frames from `source`. Subscribers stay attached when it changes. */ setSource: (source: FrameSource | null) => void; } /** * A frame source whose upstream can be swapped. Components keep a stable * subscription while the audio behind it is rebuilt. */ export const createFrameRelay = (): FrameRelay => { const subscribers = new Set<(frame: T) => void>(); let source: FrameSource | null = null; let detach: (() => void) | null = null; const forward = (frame: T) => { for (const subscriber of subscribers) { subscriber(frame); } }; const attach = () => { if (!detach && source && subscribers.size > 0) { detach = source.subscribe(forward); } }; const release = () => { detach?.(); detach = null; }; return { setSource: (next) => { if (next === source) { return; } release(); source = next; attach(); }, subscribe: (listener) => { subscribers.add(listener); attach(); return () => { subscribers.delete(listener); if (subscribers.size === 0) { release(); } }; }, }; }; 74:T707,import { clamp } from "@/lib/audio/decibels"; import type { VisualFrame } from "@/lib/audio/types"; interface HistorySample { frame: VisualFrame; fromMs: number; toMs: number; } export const createHistoryPlayback = () => { const samples: HistorySample[] = []; let previousMs: number | undefined; let previousLength = 0; let intervalMs: number | undefined; const clear = () => { samples.length = 0; previousMs = undefined; previousLength = 0; intervalMs = undefined; }; const read = (frame: VisualFrame, nowMs: number) => { const time = frame.historyUpdatedAt; const interval = frame.historyIntervalMs; if ( time === undefined || !Number.isFinite(time) || interval === undefined || !Number.isFinite(interval) || interval <= 0 || frame.historyLength === 0 ) { clear(); return { frame, progress: 1 }; } if ( intervalMs !== interval || frame.historyLength < previousLength || (previousMs !== undefined && time < previousMs) ) clear(); intervalMs = interval; previousLength = frame.historyLength; if (time !== previousMs) { samples.push({ frame: { ...frame, history: new Float32Array(frame.history) }, fromMs: previousMs ?? time - interval, toMs: time, }); previousMs = time; } const displayMs = nowMs - interval * 2; while (samples.length > 1 && (samples[0]?.toMs ?? 0) <= displayMs) samples.shift(); const [sample] = samples; if (!sample) return { frame, progress: 1 }; return { frame: sample.frame, progress: clamp( (displayMs - sample.fromMs) / (sample.toMs - sample.fromMs), 0, 1 ), }; }; return { clear, read }; }; 75:Tde2,export interface ClickSoundOptions { tone?: { decayMs?: number; gain?: number; hz?: number; }; noise?: { decayMs?: number; gain?: number; }; lengthMs?: number; pitchSpread?: number; volume?: number; } export interface ClickPlayOptions { context: BaseAudioContext; destination?: AudioNode; resume?: () => Promise; } export interface ClickSound { play: (options: ClickPlayOptions) => void; } const DEFAULTS = { tone: { hz: 4200, decayMs: 1.2, gain: 0.4 }, noise: { decayMs: 0.4, gain: 0.6 }, lengthMs: 6, pitchSpread: 0.04, volume: 0.12, } satisfies Required; export const createClickSound = ( options: ClickSoundOptions = {} ): ClickSound => { const tone = { ...DEFAULTS.tone, ...options.tone }; const noise = { ...DEFAULTS.noise, ...options.noise }; const lengthMs = options.lengthMs ?? DEFAULTS.lengthMs; const pitchSpread = options.pitchSpread ?? DEFAULTS.pitchSpread; const volume = options.volume ?? DEFAULTS.volume; const buffers = new WeakMap(); const pendingContexts = new WeakMap(); let lastPlayedAt = Number.NEGATIVE_INFINITY; const playNow = (context: BaseAudioContext, destination: AudioNode): void => { const now = performance.now(); if (now - lastPlayedAt < 30 || context.state === "closed") return; lastPlayedAt = now; const source = context.createBufferSource(); const gain = context.createGain(); source.buffer = bufferFor(context); source.playbackRate.value = 1 + (Math.random() - 0.5) * pitchSpread * 2; gain.gain.value = volume; source.connect(gain).connect(destination); source.addEventListener( "ended", () => { source.disconnect(); gain.disconnect(); }, { once: true } ); source.start(); }; const bufferFor = (context: BaseAudioContext): AudioBuffer => { const cached = buffers.get(context); if (cached) return cached; const { sampleRate } = context; const buffer = context.createBuffer( 1, Math.ceil((lengthMs / 1000) * sampleRate), sampleRate ); const samples = buffer.getChannelData(0); for (let index = 0; index < samples.length; index += 1) { const time = index / sampleRate; samples[index] = noise.gain * (Math.random() * 2 - 1) * Math.exp(-time / (noise.decayMs / 1000)) + tone.gain * Math.sin(2 * Math.PI * tone.hz * time) * Math.exp(-time / (tone.decayMs / 1000)); } buffers.set(context, buffer); return buffer; }; return { play: ({ context, destination = context.destination, resume }) => { const needsResume = context.state === "suspended" || context.state === "interrupted"; const resumePromise = resume?.(); if (!needsResume || !resumePromise) { playNow(context, destination); return; } pendingContexts.set(context, (pendingContexts.get(context) ?? 0) + 1); const settleResume = () => { const pending = pendingContexts.get(context); if (pending === undefined) return; if (context.state === "running") { pendingContexts.delete(context); playNow(context, destination); } else if (pending === 1) { pendingContexts.delete(context); } else { pendingContexts.set(context, pending - 1); } }; void resumePromise.then(settleResume, settleResume); }, }; }; 76:T46f,import type { Context } from "solid-js"; import type { JSXElement } from "@/lib/solid/jsx-types"; interface ProviderProps { value: T; readonly children?: JSXElement; } type Provider = (props: ProviderProps) => JSXElement; type CompatContext = Context | Provider; const hasProvider = ( context: CompatContext ): context is Context & { Provider: Provider } => "Provider" in context; const isProvider = (context: CompatContext): context is Provider => typeof context === "function"; /** * Provides a context value across Solid 1 and Solid 2. * * Solid 1 stores the provider on `.Provider`; Solid 2 makes the context * object itself the provider component. */ export const provideContext = ( context: CompatContext, value: T, children: () => JSXElement ): JSXElement => { const props: ProviderProps = { value, get children() { return children(); }, }; if (hasProvider(context)) { return context.Provider(props); } if (isProvider(context)) { return context(props); } throw new Error("Unsupported Solid context shape."); }; 77:T433,import * as Solid from "solid-js"; type Cleanup = void | (() => void); type EffectPayload = () => T; const hasTwoPhaseEffects = "onSettled" in Solid; /** * Runs a tracked compute phase followed by an untracked imperative apply phase. * * Both Solid versions accept this two-argument call. Solid 1 treats the second * function as the initial previous value, while Solid 2 treats it as the apply * phase. Solid 1 therefore applies inside the tracked callback after compute; * Solid 2 applies through its native second phase. */ export const createCompatEffect = ( compute: () => T, apply: (value: T) => Cleanup ): void => { const computePayload = (): EffectPayload => { const value = compute(); if (!hasTwoPhaseEffects) { const cleanup = Solid.untrack(() => apply(value)); if (cleanup) { Solid.onCleanup(cleanup); } } return () => value; }; const applyPayload = (payload: EffectPayload): Cleanup => Solid.untrack(() => apply(payload())); Solid.createEffect(computePayload, applyPayload); }; 78:T54f,/** * Copies enumerable string props as live getters without carrying framework * symbols across a DOM boundary. */ export const forwardProps = ( target: Target, source: Source, omitted: ReadonlySet = new Set() ): void => { for (const key of Object.keys(source)) { if (omitted.has(key)) { continue; } Object.defineProperty(target, key, { configurable: true, enumerable: true, get: () => { // SAFETY: Object.keys only returns own string keys that exist on Source. return source[key as keyof Source]; }, }); } }; /** * Returns a reactive plain-object view of `props` without the listed keys. * * Solid 2 marks its props objects with internal symbols. A Proxy forwards * those symbols and lets DOM spread unwrap the original props, which leaks * component-only fields as attributes. Copying only string keys as getters * keeps values live without carrying framework internals across the boundary. */ export const omitProps = ( props: T, keys: readonly K[] ): Omit => { const omitted = new Set(keys); // SAFETY: forwardProps writes only T keys not present in the omitted set. const rest = {} as Omit; forwardProps(rest, props, omitted); return rest; }; 79:T4d4,import type { JSX } from "solid-js/jsx-runtime"; export type ButtonDOMProps = JSX.ButtonHTMLAttributes; export type DivDOMProps = JSX.HTMLAttributes; export type CanvasDOMProps = JSX.IntrinsicElements["canvas"]; export type ImageDOMProps = JSX.IntrinsicElements["img"]; export type ListDOMProps = JSX.IntrinsicElements["ul"]; export type ListItemDOMProps = JSX.IntrinsicElements["li"]; export type KbdDOMProps = JSX.IntrinsicElements["kbd"]; export type LabelDOMProps = JSX.IntrinsicElements["label"]; export type FieldSetDOMProps = JSX.IntrinsicElements["fieldset"]; export type LegendDOMProps = JSX.IntrinsicElements["legend"]; export type GroupDOMProps = JSX.IntrinsicElements["g"]; export type HeadingDOMProps = JSX.HTMLAttributes; export type InputDOMProps = JSX.InputHTMLAttributes; export type LineDOMProps = JSX.IntrinsicElements["line"]; export type ParagraphDOMProps = JSX.HTMLAttributes; export type PathDOMProps = JSX.IntrinsicElements["path"]; export type SpanDOMProps = JSX.HTMLAttributes; export type SvgDOMProps = JSX.SvgSVGAttributes; export type JSXElement = JSX.Element; 7a:T56d,Audio component source adapted from https://github.com/audiocn/ui. MIT License — Copyright (c) 2026 OrcDev Regular SVG icon geometry adapted from @phosphor-icons/react 2.1.10. MIT License — Copyright (c) 2020 Phosphor Icons The following permission and warranty terms apply to both notices. Retain this file with copies or substantial portions of the source. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 5e:["$","$L6a",null,{"files":[{"path":"lib/audio/types.ts","content":"$6b","type":"registry:lib"},{"path":"lib/audio/decibels.ts","content":"$6c","type":"registry:lib"},{"path":"lib/audio/ballistics.ts","content":"$6d","type":"registry:lib"},{"path":"lib/audio/zones.ts","content":"import type { MeterZone, MeterZoneName } from \"@/lib/audio/types\";\n\n/** Green below −20 dBFS, amber from −20, red from −9: the thresholds streamers know. */\nexport const DEFAULT_ZONES: MeterZone[] = [\n { fromDb: Number.NEGATIVE_INFINITY, zone: \"ok\" },\n { fromDb: -20, zone: \"warn\" },\n { fromDb: -9, zone: \"clip\" },\n];\n\n/** A level at or above this counts as clipping for a clip light. */\nexport const CLIP_THRESHOLD_DB = -1;\n\n/** How long a clip light stays on after the last clip. */\nexport const CLIP_HOLD_MS = 1500;\n\n/** The zone a level falls in. */\nexport const zoneForDb = (\n db: number,\n zones: MeterZone[] = DEFAULT_ZONES\n): MeterZoneName => {\n let current: MeterZoneName = \"ok\";\n\n for (const zone of zones) {\n if (db >= zone.fromDb) {\n current = zone.zone;\n }\n }\n\n return current;\n};\n","type":"registry:lib"},{"path":"lib/audio/taper.ts","content":"$6e","type":"registry:lib"},{"path":"lib/audio/bands.ts","content":"$6f","type":"registry:lib"},{"path":"lib/audio/bar-levels.ts","content":"$70","type":"registry:lib"},{"path":"lib/audio/wave-line.ts","content":"$71","type":"registry:lib"},{"path":"lib/audio/time.ts","content":"const SECONDS_PER_MINUTE = 60;\n\nconst SECONDS_PER_HOUR = 3600;\n\nconst MINUS_SIGN = \"−\";\n\nexport interface FormatTimeOptions {\n /** Prefix with \"−\", for time remaining. */\n remaining?: boolean;\n /** Always show hours. */\n hours?: boolean;\n}\n\nconst pad = (value: number): string => String(value).padStart(2, \"0\");\n\n/** Formats seconds as `m:ss`, or `h:mm:ss` from one hour. */\nexport const formatTime = (\n seconds: number,\n options: FormatTimeOptions = {}\n): string => {\n const total = Number.isFinite(seconds) ? Math.max(0, Math.floor(seconds)) : 0;\n const hours = Math.floor(total / SECONDS_PER_HOUR);\n const minutes = Math.floor((total % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);\n const secs = total % SECONDS_PER_MINUTE;\n const prefix = options.remaining ? MINUS_SIGN : \"\";\n\n if (hours > 0 || options.hours) {\n return `${prefix}${hours}:${pad(minutes)}:${pad(secs)}`;\n }\n\n return `${prefix}${minutes}:${pad(secs)}`;\n};\n","type":"registry:lib"},{"path":"lib/audio/frame-loop.ts","content":"$72","type":"registry:lib"},{"path":"lib/audio/frame-source.ts","content":"$73","type":"registry:lib"},{"path":"lib/audio/history.ts","content":"import type { VisualFrame } from \"@/lib/audio/types\";\n\nexport const appendHistory = (\n frame: VisualFrame,\n level: number,\n nowMs: number,\n intervalMs: number\n): void => {\n const interval = Number.isFinite(intervalMs) ? Math.max(0, intervalMs) : 0;\n const elapsed = nowMs - (frame.historyUpdatedAt ?? 0);\n\n if (elapsed < interval || frame.history.length === 0) {\n return;\n }\n\n frame.historyIntervalMs = interval;\n frame.historyUpdatedAt = nowMs;\n const size = frame.history.length;\n\n if (frame.historyLength < size) {\n frame.history[(frame.historyStart + frame.historyLength) % size] = level;\n frame.historyLength += 1;\n } else {\n frame.historyPreviousLevel = frame.history[frame.historyStart];\n frame.history[frame.historyStart] = level;\n frame.historyStart = (frame.historyStart + 1) % size;\n }\n};\n","type":"registry:lib"},{"path":"lib/audio/history-playback.ts","content":"$74","type":"registry:lib"},{"path":"lib/audio/click.ts","content":"$75","type":"registry:lib"},{"path":"lib/solid/accessor.ts","content":"import type { Accessor } from \"solid-js\";\n\nexport type MaybeAccessor = T | Accessor;\n\nconst isAccessor = (value: MaybeAccessor): value is Accessor =>\n typeof value === \"function\";\n\nexport const readMaybeAccessor = (value: MaybeAccessor): T =>\n isAccessor(value) ? value() : value;\n","type":"registry:lib"},{"path":"lib/solid/context.ts","content":"$76","type":"registry:lib"},{"path":"lib/solid/effect.ts","content":"$77","type":"registry:lib"},{"path":"lib/solid/props.ts","content":"$78","type":"registry:lib"},{"path":"lib/solid/ref.ts","content":"export interface MutableRef {\n current: T;\n}\n\nexport type RefTarget =\n | ((value: T | null) => void)\n | { current: T | null }\n | RefTarget[]\n | null\n | undefined;\n\n/** Writes a DOM node or imperative handle to the ref shapes audiocn accepts. */\nexport const setRefValue = (ref: RefTarget, value: T | null): void => {\n if (!ref) {\n return;\n }\n\n if (Array.isArray(ref)) {\n for (const item of ref) {\n setRefValue(item, value);\n }\n\n return;\n }\n\n if (\"current\" in ref) {\n ref.current = value;\n\n return;\n }\n\n ref(value);\n};\n","type":"registry:lib"},{"path":"lib/solid/style.ts","content":"export type StyleObject = Record;\n\nexport type StyleValue = string | StyleObject;\n\nconst isStyleString = (style: StyleValue): style is string =>\n typeof style === \"string\";\n\n/** Prepends component CSS variables while preserving user style precedence. */\nexport const mergeStyleVars = (\n style: StyleValue | undefined,\n vars: StyleObject\n): StyleValue => {\n if (style === undefined) {\n return vars;\n }\n\n if (!isStyleString(style)) {\n return { ...vars, ...style };\n }\n\n let prefix = \"\";\n\n for (const [property, value] of Object.entries(vars)) {\n if (value !== undefined) {\n prefix += `${property}:${String(value)};`;\n }\n }\n\n return `${prefix}${style}`;\n};\n","type":"registry:lib"},{"path":"lib/solid/jsx-types.ts","content":"$79","type":"registry:lib"},{"path":"lib/utils.ts","content":"export { cn } from \"cn\";\n","type":"registry:lib"},{"path":"lib/number.ts","content":"export const roundValue = (value: number): number =>\n Math.round(value * 1e6) / 1e6;\n\nexport const widestFormattedValue = (\n samples: Iterable,\n format: (value: T) => string\n): number => {\n let widest = 0;\n\n for (const value of samples) {\n widest = Math.max(widest, format(value).length);\n }\n\n return widest;\n};\n","type":"registry:lib"},{"path":"lib/audiocn-license.txt","content":"$7a","type":"registry:file","target":"@lib/audiocn-license.txt"}],"className":"h-[70svh] min-h-80"}]