allyhub 0.6.0 → 0.7.0

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

@@ -1,143 +0,0 @@
-import type { ResolvedVoice } from "./recording/chain.js";
-import type { FixedShape, ResolvedShape } from "./shape.js";
-/** The rate the export mixes at, samples a second. The player mixes at its AudioContext's. */
-export declare const SAMPLE_RATE = 48000;
-/** A sound's two channels (a mono one given twice). */
-export type Stereo = readonly [Float32Array, Float32Array];
-/** A point of a gain envelope: at time t (s), gain in dB. Linear between points. */
-export interface GainPoint {
-    t: number;
-    db: number;
-}
-/** A stretch of a file placed on the film's clock. */
-export interface Segment {
-    /** Film time it starts. */
-    at: number;
-    /** File time it starts from. */
-    from: number;
-    /** Film seconds it lasts. */
-    dur: number;
-    /** File seconds per film second (footage's speed, a take's); default 1. */
-    speed?: number;
-}
-/**
- * A stretch of a voiced part's speech: of its take or its said line, at
- * its place (a cut take is several), at its speed (pitch kept, unlike
- * footage's), with its noise reduction; or the room tone that fills a
- * lead or a tail, at its matched gain. `fadeIn` and `fadeOut` are seconds
- * of equal-power fade at its start and end, where it cross-fades with the
- * clip it overlaps (room tone into the take); absent: the mix's own 10 ms
- * fade.
- */
-export interface SpeechClip extends Segment {
-    /** The file, as the host names it (a repository path). */
-    file: string;
-    /** The part whose speech it is. */
-    part?: string;
-    gainDb: number;
-    /** Noise reduction, dB (ffmpeg's afftdn where the host decodes it). */
-    denoise?: number;
-    fadeIn?: number;
-    fadeOut?: number;
-}
-/**
- * Footage's own sound: a stretch of a file at its place, at its level
- * where nobody speaks; `envelope` (relative dB) takes it to its
- * under-speech level while speech plays.
- */
-export interface FootageClip extends Segment {
-    file: string;
-    gainDb: number;
-    envelope?: GainPoint[];
-}
-/**
- * A piece of the music file the mix plays: film second `at`, file second
- * `from`, `dur` seconds, with its equal-power fades at a seam (seconds).
- * The runtime places them (the music's clock: its stretches, loops and
- * seams), from the file's length.
- */
-export interface MusicSegment {
-    at: number;
-    from: number;
-    dur: number;
-    fadeIn: number;
-    fadeOut: number;
-}
-/** The music as the film plays it. */
-export interface MusicPlay {
-    file: string;
-    /** What it plays of the file, where: each seam's cross-fade in its fades. */
-    segments: MusicSegment[];
-    /** Its gain where nobody speaks (levelled to the mix's musicAlone). */
-    gainDb: number;
-    /** The mix's musicAlone: the level a shaped stem is levelled to, by its loudness as shaped. */
-    alone: number;
-    /** Its fade in at the film's start and out at its end, seconds (linear). */
-    fadeIn: number;
-    fadeOut: number;
-    /** Film seconds its fade out ends at (it ends on a bar); absent: the film's end. */
-    until?: number;
-    /**
-     * Its gain over time relative to gainDb: down to the mix's music level
-     * while speech plays, further by the duck under words, and the music's
-     * own gain points.
-     */
-    duck: GainPoint[];
-    /** How it is shaped, its bands' keys at film seconds (its filter runs when it is decoded). */
-    shape?: ResolvedShape;
-}
-/** A sound effect: an audio file, or a built-in synthesized one (sfx.ts). */
-export interface SfxPlay {
-    /** Its name; a built-in sound's (`whoosh`, `tick`, `pop`) when it has no file. */
-    sound: string;
-    /** The audio file; absent: synthesized. */
-    file?: string;
-    /** When it starts (a built-in one is placed so its transient is at the cue). */
-    at: number;
-    gainDb: number;
-    /** Seeds a built-in sound. */
-    seed: number;
-    /** How it is shaped (its filter runs when it is decoded). */
-    shape?: FixedShape;
-    /**
-     * A shaped file's level as shaped: the mix's sfx level, and the cue's
-     * own gain over it; absent for a built-in sound, which keeps its level.
-     */
-    level?: {
-        target: number;
-        gainDb: number;
-    };
-}
-/** Where a part is on the film: where its recording's room tone runs. */
-export interface PartSpan {
-    part: string;
-    start: number;
-    end: number;
-}
-/**
- * How the speech was recorded: the video's setting and each part's own,
- * resolved over their presets (recording/), false where it plays as it
- * is; every part of the film, in order; and the seed of the rooms and
- * their tone (piece, output and combo key, as the runtime writes it).
- */
-export interface VoicePlan {
-    video: ResolvedVoice | false;
-    parts?: Record<string, ResolvedVoice | false>;
-    spans: PartSpan[];
-    seed: string;
-}
-export interface MixPlan {
-    duration: number;
-    speech: SpeechClip[];
-    footage: FootageClip[];
-    music?: MusicPlay;
-    sfx: SfxPlay[];
-    /**
-     * The speech's gain after it is recorded, relative dB over the film
-     * (each part's speechGainDb, ramped where it changes); absent: none.
-     */
-    speechGain?: GainPoint[];
-    /** How the speech is recorded; absent: every clip plays as it is. */
-    voice?: VoicePlan;
-}
-//# sourceMappingURL=plan.d.ts.map

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

