@aethervtt/shard-platform-web 0.0.1 → 0.2.0

package/dist/audio-cache.d.ts

@@ -0,0 +1,44 @@
+import type { AudioClipSource, AudioPreparation } from '@aethervtt/shard-platform';
+export interface PreparedAudio {
+    buffer: AudioBuffer | null;
+    peak: number;
+    url: string | null;
+}
+/** Owned decode cache. Both preparation leases and physical voices pin entries. */
+export declare class AudioCache {
+    private readonly entries;
+    private readonly byteKeys;
+    private readonly queue;
+    private running;
+    private stamp;
+    private closed;
+    readonly context: BaseAudioContext;
+    readonly budgetBytes: number;
+    readonly maxDecodes: number;
+    constructor(context: BaseAudioContext, budgetBytes?: number, maxDecodes?: number);
+    private slot;
+    private done;
+    private load;
+    private key;
+    /** Already prepared sources can be scheduled synchronously as one reserved group. */
+    acquireReady(clip: AudioClipSource): (AudioPreparation & {
+        value: PreparedAudio;
+    }) | null;
+    acquire(clip: AudioClipSource): Promise<AudioPreparation & {
+        value: PreparedAudio;
+    }>;
+    private lease;
+    private remove;
+    private evict;
+    collect(): void;
+    dispose(): void;
+    memory(): {
+        decodedBytes: number;
+        encodedBytes: number;
+        pinned: number;
+        evictable: number;
+        urls: number;
+        budgetBytes: number;
+        loading: number;
+    };
+}

package/dist/audio-cache.js

