@allyhub/sdk 0.1.0-alpha.8 → 0.2.0-next.0

package/node_modules/@allyhub-next/audio/dist/envelope.d.ts

@@ -0,0 +1,37 @@
+import { type MixLevels } from "./levels.js";
+import type { GainPoint, Segment } from "./plan.js";
+/** A stretch of the film, seconds. */
+export interface Span {
+    start: number;
+    end: number;
+}
+/**
+ * Music gain under speech: down by `duck.db` while words are spoken,
+ * going down over `attack` before a word and back over `release` after
+ * one. Pauses shorter than `hold` stay ducked: under a narration the
+ * music is one steady bed, not a swell between every two sentences. It
+ * comes back up between paragraphs, and where nobody speaks.
+ */
+export declare function duckEnvelope(spoken: readonly Span[], duck?: MixLevels["duck"]): GainPoint[];
+/**
+ * Where speech plays on the film's clock: its segments (room tone
+ * included), with gaps shorter than a ramp down and back up joined.
+ */
+export declare function speechSpans(segments: readonly Segment[], duck?: MixLevels["duck"]): Span[];
+/**
+ * A level that changes by `depth` dB while speech plays (the spans),
+ * ramping over the duck's attack and release: music and footage go to
+ * their under-speech level only then.
+ */
+export declare function speechEnvelope(spans: readonly Span[], depth: number, duck?: MixLevels["duck"]): GainPoint[];
+/** The sum of two envelopes, exact at every point of either. */
+export declare function addEnvelopes(a: readonly GainPoint[], b: readonly GainPoint[]): GainPoint[];
+/**
+ * The gain of an equal-power fade `x` of the way through (0 to 1): two
+ * unrelated sounds cross-faded with it keep their summed power, so room
+ * tone goes over into the take's own room without a dip.
+ */
+export declare const equalPower: (x: number) => number;
+/** The envelope's gain at t, in dB: its first value before it, its last after it. */
+export declare function gainAt(points: readonly GainPoint[], t: number): number;
+//# sourceMappingURL=envelope.d.ts.map

package/node_modules/@allyhub-next/audio/dist/envelope.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{MIX_DEFAULTS as s}from"./levels.js";function f(e,t){const n=[];for(const r of[...e].sort((a,o)=>a.start-o.start)){const a=n.at(-1);a&&r.start-a.end<t?a.end=Math.max(a.end,r.end):n.push({start:r.start,end:r.end})}return n}function u(e,t,n,r){const a=[];for(const o of e)a.push({t:Math.max(0,o.start-n),db:0},{t:o.start,db:t},{t:o.end,db:t},{t:o.end+r,db:0});return a}export function duckEnvelope(e,t=s.duck){return t.db>=0||e.length===0?[]:u(f(e,t.hold+t.attack+t.release),t.db,t.attack,t.release)}export function speechSpans(e,t=s.duck){return f(e.filter(n=>n.dur>0).map(n=>({start:n.at,end:n.at+n.dur})),t.attack+t.release)}export function speechEnvelope(e,t,n=s.duck){return t===0||e.length===0?[]:u(e,t,n.attack,n.release)}export function addEnvelopes(e,t){return e.length===0?[...t]:t.length===0?[...e]:[...new Set([...e,...t].map(r=>r.t))].sort((r,a)=>r-a).map(r=>({t:r,db:gainAt(e,r)+gainAt(t,r)}))}export const equalPower=e=>Math.sin(Math.PI/2*Math.min(1,Math.max(0,e)));export function gainAt(e,t){if(e.length===0)return 0;const n=e[0];if(!n||t<=n.t)return n?.db??0;for(let r=1;r<e.length;r++){const a=e[r-1],o=e[r];if(!(!a||!o)&&t<=o.t)return o.t===a.t?o.db:a.db+(o.db-a.db)*(t-a.t)/(o.t-a.t)}return e.at(-1)?.db??0}