@@ -1,26 +0,0 @@
-import type { ResolvedVoice } from "./recording/chain.js";
-import type { Stereo } from "./plan.js";
-import type { VoiceGroup } from "./voice.js";
-/** The speech of a plan summed per setting, before it is recorded. */
-export interface SpeechTracks {
-    /** Samples a second. */
-    rate: number;
-    /** Speech recorded alike, with its clips summed (not yet recorded). */
-    groups: readonly (VoiceGroup & {
-        dry: Stereo;
-    })[];
-    /** Speech whose setting is false, summed: played as it is. */
-    plain: Stereo;
-}
-/** All the speech summed before any of it is recorded: each setting's track and what plays as it is. */
-export declare function drySpeech(tracks: SpeechTracks): Stereo;
-/**
- * All the speech as the mix records it: each setting's track recorded
- * through its setting (or, for the group at `swap.index`, through
- * `swap.voice`), with what plays as it is.
- */
-export declare function recordedSpeech(tracks: SpeechTracks, swap?: {
-    index: number;
-    voice: ResolvedVoice;
-}): Stereo;
-//# sourceMappingURL=recorded.d.ts.map

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

@@ -1,47 +0,0 @@
-export interface BandwidthOptions {
-    /** The level is read at this frequency, Hz. */
-    ref: number;
-    /** How far under the level at `ref` the sound may fall and still reach, dB, each. */
-    drops: number[];
-    /** Levels are averaged over this share of an octave around each frequency. */
-    smooth: number;
-    /** Steps are looked for from this frequency, Hz… */
-    stepsFrom: number;
-    /** …as falls over spans of this share of an octave… */
-    stepSpan: number;
-    /** …at least this deep, dB, the deepest this many. */
-    stepMin: number;
-    steps: number;
-    /** A frame is in the average when its level is over this, dBFS (the frames picked, or all). */
-    floor: number;
-}
-export declare const BANDWIDTH_DEFAULTS: BandwidthOptions;
-export interface Bandwidth {
-    /** The frames averaged. */
-    frames: number;
-    /** The highest frequency the sound is within each drop of its level at `ref`, Hz; null where it never is. */
-    reach: {
-        drop: number;
-        hz: number | null;
-    }[];
-    /** The frequencies under which 95 % and 99 % of the power above `ref` lies, Hz. */
-    rolloff95: number | null;
-    rolloff99: number | null;
-    /**
-     * The deepest falls over `stepSpan` of an octave above `stepsFrom`
-     * (each the most of its neighbourhood), by frequency: their centre, Hz,
-     * and their depth, dB.
-     */
-    steps: {
-        hz: number;
-        db: number;
-    }[];
-}
-/**
- * A sound's reach (channels at `rate`), over the frames `pick` takes (by
- * the sample at a frame's middle; all by default) that are over `floor`.
- */
-export declare function bandwidthOf(channels: readonly Float32Array[], rate: number, opts?: Partial<BandwidthOptions> & {
-    pick?: (sample: number) => boolean;
-}): Bandwidth;
-//# sourceMappingURL=bandwidth.d.ts.map

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

