rescript-audio 1.0.0

package/README.md

@@ -0,0 +1,227 @@
+# rescript-audio
+
+ReScript bindings for the Web Audio API.
+
+## Installation
+
+```bash
+npm install rescript-audio
+```
+
+Add to your `rescript.json`:
+
+```json
+{
+  "dependencies": ["rescript-audio"]
+}
+```
+
+## Usage
+
+```rescript
+// Create an audio context
+let ctx = Audio.Context.make()
+
+// Create an oscillator with options
+let osc = Audio.Oscillator.make(ctx, ~options={
+  waveform: Sine,
+  frequency: 440.0,
+})
+
+// Create a gain node
+let gain = Audio.Gain.make(ctx, ~options={gain: 0.5})
+
+// Connect oscillator -> gain -> destination
+Audio.Utils.chain([
+  osc->Audio.Oscillator.asNode,
+  gain->Audio.Gain.asNode,
+  Audio.ContextExt.destination(ctx)->Audio.Destination.asNode,
+])
+
+// Start the oscillator
+Audio.Oscillator.start(osc)
+
+// Schedule parameter changes
+Audio.Gain.gainParam(gain)
+->Audio.Param.setValueAtTime(~value=0.5, ~startTime=Audio.Context.currentTime(ctx))
+->Audio.Param.linearRampToValueAtTime(~value=0.0, ~endTime=Audio.Context.currentTime(ctx) +. 1.0)
+->ignore
+```
+
+## API
+
+### Context
+
+```rescript
+Audio.Context.make()                    // Create new AudioContext
+Audio.Context.makeWithOptions(options)  // Create with options
+Audio.Context.sampleRate(ctx)           // Get sample rate
+Audio.Context.currentTime(ctx)          // Get current time
+Audio.Context.state(ctx)                // Get state: Suspended | Running | Closed
+Audio.Context.resume(ctx)               // Resume (returns promise)
+Audio.Context.suspend(ctx)              // Suspend (returns promise)
+Audio.Context.close(ctx)                // Close (returns promise)
+```
+
+### Oscillator
+
+```rescript
+// Waveform types: Sine | Square | Sawtooth | Triangle | Custom
+Audio.Oscillator.make(ctx, ~options=?)
+Audio.Oscillator.frequencyParam(osc)    // Get frequency AudioParam
+Audio.Oscillator.detuneParam(osc)       // Get detune AudioParam
+Audio.Oscillator.waveform(osc)          // Get current waveform
+Audio.Oscillator.setWaveform(osc, w)    // Set waveform
+Audio.Oscillator.start(osc)             // Start immediately
+Audio.Oscillator.startAt(osc, time)     // Start at time
+Audio.Oscillator.stop(osc)              // Stop immediately
+Audio.Oscillator.stopAt(osc, time)      // Stop at time
+```
+
+### Gain
+
+```rescript
+Audio.Gain.make(ctx, ~options=?)
+Audio.Gain.gainParam(gain)              // Get gain AudioParam
+```
+
+### BiquadFilter
+
+```rescript
+// Filter types: Lowpass | Highpass | Bandpass | Lowshelf | Highshelf | Peaking | Notch | Allpass
+Audio.BiquadFilter.make(ctx, ~options=?)
+Audio.BiquadFilter.frequencyParam(f)
+Audio.BiquadFilter.detuneParam(f)
+Audio.BiquadFilter.qParam(f)
+Audio.BiquadFilter.gainParam(f)
+Audio.BiquadFilter.filterType(f)
+Audio.BiquadFilter.setFilterType(f, ft)
+```
+
+### Delay
+
+```rescript
+Audio.Delay.make(ctx, ~options=?)
+Audio.Delay.delayTimeParam(d)
+```
+
+### Compressor
+
+```rescript
+Audio.Compressor.make(ctx, ~options=?)
+Audio.Compressor.thresholdParam(c)
+Audio.Compressor.kneeParam(c)
+Audio.Compressor.ratioParam(c)
+Audio.Compressor.attackParam(c)
+Audio.Compressor.releaseParam(c)
+Audio.Compressor.reductionDb(c)         // Current gain reduction in dB
+```
+
+### StereoPanner
+
+```rescript
+Audio.StereoPanner.make(ctx, ~options=?)
+Audio.StereoPanner.panParam(p)          // -1.0 (left) to 1.0 (right)
+```
+
+### Analyser
+
+```rescript
+Audio.Analyser.make(ctx, ~options=?)
+Audio.Analyser.fftSize(a)
+Audio.Analyser.setFftSize(a, size)
+Audio.Analyser.frequencyBinCount(a)
+Audio.Analyser.getFloatFrequencyData(a, array)
+Audio.Analyser.getByteFrequencyData(a, array)
+Audio.Analyser.getFloatTimeDomainData(a, array)
+Audio.Analyser.getByteTimeDomainData(a, array)
+```
+
+### Param (AudioParam)
+
+```rescript
+Audio.Param.value(p)                    // Get current value
+Audio.Param.setValue(p, v)              // Set value immediately
+Audio.Param.setValueAtTime(p, ~value, ~startTime)
+Audio.Param.linearRampToValueAtTime(p, ~value, ~endTime)
+Audio.Param.exponentialRampToValueAtTime(p, ~value, ~endTime)
+Audio.Param.setTargetAtTime(p, ~target, ~startTime, ~timeConstant)
+Audio.Param.setValueCurveAtTime(p, ~values, ~startTime, ~duration)
+Audio.Param.cancelScheduledValues(p, ~cancelTime)
+Audio.Param.cancelAndHoldAtTime(p, ~cancelTime)
+```
+
+### Node
+
+```rescript
+Audio.Node.connect(source, destination)
+Audio.Node.connectToParam(source, param)
+Audio.Node.disconnect(node)
+Audio.Node.disconnectFrom(node, target)
+Audio.Node.numberOfInputs(node)
+Audio.Node.numberOfOutputs(node)
+```
+
+### Utils
+
+```rescript
+Audio.Utils.chain(nodes)                // Connect array of nodes in series
+Audio.Utils.toDestination(ctx, node)    // Connect node to destination
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+npm run watch  # Development mode
+```
+
+## Contributing
+
+This project uses [Conventional Commits](https://www.conventionalcommits.org/) for automatic versioning and changelog generation.
+
+### Commit Message Format
+
+```
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+### Types
+
+| Type | Description | Version Bump |
+|------|-------------|--------------|
+| `feat` | New feature | Minor |
+| `fix` | Bug fix | Patch |
+| `perf` | Performance improvement | Patch |
+| `refactor` | Code refactoring | Patch |
+| `docs` | Documentation changes | Patch (README only) |
+| `chore` | Maintenance tasks | No release |
+| `test` | Test changes | No release |
+
+### Breaking Changes
+
+Add `BREAKING CHANGE:` in the commit footer or `!` after the type for major version bumps:
+
+```
+feat!: remove deprecated API
+
+BREAKING CHANGE: The old API has been removed.
+```
+
+### Examples
+
+```bash
+git commit -m "feat(oscillator): add custom waveform support"
+git commit -m "fix(gain): correct parameter range validation"
+git commit -m "docs(README): add filter examples"
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "rescript-audio",
+  "version": "1.0.0",
+  "description": "ReScript bindings for the Web Audio API",
+  "main": "./src/Audio.js",
+  "module": "./src/Audio.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brnrdog/rescript-audio.git"
+  },
+  "homepage": "https://github.com/brnrdog/rescript-audio#readme",
+  "bugs": {
+    "url": "https://github.com/brnrdog/rescript-audio/issues"
+  },
+  "files": [
+    "src/Audio.res",
+    "src/Audio.js",
+    "rescript.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rescript",
+    "clean": "rescript clean",
+    "watch": "rescript -w",
+    "test": "rescript && node tests/AudioTests.js"
+  },
+  "keywords": [
+    "rescript",
+    "web-audio",
+    "audio",
+    "bindings"
+  ],
+  "author": "Bernardo Gurgel <brnrdog@hey.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@rescript/core": "^1.6.1",
+    "rescript": "^12.1.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "semantic-release": "^25.0.2",
+    "zekr": "^1.2.0"
+  }
+}