package/node_modules/@allyhub-next/audio/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { SAMPLE_RATE, type FootageClip, type GainPoint, type MixPlan, type MusicPlay, type MusicSegment, type PartSpan, type Segment, type SfxPlay, type SpeechClip, type Stereo, type VoicePlan, } from "./plan.js";
+export { addEnvelopes, duckEnvelope, equalPower, gainAt, speechEnvelope, speechSpans, type Span, } from "./envelope.js";
+export { clipSource, decodeKey, decodings, speechHow, type DecodeAs, type SoundOf, } from "./decode.js";
+export { renderMix, playSfx, type RenderOptions } from "./render.js";
+export { playMusic } from "./music.js";
+export { hashSeed, SFX_HIT, synthSfx } from "./sfx.js";
+export { addSpeech, playVoice, sumSpeech, voiceGroups, type ClipSource, type VoiceGroup, } from "./voice.js";
+export { limitPeaks, masterMix, previewMaster } from "./master.js";
+export { drySpeech, recordedSpeech, type SpeechTracks } from "./recorded.js";
+export { db, levelCurve, silenceBands, soundAtCut, waveColumns, type Band, type CutSound, type SilenceOptions, } from "./at-cut.js";
+export { MASTER_DEFAULTS, MASTER_MECHANICS, MIX_DEFAULTS, resolveMaster, resolveMix, type MasterOptions, type MasterTargets, type MixLevels, type MixOptions, } from "./levels.js";
+export { BAND_TYPES, bandAt, COMPRESS_DEFAULTS, shapeProblem, shapes, shapeSound, soundFilterProblem, soundLevel, type BandKey, type BandType, type EqBand, type FixedShape, type ResolvedShape, type SoundCompressor, type SoundMoment, type SoundShape, } from "./shape.js";
+export * from "./recording/index.js";
+export { biquad, biquadGain, BUTTERWORTH_Q, chainGain, fromDb, runBiquads, toDb, type Biquad, type FilterSpec, } from "./recording/filters.js";
+export { convolve, fft, magnitudes, minimumPhase, nextPow2, } from "./recording/fft.js";
+export { agc, compress, deess, gainComputer, type AgcOptions, type CompressorOptions, type DeesserOptions, } from "./recording/dynamics.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@allyhub-next/audio/dist/index.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export{SAMPLE_RATE}from"./plan.js";export{addEnvelopes,duckEnvelope,equalPower,gainAt,speechEnvelope,speechSpans}from"./envelope.js";export{clipSource,decodeKey,decodings,speechHow}from"./decode.js";export{renderMix,playSfx}from"./render.js";export{playMusic}from"./music.js";export{hashSeed,SFX_HIT,synthSfx}from"./sfx.js";export{addSpeech,playVoice,sumSpeech,voiceGroups}from"./voice.js";export{limitPeaks,masterMix,previewMaster}from"./master.js";export{drySpeech,recordedSpeech}from"./recorded.js";export{db,levelCurve,silenceBands,soundAtCut,waveColumns}from"./at-cut.js";export{MASTER_DEFAULTS,MASTER_MECHANICS,MIX_DEFAULTS,resolveMaster,resolveMix}from"./levels.js";export{BAND_TYPES,bandAt,COMPRESS_DEFAULTS,shapeProblem,shapes,shapeSound,soundFilterProblem,soundLevel}from"./shape.js";export*from"./recording/index.js";export{biquad,biquadGain,BUTTERWORTH_Q,chainGain,fromDb,runBiquads,toDb}from"./recording/filters.js";export{convolve,fft,magnitudes,minimumPhase,nextPow2}from"./recording/fft.js";export{agc,compress,deess,gainComputer}from"./recording/dynamics.js";

package/node_modules/@allyhub-next/audio/dist/levels.d.ts

@@ -0,0 +1,97 @@
+/** `video({ mix })`: loudness targets of the stems (LUFS) and the music's ducking and fades. */
+export interface MixOptions {
+    /** Each part's speech; default -16. */
+    speech?: number;
+    /** The music while speech plays; default -20. */
+    music?: number;
+    /** The music where nobody speaks; default -16. */
+    musicAlone?: number;
+    /** Sound effects from files; built-in sounds move by the same amount from the default; default -22. */
+    sfx?: number;
+    /** Footage's own sound where nobody speaks; default -16. */
+    footage?: number;
+    /** Footage's own sound while speech plays; default -22. */
+    footageUnderSpeech?: number;
+    /**
+     * How the music dips under words: `db` below its level while speech
+     * plays (default -8), going down over `attack` seconds before a word
+     * (0.3), back up over `release` after one (1), and staying down
+     * through pauses shorter than `hold` (2).
+     */
+    duck?: {
+        db?: number;
+        attack?: number;
+        release?: number;
+        hold?: number;
+    };
+    /** The music's fade in at the start and out at the end, seconds; defaults 0.3 and 1.5 (at most a quarter of the video). */
+    musicFade?: {
+        in?: number;
+        out?: number;
+    };
+}
+/** The mix's settings with every default filled in. */
+export interface MixLevels {
+    speech: number;
+    music: number;
+    musicAlone: number;
+    sfx: number;
+    footage: number;
+    footageUnderSpeech: number;
+    duck: {
+        db: number;
+        attack: number;
+        release: number;
+        hold: number;
+    };
+    musicFade: {
+        in: number;
+        out: number;
+    };
+}
+export declare const MIX_DEFAULTS: MixLevels;
+/** An output's mix options over the defaults. */
+export declare function resolveMix(o: MixOptions | undefined): MixLevels;
+/** `video({ master })`: what the sum is mastered to. */
+export interface MasterOptions {
+    /**
+     * Integrated loudness, LUFS (-70 to 0); default the platform profile's,
+     * else -14. false keeps the mix's own level (peaks still limited).
+     */
+    lufs?: number | false;
+    /** True-peak ceiling, dBTP (-9 to 0); default -3 (AAC overshoots up to about 2 dB). */
+    truePeak?: number;
+}
+export declare const MASTER_DEFAULTS: {
+    readonly lufs: -14;
+    readonly truePeak: -3;
+};
+/**
+ * How the master reaches its targets, mechanics rather than options: the
+ * mix's integrated loudness is measured, one gain brings it to the target,
+ * a limiter at `oversample` times the rate holds the true peak under the
+ * ceiling (going down over `attack` seconds, back over `release`), and
+ * what came out is measured again; the gain is corrected by what the
+ * limiter took, at most `rounds` times, until the loudness is within
+ * `tolerance` LU of the target. Nothing rides the level over time: the
+ * mix keeps its loudness range.
+ */
+export declare const MASTER_MECHANICS: {
+    readonly attack: 0.002;
+    readonly release: 0.04;
+    readonly oversample: 4;
+    readonly rounds: 4;
+    readonly tolerance: 0.1;
+};
+/** The master's targets, or false to keep the mix's level (its peaks still limited to `truePeak`). */
+export interface MasterTargets {
+    lufs: number | false;
+    truePeak: number;
+}
+/**
+ * An output's `master` resolved: a number is the loudness, false keeps
+ * the mix's level, an object sets either; `profileLufs` is the platform
+ * profile's loudness, the default when the output names none.
+ */
+export declare function resolveMaster(master: number | false | MasterOptions | undefined, profileLufs?: number): MasterTargets;
+//# sourceMappingURL=levels.d.ts.map