@@ -1,89 +0,0 @@
-import { type FilterSpec } from "./filters.js";
-import { type Pattern } from "./mic.js";
-import { type NoiseShape } from "./noise.js";
-import { type VoiceSetting, type VoiceSetup } from "./setup.js";
-import type { CompressorOptions, DeesserOptions } from "./dynamics.js";
-import type { Vec3 } from "./vec.js";
-/** A room with every value. */
-export interface ResolvedRoom {
-    size: Vec3;
-    walls: number[];
-    floor: number[];
-    ceiling: number[];
-    rt60: number;
-    talker: Vec3;
-    open?: true;
-    order: number;
-}
-/** One microphone with every value. */
-export interface ResolvedPickup {
-    pattern: Pattern;
-    distance: number;
-    angle: number;
-    below: number;
-    response: (readonly [number, number])[];
-    band: readonly [number, number];
-    stereo: number | false;
-    room: ResolvedRoom | false;
-    noise: (NoiseShape & {
-        below: number;
-    }) | false;
-    agc: {
-        target: number;
-        most: number;
-        attack: number;
-        release: number;
-        window: number;
-        gate?: number;
-    } | false;
-    /** Its level in the sum, dB. */
-    gain: number;
-    /**
-     * The distance its room tone's `below` holds at (the setup's own): moved
-     * further, the voice reaches it weaker against the same room tone.
-     */
-    toneAt: number;
-}
-/** A finishing chain with every value. */
-export interface ResolvedPost {
-    highpass: number | false;
-    eq: FilterSpec[];
-    deess: DeesserOptions | false;
-    compress: CompressorOptions | false;
-}
-/** A voice setting with every value: what the mix and the player play it through. */
-export interface ResolvedVoice {
-    setup: VoiceSetup;
-    source: {
-        pattern: Pattern;
-        distance: number;
-    };
-    pickups: ResolvedPickup[];
-    post: ResolvedPost | false;
-}
-/** A voice setting with every value from its presets; undefined: the default (studio). */
-export declare function resolveVoice(v: VoiceSetting | undefined): ResolvedVoice | false;
-/** Why a voice setting cannot be played, with its field; undefined when it can. */
-export declare function voiceProblem(v: unknown, at?: string): string | undefined;
-/**
- * A pickup's impulse response per channel (one, or two for a stereo
- * pair), its direct sound `lead` samples in; null where it changes
- * nothing (a studio's flat microphone at the dry voice's own distance,
- * no room).
- */
-export declare function pickupImpulses(p: ResolvedPickup, source: ResolvedVoice["source"], rate: number, seed: number): {
-    channels: Float64Array[];
-    lead: number;
-} | null;
-/** Where the voice's parts play, seconds: the room tone is under them alone. */
-export interface VoiceSpan {
-    start: number;
-    end: number;
-}
-/**
- * Plays a voice (stereo, at the mix's speech level) through its setting,
- * in place: what the mix and the player both call. `seed` makes the
- * room's tail and the room tone the same every time.
- */
-export declare function recordVoice(channels: readonly [Float32Array, Float32Array], voice: ResolvedVoice, rate: number, seed: number, spans: readonly VoiceSpan[]): void;
-//# sourceMappingURL=chain.d.ts.map

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