package/rescript.json

@@ -0,0 +1,24 @@
+{
+  "name": "rescript-audio",
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    },
+    {
+      "dir": "tests",
+      "type": "dev"
+    }
+  ],
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "suffix": ".js",
+  "dependencies": [
+    "@rescript/core"
+  ],
+  "dev-dependencies": [
+    "zekr"
+  ]
+}

package/src/Audio.js

@@ -0,0 +1,294 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function state(ctx) {
+  let match = ctx.state;
+  switch (match) {
+    case "closed" :
+      return "Closed";
+    case "running" :
+      return "Running";
+    default:
+      return "Suspended";
+  }
+}
+
+let Context = {
+  state: state
+};
+
+let Param = {};
+
+let Node = {};
+
+let Destination = {};
+
+function make(ctx, options) {
+  let gainNode = ctx.createGain();
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.gain, g => {
+      gainNode.gain.value = g;
+    });
+  }
+  return gainNode;
+}
+
+let Gain = {
+  make: make
+};
+
+function waveformToString(w) {
+  switch (w) {
+    case "Sine" :
+      return "sine";
+    case "Square" :
+      return "square";
+    case "Sawtooth" :
+      return "sawtooth";
+    case "Triangle" :
+      return "triangle";
+    case "Custom" :
+      return "custom";
+  }
+}
+
+function waveformFromString(s) {
+  switch (s) {
+    case "custom" :
+      return "Custom";
+    case "sawtooth" :
+      return "Sawtooth";
+    case "square" :
+      return "Square";
+    case "triangle" :
+      return "Triangle";
+    default:
+      return "Sine";
+  }
+}
+
+function make$1(ctx, options) {
+  let osc = ctx.createOscillator();
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.waveform, w => {
+      osc.type = waveformToString(w);
+    });
+    Stdlib_Option.forEach(options.frequency, f => {
+      osc.frequency.value = f;
+    });
+    Stdlib_Option.forEach(options.detune, d => {
+      osc.detune.value = d;
+    });
+  }
+  return osc;
+}
+
+function waveform(osc) {
+  return waveformFromString(osc.type);
+}
+
+function setWaveform(osc, w) {
+  osc.type = waveformToString(w);
+}
+
+let Oscillator = {
+  waveformToString: waveformToString,
+  waveformFromString: waveformFromString,
+  make: make$1,
+  waveform: waveform,
+  setWaveform: setWaveform
+};
+
+function filterTypeToString(ft) {
+  switch (ft) {
+    case "Lowpass" :
+      return "lowpass";
+    case "Highpass" :
+      return "highpass";
+    case "Bandpass" :
+      return "bandpass";
+    case "Lowshelf" :
+      return "lowshelf";
+    case "Highshelf" :
+      return "highshelf";
+    case "Peaking" :
+      return "peaking";
+    case "Notch" :
+      return "notch";
+    case "Allpass" :
+      return "allpass";
+  }
+}
+
+function filterTypeFromString(s) {
+  switch (s) {
+    case "allpass" :
+      return "Allpass";
+    case "bandpass" :
+      return "Bandpass";
+    case "highpass" :
+      return "Highpass";
+    case "highshelf" :
+      return "Highshelf";
+    case "lowshelf" :
+      return "Lowshelf";
+    case "notch" :
+      return "Notch";
+    case "peaking" :
+      return "Peaking";
+    default:
+      return "Lowpass";
+  }
+}
+
+function make$2(ctx, options) {
+  let filter = ctx.createBiquadFilter();
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.filterType, ft => {
+      filter.type = filterTypeToString(ft);
+    });
+    Stdlib_Option.forEach(options.frequency, f => {
+      filter.frequency.value = f;
+    });
+    Stdlib_Option.forEach(options.detune, d => {
+      filter.detune.value = d;
+    });
+    Stdlib_Option.forEach(options.q, qVal => {
+      filter.Q.value = qVal;
+    });
+    Stdlib_Option.forEach(options.gain, g => {
+      filter.gain.value = g;
+    });
+  }
+  return filter;
+}
+
+function filterType(filter) {
+  return filterTypeFromString(filter.type);
+}
+
+function setFilterType(filter, ft) {
+  filter.type = filterTypeToString(ft);
+}
+
+let BiquadFilter = {
+  filterTypeToString: filterTypeToString,
+  filterTypeFromString: filterTypeFromString,
+  make: make$2,
+  filterType: filterType,
+  setFilterType: setFilterType
+};
+
+function make$3(ctx, options) {
+  let maxDelay = Stdlib_Option.flatMap(options, o => o.maxDelayTime);
+  let delay = ctx.createDelay(maxDelay !== undefined ? Primitive_option.valFromOption(maxDelay) : undefined);
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.delayTime, dt => {
+      delay.delayTime.value = dt;
+    });
+  }
+  return delay;
+}
+
+let Delay = {
+  make: make$3
+};
+
+function make$4(ctx, options) {
+  let comp = ctx.createDynamicsCompressor();
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.threshold, t => {
+      comp.threshold.value = t;
+    });
+    Stdlib_Option.forEach(options.knee, k => {
+      comp.knee.value = k;
+    });
+    Stdlib_Option.forEach(options.ratio, r => {
+      comp.ratio.value = r;
+    });
+    Stdlib_Option.forEach(options.attack, a => {
+      comp.attack.value = a;
+    });
+    Stdlib_Option.forEach(options.release, rel => {
+      comp.release.value = rel;
+    });
+  }
+  return comp;
+}
+
+let Compressor = {
+  make: make$4
+};
+
+function make$5(ctx, options) {
+  let panner = ctx.createStereoPanner();
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.pan, p => {
+      panner.pan.value = p;
+    });
+  }
+  return panner;
+}
+
+let StereoPanner = {
+  make: make$5
+};
+
+function make$6(ctx, options) {
+  let analyser = ctx.createAnalyser();
+  if (options !== undefined) {
+    Stdlib_Option.forEach(options.fftSize, size => {
+      analyser.fftSize = size;
+    });
+    Stdlib_Option.forEach(options.minDecibels, min => {
+      analyser.minDecibels = min;
+    });
+    Stdlib_Option.forEach(options.maxDecibels, max => {
+      analyser.maxDecibels = max;
+    });
+    Stdlib_Option.forEach(options.smoothingTimeConstant, s => {
+      analyser.smoothingTimeConstant = s;
+    });
+  }
+  return analyser;
+}
+
+let Analyser = {
+  make: make$6
+};
+
+let ContextExt = {};
+
+function chain(nodes) {
+  for (let i = 0, i_finish = nodes.length - 2 | 0; i <= i_finish; ++i) {
+    Stdlib_Option.getOrThrow(nodes[i], undefined).connect(Stdlib_Option.getOrThrow(nodes[i + 1 | 0], undefined));
+  }
+}
+
+function toDestination(ctx, node) {
+  node.connect(ctx.destination);
+}
+
+let Utils = {
+  chain: chain,
+  toDestination: toDestination
+};
+
+export {
+  Context,
+  Param,
+  Node,
+  Destination,
+  Gain,
+  Oscillator,
+  BiquadFilter,
+  Delay,
+  Compressor,
+  StereoPanner,
+  Analyser,
+  ContextExt,
+  Utils,
+}
+/* No side effect */