package/node_modules/@allyhub-next/audio/dist/levels.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export const MIX_DEFAULTS={speech:-16,music:-20,musicAlone:-16,sfx:-22,footage:-16,footageUnderSpeech:-22,duck:{db:-8,attack:.3,release:1,hold:2},musicFade:{in:.3,out:1.5}};export function resolveMix(e){const u=MIX_DEFAULTS;return{speech:e?.speech??u.speech,music:e?.music??u.music,musicAlone:e?.musicAlone??u.musicAlone,sfx:e?.sfx??u.sfx,footage:e?.footage??u.footage,footageUnderSpeech:e?.footageUnderSpeech??u.footageUnderSpeech,duck:{...u.duck,...e?.duck},musicFade:{...u.musicFade,...e?.musicFade}}}export const MASTER_DEFAULTS={lufs:-14,truePeak:-3},MASTER_MECHANICS={attack:.002,release:.04,oversample:4,rounds:4,tolerance:.1};export function resolveMaster(e,u){const s=u??MASTER_DEFAULTS.lufs;return e===!1?{lufs:!1,truePeak:MASTER_DEFAULTS.truePeak}:typeof e=="number"?{lufs:e,truePeak:MASTER_DEFAULTS.truePeak}:{lufs:e?.lufs??s,truePeak:e?.truePeak??MASTER_DEFAULTS.truePeak}}

package/node_modules/@allyhub-next/audio/dist/master.d.ts

@@ -0,0 +1,29 @@
+import { type MasterTargets } from "./levels.js";
+import type { Stereo } from "./plan.js";
+/**
+ * Holds the samples' peaks at `ceiling` (linear) in place: a gain that
+ * looks `attack` seconds ahead, comes down to what the loudest sample in
+ * that window allows, averaged over the window so it never jumps, and
+ * comes back up over `release`. The preview's limiter: it holds the
+ * samples, not the peaks between them, which the export's limiter holds
+ * at four times the rate.
+ */
+export declare function limitPeaks(bus: Stereo, ceiling: number, rate: number, attack?: number, release?: number): void;
+/**
+ * The preview's master, in place: the export's measured gain to the
+ * target loudness and a limiter at the ceiling, the gain corrected by
+ * what the limiter took (MASTER_MECHANICS). Its limiter holds samples,
+ * not true peaks, so the preview's peaks and loudness can differ from the
+ * export's by a fraction of a dB where the mix is limited hard.
+ */
+export declare function masterMix(bus: Stereo, rate: number, targets: MasterTargets): {
+    gainDb: number;
+    integrated?: number;
+};
+/**
+ * A plan's mix as the player plays it: rendered (render.ts), then
+ * mastered in place as the export is. Undefined where it is silent:
+ * nothing to master or to play.
+ */
+export declare function previewMaster(bus: Stereo, rate: number, targets: MasterTargets): Stereo | undefined;
+//# sourceMappingURL=master.d.ts.map

package/node_modules/@allyhub-next/audio/dist/master.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{integratedLoudness as w}from"./recording/loudness.js";import{MASTER_MECHANICS as M}from"./levels.js";export function limitPeaks(e,s,i,m=M.attack,c=M.release){const n=e[0].length,o=Math.max(1,Math.round(m*i)),a=new Float32Array(n);for(let t=0;t<n;t++){const d=Math.max(Math.abs(e[0][t]??0),Math.abs(e[1][t]??0));a[t]=d>s?s/d:1}const r=new Float32Array(n),l=[];let f=0;for(let t=n-1;t>=0;t--){const d=a[t]??1;for(;l.length>f&&(a[l[l.length-1]??0]??1)>=d;)l.pop();for(l.push(t);(l[f]??0)>t+o;)f++;r[t]=a[l[f]??t]??1}const u=Math.exp(-1/(Math.max(c,1e-4)*i));let h=1;for(let t=0;t<n;t++)h=Math.min(r[t]??1,1-(1-h)*u),r[t]=h;let p=0;const x=new Float32Array(n);for(let t=0;t<n;t++)p+=r[t]??1,t>=o&&(p-=r[t-o]??1),x[t]=p/Math.min(o,t+1);for(let t=0;t<n;t++){const d=Math.min(x[t]??1,a[t]??1);e[0][t]=(e[0][t]??0)*d,e[1][t]=(e[1][t]??0)*d}}export function masterMix(e,s,i){const m=10**(i.truePeak/20),c=w(e,s),n=l=>{const f=10**(l/20),u=[Float32Array.from(e[0],h=>h*f),Float32Array.from(e[1],h=>h*f)];return limitPeaks(u,m,s),u};let o=i.lufs===!1||c===void 0?0:i.lufs-c,a=n(o),r=w(a,s);if(i.lufs!==!1&&c!==void 0)for(let l=1;l<M.rounds&&r!==void 0;l++){const f=i.lufs-r;if(Math.abs(f)<=M.tolerance)break;o+=f,a=n(o),r=w(a,s)}return e[0].set(a[0]),e[1].set(a[1]),{gainDb:o,...r===void 0?{}:{integrated:r}}}export function previewMaster(e,s,i){const[m,c]=e;let n=!1;for(let o=0;o<m.length&&!n;o++)n=m[o]!==0||c[o]!==0;if(n)return masterMix(e,s,i),e}

package/node_modules/@allyhub-next/audio/dist/music.d.ts