@@ -1,64 +0,0 @@
-/** A compressor's settings; levels in dBFS. */
-export interface CompressorOptions {
-    /** Where it starts to act, dBFS. */
-    threshold: number;
-    /** Input dB over the threshold per output dB. */
-    ratio: number;
-    /** The knee's width, dB (0: hard). */
-    knee: number;
-    /** Seconds to go down, and to come back. */
-    attack: number;
-    release: number;
-    /** The level's detector: a window's RMS, seconds (0: the peak). */
-    window: number;
-}
-/** The gain reduction (dB, ≤ 0) of the gain computer for an input level. */
-export declare function gainComputer(x: number, o: Pick<CompressorOptions, "threshold" | "ratio" | "knee">): number;
-/** Compresses the channels in place. */
-export declare function compress(channels: readonly Float32Array[], o: CompressorOptions, rate: number): void;
-/** A de-esser's settings: the band it listens to, and how it presses it down. */
-export interface DeesserOptions {
-    /** Where sibilance starts, Hz: the band over it is what is pressed down. */
-    hz: number;
-    /** The band's level where it starts, dBFS, and its ratio. */
-    threshold: number;
-    ratio: number;
-    attack: number;
-    release: number;
-}
-/**
- * Presses the highs down where they are loud: split at `hz` by a
- * fourth-order Linkwitz–Riley crossover (two Butterworth sections each
- * way, whose sum is an all-pass: flat when nothing is pressed), the band
- * over it given the gain its own level asks for.
- */
-export declare function deess(channels: readonly Float32Array[], o: DeesserOptions, rate: number): void;
-/** A phone's automatic gain control. */
-export interface AgcOptions {
-    /** The level it rides toward, dBFS (the speech's level). */
-    target: number;
-    /** The most it lifts, dB; it never lowers more than `target` asks. */
-    most: number;
-    /** Seconds for the gain to come down, and to rise. */
-    attack: number;
-    release: number;
-    /**
-     * The speech's level it follows: the mean power of 50 ms windows over
-     * this many seconds, s.
-     */
-    window: number;
-    /**
-     * Under this level (dBFS) a window is not speech: the level it follows,
-     * and so its gain, hold through it (no gate: undefined, and a pause
-     * lifts the room).
-     */
-    gate?: number;
-}
-/**
- * Rides the level in place toward `target`, as a device's automatic gain
- * does: it follows the speech's level over `window` seconds (holding it
- * through what is under `gate`) and sets the gain that brings that level
- * to the target, at most `most` up, moving at `attack` and `release`.
- */
-export declare function agc(channels: readonly Float32Array[], o: AgcOptions, rate: number): void;
-//# sourceMappingURL=dynamics.d.ts.map

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

@@ -1,26 +0,0 @@
-/** The least power of two at or above n. */
-export declare function nextPow2(n: number): number;
-/**
- * In place: the discrete Fourier transform of re + i·im (`inverse`: its
- * inverse, divided by n). n is a power of two.
- */
-export declare function fft(re: Float64Array, im: Float64Array, inverse?: boolean): void;
-/**
- * `x` convolved with `h`, as long as `x` (what rings on past its end is
- * cut): overlap-add in blocks, two real signals per complex transform.
- */
-export declare function convolve(x: Float32Array, h: Float32Array | Float64Array): Float32Array;
-/**
- * The magnitude of a filter's response at `n / 2 + 1` frequencies from 0
- * to half the rate, of an impulse response `h` (n a power of two ≥ its
- * length).
- */
-export declare function magnitudes(h: Float32Array | Float64Array, n: number): Float64Array;
-/**
- * A minimum-phase impulse response of `taps` taps whose magnitude is
- * `gain(frequency in Hz)` (linear) at `rate`: by the real cepstrum folded
- * onto positive quefrencies (the homomorphic method), its end faded by a
- * half Hann window.
- */
-export declare function minimumPhase(gain: (hz: number) => number, rate: number, taps?: number): Float64Array;
-//# sourceMappingURL=fft.d.ts.map

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

