@jpdutoit/squelchy 0.0.1

package/index.d.ts

@@ -0,0 +1,1946 @@
+interface ParamSpec {
+	/** Optional convenience for modules whose panel maps 1:1 onto params.
+	 *  When the UI diverges (connection-dependent labels/ranges), omit it and
+	 *  keep labels + hover tips in the UI layer (see lfo). Never shipped in docs. */
+	label?: string;
+	default: number | string | boolean;
+	/** One-shot actions are not params: they are rising edges on a gate port
+	 *  (panel buttons use `pulse()` from src/lib/dsp/pulse.ts). */
+	kind?: "number" | "enum";
+	min?: number;
+	max?: number;
+	scale?: "linear" | "log" | "sqrt";
+	unit?: string;
+	options?: readonly string[];
+	/** Backing AudioParam, resolved like ports: key in the createNodes record
+	 *  + AudioParam property (or worklet parameter) name. Declare ONLY when the
+	 *  param value is written to that AudioParam 1:1 — no conversion, no split.
+	 *  The library exposes it as `instance.params.<key>` for native automation. */
+	node?: string;
+	field?: string;
+	short: string;
+	long: string;
+}
+interface PortDefinition {
+	type: "input" | "output" | "modulation" | "trigger";
+	label: string;
+	name: string;
+	desc: string;
+	/** Key in the createNodes record that this port maps to.
+	 *  Omit for trigger ports which are routed by the engine without audio nodes. */
+	node?: string;
+	/** For modulation ports: the AudioParam property name on the target node (e.g. 'frequency', 'gain'). */
+	field?: string;
+	/** Signal semantics — determines port and cable colour.
+	 *  'audio' = emerald, 'pitch' = amber, 'gate' = orange, 'modulation' = violet. */
+	signal: "audio" | "pitch" | "gate" | "modulation";
+}
+/**
+ * Register every bundled worklet processor on `ctx`. Required before any
+ * module's create() on that context. Safe to call twice or concurrently —
+ * subsequent calls return the same promise.
+ *
+ * Processors are inlined as minified source strings and loaded via blob URLs,
+ * so the package needs zero fetches and zero consumer asset setup. Consumers
+ * under a strict CSP need `worker-src blob:` allowed.
+ */
+export declare function preload(ctx: BaseAudioContext, opts?: {
+	allWorklets?: boolean;
+}): Promise<void>;
+export type ParamValue = number | string | boolean | number[] | boolean[][];
+/** Runtime metadata — only what code needs. Human-facing text (names,
+ *  descriptions, labels) is stripped from the bundle; it lives in the
+ *  generated docs/MODULES.md, meta.json and the .d.ts JSDoc instead. */
+export interface ModuleMeta {
+	type: string;
+	ports: Record<string, Pick<PortDefinition, "type" | "signal">>;
+	params: Record<string, Pick<ParamSpec, "default" | "kind" | "min" | "max" | "scale" | "options" | "node" | "field">>;
+}
+type AnyParams = Record<string, ParamValue>;
+type PortMap = Record<string, AudioNode>;
+type InputMap = Record<string, AudioNode | AudioParam>;
+interface InstanceApi<P extends object = AnyParams, In extends InputMap = InputMap, Out extends PortMap = PortMap> {
+	/** Native connect target behind an input slug: AudioParam or AudioNode. */
+	input<K extends keyof In & string>(slug: K): In[K];
+	output<K extends keyof Out & string>(slug: K): Out[K];
+	/** Change a parameter now. For timed changes (ramps, curves, schedules)
+	 *  use the native AudioParam in `params` — enums and derived params
+	 *  (curves, filter banks) are set()-only by design. */
+	set<K extends keyof P & string>(key: K, value: Exclude<P[K], undefined>): void;
+	dispose(): void;
+}
+/** A module instance is the API above plus one native-feeling property per
+ *  port: camelCased slug → the same AudioParam/AudioNode input()/output()
+ *  returns, so `lfo.out.connect(vco.modDetune)` reads like a native node.
+ *  Slugs that would collide (with each other after camelCasing, or with a
+ *  reserved method name) are simply not exposed — the build refuses them. */
+export type ModuleInstance<P extends object = AnyParams, In extends InputMap = InputMap, Out extends PortMap = PortMap, Props extends object = Record<never, never>> = InstanceApi<P, In, Out> & Props;
+export interface LibModule<P extends object = AnyParams, In extends InputMap = InputMap, Out extends PortMap = PortMap, Props extends object = Record<never, never>> {
+	meta: ModuleMeta;
+	create(ctx: BaseAudioContext, params?: Partial<P>): ModuleInstance<P, In, Out, Props>;
+}
+declare const unit: unique symbol;
+type Brand<U extends string> = number & {
+	readonly [unit]: U;
+};
+/** Absolute key position, MIDI datum (69 = A4). */
+export type Note = Brand<"note">;
+/** Relative pitch offset (12 = one octave). Also the V/OCT signal scale. */
+export type Semitones = Brand<"semitone">;
+/** 1/100 semitone, relative. */
+export type Cents = Brand<"cents">;
+/** Cycles per second. */
+export type Hz = Brand<"Hz">;
+/** Audio time or duration in seconds (ctx.currentTime domain). */
+export type Seconds = Brand<"s">;
+export type Milliseconds = Brand<"ms">;
+export type Decibels = Brand<"dB">;
+/** Musical position or length in quarter-note beats. */
+export type Beats = Brand<"beats">;
+export declare const sec: (v: number) => Seconds;
+export declare const ms: (v: number) => Milliseconds;
+export declare const beats: (v: number) => Beats;
+export declare const hz: (v: number) => Hz;
+export declare const semitones: (v: number) => Semitones;
+export declare const cents: (v: number) => Cents;
+export declare const db: (v: number) => Decibels;
+export declare const noteToHz: (n: Note) => Hz;
+export declare const hzToNote: (f: Hz) => Note;
+export declare const transpose: (n: Note, by: Semitones) => Note;
+/** Distance from `a` to `b`. */
+export declare const interval: (a: Note, b: Note) => Semitones;
+export declare const centsToSemitones: (c: Cents) => Semitones;
+export declare const msToSeconds: (ms: Milliseconds) => Seconds;
+export declare const dbToGain: (db: Decibels) => number;
+export declare const gainToDb: (g: number) => Decibels;
+/** `ctx.currentTime`, typed. */
+export declare const now: (ctx: BaseAudioContext) => Seconds;
+declare const signal: unique symbol;
+/** An AudioNode whose stream carries quantity Q. `Signal<Note>` is a V/OCT
+ *  pitch signal (absolute key position, 69 = A4); factor signals are plain
+ *  `AudioNode` (no wrapper — audio, gates, clocks and CV connect freely). */
+export type Signal<Q> = AudioNode & {
+	readonly [signal]: Q;
+};
+/** Reinterpret a node as a pitch signal — the greppable escape hatch for
+ *  deliberate cross-quantity patches. */
+export declare const asPitch: (n: AudioNode) => Signal<Note>;
+/** Where a playback starts. Default 'bar' = next bar line (beat 0 if stopped). */
+export type StartAt = "now" | "beat" | "bar" | {
+	bar: number;
+} | {
+	beat: Beats;
+};
+/** Rich step form, for when a plain value isn't enough. */
+export interface StepObject<V> {
+	value: V;
+	/** 0..1, default 1. */
+	velocity?: number;
+	/** Gate length in steps, default = the playback's `gate`. */
+	length?: number;
+}
+/** A pattern step: a value, a rest (null/undefined/false/0/'.'/'-'), or a StepObject. */
+export type Step<V> = V | StepObject<V> | null | undefined | false;
+/** What a voice receives per hit. */
+export interface Hit<V = unknown> {
+	/** Audio time the sound starts (ctx.currentTime domain). */
+	time: Seconds;
+	/** Musical position of the hit, in beats. */
+	beat: Beats;
+	/** Step index within the pattern. */
+	step: number;
+	/** Loop iteration, 0-based. */
+	cycle: number;
+	/** The step's value (true for `steps('x..x')`, a midi number for melodies, …). */
+	value: V;
+	velocity: number;
+	/** Gate length in seconds. */
+	duration: Seconds;
+}
+/**
+ * Anything that makes sound at a time. Voice objects expose `trigger`; a plain
+ * function `(time, hit) => void` works too, so any existing Web Audio code
+ * (e.g. `(t) => osc.start(t)`) can be driven by a pattern.
+ */
+export type Voice<V = unknown> = {
+	trigger(time: Seconds, hit?: Partial<Hit<V>>): void;
+} | ((time: Seconds, hit: Hit<V>) => void);
+export interface PlayOptions<V> {
+	/** Step length in beats. Default 0.25 (16ths). */
+	every?: Beats;
+	/** Where to start. Default 'bar'. */
+	start?: StartAt;
+	/** true = forever (default), false = once, n = n times. */
+	loop?: boolean | number;
+	/** Gate length as a fraction of a step. Default 0.5. */
+	gate?: number;
+	/** 0..1 — delays every odd step by swing × half a step. Default 0. */
+	swing?: number;
+	/** Visual tap for this playback (fires when the hit is audible). */
+	onHit?: (hit: Hit<V>) => void;
+}
+export interface Playback<V> {
+	/** Swap the pattern; takes effect at the next cycle start, so it stays in time. */
+	set(pattern: readonly Step<V>[]): void;
+	/** Stop scheduling. With a StartAt, stops at that musical boundary instead of now. */
+	stop(at?: StartAt): void;
+	readonly done: boolean;
+}
+export interface TransportOptions {
+	bpm?: number;
+	beatsPerBar?: number;
+	/** Seconds scheduled ahead. Default 0.1. */
+	lookahead?: Seconds;
+	/** 'auto' = internal 25 ms timer; 'manual' = you call tick() (tests, custom loops). */
+	clock?: "auto" | "manual";
+}
+export interface Transport {
+	readonly ctx: BaseAudioContext;
+	bpm: number;
+	readonly beatsPerBar: number;
+	readonly running: boolean;
+	/** Start at audio time `when` (default: a hair from now). Beat 0 = that moment. */
+	start(when?: Seconds): void;
+	/** Stop scheduling and cancel pending taps. Already-written events (≤ lookahead) still sound. */
+	stop(): void;
+	/** Musical position at an audio time. */
+	beatAt(time: Seconds): Beats;
+	/** Audio time of a musical position. */
+	timeAt(beat: Beats): Seconds;
+	/** Resolve a StartAt to a beat, from the current position. */
+	resolve(at: StartAt): Beats;
+	/** Play a pattern array through a voice. */
+	play<V>(pattern: readonly Step<V>[], voice: Voice<V>, opts?: PlayOptions<V>): Playback<V>;
+	/** Run `fn(time)` once at a musical position — for automation, e.g. `vca.set('gain', 0, time)`. */
+	at(when: StartAt | Beats, fn: (time: Seconds) => void): () => void;
+	/** Global visual tap: every hit of every playback, fired when audible. Returns unsubscribe. */
+	onHit(cb: (hit: Hit) => void): () => void;
+	/** Schedule everything due inside the lookahead window. Auto-called in 'auto' mode. */
+	tick(): void;
+	dispose(): void;
+}
+export declare function isRest(v: unknown): boolean;
+export declare function createTransport(ctx: BaseAudioContext, opts?: TransportOptions): Transport;
+/** `steps('x... x... x..x x...')` → boolean[]. x/X = hit, anything else = rest; spaces/| ignored. */
+export declare function steps(s: string): boolean[];
+/** 'A4' → 69, 'C4' → 60, 'F#2' → 42; a number passes through typed. Midi numbers are the pitch unit everywhere (V/Oct = semitones). */
+export declare function note(name: string | number): Note;
+/** `notes('C3 . E3 G3 - C4')` → (Note | null)[]. '.'/'-' = rest. */
+export declare function notes(s: string): (Note | null)[];
+export interface VoiceInstance<V = unknown> {
+	output: AudioNode;
+	trigger(time: Seconds, hit?: Partial<Hit<V>>): void;
+	connect<T extends AudioNode>(dest: T): T;
+	disconnect(): void;
+}
+export declare const Kick: {
+	create(ctx: BaseAudioContext): VoiceInstance;
+};
+export declare const Snare: {
+	create(ctx: BaseAudioContext): VoiceInstance;
+};
+export declare const Hat: {
+	create(ctx: BaseAudioContext): VoiceInstance;
+};
+/**
+ * Gate + pitch CV for driving patchable modules (Envelope trig, V/Oct inputs).
+ * `gate` goes 1 at `time`, back to 0 after `duration`; `pitch` holds the midi
+ * value (semitones = the project's V/Oct unit). Both are ConstantSourceNodes.
+ */
+export declare const NoteCv: {
+	create(ctx: BaseAudioContext): {
+		gate: ConstantSourceNode;
+		pitch: ConstantSourceNode;
+		trigger(time: Seconds, h?: Partial<Hit<Note>>): void;
+		dispose(): void;
+	};
+};
+export declare function pulse(target: AudioNode, when?: number): void;
+/** Canonical percussion voice keys shared by every sample set and by any
+ *  module that plays percussion (DRUMS, 808, and anything added later).
+ *
+ *  A set may omit voices; `resolveVoice` in sampleBank.ts walks a fallback
+ *  chain so a module never goes silent because a kit lacks, say, an open hat.
+ */
+export declare const VOICE_KEYS: readonly [
+	"bd",
+	"sd",
+	"rim",
+	"clap",
+	"ch",
+	"oh",
+	"lt",
+	"mt",
+	"ht",
+	"cym",
+	"perc"
+];
+export type VoiceKey = (typeof VOICE_KEYS)[number];
+/** Where the kit audio is hosted. Override with `loadSampleSet(..., { baseUrl })`. */
+export declare const DEFAULT_SAMPLE_BASE_URL = "https://squelchy.studio";
+export interface SampleSetInfo {
+	name: string;
+	blurb: string;
+	family: "Machines" | "Acoustic" | "Digital" | "Character";
+	credit: string;
+	license: string;
+	licenseUrl: string;
+	/** Root-relative sample path per voice; resolved against baseUrl on load. */
+	voices: Partial<Record<VoiceKey, string>>;
+}
+export interface LoadedSampleSet {
+	set: SampleSetInfo;
+	buffers: Partial<Record<VoiceKey, AudioBuffer>>;
+	/** Buffer for a voice, walking the fallback chain when the kit lacks it. */
+	buffer(key: VoiceKey): AudioBuffer | undefined;
+}
+/** Fetch + decode every voice of a kit in parallel. */
+export declare function loadSampleSet(ctx: BaseAudioContext, set: SampleSetInfo, opts?: {
+	baseUrl?: string;
+	fetch?: typeof fetch;
+}): Promise<LoadedSampleSet>;
+/** A one-sample voice. velocity 0..1 scales level; `value` (semitones) repitches. */
+export declare const SampleVoice: {
+	create(ctx: BaseAudioContext, kit: LoadedSampleSet, key: VoiceKey): VoiceInstance<number>;
+};
+export declare const SampleSets: {
+	readonly "roland-808": {
+		readonly name: "Roland TR-808";
+		readonly blurb: "The original machine, sampled from hardware. Deep sub kick, ticking hats.";
+		readonly family: "Machines";
+		readonly credit: "Michael Fischer / Technopolis TR-808 sample set, released to the public domain";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/c4b2fc55-dcf1-4248-a7fb-2cd3653a659b/roland-808-bd.flac";
+			readonly ch: "/__l5e/assets-v1/c1ec3b3d-571f-46a6-9d05-12b2fe5f6fc5/roland-808-ch.flac";
+			readonly clap: "/__l5e/assets-v1/8bd15e4b-96b7-46b6-b26a-35283c816f1e/roland-808-clap.flac";
+			readonly cym: "/__l5e/assets-v1/033f0719-913a-4a7a-998e-92a7319d806f/roland-808-cym.flac";
+			readonly ht: "/__l5e/assets-v1/ca555782-7544-446a-a461-9b56b4d30072/roland-808-ht.flac";
+			readonly lt: "/__l5e/assets-v1/8e100e1c-3844-42aa-bbe7-9eb52b9d704e/roland-808-lt.flac";
+			readonly mt: "/__l5e/assets-v1/93dd309f-9347-4ea1-909f-56196b08dc88/roland-808-mt.flac";
+			readonly oh: "/__l5e/assets-v1/4881941c-b558-4159-babd-fe224b0f1543/roland-808-oh.flac";
+			readonly perc: "/__l5e/assets-v1/d13076b5-50ca-4675-9d4e-70afd6e6203d/roland-808-perc.flac";
+			readonly rim: "/__l5e/assets-v1/ce82e0e9-402d-4a5e-bf01-59dfb922d1ba/roland-808-rim.flac";
+			readonly sd: "/__l5e/assets-v1/67a799c9-e019-442b-8025-99d69bc493b9/roland-808-sd.flac";
+		};
+	};
+	readonly "tr-909": {
+		readonly name: "Roland TR-909";
+		readonly blurb: "Punchy transistor kick, snappy sampled snare, sizzling metal hats. House and techno.";
+		readonly family: "Machines";
+		readonly credit: "MckAudio TR8 sample pack, dedicated to the public domain (CC0)";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/fd3911bb-6783-4db6-bee2-bb8c5a589f26/tr-909-bd.flac";
+			readonly ch: "/__l5e/assets-v1/6f795c20-fb89-4cd5-b696-3a505d487baa/tr-909-ch.flac";
+			readonly clap: "/__l5e/assets-v1/7b1ccf8e-0dd6-4189-82d7-03a910e895f2/tr-909-clap.flac";
+			readonly cym: "/__l5e/assets-v1/f0d5ce25-3238-4e89-bb09-f5b7118fa0a7/tr-909-cym.flac";
+			readonly ht: "/__l5e/assets-v1/5f9b4c37-25a7-492c-aaed-f7fe24fbfe2c/tr-909-ht.flac";
+			readonly lt: "/__l5e/assets-v1/8477dddd-b9ed-4957-9a48-b5501bc77056/tr-909-lt.flac";
+			readonly mt: "/__l5e/assets-v1/92d461e5-d74a-4ba2-a899-4dea1ad06d13/tr-909-mt.flac";
+			readonly oh: "/__l5e/assets-v1/20c51259-d8d1-4ee3-a1d6-e850c3227b1a/tr-909-oh.flac";
+			readonly perc: "/__l5e/assets-v1/147d346e-9ae7-4413-a50a-de4f03ef7342/tr-909-perc.flac";
+			readonly rim: "/__l5e/assets-v1/0c9f157d-1329-4804-aa12-6819651d69fb/tr-909-rim.flac";
+			readonly sd: "/__l5e/assets-v1/bd8069c2-e07c-4d5c-b05a-fb5b9a31eadb/tr-909-sd.flac";
+		};
+	};
+	readonly "tr-707": {
+		readonly name: "Roland TR-707";
+		readonly blurb: "Twelve-bit sampled kit with early-digital crunch. Big eighties snare and claps.";
+		readonly family: "Machines";
+		readonly credit: "MckAudio TR8 sample pack, dedicated to the public domain (CC0)";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/825b2c7c-5c5f-411c-8191-306549ee26f2/tr-707-bd.flac";
+			readonly ch: "/__l5e/assets-v1/6b35b393-7e9c-462d-8d2f-dc834417062b/tr-707-ch.flac";
+			readonly clap: "/__l5e/assets-v1/efbe819a-b13e-4bf2-a6bd-9bc15a09ff3f/tr-707-clap.flac";
+			readonly cym: "/__l5e/assets-v1/4a34902b-8592-46d8-b339-05a0648cac4f/tr-707-cym.flac";
+			readonly ht: "/__l5e/assets-v1/e58beee9-45e5-4b65-af99-a05fcb96f55b/tr-707-ht.flac";
+			readonly lt: "/__l5e/assets-v1/a0d6f499-4af6-4d34-96de-5ad7c2397229/tr-707-lt.flac";
+			readonly mt: "/__l5e/assets-v1/6c4bd12b-78ff-4f70-863b-cd482f684eb6/tr-707-mt.flac";
+			readonly oh: "/__l5e/assets-v1/c07159f3-d763-4698-a786-aeae60d38ac9/tr-707-oh.flac";
+			readonly perc: "/__l5e/assets-v1/2f8cffcb-8e86-4f65-99db-a705727ed3ab/tr-707-perc.flac";
+			readonly rim: "/__l5e/assets-v1/3d6445b1-38bd-4e9f-b048-db8c079b3c03/tr-707-rim.flac";
+			readonly sd: "/__l5e/assets-v1/aaf70dd8-c740-4b05-9369-feb80f3e26be/tr-707-sd.flac";
+		};
+	};
+	readonly "tr-606": {
+		readonly name: "Roland TR-606";
+		readonly blurb: "Tiny Drumatix voices \u2014 thin kick, spitty snare, ticking hats. Perfect with a 303.";
+		readonly family: "Machines";
+		readonly credit: "MckAudio TR8 sample pack, dedicated to the public domain (CC0)";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/f46ec897-9319-4c25-b63b-74df979de508/tr-606-bd.flac";
+			readonly ch: "/__l5e/assets-v1/f4c57254-c711-43b0-82c6-52b011e205ba/tr-606-ch.flac";
+			readonly cym: "/__l5e/assets-v1/db524ec1-36d3-43db-bfc4-fd84a1ddd2ac/tr-606-cym.flac";
+			readonly ht: "/__l5e/assets-v1/74b486cf-c1f1-45c7-bd2a-4fd0c3794e1a/tr-606-ht.flac";
+			readonly lt: "/__l5e/assets-v1/6b1a564f-6388-40c1-8028-3ea9b6824256/tr-606-lt.flac";
+			readonly mt: "/__l5e/assets-v1/d871a86a-fcc8-45a6-b5a4-83977a689593/tr-606-mt.flac";
+			readonly oh: "/__l5e/assets-v1/a4c607d2-d62c-49b5-ac99-549fd6262468/tr-606-oh.flac";
+			readonly sd: "/__l5e/assets-v1/2062f1d4-e34f-406f-911b-2eb2ec523a89/tr-606-sd.flac";
+		};
+	};
+	readonly "compu-78": {
+		readonly name: "Compu-78";
+		readonly blurb: "Tiny, dry preset-box percussion. Bossa nova organ rhythm energy.";
+		readonly family: "Machines";
+		readonly credit: "Synthesised for Squelchy";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/150a91e2-8b92-40f2-80e0-10b30f10976b/compu-78-bd.flac";
+			readonly ch: "/__l5e/assets-v1/da9dcfc4-5f29-43b9-979f-9679edeb09ed/compu-78-ch.flac";
+			readonly clap: "/__l5e/assets-v1/f3b5d485-44bc-4b34-b2bc-d37f436dffc2/compu-78-clap.flac";
+			readonly cym: "/__l5e/assets-v1/627db2bf-08d5-4054-8de9-b8ec0ca4436a/compu-78-cym.flac";
+			readonly ht: "/__l5e/assets-v1/1323f20c-3c98-45fb-abd1-e4b1e4be158f/compu-78-ht.flac";
+			readonly lt: "/__l5e/assets-v1/ba67ce5c-3f01-4e1b-9fd8-a96bb5428cf4/compu-78-lt.flac";
+			readonly mt: "/__l5e/assets-v1/f8cd42d6-2f98-4e9d-9428-ba091ec125cf/compu-78-mt.flac";
+			readonly oh: "/__l5e/assets-v1/b4a1d5b2-0022-4f1b-ac52-1618ba03ea67/compu-78-oh.flac";
+			readonly perc: "/__l5e/assets-v1/55e15a92-ba17-48cb-aec0-47e5198f073f/compu-78-perc.flac";
+			readonly rim: "/__l5e/assets-v1/698aaf24-8e84-4b3b-8f13-dc95f2b3f157/compu-78-rim.flac";
+			readonly sd: "/__l5e/assets-v1/41357245-d767-410e-8415-08dbb9e7503e/compu-78-sd.flac";
+		};
+	};
+	readonly "dr5-studio": {
+		readonly name: "Studio Kit";
+		readonly blurb: "Acoustic drums in a small dry room. Skin, air and a little ambience.";
+		readonly family: "Acoustic";
+		readonly credit: "MckAudio DR5 sample pack, dedicated to the public domain (CC0)";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/9bc4c40f-432c-4fd1-98f8-dc3343b5dd31/dr5-studio-bd.flac";
+			readonly ch: "/__l5e/assets-v1/862411a4-6d87-45e7-a3a2-2c4062f8e79b/dr5-studio-ch.flac";
+			readonly clap: "/__l5e/assets-v1/2feebc4f-49d2-4ea0-9b5a-890059c24a9c/dr5-studio-clap.flac";
+			readonly cym: "/__l5e/assets-v1/5abff1b5-b403-403b-b681-9ac37a394442/dr5-studio-cym.flac";
+			readonly ht: "/__l5e/assets-v1/4e6883a5-e310-4035-a6ae-ee4033c7a0a1/dr5-studio-ht.flac";
+			readonly lt: "/__l5e/assets-v1/faf35ae9-f89f-4ceb-ad5e-c562dd5d261a/dr5-studio-lt.flac";
+			readonly mt: "/__l5e/assets-v1/4b923b44-9e79-4aa0-a9ef-4178a9f0279b/dr5-studio-mt.flac";
+			readonly oh: "/__l5e/assets-v1/5a5e6d0c-4c8f-4dc5-9dea-55f90083a55a/dr5-studio-oh.flac";
+			readonly perc: "/__l5e/assets-v1/8d286dd0-4201-49f6-9738-0a39e3a3d860/dr5-studio-perc.flac";
+			readonly rim: "/__l5e/assets-v1/1d139e86-288e-48bd-baba-f7d2502271a5/dr5-studio-rim.flac";
+			readonly sd: "/__l5e/assets-v1/eb7b02d6-7063-4350-9515-40010dd583cb/dr5-studio-sd.flac";
+		};
+	};
+	readonly "tape-dust": {
+		readonly name: "Tape Dust";
+		readonly blurb: "Wobbly, hissy and rolled-off. Everything through a tired cassette.";
+		readonly family: "Character";
+		readonly credit: "Synthesised for Squelchy";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/7e90ada0-1da8-4930-9c05-48c395e8a863/tape-dust-bd.flac";
+			readonly ch: "/__l5e/assets-v1/538fd73f-f7ee-408e-ab69-f8865506f4f5/tape-dust-ch.flac";
+			readonly clap: "/__l5e/assets-v1/21b5b5ea-6dce-495d-b740-e7162941c972/tape-dust-clap.flac";
+			readonly cym: "/__l5e/assets-v1/ac1a7f2d-9a96-4f61-b2ec-743854f15bbe/tape-dust-cym.flac";
+			readonly ht: "/__l5e/assets-v1/93dd3f9c-8267-4f4e-b292-807cf0022c9e/tape-dust-ht.flac";
+			readonly lt: "/__l5e/assets-v1/7a51ff67-62ec-408b-b6c3-4a0cae248eaf/tape-dust-lt.flac";
+			readonly mt: "/__l5e/assets-v1/ba3340c5-6ead-419a-836a-a041448f06da/tape-dust-mt.flac";
+			readonly oh: "/__l5e/assets-v1/e924553d-ac9a-427e-a69a-2939032ee618/tape-dust-oh.flac";
+			readonly perc: "/__l5e/assets-v1/abfad1e6-998b-47a8-8c98-6f511c151143/tape-dust-perc.flac";
+			readonly rim: "/__l5e/assets-v1/c86262d8-9711-41d4-b866-19a1ffcaf443/tape-dust-rim.flac";
+			readonly sd: "/__l5e/assets-v1/2d1090cf-0284-4c33-9ba2-430c5c7b4730/tape-dust-sd.flac";
+		};
+	};
+	readonly "hard-cell": {
+		readonly name: "Hard Cell";
+		readonly blurb: "Overdriven and bit-crushed. Industrial techno with no headroom left.";
+		readonly family: "Character";
+		readonly credit: "Synthesised for Squelchy";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/d8f1c5cf-8e07-4a1e-a519-d7f69781329b/hard-cell-bd.flac";
+			readonly ch: "/__l5e/assets-v1/c3275e9a-dd79-4ac8-b4b9-84ebe25b5529/hard-cell-ch.flac";
+			readonly clap: "/__l5e/assets-v1/160a5d2c-01e0-49da-a998-149a0cf08317/hard-cell-clap.flac";
+			readonly cym: "/__l5e/assets-v1/910f3623-0209-439f-9e34-0c0f842bc78f/hard-cell-cym.flac";
+			readonly ht: "/__l5e/assets-v1/36f5b37b-9d44-49b8-a57b-bf5d2a1aa523/hard-cell-ht.flac";
+			readonly lt: "/__l5e/assets-v1/6065e512-578b-477f-88d9-49b3ccccacea/hard-cell-lt.flac";
+			readonly mt: "/__l5e/assets-v1/4e33c147-b8da-4b03-abca-4fd254d5006d/hard-cell-mt.flac";
+			readonly oh: "/__l5e/assets-v1/3e5b3bce-f21b-4ecb-8f28-375ce871427f/hard-cell-oh.flac";
+			readonly perc: "/__l5e/assets-v1/ab27e781-3d41-4e04-8f44-f7a568543586/hard-cell-perc.flac";
+			readonly rim: "/__l5e/assets-v1/ea2989c5-2354-4574-ae38-4786deeee151/hard-cell-rim.flac";
+			readonly sd: "/__l5e/assets-v1/5bd3dca9-bdb7-4618-8e0b-9ed1c0b062c7/hard-cell-sd.flac";
+		};
+	};
+	readonly "rx5-fm": {
+		readonly name: "Yamaha RX5";
+		readonly blurb: "FM percussion \u2014 glassy, bell-like, unmistakably late-eighties digital.";
+		readonly family: "Digital";
+		readonly credit: "MckAudio RX5 sample pack, dedicated to the public domain (CC0)";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/22b27f9f-d301-48e2-a0e4-e6b6e538ec31/rx5-fm-bd.flac";
+			readonly ch: "/__l5e/assets-v1/236fb4f5-7d2a-48c0-be18-bc3777a6be91/rx5-fm-ch.flac";
+			readonly clap: "/__l5e/assets-v1/58402fc0-996c-4577-9074-bb40b585c26e/rx5-fm-clap.flac";
+			readonly cym: "/__l5e/assets-v1/d3e6ba9b-a2b8-4467-8923-97594723720e/rx5-fm-cym.flac";
+			readonly ht: "/__l5e/assets-v1/a5edef5d-7861-4b3a-99bc-10ece111ca64/rx5-fm-ht.flac";
+			readonly lt: "/__l5e/assets-v1/7151d30d-fe90-4ac5-9c9f-e91a808a1efa/rx5-fm-lt.flac";
+			readonly mt: "/__l5e/assets-v1/46119925-9ecd-431a-94ee-2135c8ce4382/rx5-fm-mt.flac";
+			readonly oh: "/__l5e/assets-v1/9fe4938f-fda7-43f8-84c6-c53325fd674c/rx5-fm-oh.flac";
+			readonly perc: "/__l5e/assets-v1/1aa471d4-4737-45e6-9070-6301892dcdfa/rx5-fm-perc.flac";
+			readonly rim: "/__l5e/assets-v1/2b0409a0-1aa6-41a4-9593-553247a2e624/rx5-fm-rim.flac";
+			readonly sd: "/__l5e/assets-v1/3d9c426c-7783-4106-940f-1e6b6405bdd5/rx5-fm-sd.flac";
+		};
+	};
+	readonly "micro-click": {
+		readonly name: "Micro Click";
+		readonly blurb: "Clicks, ticks and pops. Minimal and micro-house, nothing sustains.";
+		readonly family: "Digital";
+		readonly credit: "Synthesised for Squelchy";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/58e3ce80-d300-47c6-8d79-52b00376550f/micro-click-bd.flac";
+			readonly ch: "/__l5e/assets-v1/1c12e400-5c5f-4aae-b006-5a3fe3c6ef2c/micro-click-ch.flac";
+			readonly clap: "/__l5e/assets-v1/b1f402f6-a85d-421b-9684-4b78719726d5/micro-click-clap.flac";
+			readonly cym: "/__l5e/assets-v1/fe501055-43d7-427f-9ab4-5efd0423292e/micro-click-cym.flac";
+			readonly ht: "/__l5e/assets-v1/3aab93cb-cd84-4600-a3e5-458fa74a2a86/micro-click-ht.flac";
+			readonly lt: "/__l5e/assets-v1/b09a0d61-c9a2-4b31-b0f2-10d3c10ef83c/micro-click-lt.flac";
+			readonly mt: "/__l5e/assets-v1/988e7a56-e914-43ad-aff1-71ec3a04b8e4/micro-click-mt.flac";
+			readonly oh: "/__l5e/assets-v1/122a3f93-4542-471b-b390-996665248653/micro-click-oh.flac";
+			readonly perc: "/__l5e/assets-v1/cae413d7-a68c-411a-a4b4-b7c20a83946d/micro-click-perc.flac";
+			readonly rim: "/__l5e/assets-v1/41922292-1c6e-4bef-ac8e-fa1ce09eefca/micro-click-rim.flac";
+			readonly sd: "/__l5e/assets-v1/6218ccdd-cba1-466e-af8b-665d7a2d4640/micro-click-sd.flac";
+		};
+	};
+	readonly "deep-analogue": {
+		readonly name: "Deep Analogue";
+		readonly blurb: "Long sub kick, soft snare, warm hats. Deep house at three in the morning.";
+		readonly family: "Acoustic";
+		readonly credit: "Synthesised for Squelchy";
+		readonly license: "CC0 1.0 / public domain \u2014 free to use, no attribution required";
+		readonly licenseUrl: "https://creativecommons.org/publicdomain/zero/1.0/";
+		readonly voices: {
+			readonly bd: "/__l5e/assets-v1/93c55e12-44f1-4cf9-8b19-82833257a68f/deep-analogue-bd.flac";
+			readonly ch: "/__l5e/assets-v1/7c881111-83d8-4c1a-b4af-4f09d2a09f4b/deep-analogue-ch.flac";
+			readonly clap: "/__l5e/assets-v1/e8b67bb8-8f7f-4b87-9ee4-d9cb7bc43efe/deep-analogue-clap.flac";
+			readonly cym: "/__l5e/assets-v1/b329f9e1-3eb0-471c-b7c7-8ad7f639323f/deep-analogue-cym.flac";
+			readonly ht: "/__l5e/assets-v1/a381a6b5-fd09-4fa6-b88e-86a29b8f25d9/deep-analogue-ht.flac";
+			readonly lt: "/__l5e/assets-v1/c9ebc90a-20aa-4f76-9e79-f440258d4bac/deep-analogue-lt.flac";
+			readonly mt: "/__l5e/assets-v1/5e1b803c-748e-4f09-bed7-c7b4511dc8b0/deep-analogue-mt.flac";
+			readonly oh: "/__l5e/assets-v1/289d67f2-6d55-4a04-8607-302442465e81/deep-analogue-oh.flac";
+			readonly perc: "/__l5e/assets-v1/8ef1f592-a3a4-45a5-9ea4-80362953aee4/deep-analogue-perc.flac";
+			readonly rim: "/__l5e/assets-v1/102a1c23-6e5f-468e-95c8-e414ce849884/deep-analogue-rim.flac";
+			readonly sd: "/__l5e/assets-v1/9be98c57-13c4-4337-bb2f-53c0b2ff7150/deep-analogue-sd.flac";
+		};
+	};
+};
+export type SampleSetId = keyof typeof SampleSets;
+export interface AcidFilterParams {
+	/** Cutoff Note. Base cutoff as a note (67 ≈ 400 Hz, 69 = 440 Hz) for the iconic squelchy acid sound. Drives the V/OCT worklet 1:1 — the panel knob shows the equivalent Hz. Range 15–135 notes. Default 67. */
+	note?: Note;
+	/** Resonance. Resonance amount, 0–100% of travel. Creates the characteristic 303 "wow" at high settings. Like the hardware, there is no resonance CV input — the knob is the only control. Range 0–15 (sqrt). Default 8. */
+	resonance?: number;
+	/** Envelope Mod. How much the triggered envelope sweeps the filter cutoff. Range 0–1. Default 0.7. */
+	envMod?: number;
+	/** Accent. Intensifies the envelope sweep for more aggressive acid sounds. Range 0–1. Default 0.5. */
+	accent?: number;
+	/** Decay Time. How quickly the filter envelope falls. Short = plucky, long = sustained. Range 0.05–1 s (log). Default 0.2. */
+	decay?: Seconds;
+}
+export type AcidFilterInputs = {
+	"in": AudioNode;
+	"trigger": AudioNode;
+	"modFreq": AudioNode;
+};
+export type AcidFilterOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type AcidFilterProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"trigger": AudioNode;
+	"modFreq": AudioNode;
+	readonly params: {
+		/** Cutoff Note. Native AudioParam — value is note 1:1. */
+		"note": AudioParam;
+		/** Decay Time. Native AudioParam — value is s 1:1. */
+		"decay": AudioParam;
+	};
+};
+export declare const AcidFilter: LibModule<AcidFilterParams, AcidFilterInputs, AcidFilterOutputs, AcidFilterProps>;
+export interface AutoPanParams {
+	/** Rate. Panning LFO speed, driven directly by the oscillator frequency. modRate sums into the same AudioParam. Range 0.1–10 Hz. Default 2. */
+	rate?: Hz;
+	/** Depth. How far the pan sweeps from left to right. 1 = full stereo sweep. modDepth sums into the same AudioParam. Range 0–1. Default 0.8. */
+	depth?: number;
+	/** LFO Shape. Waveform shape: sine for smooth, triangle for linear, square for hard left/right. Default "sine". */
+	shape?: "sine" | "triangle" | "square";
+}
+export type AutoPanInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+	"modDepth": AudioParam;
+};
+export type AutoPanOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type AutoPanProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	"modDepth": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+		/** Depth. Native AudioParam — value is the param value 1:1. */
+		"depth": AudioParam;
+	};
+};
+export declare const AutoPan: LibModule<AutoPanParams, AutoPanInputs, AutoPanOutputs, AutoPanProps>;
+export interface BitcrusherParams {
+	/** Bit Depth. Number of bits for quantization. Lower = crunchier, more lo-fi. Range 1–16. Default 8. */
+	bits?: number;
+	/** Sample Rate. Sample rate reduction factor. 1 = original, lower = more aliased and crunchy. Creates the classic "staircase" sample-and-hold effect. Range 0.01–1 (log). Default 0.5. */
+	rate?: number;
+	/** Dry/Wet Mix. Balance between clean and crushed signal. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type BitcrusherInputs = {
+	"in": AudioNode;
+};
+export type BitcrusherOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type BitcrusherProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Bit Depth. Native AudioParam — value is the param value 1:1. */
+		"bits": AudioParam;
+		/** Sample Rate. Native AudioParam — value is the param value 1:1. */
+		"rate": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Bitcrusher: LibModule<BitcrusherParams, BitcrusherInputs, BitcrusherOutputs, BitcrusherProps>;
+export interface ChorusParams {
+	/** Rate. Chorus sweep LFO speed, driven directly by the oscillator frequency. modRate sums into the same AudioParam. Range 0.1–5 Hz. Default 1.5. */
+	rate?: Hz;
+	/** Modulation Depth. How much the delay time is modulated. More = wider detuning. Scaled onto the LFO gain, so it is set-only (no single AudioParam carries it 1:1). Range 0–1. Default 0.5. */
+	depth?: number;
+	/** Dry/Wet Mix. Balance between original and chorused signal, driven by one ConstantSource (dry = 1 − mix·0.5, wet = mix — the antiphase voices already carry half the width at mix 1). Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type ChorusInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+	"modMix": AudioParam;
+};
+export type ChorusOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type ChorusProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	"modMix": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Chorus: LibModule<ChorusParams, ChorusInputs, ChorusOutputs, ChorusProps>;
+export interface CombFilterParams {
+	/** Pitch Offset. Semitones added to the V/OCT input (12 = one octave). Unpatched the input is silent, so this is the comb note itself: 55 ≈ 196 Hz, 69 = 440 Hz. Driven by an absolute pitch CV, set 0 to track it as-is. Range -48–96 semitones. Default 55. */
+	offset?: Semitones;
+	/** Feedback. Resonance amount. Higher values create more pronounced, ringing tones. Range 0–0.95. Default 0.7. */
+	feedback?: number;
+	/** Dry/Wet Mix. Balance between original and comb-filtered signal. Range 0–1. Default 0.5. */
+	mix?: number;
+	/** Tuning Mode. CHROMATIC snaps the FREQ knob to semitones; FREE allows continuous tuning. Default "chromatic". */
+	tuning?: "chromatic" | "free";
+}
+export type CombFilterInputs = {
+	"in": AudioNode;
+	"voct": AudioNode;
+	"modFreq": AudioNode;
+};
+export type CombFilterOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type CombFilterProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"voct": AudioNode;
+	"modFreq": AudioNode;
+	readonly params: {
+		/** Pitch Offset. Native AudioParam — value is semitone 1:1. */
+		"offset": AudioParam;
+		/** Feedback. Native AudioParam — value is the param value 1:1. */
+		"feedback": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const CombFilter: LibModule<CombFilterParams, CombFilterInputs, CombFilterOutputs, CombFilterProps>;
+export interface CompressorParams {
+	/** Threshold. Level above which compression kicks in. Lower = more compression. Range -60–0 dB. Default -24. */
+	threshold?: Decibels;
+	/** Ratio. How much to reduce signal above threshold. 4:1 = every 4dB over becomes 1dB. Range 1–20 (log). Default 4. */
+	ratio?: number;
+	/** Attack. How fast compression responds to loud signals. Range 0.001–1 s (log). Default 0.003. */
+	attack?: Seconds;
+	/** Release. How fast compression releases after signal drops. Range 0.01–1 s (log). Default 0.25. */
+	release?: Seconds;
+	/** Knee. Width of the transition zone around the threshold. 0 = hard knee (abrupt), 40 = soft knee (gradual). Range 0–40 dB. Default 10. */
+	knee?: Decibels;
+	/** Makeup Gain. Boosts the output level to compensate for gain reduction. Up to +30 dB. Range 0–30 dB. Default 0. */
+	makeup?: Decibels;
+}
+export type CompressorInputs = {
+	"in": AudioNode;
+};
+export type CompressorOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type CompressorProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Threshold. Native AudioParam — value is dB 1:1. */
+		"threshold": AudioParam;
+		/** Ratio. Native AudioParam — value is the param value 1:1. */
+		"ratio": AudioParam;
+		/** Attack. Native AudioParam — value is s 1:1. */
+		"attack": AudioParam;
+		/** Release. Native AudioParam — value is s 1:1. */
+		"release": AudioParam;
+		/** Knee. Native AudioParam — value is dB 1:1. */
+		"knee": AudioParam;
+	};
+};
+export declare const Compressor: LibModule<CompressorParams, CompressorInputs, CompressorOutputs, CompressorProps>;
+export interface CrossfadeParams {
+	/** Crossfade Position. Position between inputs. 0 = all A, 1 = all B. Range 0–1. Default 0.5. */
+	blend?: number;
+	/** Curve Type. Linear or equal-power crossfade curve. Default "equal-power". */
+	curve?: "linear" | "equal-power";
+}
+export type CrossfadeInputs = {
+	"a": AudioNode;
+	"b": AudioNode;
+};
+export type CrossfadeOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type CrossfadeProps = {
+	"a": AudioNode;
+	"b": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Crossfade Position. Native AudioParam — value is the param value 1:1. */
+		"blend": AudioParam;
+	};
+};
+export declare const Crossfade: LibModule<CrossfadeParams, CrossfadeInputs, CrossfadeOutputs, CrossfadeProps>;
+export interface DelayParams {
+	/** Delay Time. Time between original signal and echo. Sync to tempo for rhythmic effects. Range 0.01–1 s (log). Default 0.3. */
+	time?: Seconds;
+	/** Feedback. How much delayed signal feeds back. Higher = more repeats. Be careful of runaway feedback! Range 0–0.95. Default 0.4. */
+	feedback?: number;
+	/** Dry/Wet Mix. Balance between original (dry) and delayed (wet) signal. Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type DelayInputs = {
+	"in": AudioNode;
+};
+export type DelayOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type DelayProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Delay Time. Native AudioParam — value is s 1:1. */
+		"time": AudioParam;
+		/** Feedback. Native AudioParam — value is the param value 1:1. */
+		"feedback": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Delay: LibModule<DelayParams, DelayInputs, DelayOutputs, DelayProps>;
+export interface DimensionParams {
+	/** Rate. Widening LFO speed, driven directly by the oscillator frequency. modRate sums into the same AudioParam. Range 0.1–5 Hz. Default 0.5. */
+	rate?: Hz;
+	/** Modulation Depth. Amount of chorus-like modulation for that classic 80s wide sound. Scaled onto the LFO gains, so it is set-only (no single AudioParam carries it 1:1). Range 0–1. Default 0.3. */
+	depth?: number;
+}
+export type DimensionInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+};
+export type DimensionOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type DimensionProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+	};
+};
+export declare const Dimension: LibModule<DimensionParams, DimensionInputs, DimensionOutputs, DimensionProps>;
+export interface DistortionParams {
+	/** Clipping Curve. Which clipping transfer curve the signal is pushed into. Default "soft". */
+	distortionType?: "soft" | "hard" | "fuzz";
+	/** Drive Amount. How hard the signal is pushed into the clipping curve. The whole travel is usable: low = warm break-up, high = full clipping. Range 1–20 (log). Default 5. */
+	drive?: number;
+	/** Tone. Post-clip lowpass (500 Hz – 16 kHz). Turn down to tame the high-frequency fizz clipping creates — the Filter knob on a RAT. Range 500–16000 Hz (log). Default 16000. */
+	frequency?: Hz;
+	/** Dry/Wet Mix. Balance between clean and distorted signal. Low settings give parallel distortion. Range 0–1. Default 0.8. */
+	mix?: number;
+}
+export type DistortionInputs = {
+	"in": AudioNode;
+};
+export type DistortionOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type DistortionProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Tone. Native AudioParam — value is Hz 1:1. */
+		"frequency": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Distortion: LibModule<DistortionParams, DistortionInputs, DistortionOutputs, DistortionProps>;
+export interface DuckerParams {
+	/** Threshold. Sidechain level that triggers ducking. Lower = more sensitive. Range -60–0 dB. Default -24. */
+	threshold?: Decibels;
+	/** Duck Amount. How much to reduce the main signal when triggered. Range 0–1. Default 0.7. */
+	amount?: number;
+	/** Attack. How fast ducking kicks in after sidechain exceeds threshold. Range 0.001–0.1 s (log). Default 0.01. */
+	attack?: Seconds;
+	/** Release. How fast signal returns to normal after sidechain drops. Range 0.001–1 s (log). Default 0.2. */
+	release?: Seconds;
+}
+export type DuckerInputs = {
+	"in": AudioNode;
+	"sc": AudioNode;
+};
+export type DuckerOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type DuckerProps = {
+	"in": AudioNode;
+	"sc": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Attack. Native AudioParam — value is s 1:1. */
+		"attack": AudioParam;
+		/** Release. Native AudioParam — value is s 1:1. */
+		"release": AudioParam;
+	};
+};
+export declare const Ducker: LibModule<DuckerParams, DuckerInputs, DuckerOutputs, DuckerProps>;
+export interface EnvelopeFollowerParams {
+	/** Attack Time. How quickly the envelope responds to rising levels. Shorter = snappier transient tracking. Range 0.001–0.5 s (log). Default 0.01. */
+	attack?: Seconds;
+	/** Release Time. How quickly the envelope responds to falling levels. Longer = smoother, more sustained envelope. Range 0.001–2 s (log). Default 0.1. */
+	release?: Seconds;
+	/** Sensitivity. Input gain before envelope detection. Higher = more responsive to quiet signals. Range 0–1. Default 0.5. */
+	sensitivity?: number;
+	/** Output Depth. Scales the CV output amplitude. For V/Oct filter targets, 12 semitones = one octave, so 48 ≈ four octaves. For VCA or other targets, use lower values (0.5–2). Range 0–96 semitones (sqrt). Default 48. */
+	depth?: Semitones;
+}
+export type EnvelopeFollowerInputs = {
+	"in": AudioNode;
+};
+export type EnvelopeFollowerOutputs = {
+	"env": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type EnvelopeFollowerProps = {
+	"in": AudioNode;
+	"env": AudioNode;
+	readonly params: {
+		/** Attack Time. Native AudioParam — value is s 1:1. */
+		"attack": AudioParam;
+		/** Release Time. Native AudioParam — value is s 1:1. */
+		"release": AudioParam;
+		/** Output Depth. Native AudioParam — value is semitone 1:1. */
+		"depth": AudioParam;
+	};
+};
+export declare const EnvelopeFollower: LibModule<EnvelopeFollowerParams, EnvelopeFollowerInputs, EnvelopeFollowerOutputs, EnvelopeFollowerProps>;
+export interface EnvelopeParams {
+	/** Attack. Time for signal to rise from zero to full level when triggered. Range 0.001–2 s (log). Default 0.01. */
+	attack?: Seconds;
+	/** Decay. Time to fall from peak to sustain level after attack completes. Range 0.001–2 s (log). Default 0.1. */
+	decay?: Seconds;
+	/** Sustain. Level held while the note is held. 0 = plucky, 1 = organ-like. Range 0–1. Default 0.7. */
+	sustain?: number;
+	/** Release. Time to fade to silence after note is released. Range 0.001–3 s (log). Default 0.3. */
+	release?: Seconds;
+	/** ENV Depth. Scales the ENV output in semitones (12 = one octave), the unit every pitch and cutoff modulation input on this rack reads. Higher values produce a wider sweep on the modulation target. Range 0–96 semitones (sqrt). Default 48. */
+	depth?: Semitones;
+}
+export type EnvelopeInputs = {
+	"in": AudioNode;
+	"trigger": AudioNode;
+};
+export type EnvelopeOutputs = {
+	"out": AudioNode;
+	"env": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type EnvelopeProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"env": AudioNode;
+	"trigger": AudioNode;
+	readonly params: {
+		/** Attack. Native AudioParam — value is s 1:1. */
+		"attack": AudioParam;
+		/** Decay. Native AudioParam — value is s 1:1. */
+		"decay": AudioParam;
+		/** Sustain. Native AudioParam — value is the param value 1:1. */
+		"sustain": AudioParam;
+		/** Release. Native AudioParam — value is s 1:1. */
+		"release": AudioParam;
+		/** ENV Depth. Native AudioParam — value is semitone 1:1. */
+		"depth": AudioParam;
+	};
+};
+export declare const Envelope: LibModule<EnvelopeParams, EnvelopeInputs, EnvelopeOutputs, EnvelopeProps>;
+export interface ThreeBandEqParams {
+	/** Bass. Low shelf gain at 320 Hz. Boost for warmth, cut for clarity. Range -12–12 dB. Default 0. */
+	low?: Decibels;
+	/** Midrange. Peaking gain at the mid frequency. The presence and body range. Range -12–12 dB. Default 0. */
+	mid?: Decibels;
+	/** Treble. High shelf gain at 3.2 kHz. Boost for brightness, cut for smoothness. Range -12–12 dB. Default 0. */
+	high?: Decibels;
+	/** Mid Frequency. Center frequency for the mid band EQ. Range 200–5000 Hz (log). Default 1000. */
+	midFreq?: Hz;
+}
+export type ThreeBandEqInputs = {
+	"in": AudioNode;
+};
+export type ThreeBandEqOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type ThreeBandEqProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Bass. Native AudioParam — value is dB 1:1. */
+		"low": AudioParam;
+		/** Midrange. Native AudioParam — value is dB 1:1. */
+		"mid": AudioParam;
+		/** Treble. Native AudioParam — value is dB 1:1. */
+		"high": AudioParam;
+		/** Mid Frequency. Native AudioParam — value is Hz 1:1. */
+		"midFreq": AudioParam;
+	};
+};
+export declare const ThreeBandEq: LibModule<ThreeBandEqParams, ThreeBandEqInputs, ThreeBandEqOutputs, ThreeBandEqProps>;
+export interface ExciterParams {
+	/** Drive. Amount of harmonic saturation added to high frequencies. Range 0–1. Default 0.5. */
+	drive?: number;
+	/** Frequency. Cutoff frequency above which excitement is applied. Range 2000–8000 Hz (log). Default 4000. */
+	frequency?: Hz;
+	/** Mix Amount. How much excited signal is added to the original. Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type ExciterInputs = {
+	"in": AudioNode;
+};
+export type ExciterOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type ExciterProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Mix Amount. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Exciter: LibModule<ExciterParams, ExciterInputs, ExciterOutputs, ExciterProps>;
+export interface FlangerParams {
+	/** Rate. Flanger sweep LFO speed, a real a-rate AudioParam on the worklet. modRate sums into the same AudioParam. Range 0.1–5 Hz. Default 0.5. */
+	rate?: Hz;
+	/** Modulation Depth. How much the delay time is modulated, a real AudioParam on the worklet. modDepth sums into the same AudioParam. Range 0–1. Default 0.7. */
+	depth?: number;
+	/** Feedback. Resonance amount, a real AudioParam on the worklet. modFeedback sums into the same AudioParam. Range 0–0.95. Default 0.7. */
+	feedback?: number;
+	/** Dry/Wet Mix. Crossfade between original and flanged signal, driven by one ConstantSource (linear law: dry = 1 − mix, wet = mix). Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type FlangerInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+	"modDepth": AudioParam;
+	"modFeedback": AudioParam;
+	"modMix": AudioParam;
+};
+export type FlangerOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type FlangerProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	"modDepth": AudioParam;
+	"modFeedback": AudioParam;
+	"modMix": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+		/** Modulation Depth. Native AudioParam — value is the param value 1:1. */
+		"depth": AudioParam;
+		/** Feedback. Native AudioParam — value is the param value 1:1. */
+		"feedback": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Flanger: LibModule<FlangerParams, FlangerInputs, FlangerOutputs, FlangerProps>;
+export interface FormantParams {
+	/** Vowel Morph. Position along the A-E-I-O-U vowel formant chain. 0 = A, 5 wraps back to A; fractional values interpolate between neighbouring vowels. Range 0–5. Default 0. */
+	morph?: number;
+	/** Resonance. Sharpness of the formant peaks, scaled per band. Higher values sound more pronounced and vocal. Range 1–20 (sqrt). Default 6. */
+	resonance?: number;
+	/** Dry/Wet Mix. Balance between the original signal and the formant-filtered output. 0 = dry, 1 = fully wet. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type FormantInputs = {
+	"in": AudioNode;
+	"modVowel": AudioNode;
+};
+export type FormantOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type FormantProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modVowel": AudioNode;
+	readonly params: Record<never, never>;
+};
+export declare const Formant: LibModule<FormantParams, FormantInputs, FormantOutputs, FormantProps>;
+export interface FrequencyShifterParams {
+	/** Frequency Shift. Amount to shift all frequencies in Hz. Positive = up, negative = down. Range -500–500 Hz. Default 0. */
+	shift?: Hz;
+	/** Dry/Wet Mix. Balance between original and frequency-shifted signal. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type FrequencyShifterInputs = {
+	"in": AudioNode;
+	"modShift": AudioParam;
+};
+export type FrequencyShifterOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type FrequencyShifterProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modShift": AudioParam;
+	readonly params: {
+		/** Frequency Shift. Native AudioParam — value is Hz 1:1. */
+		"shift": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const FrequencyShifter: LibModule<FrequencyShifterParams, FrequencyShifterInputs, FrequencyShifterOutputs, FrequencyShifterProps>;
+export interface GateParams {
+	/** Threshold. Level below which the gate closes and silences audio. Range -60–0 dB. Default -40. */
+	threshold?: Decibels;
+	/** Range. How much the signal is attenuated when gate is closed. 0=full mute, lower=gentler. Range 0–1. Default 0.8. */
+	range?: number;
+	/** Attack. How fast the gate opens when signal exceeds threshold. Short = tight, long = gentle fade-in. Range 0.001–0.05 s (log). Default 0.005. */
+	attack?: Seconds;
+	/** Release. How fast the gate closes when signal falls below threshold. Range 0.01–0.5 s (log). Default 0.1. */
+	release?: Seconds;
+}
+export type GateInputs = {
+	"in": AudioNode;
+};
+export type GateOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type GateProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Attack. Native AudioParam — value is s 1:1. */
+		"attack": AudioParam;
+		/** Release. Native AudioParam — value is s 1:1. */
+		"release": AudioParam;
+	};
+};
+export declare const Gate: LibModule<GateParams, GateInputs, GateOutputs, GateProps>;
+export interface GlideParams {
+	/** Glide Time. How long it takes to slide between pitches. Longer = more portamento. Range 0.01–10 s (log). Default 0.1. */
+	time?: Seconds;
+}
+export type GlideInputs = {
+	"in": AudioNode;
+	"gate": AudioNode;
+};
+export type GlideOutputs = {
+	"out": Signal<Note>;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type GlideProps = {
+	"in": AudioNode;
+	"gate": AudioNode;
+	"out": Signal<Note>;
+	readonly params: {
+		/** Glide Time. Native AudioParam — value is s 1:1. */
+		"time": AudioParam;
+	};
+};
+export declare const Glide: LibModule<GlideParams, GlideInputs, GlideOutputs, GlideProps>;
+export interface HaasWidenerParams {
+	/** Micro-Delay. Delay time in milliseconds (1–35 ms). The Haas effect range. Range 1–35 ms. Default 15. */
+	delay?: Milliseconds;
+	/** Delayed Side. Which channel receives the delay — left or right. Default "right". */
+	side?: "left" | "right";
+	/** Effect Level. Amount of stereo widening effect. 0 = mono passthrough, 1 = fully delayed side. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type HaasWidenerInputs = {
+	"in": AudioNode;
+};
+export type HaasWidenerOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type HaasWidenerProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Effect Level. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const HaasWidener: LibModule<HaasWidenerParams, HaasWidenerInputs, HaasWidenerOutputs, HaasWidenerProps>;
+export interface HarmonicTremoloParams {
+	/** Rate. Tremolo LFO speed, driven directly by the oscillator frequency. modRate sums into the same AudioParam. Range 1–10 Hz. Default 4. */
+	rate?: Hz;
+	/** Modulation Depth. Intensity of the volume modulation. Split across the low- and high-band LFO gains, so it is set-only (no single AudioParam carries it). Range 0–1. Default 0.7. */
+	depth?: number;
+	/** Crossover Frequency. Frequency where signal splits into low and high bands. Only the lowpass moves; the high band is derived (input − LP) and follows. modCrossover sums into the same AudioParam. Range 200–2000 Hz. Default 800. */
+	crossover?: Hz;
+}
+export type HarmonicTremoloInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+	"modCrossover": AudioParam;
+};
+export type HarmonicTremoloOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type HarmonicTremoloProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	"modCrossover": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+		/** Crossover Frequency. Native AudioParam — value is Hz 1:1. */
+		"crossover": AudioParam;
+	};
+};
+export declare const HarmonicTremolo: LibModule<HarmonicTremoloParams, HarmonicTremoloInputs, HarmonicTremoloOutputs, HarmonicTremoloProps>;
+export interface LadderFilterParams {
+	/** Cutoff Note. Filter cutoff as a note (83 ≈ 1 kHz, 69 = 440 Hz). Drives the V/OCT worklet 1:1 — the panel knob shows the equivalent Hz. At full resonance this plays the self-oscillation like an oscillator. Range 15–135 notes. Default 83. */
+	note?: Note;
+	/** Resonance. Feedback around the whole ladder. At 100% the filter self-oscillates into a sine you can play via the V/OCT input. Range 0–4 (sqrt). Default 2.5. */
+	resonance?: number;
+	/** Input Drive. Saturation inside the ladder loop — thicker and more compressed as you push it, just like overdriving the original circuit. Range 0–1. Default 0.3. */
+	drive?: number;
+}
+export type LadderFilterInputs = {
+	"in": AudioNode;
+	"modFreq": AudioNode;
+	"modRes": AudioParam;
+};
+export type LadderFilterOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type LadderFilterProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modFreq": AudioNode;
+	"modRes": AudioParam;
+	readonly params: {
+		/** Cutoff Note. Native AudioParam — value is note 1:1. */
+		"note": AudioParam;
+		/** Input Drive. Native AudioParam — value is the param value 1:1. */
+		"drive": AudioParam;
+	};
+};
+export declare const LadderFilter: LibModule<LadderFilterParams, LadderFilterInputs, LadderFilterOutputs, LadderFilterProps>;
+export interface LfoParams {
+	/** Skew. Waveform symmetry. 0 = symmetric; ±1 folds the cycle into a rising or falling ramp. Range -1–1. Default 0. */
+	skew?: number;
+	/** Shape. Waveform curvature. +1 = sine, 0 = triangle, −1 = exact square. With skew ±1 and shape 0 the output is a saw. Range -1–1. Default 1. */
+	shape?: number;
+	/** Frequency. Base oscillation rate, summed with the modRate input. 0 freezes the phase; negative values run the waveform backwards. Range -10–20 Hz. Default 2. */
+	frequency?: Hz;
+	/** Amount. Output scale: out swings ±amount (semitones when patched to a V/Oct-style mod input). modAmount is summed onto it. Range 0–500 semitones (sqrt). Default 12. */
+	amount?: Semitones;
+}
+export type LfoInputs = {
+	"modRate": AudioParam;
+	"modAmount": AudioParam;
+	"modSkew": AudioParam;
+	"modShape": AudioParam;
+};
+export type LfoOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type LfoProps = {
+	"out": AudioNode;
+	"modRate": AudioParam;
+	"modAmount": AudioParam;
+	"modSkew": AudioParam;
+	"modShape": AudioParam;
+	readonly params: {
+		/** Skew. Native AudioParam — value is the param value 1:1. */
+		"skew": AudioParam;
+		/** Shape. Native AudioParam — value is the param value 1:1. */
+		"shape": AudioParam;
+		/** Frequency. Native AudioParam — value is Hz 1:1. */
+		"frequency": AudioParam;
+		/** Amount. Native AudioParam — value is semitone 1:1. */
+		"amount": AudioParam;
+	};
+};
+export declare const Lfo: LibModule<LfoParams, LfoInputs, LfoOutputs, LfoProps>;
+export interface LoFiParams {
+	/** Saturation. Amount of warm tape-like saturation and compression. Rebuilds the waveshaper curve, so it is set-only (no single AudioParam carries it). Range 0–1. Default 0.3. */
+	drive?: number;
+	/** Cutoff. Lowpass filter frequency. Lower = more muffled, vintage sound. Range 500–8000 Hz. Default 4000. */
+	cutoff?: Hz;
+	/** Vinyl Noise. Amount of background crackle and hiss for authentic vinyl character. Scaled onto the noise gain, so it is set-only (no single AudioParam carries it 1:1). Range 0–1. Default 0.2. */
+	noise?: number;
+	/** Wobble. Pitch instability like a worn tape or warped record. Scaled onto the wobble-LFO gain, so it is set-only (no single AudioParam carries it 1:1). Range 0–1. Default 0.1. */
+	wobble?: number;
+}
+export type LoFiInputs = {
+	"in": AudioNode;
+	"modCutoff": AudioParam;
+};
+export type LoFiOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type LoFiProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modCutoff": AudioParam;
+	readonly params: {
+		/** Cutoff. Native AudioParam — value is Hz 1:1. */
+		"cutoff": AudioParam;
+	};
+};
+export declare const LoFi: LibModule<LoFiParams, LoFiInputs, LoFiOutputs, LoFiProps>;
+export interface MidSideParams {
+	/** Mid Gain. Controls the center/mono content of the stereo image. Range 0–2. Default 1. */
+	midGain?: number;
+	/** Side Gain. Controls the stereo edges/differences between left and right. Range 0–2. Default 1. */
+	sideGain?: number;
+}
+export type MidSideInputs = {
+	"in": AudioNode;
+};
+export type MidSideOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type MidSideProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Mid Gain. Native AudioParam — value is the param value 1:1. */
+		"midGain": AudioParam;
+		/** Side Gain. Native AudioParam — value is the param value 1:1. */
+		"sideGain": AudioParam;
+	};
+};
+export declare const MidSide: LibModule<MidSideParams, MidSideInputs, MidSideOutputs, MidSideProps>;
+export interface NoiseParams {
+	/** Noise Color. White, pink, or brown noise spectrum. Default "white". */
+	noiseType?: "white" | "pink" | "brown";
+	/** Noise Level. Output amplitude of the noise generator. Range 0–1. Default 0.3. */
+	gain?: number;
+}
+export type NoiseInputs = {
+	"modLevel": AudioParam;
+};
+export type NoiseOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type NoiseProps = {
+	"out": AudioNode;
+	"modLevel": AudioParam;
+	readonly params: {
+		/** Noise Level. Native AudioParam — value is the param value 1:1. */
+		"gain": AudioParam;
+	};
+};
+export declare const Noise: LibModule<NoiseParams, NoiseInputs, NoiseOutputs, NoiseProps>;
+export interface OctaverParams {
+	/** Two Octaves Down. Level of the ÷4 divided square wave — two octaves below the input. Range 0–1. Default 0.3. */
+	octDown2?: number;
+	/** One Octave Down. Level of the ÷2 divided square wave — one octave below the input. Range 0–1. Default 0.5. */
+	octDown1?: number;
+	/** Dry Level. Level of the original unprocessed signal. Range 0–1. Default 0.7. */
+	dry?: number;
+	/** One Octave Up. Level of the rectified octave-up voice, bandpassed around the tracked fundamental. Range 0–1. Default 0. */
+	octUp?: number;
+}
+export type OctaverInputs = {
+	"in": AudioNode;
+};
+export type OctaverOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type OctaverProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Two Octaves Down. Native AudioParam — value is the param value 1:1. */
+		"octDown2": AudioParam;
+		/** One Octave Down. Native AudioParam — value is the param value 1:1. */
+		"octDown1": AudioParam;
+		/** Dry Level. Native AudioParam — value is the param value 1:1. */
+		"dry": AudioParam;
+		/** One Octave Up. Native AudioParam — value is the param value 1:1. */
+		"octUp": AudioParam;
+	};
+};
+export declare const Octaver: LibModule<OctaverParams, OctaverInputs, OctaverOutputs, OctaverProps>;
+export interface PhaserParams {
+	/** Rate. Phaser sweep LFO speed, driven directly by the oscillator frequency. modRate sums into the same AudioParam. Range 0.1–10 Hz. Default 0.5. */
+	rate?: Hz;
+	/** Modulation Depth. Intensity of the phase shifting effect. Split proportionally across the four allpass stage gains, so it is set-only (no single AudioParam carries it). Range 0–1. Default 0.7. */
+	depth?: number;
+	/** Feedback. Resonance amount. Higher values create more pronounced, whistling sweeps. modFeedback sums into the same AudioParam. Range 0–0.9. Default 0.6. */
+	feedback?: number;
+	/** Dry/Wet Mix. Balance between original and phased signal, driven by one ConstantSource (linear law: dry = 1 − mix, wet = mix). Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type PhaserInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+	"modFeedback": AudioParam;
+	"modMix": AudioParam;
+};
+export type PhaserOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type PhaserProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	"modFeedback": AudioParam;
+	"modMix": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+		/** Feedback. Native AudioParam — value is the param value 1:1. */
+		"feedback": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Phaser: LibModule<PhaserParams, PhaserInputs, PhaserOutputs, PhaserProps>;
+export interface PingPongParams {
+	/** Delay Time. Time between each stereo bounce. Range 0.1–1 s (log). Default 0.3. */
+	time?: Seconds;
+	/** Feedback. How much delayed signal feeds back for more repeats. Range 0–0.9. Default 0.4. */
+	feedback?: number;
+	/** Stereo Spread. Controls how far left/right the bounces are panned. 0% = mono center, 100% = full stereo. Range 0–1. Default 1. */
+	spread?: number;
+	/** Dry/Wet Mix. Balance between original and delayed signal. Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type PingPongInputs = {
+	"in": AudioNode;
+};
+export type PingPongOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type PingPongProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Delay Time. Native AudioParam — value is s 1:1. */
+		"time": AudioParam;
+		/** Feedback. Native AudioParam — value is the param value 1:1. */
+		"feedback": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const PingPong: LibModule<PingPongParams, PingPongInputs, PingPongOutputs, PingPongProps>;
+export interface ResonatorParams {
+	/** Root Pitch Offset. Semitones added to the V/OCT input. Unpatched the input is silent, so this is the root note itself: 57 = A3 (220 Hz). Driven by a keyboard or sequencer, 0 tracks the incoming notes. Every partial follows. Range -48–108 semitones. Default 57. */
+	offset?: Semitones;
+	/** Structure. Harmonic spacing of the resonator partials. Left = standard harmonic series, center = bell-like, right = metallic/inharmonic. Range 0–1. Default 0. */
+	structure?: number;
+	/** Damping. Decay time of the modes, exponential across the knob: at A3 the ring lasts ~10 s at 0, ~0.45 s at the centre and ~20 ms at 1 (T60 ≈ 2.2·Q/f, Q 1000 → 2). Upper partials fade faster than the root, as on a real string. Loudness holds across the range — less damping spreads the same strike over a longer ring instead of making it quieter. Range 0–1. Default 0.5. */
+	damping?: number;
+	/** Dry/Wet Mix. Balance between original and resonated signal. Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type ResonatorInputs = {
+	"in": AudioNode;
+	"voct": AudioNode;
+	"modFreq": AudioNode;
+};
+export type ResonatorOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type ResonatorProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"voct": AudioNode;
+	"modFreq": AudioNode;
+	readonly params: {
+		/** Root Pitch Offset. Native AudioParam — value is semitone 1:1. */
+		"offset": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Resonator: LibModule<ResonatorParams, ResonatorInputs, ResonatorOutputs, ResonatorProps>;
+export interface ReverbParams {
+	/** Decay Time (RT60). How long the tail takes to fall 60 dB. Short = room, long = hall or cathedral. Range 0.1–8 s (log). Default 2. */
+	decay?: Seconds;
+	/** Dry/Wet Mix. Equal-power balance between original (dry) and reverberant (wet) signal. Range 0–1. Default 0.3. */
+	mix?: number;
+}
+export type ReverbInputs = {
+	"in": AudioNode;
+};
+export type ReverbOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type ReverbProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Decay Time (RT60). Native AudioParam — value is s 1:1. */
+		"decay": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Reverb: LibModule<ReverbParams, ReverbInputs, ReverbOutputs, ReverbProps>;
+export interface RingModulatorParams {
+	/** Carrier Pitch Offset. Semitones added to the V/OCT input. Unpatched the input is silent, so this is the carrier note itself: 69 = 440 Hz. Driven by a keyboard or sequencer, 0 tracks the incoming notes. Range -48–108 semitones. Default 69. */
+	offset?: Semitones;
+	/** Dry/Wet Mix. Balance between original and ring-modulated signal. Range 0–1. Default 0.5. */
+	mix?: number;
+}
+export type RingModulatorInputs = {
+	"in": AudioNode;
+	"voct": AudioNode;
+	"modFreq": AudioNode;
+};
+export type RingModulatorOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type RingModulatorProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"voct": AudioNode;
+	"modFreq": AudioNode;
+	readonly params: {
+		/** Carrier Pitch Offset. Native AudioParam — value is semitone 1:1. */
+		"offset": AudioParam;
+	};
+};
+export declare const RingModulator: LibModule<RingModulatorParams, RingModulatorInputs, RingModulatorOutputs, RingModulatorProps>;
+export interface RotaryParams {
+	/** Speed Mode. Toggle between slow "chorale" and fast "tremolo". The rotors ramp between speeds with inertia — horn in ~1 s, drum in ~4–5 s — so this is a mode switch, not a continuous rate. Default "slow". */
+	speed?: "slow" | "fast";
+	/** Slow Rate. Horn speed in chorale mode (the drum turns at 0.85× this). Applied via an inertia ramp, so it is set-only. Range 0.5–2 Hz. Default 0.8. */
+	slowRate?: Hz;
+	/** Fast Rate. Horn speed in tremolo mode (the drum turns at 0.85× this). Applied via an inertia ramp, so it is set-only. Range 4–8 Hz. Default 6. */
+	fastRate?: Hz;
+	/** Dry/Wet Mix. Balance between original and rotary speaker signal, driven by one ConstantSource (linear law: dry = 1 − mix, wet = mix). Range 0–1. Default 0.7. */
+	mix?: number;
+}
+export type RotaryInputs = {
+	"in": AudioNode;
+	"modMix": AudioParam;
+};
+export type RotaryOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type RotaryProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modMix": AudioParam;
+	readonly params: {
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Rotary: LibModule<RotaryParams, RotaryInputs, RotaryOutputs, RotaryProps>;
+export interface SaturatorParams {
+	/** Drive. How hard to push into saturation. Adds harmonics and soft compression. Range 0–1. Default 0.5. */
+	drive?: number;
+	/** Warmth. Low frequency emphasis for a thicker, analog-like tone. Range 0–1. Default 0.5. */
+	warmth?: number;
+	/** Dry/Wet Mix. Balance between clean and saturated signal. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type SaturatorInputs = {
+	"in": AudioNode;
+};
+export type SaturatorOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type SaturatorProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Saturator: LibModule<SaturatorParams, SaturatorInputs, SaturatorOutputs, SaturatorProps>;
+export interface ShimmerParams {
+	/** Reverb Decay. RT60 of the reverb tank in seconds. Range 0.5–10 s (log). Default 3. */
+	decay?: Seconds;
+	/** Pitch Shift. Transposition applied by the granular pitch shifter on every trip round the feedback loop (12 = one octave). +12 = octave up, +7 = fifth up, -12 = octave down. Range -12–24 semitones. Default 12. */
+	pitch?: Semitones;
+	/** Dry/Wet Mix. Equal-power balance between dry signal and shimmer output — independent of the regen amount. Range 0–1. Default 0.5. */
+	mix?: number;
+	/** Shimmer Regen. How much pitch-shifted signal is fed back into the tank. High = endless rising choir. Range 0–0.95. Default 0.5. */
+	shimmer?: number;
+}
+export type ShimmerInputs = {
+	"in": AudioNode;
+};
+export type ShimmerOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type ShimmerProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+		/** Shimmer Regen. Native AudioParam — value is the param value 1:1. */
+		"shimmer": AudioParam;
+	};
+};
+export declare const Shimmer: LibModule<ShimmerParams, ShimmerInputs, ShimmerOutputs, ShimmerProps>;
+export interface SoftLimiterParams {
+	/** Input Drive. Pushes signal into the limiter for more saturation and loudness. Range 0–1. Default 0.5. */
+	drive?: number;
+	/** Soft Knee. How gradually limiting kicks in. Higher = softer, more transparent. Range 0–1. Default 0.5. */
+	knee?: number;
+	/** Ceiling. Maximum output level in dB. Prevents clipping above this level. Range -12–0 dB. Default -0.5. */
+	ceiling?: Decibels;
+}
+export type SoftLimiterInputs = {
+	"in": AudioNode;
+};
+export type SoftLimiterOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type SoftLimiterProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: Record<never, never>;
+};
+export declare const SoftLimiter: LibModule<SoftLimiterParams, SoftLimiterInputs, SoftLimiterOutputs, SoftLimiterProps>;
+export interface SpringReverbParams {
+	/** Dry/Wet Mix. Equal-power blend of dry signal and spring output. Range 0–1. Default 0.35. */
+	mix?: number;
+	/** Reverb Decay. Stretch/sag of the spring's dispersion — higher values ring longer and smear more. Range 0.3–4 s (log). Default 1.5. */
+	decay?: Seconds;
+	/** Tone. Brightness of the spring output: darkens the rattly top end as it falls. Range 0–1. Default 0.6. */
+	tone?: number;
+	/** Drip. Spring bounce character — how much the delayed tail drips and boings. Range 0–1. Default 0.5. */
+	drip?: number;
+}
+export type SpringReverbInputs = {
+	"in": AudioNode;
+	"knock": AudioNode;
+};
+export type SpringReverbOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type SpringReverbProps = {
+	"in": AudioNode;
+	"knock": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+		/** Reverb Decay. Native AudioParam — value is s 1:1. */
+		"decay": AudioParam;
+		/** Tone. Native AudioParam — value is the param value 1:1. */
+		"tone": AudioParam;
+		/** Drip. Native AudioParam — value is the param value 1:1. */
+		"drip": AudioParam;
+	};
+};
+export declare const SpringReverb: LibModule<SpringReverbParams, SpringReverbInputs, SpringReverbOutputs, SpringReverbProps>;
+export interface StereoSpreadParams {
+	/** Spread Amount. Controls the micro-delay time for Haas widening (0–5ms). More spread = wider perceived stereo image. Range 0–1. Default 0.7. */
+	spread?: number;
+	/** Crossover Frequency. Frequency above which Haas spreading is applied. Lows below this stay centered for mono compatibility. Range 200–2000 Hz (log). Default 800. */
+	center?: Hz;
+}
+export type StereoSpreadInputs = {
+	"in": AudioNode;
+};
+export type StereoSpreadOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type StereoSpreadProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: Record<never, never>;
+};
+export declare const StereoSpread: LibModule<StereoSpreadParams, StereoSpreadInputs, StereoSpreadOutputs, StereoSpreadProps>;
+export interface SubharmonicParams {
+	/** Direct Level. Level of the dry input signal passed through to the output. Range 0–1. Default 1. */
+	direct?: number;
+	/** Octave Down. Level of the first sub-octave (one octave below input via ÷2 frequency division). Range 0–1. Default 0.5. */
+	octave1?: number;
+	/** Two Octaves Down. Level of the second sub-octave (two octaves below input via ÷4 frequency division). Range 0–1. Default 0.3. */
+	octave2?: number;
+}
+export type SubharmonicInputs = {
+	"in": AudioNode;
+};
+export type SubharmonicOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type SubharmonicProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Direct Level. Native AudioParam — value is the param value 1:1. */
+		"direct": AudioParam;
+		/** Octave Down. Native AudioParam — value is the param value 1:1. */
+		"octave1": AudioParam;
+		/** Two Octaves Down. Native AudioParam — value is the param value 1:1. */
+		"octave2": AudioParam;
+	};
+};
+export declare const Subharmonic: LibModule<SubharmonicParams, SubharmonicInputs, SubharmonicOutputs, SubharmonicProps>;
+export interface TapeDelayParams {
+	/** Delay Time. Echo time. Changes glide with a tape-style pitch bend instead of jumping. Range 0.05–1.5 s (log). Default 0.375. */
+	time?: Seconds;
+	/** Feedback. Repeat intensity. High values create dreamy, degrading echoes. Range 0–0.95. Default 0.5. */
+	feedback?: number;
+	/** Dry/Wet Mix. Balance between original and delayed signal. Range 0–1. Default 0.4. */
+	mix?: number;
+	/** Wow & Flutter. Slow wow plus fast flutter — tape transport speed wobble, proportional to delay time. Range 0–1. Default 0.3. */
+	flutter?: number;
+	/** Saturation. Tape saturation warmth and subtle compression, applied on every pass. Range 0–1. Default 0.4. */
+	saturation?: number;
+}
+export type TapeDelayInputs = {
+	"in": AudioNode;
+};
+export type TapeDelayOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type TapeDelayProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Delay Time. Native AudioParam — value is s 1:1. */
+		"time": AudioParam;
+		/** Feedback. Native AudioParam — value is the param value 1:1. */
+		"feedback": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+		/** Wow & Flutter. Native AudioParam — value is the param value 1:1. */
+		"flutter": AudioParam;
+		/** Saturation. Native AudioParam — value is the param value 1:1. */
+		"saturation": AudioParam;
+	};
+};
+export declare const TapeDelay: LibModule<TapeDelayParams, TapeDelayInputs, TapeDelayOutputs, TapeDelayProps>;
+export interface TapeStopParams {
+	/** Stop/Start Time. Duration of the tape deceleration or acceleration ramp. Range 0.01–4 s (log). Default 0.5. */
+	time?: Seconds;
+	/** Dry/Wet Mix. Balance between original signal and tape-stopped signal. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type TapeStopInputs = {
+	"in": AudioNode;
+	"trigger": AudioNode;
+};
+export type TapeStopOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type TapeStopProps = {
+	"in": AudioNode;
+	"trigger": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Stop/Start Time. Native AudioParam — value is s 1:1. */
+		"time": AudioParam;
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const TapeStop: LibModule<TapeStopParams, TapeStopInputs, TapeStopOutputs, TapeStopProps>;
+export interface TiltParams {
+	/** Tilt Amount. Positive tilts towards highs (brighter), negative towards lows (darker). Drives the low shelf (inverted) and high shelf gains. Range -12–12 dB. Default 0. */
+	tilt?: Decibels;
+	/** Pivot Frequency. Center frequency around which the tilt occurs, shared by both the low and high shelf filters. Range 200–5000 Hz. Default 1000. */
+	frequency?: Hz;
+}
+export type TiltInputs = {
+	"in": AudioNode;
+};
+export type TiltOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type TiltProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: Record<never, never>;
+};
+export declare const Tilt: LibModule<TiltParams, TiltInputs, TiltOutputs, TiltProps>;
+export interface TremoloParams {
+	/** Rate. Amplitude-modulation LFO speed, driven directly by the oscillator frequency. modRate sums into the same AudioParam. Range 0.5–20 Hz. Default 5. */
+	rate?: Hz;
+	/** Modulation Depth. How much the volume varies. 100% goes from silence to full volume. Split across a depth gain and a DC offset, so it is set-only (no single AudioParam carries it). Range 0–1. Default 0.5. */
+	depth?: number;
+	/** LFO Shape. Waveform shape: sine for smooth, triangle for linear, square for choppy. Default "sine". */
+	shape?: "sine" | "triangle" | "square";
+}
+export type TremoloInputs = {
+	"in": AudioNode;
+	"modRate": AudioParam;
+};
+export type TremoloOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type TremoloProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modRate": AudioParam;
+	readonly params: {
+		/** Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+	};
+};
+export declare const Tremolo: LibModule<TremoloParams, TremoloInputs, TremoloOutputs, TremoloProps>;
+export interface VcaParams {
+	/** Resting level. Sets the level when no CV is patched, and the offset the CV rides on. Leave at 0 for envelope-gated patches so the VCA fully closes. Range 0–2. Default 0.5. */
+	gain?: number;
+	/** CV attenuverter. Scales the control voltage from the CV input. Negative values invert it, so the signal ducks instead of swelling. Range -1–1. Default 1. */
+	cvAmount?: number;
+}
+export type VcaInputs = {
+	"in": AudioNode;
+	"modGain": AudioParam;
+};
+export type VcaOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type VcaProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modGain": AudioParam;
+	readonly params: {
+		/** Resting level. Native AudioParam — value is the param value 1:1. */
+		"gain": AudioParam;
+		/** CV attenuverter. Native AudioParam — value is the param value 1:1. */
+		"cvAmount": AudioParam;
+	};
+};
+export declare const Vca: LibModule<VcaParams, VcaInputs, VcaOutputs, VcaProps>;
+export interface VcfParams {
+	/** Filter Type. Selects lowpass, highpass, bandpass, or notch response. Default "lowpass". */
+	filterType?: "lowpass" | "highpass" | "bandpass" | "notch";
+	/** Cutoff Note. Filter cutoff as a note (83 ≈ 1 kHz, 69 = 440 Hz). Drives the V/OCT worklet 1:1 — the panel knob shows the equivalent Hz. Range 15–135 notes. Default 83. */
+	note?: Note;
+	/** Resonance (Q). True filter Q, identical in every mode: Q 0.707 is maximally flat, Q 8 peaks ~+18 dB in lowpass and narrows bandpass to f/8. Range 0.1–20 (sqrt). Default 1. */
+	resonance?: number;
+}
+export type VcfInputs = {
+	"in": AudioNode;
+	"modFreq": AudioNode;
+	"modQ": AudioNode;
+};
+export type VcfOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type VcfProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modFreq": AudioNode;
+	"modQ": AudioNode;
+	readonly params: {
+		/** Cutoff Note. Native AudioParam — value is note 1:1. */
+		"note": AudioParam;
+	};
+};
+export declare const Vcf: LibModule<VcfParams, VcfInputs, VcfOutputs, VcfProps>;
+export interface VcoParams {
+	/** Waveshape Skew. Symmetry of the waveform: −1 reversed sawtooth, 0 symmetric, +1 sawtooth. Range -1–1. Default 1. */
+	skew?: number;
+	/** Waveshape Curvature. Curvature of the waveform: −1 square, 0 triangle, +1 sine. Range -1–1. Default 0. */
+	shape?: number;
+	/** Pitch Offset. Semitones added to the V/OCT input (12 = one octave). Unpatched the input is silent, so this is the note itself: 69 = A4. Driven by an absolute pitch CV (keyboard, sequencer), set 0 to play as-is or ±12 to shift an octave. Range -48–108 semitones. Default 69. */
+	offset?: Semitones;
+	/** Detune. Fine pitch offset in semitones; ±1 = ±100 cents. Use for detuning oscillators against each other. Range -1–1 semitones. Default 0. */
+	detune?: Semitones;
+	/** Output Level. Amplitude of the oscillator output signal. Range 0–1. Default 0.5. */
+	gain?: number;
+}
+export type VcoInputs = {
+	"voct": AudioNode;
+	"modSkew": AudioParam;
+	"modShape": AudioParam;
+	"modDetune": AudioParam;
+};
+export type VcoOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type VcoProps = {
+	"voct": AudioNode;
+	"out": AudioNode;
+	"modSkew": AudioParam;
+	"modShape": AudioParam;
+	"modDetune": AudioParam;
+	readonly params: {
+		/** Waveshape Skew. Native AudioParam — value is the param value 1:1. */
+		"skew": AudioParam;
+		/** Waveshape Curvature. Native AudioParam — value is the param value 1:1. */
+		"shape": AudioParam;
+		/** Pitch Offset. Native AudioParam — value is semitone 1:1. */
+		"offset": AudioParam;
+		/** Detune. Native AudioParam — value is semitone 1:1. */
+		"detune": AudioParam;
+		/** Output Level. Native AudioParam — value is the param value 1:1. */
+		"gain": AudioParam;
+	};
+};
+export declare const Vco: LibModule<VcoParams, VcoInputs, VcoOutputs, VcoProps>;
+export interface WahParams {
+	/** Center Note. Wah center frequency as a note (79 ≈ 800 Hz, 69 = 440 Hz). Drives the V/OCT worklet 1:1 — the panel knob shows the equivalent Hz. Range 55–95 notes. Default 79. */
+	note?: Note;
+	/** Resonance. How pronounced and vocal the wah peak sounds. Range 1–20 (log). Default 8. */
+	resonance?: number;
+	/** Auto-Wah Rate. Speed of the automatic wah sweep in Hz. Range 0.1–10 Hz (log). Default 1. */
+	rate?: Hz;
+	/** Modulation Depth. How much the frequency sweeps. Full depth ≈ 3 octaves. Range 0–1. Default 0.6. */
+	depth?: number;
+}
+export type WahInputs = {
+	"in": AudioNode;
+	"modFreq": AudioNode;
+};
+export type WahOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type WahProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	"modFreq": AudioNode;
+	readonly params: {
+		/** Center Note. Native AudioParam — value is note 1:1. */
+		"note": AudioParam;
+		/** Auto-Wah Rate. Native AudioParam — value is Hz 1:1. */
+		"rate": AudioParam;
+	};
+};
+export declare const Wah: LibModule<WahParams, WahInputs, WahOutputs, WahProps>;
+export interface WavefolderParams {
+	/** Fold Amount. How many times the waveform folds back. More folds = richer harmonics. Range 1–10. Default 2. */
+	folds?: number;
+	/** Symmetry. Asymmetric folding creates even harmonics for different timbres. Range -1–1. Default 0. */
+	symmetry?: number;
+	/** Dry/Wet Mix. Balance between original and wavefolded signal. Range 0–1. Default 1. */
+	mix?: number;
+}
+export type WavefolderInputs = {
+	"in": AudioNode;
+};
+export type WavefolderOutputs = {
+	"out": AudioNode;
+};
+/** Port properties on the instance: slug → native connect target (same as input()/output()). */
+export type WavefolderProps = {
+	"in": AudioNode;
+	"out": AudioNode;
+	readonly params: {
+		/** Dry/Wet Mix. Native AudioParam — value is the param value 1:1. */
+		"mix": AudioParam;
+	};
+};
+export declare const Wavefolder: LibModule<WavefolderParams, WavefolderInputs, WavefolderOutputs, WavefolderProps>;
+
+export {};