@@ -0,0 +1,11 @@
+import type { MusicPlay, Stereo } from "./plan.js";
+/**
+ * The music as the film plays it, at `rate`: its segments with their
+ * seams' equal-power fades, shaped by its bands and compressor, levelled
+ * (a shaped stem by its loudness as shaped, to the mix's musicAlone),
+ * then its gain over time (its dip under speech and its own points) and
+ * its fades, ending at `until` or the film's end. What the render's mix
+ * and the player add.
+ */
+export declare function playMusic(m: MusicPlay, src: Stereo, duration: number, rate: number): Stereo;
+//# sourceMappingURL=music.d.ts.map

package/node_modules/@allyhub-next/audio/dist/music.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{equalPower as b,gainAt as D}from"./envelope.js";import{shapes as F,shapeSound as I,soundLevel as O}from"./shape.js";export function playMusic(f,c,M,t){const i=Math.round(M*t),o=[new Float32Array(i),new Float32Array(i)],g=c[0].length;if(g===0)return o;for(const n of f.segments){const e=Math.round(n.at*t),k=Math.round(n.from*t),r=Math.round(n.dur*t),l=Math.round(n.fadeIn*t),p=Math.round(n.fadeOut*t);for(let s=0;s<r;s++){const u=e+s,a=k+s;if(u<0||u>=i||a<0||a>=g)continue;let d=1;l>0&&s<l&&(d*=b(s/l)),p>0&&r-1-s<p&&(d*=b((r-1-s)/p)),o[0][u]=(o[0][u]??0)+(c[0][a]??0)*d,o[1][u]=(o[1][u]??0)+(c[1][a]??0)*d}}let w=f.gainDb;if(f.shape&&(F(f.shape)||f.shape.filter!==void 0)){I(o,f.shape,t,0);const n=O(o,t);n&&(w=f.alone-n.lufs)}const y=Math.round(f.fadeIn*t),A=Math.round(f.fadeOut*t),h=Math.min(i,Math.round((f.until??M)*t));for(let n=0;n<i;n++){if(n>=h){o[0][n]=0,o[1][n]=0;continue}let e=10**((w+D(f.duck,n/t))/20);n<y&&(e*=n/y),h-n<A&&(e*=(h-n)/A),o[0][n]=(o[0][n]??0)*e,o[1][n]=(o[1][n]??0)*e}return o}

package/node_modules/@allyhub-next/audio/dist/node/decode.d.ts

@@ -0,0 +1,39 @@
+import { type DecodeAs, type SoundOf } from "../decode.js";
+import { type MixPlan } from "../plan.js";
+import { type FfmpegOptions } from "./ffmpeg.js";
+/**
+ * Speech clean-up: ffmpeg's FFT denoiser (afftdn) reducing the noise by
+ * `db`, tracking the noise floor as it changes.
+ */
+export declare function denoiseFilter(db: number): string;
+/**
+ * The filters that play a file's sound as the mix does: a stem's own
+ * filter chain, the denoiser, then ffmpeg's atempo (a time stretch that
+ * keeps the pitch; one filter covers 0.5 to 2). None for a file played
+ * as recorded.
+ */
+export declare function speechFilters(o: DecodeAs): string[];
+/**
+ * A file's sound denoised, sped or filtered as the mix plays it (the
+ * same filters, stereo at 48 kHz), written to `out` as FLAC: what the
+ * preview plays for a take with denoise() or speed(), or a stem with a
+ * filter.
+ */
+export declare function speechFile(path: string, out: string, how: DecodeAs, o?: FfmpegOptions): Promise<void>;
+/**
+ * A sound or video file's sound as two channels at 48 kHz (a mono file
+ * given twice), through the filters `how` asks for.
+ */
+export declare function decodeStereo(path: string, how?: DecodeAs, o?: FfmpegOptions): Promise<[Float32Array, Float32Array]>;
+/** A file's sound as one channel at `rate` (its channels mixed down), as ffmpeg resamples it. */
+export declare function decodeMono(path: string, rate: number, o?: FfmpegOptions): Promise<Float32Array>;
+/** Where the plan's files are: its name for a file (a repository path) to a path on this computer. */
+export interface MixSources {
+    file(name: string): string | undefined;
+}
+/**
+ * Every file the plan plays decoded as it asks (a take denoised and sped,
+ * a stem filtered), each once; a file that cannot be decoded is left out.
+ */
+export declare function decodePlan(plan: MixPlan, sources: MixSources, o?: FfmpegOptions): Promise<SoundOf>;
+//# sourceMappingURL=decode.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/decode.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{decodeKey as p,decodings as g}from"../decode.js";import{SAMPLE_RATE as w}from"../plan.js";import{ffmpegOf as d,floats as u,runFfmpeg as l}from"./ffmpeg.js";const m=w;export function denoiseFilter(t){return`afftdn=nr=${Math.min(Math.max(t,.01),97).toFixed(2)}:nf=-50:tn=1`}export function speechFilters(t){return[...t.filter?[t.filter]:[],...t.denoise?[denoiseFilter(t.denoise)]:[],...t.speed!==void 0&&t.speed!==1?[`atempo=${t.speed.toFixed(6)}`]:[]]}export async function speechFile(t,n,i,r={}){const c=speechFilters(i);await l(await d(r),["-v","error","-y","-i",t,"-vn",...c.length>0?["-af",c.join(",")]:[],"-ac","2","-ar",String(m),"-c:a","flac","-f","flac",n])}export async function decodeStereo(t,n={},i={}){const r=speechFilters(n),{out:c}=await l(await d(i),["-v","error","-i",t,...r.length>0?["-af",r.join(",")]:[],"-f","f32le","-ac","2","-ar",String(m),"-"],!0),o=u(c),e=Math.floor(o.length/2),a=new Float32Array(e),s=new Float32Array(e);for(let f=0;f<e;f++)a[f]=o[f*2]??0,s[f]=o[f*2+1]??0;return[a,s]}export async function decodeMono(t,n,i={}){const{out:r}=await l(await d(i),["-v","error","-i",t,"-map","0:a:0","-ac","1","-ar",String(n),"-f","f32le","-"],!0);return u(r)}export async function decodePlan(t,n,i={}){const r=await d(i),c=new Map;for(const{file:o,how:e}of g(t)){const a=n.file(o);if(!a)continue;const s=await decodeStereo(a,e,{ffmpeg:r}).catch(()=>{});s&&c.set(p(o,e),s)}return(o,e)=>{const a=c.get(p(o,e));return a?{src:a,made:e}:void 0}}