@@ -1,42 +0,0 @@
-/** A biquad's coefficients, a0 divided out. */
-export interface Biquad {
-    b0: number;
-    b1: number;
-    b2: number;
-    a1: number;
-    a2: number;
-}
-/** One band of an equalizer or a pass, as the cookbook names them. */
-export type FilterSpec = {
-    type: "highpass" | "lowpass";
-    hz: number;
-    q?: number;
-} | {
-    type: "peak";
-    hz: number;
-    db: number;
-    q?: number;
-} | {
-    type: "lowshelf" | "highshelf";
-    hz: number;
-    db: number;
-    slope?: number;
-} | {
-    type: "bandpass";
-    hz: number;
-    q?: number;
-};
-/** A Butterworth's Q: the flattest pass band. */
-export declare const BUTTERWORTH_Q: number;
-/** A cookbook biquad at `rate`. */
-export declare function biquad(spec: FilterSpec, rate: number): Biquad;
-/** A biquad's gain at `hz` (linear), at `rate`. */
-export declare function biquadGain(b: Biquad, hz: number, rate: number): number;
-/** Filters `x` in place through the biquads in turn. */
-export declare function runBiquads(x: Float32Array, chain: readonly Biquad[]): void;
-/** The gain of a chain of filter specs at `hz` (linear). */
-export declare function chainGain(specs: readonly FilterSpec[], hz: number, rate: number): number;
-/** dB of a linear gain, and the way back. */
-export declare const toDb: (g: number) => number;
-export declare const fromDb: (db: number) => number;
-//# sourceMappingURL=filters.d.ts.map

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

@@ -1,56 +0,0 @@
-import { type ResolvedVoice } from "./chain.js";
-import { type RecordingMeasureOptions, type RecordingMeasurement } from "./measure.js";
-import type { VoiceOptions, VoiceSetting } from "./setup.js";
-/** How a setting is fitted. */
-export interface VoiceFitOptions {
-    /** Rounds of recording, measuring and moving. */
-    rounds: number;
-    /** The response moves at most this many dB at any band. */
-    most: number;
-    /** The bands the response is fitted over, Hz. */
-    from: number;
-    to: number;
-    /** The room's reverberation time stays within these, s. */
-    rt60: readonly [number, number];
-    /** How both voices are measured. */
-    measure: RecordingMeasureOptions;
-}
-export declare const VOICE_FIT_DEFAULTS: VoiceFitOptions;
-/** How far a voice's measurement is from the reference's. */
-export interface FitDistance {
-    /** RMS of the spectrum's difference over the fitted bands, dB. */
-    spectrum: number;
-    /** The decay's difference (piece minus reference), s; absent where either is missing. */
-    decay?: number;
-    /** The room tone's level under the voice, piece minus reference, LU. */
-    tone?: number;
-    /** The tone's tilt, piece minus reference, dB per octave. */
-    tilt?: number;
-}
-/** A setting fitted to a reference. */
-export interface VoiceFit {
-    /** The piece's setting with the numbers moved. */
-    setting: VoiceOptions;
-    /** The fields that moved. */
-    moved: string[];
-    /** The piece's voice before and after, and how far each is from the reference. */
-    before: RecordingMeasurement;
-    after: RecordingMeasurement;
-    distance: {
-        before: FitDistance;
-        after: FitDistance;
-    };
-    /** The bands where the response reached `most`, Hz. */
-    limited: number[];
-    /** What the reference shows that the setup does not record, and what could not be measured. */
-    notes: string[];
-}
-/** The distance of one measurement from another. */
-export declare function fitDistance(piece: RecordingMeasurement, reference: RecordingMeasurement, from?: number, to?: number): FitDistance;
-/**
- * Fits a voice's setting to a reference's measurement. `record` plays the
- * piece's speech through a resolved setting and returns its channels at
- * `rate` (the whole voice, as the measurement should hear it).
- */
-export declare function fitVoice(setting: VoiceSetting | undefined, record: (voice: ResolvedVoice) => readonly Float32Array[], reference: RecordingMeasurement, rate: number, options?: Partial<VoiceFitOptions>): VoiceFit;
-//# sourceMappingURL=fit.d.ts.map

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