@@ -0,0 +1,215 @@
+import { ShardError } from "@aethervtt/shard-core";
+class AudioCache {
+  entries = /* @__PURE__ */ new Map();
+  byteKeys = /* @__PURE__ */ new WeakMap();
+  queue = [];
+  running = 0;
+  stamp = 0;
+  closed = false;
+  context;
+  budgetBytes;
+  maxDecodes;
+  constructor(context, budgetBytes = 64 * 1024 * 1024, maxDecodes = 4) {
+    if (!Number.isInteger(maxDecodes) || maxDecodes < 1 || !Number.isFinite(budgetBytes) || budgetBytes <= 0)
+      throw new ShardError(
+        "audio/invalid-range",
+        "Decode concurrency and memory budget must be positive"
+      );
+    this.context = context;
+    this.budgetBytes = budgetBytes;
+    this.maxDecodes = maxDecodes;
+  }
+  async slot() {
+    if (this.running < this.maxDecodes) {
+      this.running++;
+      return;
+    }
+    if (this.queue.length >= 2048)
+      throw new ShardError("audio/capacity", "Audio decode queue is full");
+    await new Promise((resolve) => this.queue.push(resolve));
+  }
+  done() {
+    const next = this.queue.shift();
+    if (next) next();
+    else this.running--;
+  }
+  async load(entry) {
+    await this.slot();
+    try {
+      if (this.closed) throw new ShardError("audio/prepare-failed", "The audio host was disposed");
+      const clip = entry.clip;
+      if (clip.stream) {
+        if (clip.url) return { buffer: null, peak: 1, url: clip.url };
+        entry.url = URL.createObjectURL(new Blob([clip.bytes.slice().buffer]));
+        return { buffer: null, peak: 1, url: entry.url };
+      }
+      const buffer = await this.context.decodeAudioData(clip.bytes.slice().buffer);
+      const bytes = buffer.length * buffer.numberOfChannels * 4;
+      if (this.memory().decodedBytes - entry.bytes + bytes > this.budgetBytes) {
+        throw new ShardError(
+          "audio/memory-budget",
+          "Decoded samples exceed the audio memory budget",
+          {
+            hint: "Release unused collections, shorten clips, or increase decodedBudgetMiB."
+          }
+        );
+      }
+      entry.bytes = bytes;
+      let peak = 0;
+      for (let c = 0; c < buffer.numberOfChannels; c++) {
+        const samples = buffer.getChannelData(c);
+        for (let i = 0; i < samples.length; i++) peak = Math.max(peak, Math.abs(samples[i]));
+      }
+      return { buffer, peak, url: null };
+    } catch (cause) {
+      if (cause instanceof ShardError) throw cause;
+      throw new ShardError("audio/decode-failed", `Cannot decode ${entry.clip.id}`, {
+        cause,
+        hint: "Check the source file and codec support on this host. Try PCM WAV."
+      });
+    } finally {
+      this.done();
+    }
+  }
+  key(clip) {
+    let key;
+    if (clip.url) key = `${clip.stream ? "media" : "decoded"}:${clip.url}`;
+    else {
+      let keys = this.byteKeys.get(clip.bytes);
+      if (!keys) {
+        keys = { decoded: {}, media: {} };
+        this.byteKeys.set(clip.bytes, keys);
+      }
+      key = clip.stream ? keys.media : keys.decoded;
+    }
+    return key;
+  }
+  /** Already prepared sources can be scheduled synchronously as one reserved group. */
+  acquireReady(clip) {
+    if (this.closed) return null;
+    const key = this.key(clip), entry = this.entries.get(key);
+    if (!entry?.value) return null;
+    entry.refs++;
+    entry.touched = this.stamp++;
+    return this.lease(clip, key, entry, entry.value);
+  }
+  async acquire(clip) {
+    if (this.closed) throw new ShardError("audio/prepare-failed", "The audio host was disposed");
+    const key = this.key(clip);
+    let entry = this.entries.get(key);
+    if (!entry) {
+      const bytes = clip.stream ? 0 : Math.ceil(clip.duration * this.context.sampleRate) * (clip.channels ?? 2) * 4;
+      this.evict(bytes);
+      if (this.memory().decodedBytes + bytes > this.budgetBytes) {
+        throw new ShardError(
+          "audio/memory-budget",
+          `Cannot prepare ${clip.id}: pinned audio fills the budget`,
+          {
+            hint: "Release preparation leases or increase the decoded audio budget."
+          }
+        );
+      }
+      entry = {
+        clip,
+        refs: 0,
+        bytes,
+        touched: this.stamp++,
+        url: null,
+        value: null,
+        promise: Promise.resolve({ buffer: null, peak: 1, url: null })
+      };
+      this.entries.set(key, entry);
+      const pending = entry;
+      entry.promise = this.load(entry).then((value2) => {
+        pending.value = value2;
+        return value2;
+      });
+    }
+    const owned = entry;
+    owned.refs++;
+    owned.touched = this.stamp++;
+    let value;
+    try {
+      value = await owned.promise;
+    } catch (error) {
+      owned.refs--;
+      if (owned.refs === 0) this.remove(key, owned);
+      throw error;
+    }
+    if (this.closed) {
+      owned.refs--;
+      this.remove(key, owned);
+      throw new ShardError("audio/prepare-failed", "Audio preparation was cancelled by disposal");
+    }
+    return this.lease(clip, key, owned, value);
+  }
+  lease(clip, key, owned, value) {
+    let released = false;
+    return {
+      clip,
+      value,
+      decodedBytes: owned.bytes,
+      encodedBytes: clip.bytes.byteLength,
+      sampleRate: value.buffer?.sampleRate ?? this.context.sampleRate,
+      samples: value.buffer?.length ?? 0,
+      channels: value.buffer?.numberOfChannels ?? clip.channels ?? 0,
+      get released() {
+        return released;
+      },
+      release: () => {
+        if (released) return;
+        released = true;
+        owned.refs--;
+        owned.touched = this.stamp++;
+        if (owned.refs === 0 && (clip.stream || this.closed)) this.remove(key, owned);
+      }
+    };
+  }
+  remove(key, entry) {
+    if (entry.url) {
+      URL.revokeObjectURL(entry.url);
+      entry.url = null;
+    }
+    if (this.entries.get(key) === entry) this.entries.delete(key);
+  }
+  evict(required) {
+    const unused = [...this.entries].filter(([, entry]) => entry.refs === 0).sort((a, b) => a[1].touched - b[1].touched);
+    for (const [key, entry] of unused) {
+      if (this.memory().decodedBytes + required <= this.budgetBytes) break;
+      this.remove(key, entry);
+    }
+  }
+  collect() {
+    for (const [key, entry] of this.entries) if (!entry.refs) this.remove(key, entry);
+  }
+  dispose() {
+    this.closed = true;
+    this.collect();
+  }
+  memory() {
+    let decodedBytes = 0;
+    let encodedBytes = 0;
+    let pinned = 0;
+    let evictable = 0;
+    let urls = 0;
+    for (const entry of this.entries.values()) {
+      decodedBytes += entry.bytes;
+      encodedBytes += entry.clip.bytes.byteLength;
+      if (entry.refs) pinned++;
+      else evictable++;
+      if (entry.url) urls++;
+    }
+    return {
+      decodedBytes,
+      encodedBytes,
+      pinned,
+      evictable,
+      urls,
+      budgetBytes: this.budgetBytes,
+      loading: this.running + this.queue.length
+    };
+  }
+}
+export {
+  AudioCache
+};