package/node_modules/@allyhub-next/audio/dist/node/ebur128.d.ts

@@ -0,0 +1,25 @@
+/** One ebur128 measurement, every 100 ms. */
+export interface LoudnessFrame {
+    /** End of the measured window, seconds. */
+    t: number;
+    /** Momentary loudness (400 ms window), LUFS. */
+    momentary: number;
+    /** Short-term loudness (3 s window), LUFS. */
+    shortTerm: number;
+}
+/** The summary: integrated loudness (LUFS), its range (LU) and true peak (dBTP). */
+export interface LoudnessSummary {
+    /** Absent when everything is gated out: ebur128 says −70 LUFS then, nothing to hear. */
+    integrated?: number;
+    range?: number;
+    truePeak?: number;
+}
+/** A finite number in a match, or undefined (`-inf`, missing). */
+export declare function num(s: string | undefined): number | undefined;
+/** ebur128's summary, the last one in the log. */
+export declare function ebur128Summary(log: string): LoudnessSummary;
+/** ebur128's per-frame log (framelog=info) and its summary. */
+export declare function parseEbur128(log: string): LoudnessSummary & {
+    frames: LoudnessFrame[];
+};
+//# sourceMappingURL=ebur128.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/ebur128.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export function num(e){if(e===void 0)return;const n=Number(e);return Number.isFinite(n)?n:void 0}export function ebur128Summary(e){const n=e.slice(e.lastIndexOf("Summary:")),t=num(/Integrated loudness:\s*\n\s*I:\s*(-?[\d.]+|-inf) LUFS/.exec(n)?.[1]),s=num(/Loudness range:\s*\n\s*LRA:\s*(-?[\d.]+)/.exec(n)?.[1]),r=num(/True peak:\s*\n\s*Peak:\s*(-?[\d.]+|-inf)/.exec(n)?.[1]);return{...t!==void 0&&t>-70?{integrated:t}:{},...s===void 0?{}:{range:s},...r===void 0?{}:{truePeak:r}}}export function parseEbur128(e){const n=[],t=/\bt:\s*(-?[\d.]+)\s+TARGET:.*?\bM:\s*(-?[\d.]+|-inf)\s+S:\s*(-?[\d.]+|-inf)/g;for(const s of e.matchAll(t)){const r=num(s[1]);r!==void 0&&n.push({t:r,momentary:num(s[2])??-120,shortTerm:num(s[3])??-120})}return{frames:n,...ebur128Summary(e)}}

package/node_modules/@allyhub-next/audio/dist/node/ffmpeg.d.ts

@@ -0,0 +1,31 @@
+/** What can go wrong, by a code a caller branches on. */
+export type AudioErrorCode = 
+/** The file has no sound stream. */
+"no-sound"
+/** ffmpeg exited with an error. */
+ | "ffmpeg";
+export declare class AudioError extends Error {
+    readonly code: AudioErrorCode;
+    constructor(code: AudioErrorCode, message: string, options?: ErrorOptions);
+}
+/** Which ffmpeg to run; default the runtime manager's pinned build, fetched when first needed. */
+export interface FfmpegOptions {
+    ffmpeg?: string | undefined;
+}
+/** The ffmpeg to run: the one named, else the pinned one. */
+export declare function ffmpegOf(o?: FfmpegOptions): Promise<string>;
+/** How much of ffmpeg's log a run keeps unless it asks for more, in characters. */
+export declare const FFMPEG_LOG = 200000;
+/**
+ * Runs ffmpeg; resolves with its stdout (when asked for) and stderr. Of
+ * its log, the last `keep` characters are kept (at least half of them):
+ * enough to say what went wrong. A run that measures from the log (a
+ * line per moment of the sound) asks for all of it.
+ */
+export declare function runFfmpeg(ffmpeg: string, args: string[], stdout?: boolean, keep?: number): Promise<{
+    out: Buffer;
+    err: string;
+}>;
+/** Samples of 32-bit floats from ffmpeg's output, copied: the Buffer may not be 4-byte aligned. */
+export declare function floats(out: Buffer): Float32Array;
+//# sourceMappingURL=ffmpeg.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/ffmpeg.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{spawn as d}from"node:child_process";import{createRuntimes as m}from"@allyhub-next/runtimes";export class AudioError extends Error{code;constructor(r,o,f){super(o,f),this.name="AudioError",this.code=r}}let s;export function ffmpegOf(e={}){if(e.ffmpeg!==void 0)return Promise.resolve(e.ffmpeg);const r=s??m().bin("ffmpeg","ffmpeg").catch(o=>{throw s=void 0,o});return s=r,r}export const FFMPEG_LOG=2e5;export function runFfmpeg(e,r,o=!1,f=FFMPEG_LOG){return new Promise((u,p)=>{const i=d(e,r,{stdio:["ignore",o?"pipe":"ignore","pipe"]}),c=[];let t="";i.stdout?.on("data",n=>c.push(n)),i.stderr?.on("data",n=>{t+=n.toString(),t.length>f&&(t=t.slice(-f/2))}),i.on("error",p),i.on("close",n=>{n===0?u({out:Buffer.concat(c),err:t}):p(new AudioError("ffmpeg",`ffmpeg failed (${String(n)}): ${t.slice(-2e3)}`))})})}export function floats(e){return new Float32Array(e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength-e.byteLength%4))}