@@ -1,10 +0,0 @@
-export { pickupImpulses, recordVoice, resolveVoice, voiceProblem, type ResolvedPickup, type ResolvedPost, type ResolvedRoom, type ResolvedVoice, type VoiceSpan, } from "./chain.js";
-export { fitDistance, fitVoice, VOICE_FIT_DEFAULTS, type FitDistance, type VoiceFit, type VoiceFitOptions, } from "./fit.js";
-export { bandwidthOf, BANDWIDTH_DEFAULTS, type Bandwidth, type BandwidthOptions, } from "./bandwidth.js";
-export { integratedLoudness, steadyLoudness } from "./loudness.js";
-export { measureRecording, RECORDING_MEASURE_DEFAULTS, THIRD_OCTAVES, type RecordingMeasureOptions, type RecordingMeasurement, } from "./measure.js";
-export { PATTERNS, type Pattern } from "./mic.js";
-export { POST_PRESETS, ROOM_PRESETS, SETUP_PRESETS, SOURCE_DEFAULTS, type PostPreset, type RoomPreset, type SetupPreset, } from "./presets.js";
-export { MATERIALS } from "./room.js";
-export { POSTS, ROOMS, VOICE_SETUPS, type AgcSettings, type NoiseOptions, type PostName, type PostOptions, type RoomName, type RoomOptions, type Surface, type VoiceOptions, type VoiceSetting, type VoiceSetup, } from "./setup.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,12 +0,0 @@
-/**
- * Integrated loudness, LUFS, of channels at `rate` (each weighted 1, as
- * left and right are); undefined when everything is under the gate.
- */
-export declare function integratedLoudness(channels: readonly Float32Array[], rate: number): number | undefined;
-/**
- * The K-weighted level of everything, LUFS, with no gate: for a steady
- * sound too quiet for the integrated loudness's -70 LUFS gate (a room's
- * tone); undefined for digital silence.
- */
-export declare function steadyLoudness(channels: readonly Float32Array[], rate: number): number | undefined;
-//# sourceMappingURL=loudness.d.ts.map

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

@@ -1,67 +0,0 @@
-/** The measurement's thresholds. */
-export interface RecordingMeasureOptions {
-    /**
-     * A frame is speech when it is this share of the way from the quiet end
-     * (the 10th percentile of frame levels, at most `range` dB under the
-     * loud end) to the loud end (the 95th percentile).
-     */
-    split: number;
-    range: number;
-    /** Speech joined over gaps shorter than this, s. */
-    join: number;
-    /** A pause is at least this long, s. */
-    gap: number;
-    /** A fall is read from this many dB under where speech stopped… */
-    skip: number;
-    /** …down to this many dB over the pause's floor. */
-    floor: number;
-    /** Fewer ends than this measure no decay. */
-    least: number;
-    /** An end whose fall from `skip` to `floor` spans fewer dB than this is not read. */
-    fall: number;
-}
-export declare const RECORDING_MEASURE_DEFAULTS: RecordingMeasureOptions;
-/** Third-octave band centres, Hz (ISO 266, 63 Hz to 16 kHz). */
-export declare const THIRD_OCTAVES: number[];
-/** What a voice's recording measures. */
-export interface RecordingMeasurement {
-    /** Its integrated loudness, LUFS. */
-    loudness: number | null;
-    /** Seconds of speech and of pauses. */
-    speech: number;
-    pauses: number;
-    /** dB by third-octave band against the 1 kHz band, over its speech. */
-    spectrum: {
-        hz: number;
-        db: number;
-    }[];
-    /** The room's decay where speech stops: its median time, the spread of the middle half, how many ends. */
-    decay: {
-        t60: number;
-        low: number;
-        high: number;
-        ends: number;
-    } | {
-        missing: string;
-    };
-    /** The pauses' loudness under the speech's, LU, and the tone's tilt, dB per octave. */
-    tone: {
-        below: number;
-        tilt: number;
-    } | {
-        missing: string;
-    };
-    /** Short-term loudness spread over the speech, LU (10th to 90th percentile), and peak over RMS, dB. */
-    dynamics: {
-        spread: number;
-        crest: number;
-    };
-}
-/** Speech and pauses as frame runs. */
-export declare function speechRuns(levels: readonly number[], frame: number, o?: RecordingMeasureOptions): {
-    speech: [number, number][];
-    pauses: [number, number][];
-};
-/** A voice's recording measured (channels at `rate`). */
-export declare function measureRecording(channels: readonly Float32Array[], rate: number, o?: RecordingMeasureOptions): RecordingMeasurement;
-//# sourceMappingURL=measure.d.ts.map

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