package/dist/audio-compat.d.ts

@@ -0,0 +1,4 @@
+/** Firefox exposes legacy listener methods instead of AudioParam listener coordinates. */
+export declare function setListenerPose(listener: AudioListener, matrix: ArrayLike<number>): void;
+/** At current time .value is the rendered value; future automation supplies its tracked value. */
+export declare function holdAudioParam(param: AudioParam, at: number, value?: number): void;

package/dist/audio-compat.js

@@ -0,0 +1,34 @@
+function setListenerPose(listener, matrix) {
+  if (listener.positionX) {
+    listener.positionX.value = matrix[3];
+    listener.positionY.value = matrix[7];
+    listener.positionZ.value = matrix[11];
+    listener.forwardX.value = -matrix[2];
+    listener.forwardY.value = -matrix[6];
+    listener.forwardZ.value = -matrix[10];
+    listener.upX.value = matrix[1];
+    listener.upY.value = matrix[5];
+    listener.upZ.value = matrix[9];
+  } else {
+    listener.setPosition(matrix[3], matrix[7], matrix[11]);
+    listener.setOrientation(
+      -matrix[2],
+      -matrix[6],
+      -matrix[10],
+      matrix[1],
+      matrix[5],
+      matrix[9]
+    );
+  }
+}
+function holdAudioParam(param, at, value = param.value) {
+  if (typeof param.cancelAndHoldAtTime === "function") param.cancelAndHoldAtTime(at);
+  else {
+    param.cancelScheduledValues(at);
+    param.setValueAtTime(value, at);
+  }
+}
+export {
+  holdAudioParam,
+  setListenerPose
+};

package/dist/audio-graph.d.ts

@@ -0,0 +1,35 @@
+import type { AudioMixerGraph, AudioPreparation } from '@aethervtt/shard-platform';
+import type { AudioCache } from './audio-cache.js';
+/** A compiled Web Audio graph. No DOM or nodes escape the platform boundary. */
+export declare class WebAudioGraph {
+    readonly inputs: Map<string, GainNode>;
+    readonly outputs: Map<string, GainNode>;
+    readonly sendInputs: Map<string, Map<string, GainNode>>;
+    readonly nodes: AudioNode[];
+    readonly leases: AudioPreparation[];
+    private readonly values;
+    private readonly gates;
+    private readonly userGains;
+    private readonly ancestry;
+    private readonly buses;
+    readonly context: BaseAudioContext;
+    readonly output: GainNode;
+    readonly maxNodes: number;
+    tailSeconds: number;
+    generatedBytes: number;
+    private readonly delays;
+    hasBus(id: string): boolean;
+    private buffer;
+    private writeDelay;
+    /** Coalesce rapid delay edits, then crossfade finite kernels at an audio-clock boundary. */
+    tick(): void;
+    private constructor();
+    private own;
+    private bind;
+    private effect;
+    private chain;
+    static build(context: BaseAudioContext, graph: AudioMixerGraph, output: GainNode, cache: Pick<AudioCache, 'acquire'>): Promise<WebAudioGraph>;
+    private refreshGates;
+    set(bus: string, field: string, value: number, seconds: number): void;
+    dispose(): void;
+}