package/node_modules/@allyhub-next/audio/dist/node/index.d.ts

@@ -0,0 +1,8 @@
+export { AudioError, FFMPEG_LOG, ffmpegOf, runFfmpeg, type AudioErrorCode, type FfmpegOptions, } from "./ffmpeg.js";
+export { decodeMono, decodePlan, decodeStereo, denoiseFilter, speechFile, speechFilters, type MixSources, } from "./decode.js";
+export { mixToSamples, voiceTracks, type VoiceTracks } from "./mix.js";
+export { master, type Mastered, type Measured } from "./master.js";
+export { fileLoudness, type FileLoudness } from "./loudness.js";
+export { ebur128Summary, parseEbur128, type LoudnessFrame, type LoudnessSummary, } from "./ebur128.js";
+export { ANALYZE_DEFAULTS, analyzeSound, parseAstats, parseSilences, spanLoudness, type AnalyzeOptions, type Silence, type SoundAnalysis, } from "./measure.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/index.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export{AudioError,FFMPEG_LOG,ffmpegOf,runFfmpeg}from"./ffmpeg.js";export{decodeMono,decodePlan,decodeStereo,denoiseFilter,speechFile,speechFilters}from"./decode.js";export{mixToSamples,voiceTracks}from"./mix.js";export{master}from"./master.js";export{fileLoudness}from"./loudness.js";export{ebur128Summary,parseEbur128}from"./ebur128.js";export{ANALYZE_DEFAULTS,analyzeSound,parseAstats,parseSilences,spanLoudness}from"./measure.js";

package/node_modules/@allyhub-next/audio/dist/node/loudness.d.ts

@@ -0,0 +1,18 @@
+import { type FfmpegOptions } from "./ffmpeg.js";
+/** A file's loudness, LUFS, and how it was measured. */
+export interface FileLoudness {
+    lufs: number;
+    /**
+     * "integrated": BS.1770's gated integrated loudness (ffmpeg's ebur128);
+     * "level": the K-weighted level over the whole file, for a sound too
+     * short for one 0.4 s block (a click) or all under the gate.
+     */
+    by: "integrated" | "level";
+}
+/**
+ * A file's loudness, cached per file version (its path, size and time):
+ * its integrated loudness, else its K-weighted level over its whole
+ * length (`by` says which); undefined for a file with no sound.
+ */
+export declare function fileLoudness(path: string, o?: FfmpegOptions): Promise<FileLoudness | undefined>;
+//# sourceMappingURL=loudness.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/loudness.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{stat as u}from"node:fs/promises";import{SAMPLE_RATE as d}from"../plan.js";import{soundLevel as l}from"../shape.js";import{decodeStereo as g}from"./decode.js";import{ebur128Summary as p}from"./ebur128.js";import{ffmpegOf as b,runFfmpeg as w}from"./ffmpeg.js";const m=new Map;export async function fileLoudness(t,a={}){const n=await u(t),o=`${t}:${String(n.size)}:${String(n.mtimeMs)}`,r=m.get(o);if(r!==void 0)return r;const i=await b(a),{err:c}=await w(i,["-hide_banner","-nostats","-i",t,"-vn","-sn","-dn","-af","ebur128=framelog=verbose","-f","null","-"]),f=p(c).integrated;let e;if(f!==void 0)e={lufs:f,by:"integrated"};else{const s=l(await g(t,{},{ffmpeg:i}).catch(()=>[]),d);s&&(e=s)}return e&&m.set(o,e),e}

package/node_modules/@allyhub-next/audio/dist/node/master.d.ts