@@ -1,32 +0,0 @@
-import type { Vec3 } from "./vec.js";
-/** The speed of sound, m/s, at 20 °C. */
-export declare const SOUND_SPEED = 343;
-/** A first-order pattern, as pyroomacoustics names them, and its pressure share p. */
-export declare const PATTERNS: {
-    readonly omni: 1;
-    readonly subcardioid: 0.75;
-    readonly cardioid: 0.5;
-    readonly supercardioid: 0.37;
-    readonly hypercardioid: 0.25;
-    readonly figure8: 0;
-};
-export type Pattern = keyof typeof PATTERNS;
-/** A pattern's gain toward a direction at angle θ off its axis (cos θ given). */
-export declare function patternGain(pattern: Pattern, cos: number): number;
-/**
- * The proximity effect on axis at `hz`: the near field's gain over the far
- * field's, |1 + (1 - p)/(jkr)|, of a source `distance` m away.
- */
-export declare function proximity(pattern: Pattern, distance: number, hz: number): number;
-/**
- * The talker's loss toward an angle θ off where they face, at 180° (dB, ≤ 0),
- * by octave band centre: little in the lows, much in the highs.
- */
-export declare const TALKER_BEHIND: readonly (readonly [number, number])[];
-/** A table of [Hz, dB] read at `hz`, linear in log frequency, held past its ends. */
-export declare function curveDb(table: readonly (readonly [number, number])[], hz: number): number;
-/** The talker's loss (dB) at `hz` toward a direction θ off their facing (cos θ given). */
-export declare function talkerDb(hz: number, cos: number): number;
-/** cos of the angle between two vectors (1 when either is zero). */
-export declare function cosBetween(a: Vec3, b: Vec3): number;
-//# sourceMappingURL=mic.d.ts.map

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

@@ -1,27 +0,0 @@
-/** mulberry32: the same numbers for the same seed, everywhere. */
-export declare function random(seed: number): () => number;
-/** Normal noise (Box–Muller) from a seed. */
-export declare function gaussian(seed: number): () => number;
-/** What a room tone sounds like. */
-export interface NoiseShape {
-    /** dB per octave over 1 kHz (pink noise is -3). */
-    tilt: number;
-    /** dB more below 120 Hz: ventilation, traffic, the building. */
-    rumble: number;
-    /** The mains' hum: its fundamental (50 or 60 Hz) and its level against the noise, dB; absent: none. */
-    hum?: {
-        hz: number;
-        db: number;
-    };
-    /** The highest frequency it has, Hz: a device's band. */
-    top: number;
-}
-/** The noise's gain at a frequency (linear), relative to 1 kHz. */
-export declare function noiseGain(shape: NoiseShape, hz: number): number;
-/**
- * `n` samples of room tone of unit RMS before its level is set: Gaussian
- * noise through the shape's minimum-phase filter, the hum added as sines
- * (its harmonics falling 6 dB each), all from the seed.
- */
-export declare function roomTone(n: number, rate: number, shape: NoiseShape, seed: number): Float32Array;
-//# sourceMappingURL=noise.d.ts.map