package/dist/audio-graph.js

@@ -0,0 +1,365 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { holdAudioParam } from "./audio-compat.js";
+function ramp(param, value, at, seconds) {
+  holdAudioParam(param, at);
+  if (seconds > 0) param.linearRampToValueAtTime(value, at + seconds);
+  else param.setValueAtTime(value, at);
+}
+class WebAudioGraph {
+  inputs = /* @__PURE__ */ new Map();
+  outputs = /* @__PURE__ */ new Map();
+  sendInputs = /* @__PURE__ */ new Map();
+  nodes = [];
+  leases = [];
+  values = /* @__PURE__ */ new Map();
+  gates = /* @__PURE__ */ new Map();
+  userGains = /* @__PURE__ */ new Map();
+  ancestry = /* @__PURE__ */ new Map();
+  buses = /* @__PURE__ */ new Map();
+  context;
+  output;
+  maxNodes;
+  tailSeconds = 0;
+  generatedBytes = 0;
+  delays = [];
+  hasBus(id) {
+    return this.buses.has(id);
+  }
+  buffer(channels, frames) {
+    const bytes = channels * frames * 4;
+    if (this.generatedBytes + bytes > 64 * 1024 * 1024)
+      throw new ShardError("audio/memory-budget", "Finite effect kernels exceed 64 MiB");
+    this.generatedBytes += bytes;
+    return this.context.createBuffer(channels, frames, this.context.sampleRate);
+  }
+  writeDelay(delay, slot) {
+    const buffer = delay.buffers[slot], data = buffer.getChannelData(0);
+    data.fill(0);
+    const period = delay.seconds * buffer.sampleRate;
+    if (period < 1) data[0] = 1 / (1 - delay.feedback);
+    else {
+      let gain = 1;
+      for (let position = period; position < data.length; position += period) {
+        const frame = Math.floor(position), fraction = position - frame;
+        data[frame] = data[frame] + gain * (1 - fraction);
+        if (frame + 1 < data.length) data[frame + 1] = data[frame + 1] + gain * fraction;
+        gain *= delay.feedback;
+      }
+    }
+    delay.nodes[slot].buffer = buffer;
+  }
+  /** Coalesce rapid delay edits, then crossfade finite kernels at an audio-clock boundary. */
+  tick() {
+    const at = this.context.currentTime;
+    for (let i = 0; i < this.delays.length; i++) {
+      const delay = this.delays[i];
+      if (!delay.dirty || at < delay.next) continue;
+      const next = 1 - delay.active;
+      this.writeDelay(delay, next);
+      ramp(delay.gains[delay.active].gain, 0, at, 0.02);
+      ramp(delay.gains[next].gain, 1, at, 0.02);
+      delay.active = next;
+      delay.next = at + 0.02;
+      delay.dirty = false;
+    }
+  }
+  constructor(context, graph, output) {
+    this.context = context;
+    this.output = output;
+    this.maxNodes = graph.maxNodes;
+    for (const bus of graph.buses) {
+      this.buses.set(bus.id, bus);
+      this.userGains.set(bus.id, bus.userGain);
+    }
+  }
+  own(node) {
+    this.nodes.push(node);
+    if (this.nodes.length > this.maxNodes)
+      throw new ShardError("audio/mixer-capacity", "Partitioned mixer exceeds its node budget", {
+        hint: "Reduce sends/effects or increase maxNodes; independent user categories require independent effect state."
+      });
+    return node;
+  }
+  bind(key, param) {
+    const list = this.values.get(key);
+    if (list) list.push(param);
+    else this.values.set(key, [param]);
+  }
+  async effect(bus, effect, cache) {
+    const ctx = this.context;
+    const key = `${bus}/${effect.id}/`;
+    switch (effect.kind) {
+      case "lowpass":
+      case "highpass":
+      case "peaking": {
+        const node = this.own(ctx.createBiquadFilter());
+        node.type = effect.kind;
+        node.frequency.value = Math.min(ctx.sampleRate / 2, effect.frequency);
+        node.Q.value = effect.q;
+        node.gain.value = effect.gainDb;
+        this.bind(`${key}frequency`, node.frequency);
+        this.bind(`${key}q`, node.Q);
+        this.bind(`${key}gainDb`, node.gain);
+        return { input: node, output: node };
+      }
+      case "compressor": {
+        const node = this.own(ctx.createDynamicsCompressor());
+        node.threshold.value = effect.threshold;
+        node.ratio.value = effect.ratio;
+        node.attack.value = effect.attack;
+        node.release.value = effect.release;
+        this.bind(`${key}threshold`, node.threshold);
+        this.bind(`${key}ratio`, node.ratio);
+        this.bind(`${key}attack`, node.attack);
+        this.bind(`${key}release`, node.release);
+        return { input: node, output: node };
+      }
+      case "delay": {
+        const input = this.own(ctx.createGain()), output = this.own(ctx.createGain());
+        const delay = {
+          key,
+          seconds: effect.seconds,
+          feedback: effect.feedback,
+          tail: effect.tailSeconds,
+          nodes: [],
+          gains: [],
+          buffers: [],
+          active: 0,
+          next: 0,
+          dirty: false
+        };
+        for (let i = 0; i < 2; i++) {
+          const node = this.own(ctx.createConvolver()), gain = this.own(ctx.createGain());
+          node.normalize = false;
+          gain.gain.value = i === 0 ? 1 : 0;
+          input.connect(node).connect(gain).connect(output);
+          delay.nodes.push(node);
+          delay.gains.push(gain);
+          delay.buffers.push(
+            this.buffer(1, Math.max(1, Math.ceil(effect.tailSeconds * ctx.sampleRate)))
+          );
+          this.writeDelay(delay, i);
+        }
+        this.delays.push(delay);
+        return { input, output };
+      }
+      case "reverb": {
+        if (!effect.ir || effect.ir.stream)
+          throw new ShardError("audio/invalid-effect", "Reverb requires a decoded impulse response");
+        const lease = await cache.acquire(effect.ir);
+        this.leases.push(lease);
+        if (!lease.value.buffer || ![1, 2, 4].includes(lease.channels)) {
+          throw new ShardError("audio/invalid-effect", "Impulse responses need 1, 2 or 4 channels");
+        }
+        const node = this.own(ctx.createConvolver());
+        node.normalize = false;
+        const original = lease.value.buffer;
+        const frames = Math.min(original.length, Math.ceil(effect.tailSeconds * ctx.sampleRate));
+        if (frames === original.length) node.buffer = original;
+        else {
+          const trimmed = this.buffer(original.numberOfChannels, frames);
+          const fade = Math.min(frames, Math.ceil(ctx.sampleRate * 5e-3));
+          for (let channel = 0; channel < original.numberOfChannels; channel++) {
+            const data = trimmed.getChannelData(channel);
+            data.set(original.getChannelData(channel).subarray(0, frames));
+            for (let i = frames - fade; i < frames; i++)
+              data[i] = data[i] * (frames - 1 - i) / fade;
+          }
+          node.buffer = trimmed;
+        }
+        return { input: node, output: node };
+      }
+    }
+  }
+  async chain(bus, cache) {
+    const input = this.own(this.context.createGain());
+    let tail = input;
+    for (const effect of bus.effects) {
+      const insert = await this.effect(bus.id, effect, cache);
+      tail.connect(insert.input);
+      tail = insert.output;
+    }
+    const fader = this.own(this.context.createGain());
+    fader.gain.value = bus.gain;
+    tail.connect(fader);
+    this.bind(`${bus.id}/gain`, fader.gain);
+    return { input, pre: tail, post: fader };
+  }
+  static async build(context, graph, output, cache) {
+    const result = new WebAudioGraph(context, graph, output);
+    try {
+      const master = result.buses.get("master");
+      if (!master) throw new ShardError("audio/invalid-effect", "Mixer needs a master bus");
+      const root = await result.chain(master, cache);
+      const masterUser = result.own(context.createGain());
+      masterUser.gain.value = master.userGain;
+      root.post.connect(masterUser).connect(output);
+      result.bind("master/userGain", masterUser.gain);
+      const masterInput = result.own(context.createGain());
+      masterInput.connect(root.input);
+      result.inputs.set("master", masterInput);
+      result.outputs.set("master", masterUser);
+      if (master.sends.length || master.effects.some((e) => e.kind === "delay" || e.kind === "reverb")) {
+        throw new ShardError(
+          "audio/invalid-effect",
+          "Master cannot own sends or stateful wet effects; put these inside a user-control domain"
+        );
+      }
+      const ordinary = /* @__PURE__ */ new Map();
+      for (const bus of graph.buses) {
+        if (bus.return || bus.id === "master") continue;
+        const chain = await result.chain(bus, cache);
+        ordinary.set(bus.id, chain);
+        const input = result.own(context.createGain());
+        input.connect(chain.input);
+        result.inputs.set(bus.id, input);
+        result.outputs.set(bus.id, chain.post);
+      }
+      const returns = /* @__PURE__ */ new Map();
+      const visiting = /* @__PURE__ */ new Set();
+      const routeReturn = async (id, domain) => {
+        if (id === "master") return result.gates.get(domain);
+        const key = `${domain}/${id}`;
+        if (visiting.has(key)) throw new ShardError("audio/mixer-cycle", `Return cycle at ${id}`);
+        const existing = returns.get(key);
+        if (existing) return existing.input;
+        const bus = result.buses.get(id);
+        if (!bus?.return)
+          throw new ShardError("audio/unknown-bus", `Send destination ${id} must be a return`);
+        visiting.add(key);
+        const nodes = await result.chain(bus, cache);
+        returns.set(key, nodes);
+        let meter = result.outputs.get(id);
+        if (!meter) {
+          meter = result.own(context.createGain());
+          result.outputs.set(id, meter);
+        }
+        const returnUser = result.own(context.createGain());
+        returnUser.gain.value = bus.userGain;
+        result.bind(`${bus.id}/userGain`, returnUser.gain);
+        nodes.post.connect(returnUser).connect(meter);
+        returnUser.connect(await routeReturn(bus.parent, domain));
+        for (const send of bus.sends) {
+          const gain = result.own(context.createGain());
+          gain.gain.value = send.gain;
+          (send.pre ? nodes.pre : nodes.post).connect(gain).connect(await routeReturn(send.target, domain));
+          result.bind(`${id}/send/${send.target}`, gain.gain);
+        }
+        visiting.delete(key);
+        return nodes.input;
+      };
+      for (const bus of graph.buses) {
+        if (bus.return || bus.id === "master") continue;
+        const path = [];
+        let parent = bus.id;
+        while (parent !== "master") {
+          if (path.includes(parent))
+            throw new ShardError("audio/mixer-cycle", `Parent cycle at ${parent}`);
+          path.push(parent);
+          const ancestor = result.buses.get(parent);
+          if (!ancestor || ancestor.return || !ancestor.parent)
+            throw new ShardError("audio/unknown-bus", `Invalid parent ${parent}`);
+          parent = ancestor.parent;
+        }
+        const domain = path[path.length - 1];
+        if (!result.gates.has(domain)) {
+          const gate = result.own(context.createGain());
+          gate.connect(root.input);
+          result.gates.set(domain, gate);
+          result.ancestry.set(domain, [domain]);
+        }
+        const nodes = ordinary.get(bus.id);
+        if (bus.id === domain) nodes.post.connect(result.gates.get(domain));
+        else {
+          const user = result.own(context.createGain());
+          user.gain.value = bus.userGain;
+          result.bind(`${bus.id}/userGain`, user.gain);
+          nodes.post.connect(user).connect(ordinary.get(bus.parent).input);
+        }
+        const voiceRoutes = /* @__PURE__ */ new Map();
+        result.sendInputs.set(bus.id, voiceRoutes);
+        for (const send of bus.sends) {
+          const destination = await routeReturn(send.target, domain);
+          const input = result.own(context.createGain());
+          input.connect(destination);
+          voiceRoutes.set(send.target, input);
+          const gain = result.own(context.createGain());
+          gain.gain.value = send.gain;
+          (send.pre ? nodes.pre : nodes.post).connect(gain).connect(destination);
+          result.bind(`${bus.id}/send/${send.target}`, gain.gain);
+        }
+      }
+      const tails = /* @__PURE__ */ new Map(), tailVisiting = /* @__PURE__ */ new Set();
+      const pathTail = (id) => {
+        if (tails.has(id)) return tails.get(id);
+        if (tailVisiting.has(id))
+          throw new ShardError("audio/mixer-cycle", `Tail path cycle at ${id}`);
+        tailVisiting.add(id);
+        const bus = result.buses.get(id);
+        let own = 0, next = bus.parent ? pathTail(bus.parent) : 0;
+        for (const effect of bus.effects)
+          if (effect.kind === "delay" || effect.kind === "reverb") own += effect.tailSeconds;
+        for (const send of bus.sends) next = Math.max(next, pathTail(send.target));
+        tailVisiting.delete(id);
+        tails.set(id, own + next);
+        return own + next;
+      };
+      for (const bus of graph.buses)
+        result.tailSeconds = Math.max(result.tailSeconds, pathTail(bus.id));
+      result.refreshGates();
+      return result;
+    } catch (error) {
+      result.dispose();
+      throw error;
+    }
+  }
+  refreshGates(seconds = 0) {
+    for (const [origin, gate] of this.gates) {
+      let gain = 1;
+      for (const bus of this.ancestry.get(origin)) gain *= this.userGains.get(bus) ?? 1;
+      ramp(gate.gain, gain, this.context.currentTime, seconds);
+    }
+  }
+  set(bus, field, value, seconds) {
+    if (field === "userGain" && this.gates.has(bus)) {
+      this.userGains.set(bus, value);
+      this.refreshGates(seconds);
+      return;
+    }
+    const key = `${bus}/${field}`;
+    let matched = false;
+    for (const delay of this.delays) {
+      if (key === `${delay.key}seconds`) {
+        if (delay.seconds !== value) {
+          delay.seconds = value;
+          delay.dirty = true;
+        }
+        matched = true;
+      } else if (key === `${delay.key}feedback`) {
+        if (delay.feedback !== value) {
+          delay.feedback = value;
+          delay.dirty = true;
+        }
+        matched = true;
+      }
+    }
+    if (matched) {
+      this.tick();
+      return;
+    }
+    const params = this.values.get(key);
+    if (!params) throw new ShardError("audio/invalid-effect", `No mixer target ${bus}/${field}`);
+    for (const param of params) ramp(param, value, this.context.currentTime, seconds);
+  }
+  dispose() {
+    for (const node of this.nodes) node.disconnect();
+    for (const lease of this.leases) lease.release();
+    this.nodes.length = 0;
+    this.leases.length = 0;
+    this.delays.length = 0;
+    this.generatedBytes = 0;
+  }
+}
+export {
+  WebAudioGraph
+};