@@ -0,0 +1,42 @@
+import { type MasterTargets } from "../levels.js";
+import { type FfmpegOptions } from "./ffmpeg.js";
+/** A file's loudness as measured: integrated (LUFS), its range (LU) and true peak (dBTP). */
+export interface Measured {
+    integrated: number;
+    range?: number;
+    truePeak?: number;
+}
+/** What the master did and what came out, measured on the file it wrote. */
+export interface Mastered {
+    /** The file as written; undefined when the mix is silent. */
+    loudness?: Measured;
+    /** The mix before the master, measured the same way. */
+    before?: Measured;
+    /** The gain the master applied, dB. */
+    gainDb?: number;
+    /**
+     * dB the limiter took off the loudest peak: the true peak the gain
+     * would have made, less the ceiling (0 where it did not touch it).
+     */
+    limited?: number;
+    /** What it was asked for. */
+    target: MasterTargets;
+    /** Rounds of gain, limiting and measuring it took. */
+    rounds?: number;
+}
+/**
+ * Writes an interleaved stereo mix at 48 kHz mastered to `targets.lufs`
+ * (default −14) with its true peak at most `targets.truePeak` dBTP
+ * (default −3: AAC overshoots by up to about 2 dB on a dense, bright mix,
+ * a −2 dBTP master measured −0.2 dBTP as AAC), as 48 kHz PCM WAV, exactly
+ * `duration` seconds. The mix's integrated loudness is measured, one gain
+ * brings it to the target, a limiter at four times the rate holds the
+ * peaks, and what came out is measured: the gain is corrected by what the
+ * limiter took until the loudness is within MASTER_MECHANICS.tolerance of
+ * the target, at most MASTER_MECHANICS.rounds times. Nothing rides the
+ * level over time, so the mix keeps its loudness range. With `lufs` false
+ * the mix keeps its own level: only its peaks are limited. The limiter's
+ * attack and release are mechanics, not options.
+ */
+export declare function master(mix: Float32Array, duration: number, out: string, targets?: MasterTargets, o?: FfmpegOptions): Promise<Mastered>;
+//# sourceMappingURL=master.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/master.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{rm as M,writeFile as P}from"node:fs/promises";import{MASTER_DEFAULTS as x,MASTER_MECHANICS as T}from"../levels.js";import{SAMPLE_RATE as v}from"../plan.js";import{ebur128Summary as _}from"./ebur128.js";import{ffmpegOf as R,runFfmpeg as g}from"./ffmpeg.js";const l=v;async function D(e,s,a){const{err:t}=await g(e,["-hide_banner","-nostats",...s,"-af",`${a}${a?",":""}ebur128=peak=true:framelog=quiet`,"-f","null","-"]);return _(t)}const h=e=>({integrated:e.integrated,...e.range===void 0?{}:{range:e.range},...e.truePeak===void 0?{}:{truePeak:e.truePeak}});export async function master(e,s,a,t={...x},k={}){const u=await R(k),d=`${a}.f32`;await P(d,new Uint8Array(e.buffer,e.byteOffset,e.byteLength));try{const c=["-f","f32le","-ar",String(l),"-ac","2","-i",d],p=`aresample=${String(l)}:in_chlayout=stereo:out_chlayout=stereo`,b=`apad=whole_dur=${s.toFixed(6)},atrim=0:${s.toFixed(6)}`,r=await D(u,c,p);if(r.integrated===void 0)return await g(u,["-v","error","-y",...c,"-af",b,"-c:a","pcm_s16le",a]),{target:t};const w=t.truePeak,A=10**(w/20),o=T,E=`aresample=${String(l*o.oversample)},aformat=sample_fmts=dbl:channel_layouts=stereo,alimiter=limit=${A.toFixed(4)}:level=false:attack=${String(o.attack*1e3)}:release=${String(o.release*1e3)},aresample=${String(l)},${b}`,$=async i=>{const{err:F}=await g(u,["-hide_banner","-nostats","-y",...c,"-af",`${p},volume=${i.toFixed(4)}dB:precision=double,${E},ebur128=peak=true:framelog=quiet`,"-c:a","pcm_s16le",a]);return _(F)};let f=t.lufs===!1?0:t.lufs-r.integrated,n=await $(f),m=1;if(t.lufs!==!1)for(;m<o.rounds&&n.integrated!==void 0;){const i=t.lufs-n.integrated;if(Math.abs(i)<=o.tolerance)break;f+=i,n=await $(f),m++}const y=r.truePeak===void 0?void 0:Math.max(0,r.truePeak+f-w),S=i=>Math.round(i*100)/100;return{...n.integrated===void 0?{}:{loudness:h({...n,integrated:n.integrated})},before:h({...r,integrated:r.integrated}),gainDb:S(f),...y===void 0?{}:{limited:S(y)},target:t,rounds:m}}finally{await M(d,{force:!0})}}

package/node_modules/@allyhub-next/audio/dist/node/measure.d.ts