package/src/Audio.res

@@ -0,0 +1,405 @@
+// ReScript Web Audio API bindings
+// Provides an idiomatic ReScript interface to the Web Audio API
+
+module Context = {
+  type t
+
+  type state =
+    | Suspended
+    | Running
+    | Closed
+
+  type options = {
+    latencyHint?: string,
+    sampleRate?: float,
+  }
+
+  @new external make: unit => t = "AudioContext"
+  @new external makeWithOptions: options => t = "AudioContext"
+
+  @get external sampleRate: t => float = "sampleRate"
+  @get external currentTime: t => float = "currentTime"
+  @get external baseLatency: t => float = "baseLatency"
+
+  @get external stateString: t => string = "state"
+
+  let state = (ctx: t): state => {
+    switch stateString(ctx) {
+    | "suspended" => Suspended
+    | "running" => Running
+    | "closed" => Closed
+    | _ => Suspended
+    }
+  }
+
+  @send external resume: t => promise<unit> = "resume"
+  @send external suspend: t => promise<unit> = "suspend"
+  @send external close: t => promise<unit> = "close"
+}
+
+module Param = {
+  type t
+
+  @get external value: t => float = "value"
+  @set external setValue: (t, float) => unit = "value"
+  @get external defaultValue: t => float = "defaultValue"
+  @get external minValue: t => float = "minValue"
+  @get external maxValue: t => float = "maxValue"
+
+  @send
+  external setValueAtTime: (t, ~value: float, ~startTime: float) => t = "setValueAtTime"
+
+  @send
+  external linearRampToValueAtTime: (t, ~value: float, ~endTime: float) => t =
+    "linearRampToValueAtTime"
+
+  @send
+  external exponentialRampToValueAtTime: (t, ~value: float, ~endTime: float) => t =
+    "exponentialRampToValueAtTime"
+
+  @send
+  external setTargetAtTime: (t, ~target: float, ~startTime: float, ~timeConstant: float) => t =
+    "setTargetAtTime"
+
+  @send
+  external setValueCurveAtTime: (t, ~values: array<float>, ~startTime: float, ~duration: float) => t =
+    "setValueCurveAtTime"
+
+  @send external cancelScheduledValues: (t, ~cancelTime: float) => t = "cancelScheduledValues"
+
+  @send
+  external cancelAndHoldAtTime: (t, ~cancelTime: float) => t = "cancelAndHoldAtTime"
+}
+
+module Node = {
+  type t
+
+  @get external context: t => Context.t = "context"
+  @get external numberOfInputs: t => int = "numberOfInputs"
+  @get external numberOfOutputs: t => int = "numberOfOutputs"
+  @get external channelCount: t => int = "channelCount"
+  @set external setChannelCount: (t, int) => unit = "channelCount"
+
+  @send external connect: (t, t) => t = "connect"
+  @send external connectToParam: (t, Param.t) => unit = "connect"
+  @send external disconnect: t => unit = "disconnect"
+  @send external disconnectFrom: (t, t) => unit = "disconnect"
+}
+
+module Destination = {
+  type t
+
+  @get external maxChannelCount: t => int = "maxChannelCount"
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module Gain = {
+  type t
+
+  type options = {gain?: float}
+
+  @send external _make: Context.t => t = "createGain"
+  @get external gainParam: t => Param.t = "gain"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let gainNode = _make(ctx)
+    switch options {
+    | Some(opts) => opts.gain->Option.forEach(g => Param.setValue(gainParam(gainNode), g))
+    | None => ()
+    }
+    gainNode
+  }
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module Oscillator = {
+  type t
+
+  type waveform =
+    | Sine
+    | Square
+    | Sawtooth
+    | Triangle
+    | Custom
+
+  type options = {
+    waveform?: waveform,
+    frequency?: float,
+    detune?: float,
+  }
+
+  let waveformToString = (w: waveform): string => {
+    switch w {
+    | Sine => "sine"
+    | Square => "square"
+    | Sawtooth => "sawtooth"
+    | Triangle => "triangle"
+    | Custom => "custom"
+    }
+  }
+
+  let waveformFromString = (s: string): waveform => {
+    switch s {
+    | "sine" => Sine
+    | "square" => Square
+    | "sawtooth" => Sawtooth
+    | "triangle" => Triangle
+    | "custom" => Custom
+    | _ => Sine
+    }
+  }
+
+  @send external _make: Context.t => t = "createOscillator"
+  @get external frequencyParam: t => Param.t = "frequency"
+  @get external detuneParam: t => Param.t = "detune"
+  @get external _getType: t => string = "type"
+  @set external _setType: (t, string) => unit = "type"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let osc = _make(ctx)
+    switch options {
+    | Some(opts) => {
+        opts.waveform->Option.forEach(w => _setType(osc, waveformToString(w)))
+        opts.frequency->Option.forEach(f => Param.setValue(frequencyParam(osc), f))
+        opts.detune->Option.forEach(d => Param.setValue(detuneParam(osc), d))
+      }
+    | None => ()
+    }
+    osc
+  }
+
+  let waveform = (osc: t): waveform => waveformFromString(_getType(osc))
+
+  let setWaveform = (osc: t, w: waveform): unit => _setType(osc, waveformToString(w))
+
+  @send external start: t => unit = "start"
+  @send external startAt: (t, float) => unit = "start"
+  @send external stop: t => unit = "stop"
+  @send external stopAt: (t, float) => unit = "stop"
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module BiquadFilter = {
+  type t
+
+  type filterType =
+    | Lowpass
+    | Highpass
+    | Bandpass
+    | Lowshelf
+    | Highshelf
+    | Peaking
+    | Notch
+    | Allpass
+
+  let filterTypeToString = (ft: filterType): string => {
+    switch ft {
+    | Lowpass => "lowpass"
+    | Highpass => "highpass"
+    | Bandpass => "bandpass"
+    | Lowshelf => "lowshelf"
+    | Highshelf => "highshelf"
+    | Peaking => "peaking"
+    | Notch => "notch"
+    | Allpass => "allpass"
+    }
+  }
+
+  let filterTypeFromString = (s: string): filterType => {
+    switch s {
+    | "lowpass" => Lowpass
+    | "highpass" => Highpass
+    | "bandpass" => Bandpass
+    | "lowshelf" => Lowshelf
+    | "highshelf" => Highshelf
+    | "peaking" => Peaking
+    | "notch" => Notch
+    | "allpass" => Allpass
+    | _ => Lowpass
+    }
+  }
+
+  type options = {
+    filterType?: filterType,
+    frequency?: float,
+    detune?: float,
+    q?: float,
+    gain?: float,
+  }
+
+  @send external _make: Context.t => t = "createBiquadFilter"
+  @get external frequencyParam: t => Param.t = "frequency"
+  @get external detuneParam: t => Param.t = "detune"
+  @get external qParam: t => Param.t = "Q"
+  @get external gainParam: t => Param.t = "gain"
+  @get external _getType: t => string = "type"
+  @set external _setType: (t, string) => unit = "type"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let filter = _make(ctx)
+    switch options {
+    | Some(opts) => {
+        opts.filterType->Option.forEach(ft => _setType(filter, filterTypeToString(ft)))
+        opts.frequency->Option.forEach(f => Param.setValue(frequencyParam(filter), f))
+        opts.detune->Option.forEach(d => Param.setValue(detuneParam(filter), d))
+        opts.q->Option.forEach(qVal => Param.setValue(qParam(filter), qVal))
+        opts.gain->Option.forEach(g => Param.setValue(gainParam(filter), g))
+      }
+    | None => ()
+    }
+    filter
+  }
+
+  let filterType = (filter: t): filterType => filterTypeFromString(_getType(filter))
+  let setFilterType = (filter: t, ft: filterType): unit => _setType(filter, filterTypeToString(ft))
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module Delay = {
+  type t
+
+  type options = {
+    maxDelayTime?: float,
+    delayTime?: float,
+  }
+
+  @send external _make: (Context.t, ~maxDelayTime: float=?) => t = "createDelay"
+  @get external delayTimeParam: t => Param.t = "delayTime"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let maxDelay = options->Option.flatMap(o => o.maxDelayTime)
+    let delay = _make(ctx, ~maxDelayTime=?maxDelay)
+    switch options {
+    | Some(opts) =>
+      opts.delayTime->Option.forEach(dt => Param.setValue(delayTimeParam(delay), dt))
+    | None => ()
+    }
+    delay
+  }
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module Compressor = {
+  type t
+
+  type options = {
+    threshold?: float,
+    knee?: float,
+    ratio?: float,
+    attack?: float,
+    release?: float,
+  }
+
+  @send external _make: Context.t => t = "createDynamicsCompressor"
+  @get external thresholdParam: t => Param.t = "threshold"
+  @get external kneeParam: t => Param.t = "knee"
+  @get external ratioParam: t => Param.t = "ratio"
+  @get external reductionDb: t => float = "reduction"
+  @get external attackParam: t => Param.t = "attack"
+  @get external releaseParam: t => Param.t = "release"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let comp = _make(ctx)
+    switch options {
+    | Some(opts) => {
+        opts.threshold->Option.forEach(t => Param.setValue(thresholdParam(comp), t))
+        opts.knee->Option.forEach(k => Param.setValue(kneeParam(comp), k))
+        opts.ratio->Option.forEach(r => Param.setValue(ratioParam(comp), r))
+        opts.attack->Option.forEach(a => Param.setValue(attackParam(comp), a))
+        opts.release->Option.forEach(rel => Param.setValue(releaseParam(comp), rel))
+      }
+    | None => ()
+    }
+    comp
+  }
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module StereoPanner = {
+  type t
+
+  type options = {pan?: float}
+
+  @send external _make: Context.t => t = "createStereoPanner"
+  @get external panParam: t => Param.t = "pan"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let panner = _make(ctx)
+    switch options {
+    | Some(opts) => opts.pan->Option.forEach(p => Param.setValue(panParam(panner), p))
+    | None => ()
+    }
+    panner
+  }
+
+  external asNode: t => Node.t = "%identity"
+}
+
+module Analyser = {
+  type t
+
+  type options = {
+    fftSize?: int,
+    minDecibels?: float,
+    maxDecibels?: float,
+    smoothingTimeConstant?: float,
+  }
+
+  @send external _make: Context.t => t = "createAnalyser"
+  @get external fftSize: t => int = "fftSize"
+  @set external setFftSize: (t, int) => unit = "fftSize"
+  @get external frequencyBinCount: t => int = "frequencyBinCount"
+  @get external minDecibels: t => float = "minDecibels"
+  @set external setMinDecibels: (t, float) => unit = "minDecibels"
+  @get external maxDecibels: t => float = "maxDecibels"
+  @set external setMaxDecibels: (t, float) => unit = "maxDecibels"
+  @get external smoothingTimeConstant: t => float = "smoothingTimeConstant"
+  @set external setSmoothingTimeConstant: (t, float) => unit = "smoothingTimeConstant"
+
+  let make = (ctx: Context.t, ~options: option<options>=?): t => {
+    let analyser = _make(ctx)
+    switch options {
+    | Some(opts) => {
+        opts.fftSize->Option.forEach(size => setFftSize(analyser, size))
+        opts.minDecibels->Option.forEach(min => setMinDecibels(analyser, min))
+        opts.maxDecibels->Option.forEach(max => setMaxDecibels(analyser, max))
+        opts.smoothingTimeConstant->Option.forEach(s => setSmoothingTimeConstant(analyser, s))
+      }
+    | None => ()
+    }
+    analyser
+  }
+
+  @send external getFloatFrequencyData: (t, Float32Array.t) => unit = "getFloatFrequencyData"
+  @send external getByteFrequencyData: (t, Uint8Array.t) => unit = "getByteFrequencyData"
+  @send external getFloatTimeDomainData: (t, Float32Array.t) => unit = "getFloatTimeDomainData"
+  @send external getByteTimeDomainData: (t, Uint8Array.t) => unit = "getByteTimeDomainData"
+
+  external asNode: t => Node.t = "%identity"
+}
+
+// Context extensions for getting destination and creating nodes
+module ContextExt = {
+  @get external destination: Context.t => Destination.t = "destination"
+}
+
+// Utility functions for common patterns
+module Utils = {
+  // Connect a chain of nodes
+  let chain = (nodes: array<Node.t>): unit => {
+    for i in 0 to Array.length(nodes) - 2 {
+      let _ = Node.connect(nodes[i]->Option.getOrThrow, nodes[i + 1]->Option.getOrThrow)
+    }
+  }
+
+  // Connect a node to the destination
+  let toDestination = (ctx: Context.t, node: Node.t): unit => {
+    let _ = Node.connect(node, ContextExt.destination(ctx)->Destination.asNode)
+  }
+}