@@ -0,0 +1,60 @@
+import { type LoudnessFrame } from "./ebur128.js";
+import { type FfmpegOptions } from "./ffmpeg.js";
+export interface Silence {
+    start: number;
+    end: number;
+    duration: number;
+}
+export interface SoundAnalysis {
+    duration: number;
+    /** Integrated loudness, LUFS; undefined when the file is silent. */
+    integrated?: number;
+    /** Loudness range, LU. */
+    range?: number;
+    /** True peak, dBTP. */
+    truePeak?: number;
+    /** Highest sample, dBFS. */
+    samplePeak?: number;
+    /** RMS level over the whole file, dBFS. */
+    rms?: number;
+    /** Times a sample reached full scale. */
+    clipped: number;
+    frames: LoudnessFrame[];
+    silences: Silence[];
+    /** The sound as one channel at `rate`, for measuring it further (its onsets). */
+    samples: Float32Array;
+    rate: number;
+}
+/** silencedetect's gaps; one still open at the end closes at `duration`. */
+export declare function parseSilences(log: string, duration: number): Silence[];
+/** astats' overall peak, RMS and how often the peak was reached. */
+export declare function parseAstats(log: string): {
+    samplePeak?: number;
+    rms?: number;
+    peakCount: number;
+};
+/**
+ * Loudness from `start` to `end`: the energy mean and the highest of the
+ * momentary measurements whose 400 ms window centres there.
+ */
+export declare function spanLoudness(frames: readonly LoudnessFrame[], start: number, end: number): {
+    mean?: number;
+    max?: number;
+};
+export interface AnalyzeOptions extends FfmpegOptions {
+    /** Below this level is silence, dBFS. Default −50. */
+    noise?: number;
+    /** Shortest silence reported, seconds. Default 0.5. */
+    minSilence?: number;
+    /** The rate of the samples it returns, and its duration is counted in. Default 22050 (the media module's onsets). */
+    rate?: number;
+}
+/** What `analyzeSound` measures by unless asked otherwise. */
+export declare const ANALYZE_DEFAULTS: {
+    readonly noise: -50;
+    readonly minSilence: 0.5;
+    readonly rate: 22050;
+};
+/** Measures a file's sound with ffmpeg (two passes, at once). */
+export declare function analyzeSound(file: string, o?: AnalyzeOptions): Promise<SoundAnalysis>;
+//# sourceMappingURL=measure.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/measure.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{parseEbur128 as k,num as m}from"./ebur128.js";import{AudioError as x,ffmpegOf as P,floats as S,runFfmpeg as g}from"./ffmpeg.js";export function parseSilences(r,n){const s=[];let e;for(const a of r.matchAll(/silence_(start|end):\s*(-?[\d.]+)(?:\s*\|\s*silence_duration:\s*([\d.]+))?/g)){const t=m(a[2]);t!==void 0&&(a[1]==="start"?e=Math.max(0,t):e!==void 0&&(s.push({start:e,end:t,duration:t-e}),e=void 0))}return e!==void 0&&n-e>0&&s.push({start:e,end:n,duration:n-e}),s}export function parseAstats(r){const n=r.slice(r.lastIndexOf("Overall")),s=m(/Peak level dB:\s*(-?[\d.]+|-inf)/.exec(n)?.[1]),e=m(/RMS level dB:\s*(-?[\d.]+|-inf)/.exec(n)?.[1]),a=m(/\n[^\n]*Peak count:\s*([\d.]+)/.exec(n)?.[1]);return{...s!==void 0?{samplePeak:s}:{},...e!==void 0?{rms:e}:{},peakCount:a??0}}export function spanLoudness(r,n,s){let e=0,a=0,t=-1/0;for(const o of r){const f=o.t-.2;f<n||f>=s||(e+=10**(o.momentary/10),a++,o.momentary>t&&(t=o.momentary))}if(a===0)return{};const u=10*Math.log10(e/a),i=o=>Math.round(o*10)/10;return u>-70?{mean:i(u),max:i(t)}:{}}export const ANALYZE_DEFAULTS={noise:-50,minSilence:.5,rate:22050};export async function analyzeSound(r,n={}){const s=await P(n),e=n.noise??ANALYZE_DEFAULTS.noise,a=n.minSilence??ANALYZE_DEFAULTS.minSilence,t=n.rate??ANALYZE_DEFAULTS.rate,u=["-i",r,"-map","0:a:0"];let i,o;try{[i,o]=await Promise.all([g(s,["-hide_banner","-nostats",...u,"-af",`ebur128=peak=true:framelog=info,silencedetect=n=${String(e)}dB:d=${String(a)},astats`,"-f","null","-"],!1,1/0),g(s,["-v","error",...u,"-ac","1","-ar",String(t),"-f","f32le","-"],!0)])}catch(l){throw(l instanceof Error?l.message:String(l)).includes("matches no streams")?new x("no-sound",`${r} has no sound.`,{cause:l}):l}const f=S(o.out),p=f.length/t,d=k(i.err),c=parseAstats(i.err),h=c.samplePeak!==void 0&&c.samplePeak>=-.01;return{duration:p,...d.integrated!==void 0?{integrated:d.integrated}:{},...d.range!==void 0?{range:d.range}:{},...d.truePeak!==void 0?{truePeak:d.truePeak}:{},...c.samplePeak!==void 0?{samplePeak:c.samplePeak}:{},...c.rms!==void 0?{rms:c.rms}:{},clipped:h?Math.max(1,c.peakCount):0,frames:d.frames,silences:parseSilences(i.err,p),samples:f,rate:t}}

package/node_modules/@allyhub-next/audio/dist/node/mix.d.ts

@@ -0,0 +1,31 @@
+import { type MixPlan, type Stereo } from "../plan.js";
+import { type VoiceGroup } from "../voice.js";
+import { type MixSources } from "./decode.js";
+import type { FfmpegOptions } from "./ffmpeg.js";
+/**
+ * Renders a plan to an interleaved stereo Float32 mix at 48 kHz, before
+ * mastering, its speech recorded through the plan's settings;
+ * `only: "voice"` renders the speech alone, as recorded, for measuring
+ * it.
+ */
+export declare function mixToSamples(plan: MixPlan, sources: MixSources, o?: FfmpegOptions & {
+    only?: "voice";
+}): Promise<Float32Array>;
+/** An output's speech before it is recorded: a track per setting, and what plays as it is. */
+export interface VoiceTracks {
+    /** Samples a second. */
+    rate: number;
+    /** Speech recorded alike, with its clips summed (not yet recorded). */
+    groups: (VoiceGroup & {
+        dry: Stereo;
+    })[];
+    /** Speech whose setting is false, summed: played as it is. */
+    plain: Stereo;
+}
+/**
+ * The speech of a plan summed per setting, before it is recorded: what
+ * `mixToSamples` plays through each setting, for measuring and for trying
+ * another setting on the same speech.
+ */
+export declare function voiceTracks(plan: MixPlan, sources: MixSources, o?: FfmpegOptions): Promise<VoiceTracks>;
+//# sourceMappingURL=mix.d.ts.map

package/node_modules/@allyhub-next/audio/dist/node/mix.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{clipSource as a}from"../decode.js";import{SAMPLE_RATE as d}from"../plan.js";import{renderMix as f}from"../render.js";import{sumSpeech as l,voiceGroups as y}from"../voice.js";import{decodePlan as u}from"./decode.js";const m=d,p=r=>({duration:r.duration,speech:r.speech,footage:[],sfx:[]});export async function mixToSamples(r,c,e={}){const s=await u(e.only==="voice"?p(r):r,c,e),[n,i]=f(r,s,m,e.only===void 0?{}:{only:e.only}),t=new Float32Array(n.length*2);for(let o=0;o<n.length;o++)t[o*2]=n[o]??0,t[o*2+1]=i[o]??0;return t}export async function voiceTracks(r,c,e={}){const s=a(await u(p(r),c,e)),{groups:n,dry:i}=y(r),t=o=>l(o,r.duration,m,s);return{rate:m,groups:n.map(o=>({...o,dry:t(o.clips)})),plain:t(i)}}