@vgai/engine 0.2.0 → 0.3.0

package/src/animation/property-track.ts

@@ -1,178 +0,0 @@
-/**
- * F5 — Declarative property tracks (deterministic timeline).
- * docs/VSCN-STRUCTURAL-GAPS-DESIGN.md
- *
- * A property track is DATA: a pure function of time (keyframes + named
- * easing), never behavior. `samplePropertyTrack` is the pure sampler (time →
- * value) the unit test asserts determinism against directly.
- * `PropertyTrackRunner` is a thin stateful shell that accumulates elapsed
- * time from the fixed-step `dt` already threaded through the scene tick (the
- * SAME `dt` the AnimationMixers get — see scene-loader.ts's `tickFns`) and
- * writes the sampled value onto the target Object3D property each frame. It
- * introduces NO new clock: a paused frame passes `dt = 0`, and time simply
- * does not advance — pause/timeScale are honored for free.
- *
- * Anything state-dependent ("move WHEN the player steps on it") stays a
- * GameComponent, which may start/stop/seek a track. This module only adds the
- * time→value data + a deterministic evaluator (G1 — data, not behavior).
- */
-import type * as THREE from 'three';
-import { log } from '../dev/logger';
-import type { PropertyTrack, PropertyTrackKeyframe } from '../scene/schema/animation';
-import type { UIEasing } from '../scene/schema/ui';
-
-// ---------------------------------------------------------------------------
-// Easing — mirrors packages/scene-ui/src/animation.ts's `ease` (same enum,
-// same semantics). NOT imported from there: scene-ui depends on the engine,
-// so importing it back here would be circular. A ~10-line parallel
-// implementation over the shared UIEasingSchema enum is the correct fix.
-// ---------------------------------------------------------------------------
-
-function ease(t: number, kind: UIEasing | undefined): number {
-  const x = Math.max(0, Math.min(1, t));
-  switch (kind) {
-    case 'ease-in':
-      return x * x;
-    case 'ease-out':
-      return 1 - (1 - x) * (1 - x);
-    case 'ease-in-out':
-      return x < 0.5 ? 2 * x * x : 1 - (-2 * x + 2) ** 2 / 2;
-    case 'step':
-      return x < 1 ? 0 : 1; // hold the previous value until the next keyframe
-    default:
-      return x; // linear
-  }
-}
-
-/**
- * Sample a track at `time` seconds from track start. `time` is assumed
- * already wrapped/clamped by the caller (see {@link PropertyTrackRunner});
- * this function is a pure, side-effect-free keyframe interpolation and is
- * safe to call directly from tests.
- */
-export function samplePropertyTrack(track: PropertyTrack, time: number): number {
-  const kfs = track.keyframes;
-  if (kfs.length === 0) return 0;
-  const first = kfs[0] as PropertyTrackKeyframe;
-  if (time <= first.time) return first.value;
-  const last = kfs[kfs.length - 1] as PropertyTrackKeyframe;
-  if (time >= last.time) return last.value;
-  for (let i = 0; i < kfs.length - 1; i++) {
-    const k0 = kfs[i] as PropertyTrackKeyframe;
-    const k1 = kfs[i + 1] as PropertyTrackKeyframe;
-    if (time >= k0.time && time <= k1.time) {
-      const span = k1.time - k0.time || 1;
-      const raw = (time - k0.time) / span;
-      const t = ease(raw, k0.easing);
-      return k0.value + (k1.value - k0.value) * t;
-    }
-  }
-  return last.value;
-}
-
-/** Wrap/clamp elapsed time against a track's `duration`/`loop`. */
-function resolveTrackTime(track: PropertyTrack, elapsed: number): number {
-  if (track.duration <= 0) return elapsed;
-  if (track.loop) return elapsed % track.duration;
-  return Math.min(elapsed, track.duration);
-}
-
-type TargetSetter = (object3D: THREE.Object3D, value: number, warnOnce: () => void) => void;
-
-// Allowlisted target → setter. Keys are exactly PropertyTrackTargetSchema's
-// enum values — the allowlist IS the schema; no arbitrary path resolution.
-const TARGET_SETTERS: Record<string, TargetSetter> = {
-  'position.x': (o, v) => {
-    o.position.x = v;
-  },
-  'position.y': (o, v) => {
-    o.position.y = v;
-  },
-  'position.z': (o, v) => {
-    o.position.z = v;
-  },
-  'rotation.x': (o, v) => {
-    o.rotation.x = v;
-  },
-  'rotation.y': (o, v) => {
-    o.rotation.y = v;
-  },
-  'rotation.z': (o, v) => {
-    o.rotation.z = v;
-  },
-  'scale.x': (o, v) => {
-    o.scale.x = v;
-  },
-  'scale.y': (o, v) => {
-    o.scale.y = v;
-  },
-  'scale.z': (o, v) => {
-    o.scale.z = v;
-  },
-  'material.opacity': (o, v, warnOnce) => {
-    const mesh = o as THREE.Mesh;
-    const material = mesh.material as THREE.Material | THREE.Material[] | undefined;
-    if (!material) {
-      warnOnce();
-      return;
-    }
-    for (const mat of Array.isArray(material) ? material : [material]) {
-      mat.transparent = true;
-      mat.opacity = v;
-      mat.needsUpdate = true;
-    }
-  },
-  'light.intensity': (o, v, warnOnce) => {
-    const light = o as THREE.Light;
-    if (!light.isLight) {
-      warnOnce();
-      return;
-    }
-    light.intensity = v;
-  },
-};
-
-/**
- * Drives 1..N property tracks against a single Object3D. Constructed once per
- * entity that declares `animation.tracks`; `update(dt)` is registered in the
- * SAME tickFns list AnimationMixers use (scene-loader.ts), so it runs in the
- * animation phase on the same deterministic clock.
- */
-export class PropertyTrackRunner {
-  private readonly object3D: THREE.Object3D;
-  private readonly tracks: PropertyTrack[];
-  private elapsed: number[];
-  private readonly warned = new Set<string>();
-
-  constructor(object3D: THREE.Object3D, tracks: PropertyTrack[]) {
-    this.object3D = object3D;
-    this.tracks = tracks;
-    this.elapsed = tracks.map(() => 0);
-  }
-
-  /** Advance every track by `dt` seconds and write the sampled value. A paused
-   * frame (`dt = 0`) leaves every track's value unchanged — no wall-clock, no
-   * new clock; determinism follows directly from the caller's `dt`. */
-  update(dt: number): void {
-    for (let i = 0; i < this.tracks.length; i++) {
-      const track = this.tracks[i] as PropertyTrack;
-      this.elapsed[i] = (this.elapsed[i] ?? 0) + dt;
-      const time = resolveTrackTime(track, this.elapsed[i] ?? 0);
-      const value = samplePropertyTrack(track, time);
-      const setter = TARGET_SETTERS[track.target];
-      // Unreachable when `target` was parsed through PropertyTrackTargetSchema
-      // (the allowlist enum) — guarded defensively since TARGET_SETTERS is a
-      // separate table that must stay in sync with the schema.
-      if (!setter) continue;
-      setter(this.object3D, value, () => {
-        if (this.warned.has(track.target)) return;
-        this.warned.add(track.target);
-        log.scene.warn(
-          `Property track target "${track.target}" has no effect on entity "${this.object3D.name}" ` +
-            '(no material / not a light) — no-op.',
-          { entityName: this.object3D.name, target: track.target },
-        );
-      });
-    }
-  }
-}

package/src/animation/schema.ts

@@ -1,204 +0,0 @@
-// T4.6 — the `.animgraph.json` schema.
-//
-// Was TS-types-only (`anim-graph-types.ts`) until T4.6 authored this Zod
-// schema — see docs/BACKBONE-TASKS.md T4.6. `asset-loaders.ts`'s
-// `loadAnimGraphData` is this schema's runtime reader: it parses via this
-// schema before handing the data to `AnimGraph`/`LayerRuntime` (anim-graph.ts).
-//
-// Every field has a `.describe()` (repo policy — powers
-// `scripts/generate-schema.ts` and the T4.1/T4.6 schema-walk coverage test).
-// No runtime dependency beyond `zod`, matching the `scene/schema/` and
-// `manifest/schema.ts` precedent.
-//
-// T4.1 inheritance + one NEW finding (T4.6 audit, same pattern as `ui.locked`/
-// `ui.tags` being found beyond BACKBONE-TASKS.md's originally-named three):
-// `LayerRuntime`'s constructor (anim-graph.ts) only ever destructures
-// `layerDef.states`/`.transitions`/`.defaultState` — `blendMode` and
-// `boneMask` are confirmed dead (named in T4.1/docs/BACKBONE-TASKS.md), and
-// `weight` (an optional per-layer field, presumably meant for compositing
-// multiple layers) is ALSO never read anywhere — there is no cross-layer
-// weight combination in `AnimGraph.update()`, each layer's actions are
-// weighted independently. All three are REJECTED at parse, mirroring the
-// `scene/schema/ui.ts` dead-field mechanism (a `.superRefine` that throws
-// naming the field). `packages/editor/src/components/asset-viewers/
-// AnimGraphViewer.tsx` echoes `layer.blendMode` back verbatim in a read-only
-// raw-JSON asset preview — that is not a behavioral reader (it fetches raw
-// JSON directly, bypassing this schema, and merely echoes whatever value is
-// present with no downstream effect), so it does not change the verdict —
-// same distinction `schema-consumption-map.ts` draws for `ui.locked`.
-//
-// `layers[].name` is REQUIRED (not optional) and has no reader either — but
-// the T4.1 "throw when authored" mechanism only fits OPTIONAL fields (you
-// cannot reject a value that must always be present). It's structural
-// identity metadata (distinguishing layers when there is more than one, and
-// the natural key a future multi-layer inspector/editor would use), the same
-// role the file-format `version` field plays — so it is RESERVED, not dead,
-// matching the `2d.version`/`2d.surface` convention in
-// `schema-consumption-map.ts`.
-
-import { z } from 'zod';
-import type {
-  AnimGraphFile,
-  AnimLayer,
-  AnimParameter,
-  AnimState,
-  AnimTransition,
-  BlendChild,
-  BlendTreeDef,
-  TransitionCondition,
-} from './anim-graph-types';
-
-export const AnimParameterSchema: z.ZodType<AnimParameter> = z.object({
-  type: z
-    .enum(['float', 'int', 'bool', 'trigger'])
-    .describe('Parameter kind — drives which inspector widget/comparison semantics apply'),
-  default: z
-    .union([z.number(), z.boolean()])
-    .describe('Initial value (AnimGraph constructor seeds `this.parameters` with this)'),
-});
-
-// NOTE: the `as z.ZodType<X>` casts below (mirroring `UIRootSchema`'s pattern
-// in `scene/schema/ui.ts`) are needed because the hand-written TS interfaces
-// in `anim-graph-types.ts` declare optional fields as `foo?: T` rather than
-// `foo?: T | undefined` — under this repo's `exactOptionalPropertyTypes`,
-// Zod's `.optional()` output (`T | undefined`) isn't structurally assignable
-// to that without the cast, even though the two are semantically identical
-// (an omittable field). The runtime schema is unaffected; this is purely a
-// pure tsc-strictness accommodation.
-
-const TransitionConditionSchema: z.ZodType<TransitionCondition> = z.object({
-  param: z.string().describe('Parameter (or trigger) name this condition tests'),
-  op: z
-    .enum(['>', '<', '>=', '<=', '==', '!=', 'trigger'])
-    .describe('Comparison operator, or "trigger" to test a fired-trigger flag'),
-  value: z
-    .union([z.number(), z.boolean()])
-    .optional()
-    .describe('Value to compare against (unused when op is "trigger")'),
-}) as z.ZodType<TransitionCondition>;
-
-const AnimTransitionSchema: z.ZodType<AnimTransition> = z.object({
-  from: z.string().describe('Source state name, or "*" to match any current state'),
-  to: z.string().describe('Destination state name'),
-  conditions: z
-    .array(TransitionConditionSchema)
-    .optional()
-    .describe('All conditions must hold for this transition to fire'),
-  duration: z.number().describe('Crossfade duration in seconds'),
-  exitTime: z
-    .number()
-    .optional()
-    .describe(
-      'Normalized time (0-1) into the source state before this transition is eligible to fire',
-    ),
-}) as z.ZodType<AnimTransition>;
-
-const BlendChildSchema: z.ZodType<BlendChild> = z.object({
-  clip: z.string().describe('Animation clip name this child plays'),
-  threshold: z.number().describe('1D/2D blend position on the primary parameter axis'),
-  thresholdY: z.number().optional().describe('2D blend position on the secondary parameter axis'),
-  weight: z.number().optional().describe('Explicit weight for "direct" blend trees'),
-}) as z.ZodType<BlendChild>;
-
-const BlendTreeDefSchema: z.ZodType<BlendTreeDef> = z.object({
-  type: z.enum(['1D', '2D', 'direct']).describe('Blend tree evaluation mode'),
-  parameter: z.string().describe('Primary parameter driving the blend'),
-  parameterY: z.string().optional().describe('Secondary parameter driving a 2D blend'),
-  children: z.array(BlendChildSchema).describe('Clips (and their blend positions/weights)'),
-}) as z.ZodType<BlendTreeDef>;
-
-const AnimStateSchema: z.ZodType<AnimState> = z.object({
-  clip: z
-    .string()
-    .optional()
-    .describe('Single clip to play in this state (mutually exclusive with blendTree in practice)'),
-  loop: z.boolean().optional().describe('Loop the clip (default true)'),
-  speed: z.number().optional().describe('Playback speed multiplier (default 1)'),
-  blendTree: BlendTreeDefSchema.optional().describe(
-    'Blend tree to evaluate instead of a single clip',
-  ),
-}) as z.ZodType<AnimState>;
-
-const AnimLayerSchema: z.ZodType<AnimLayer> = z
-  .object({
-    name: z
-      .string()
-      .describe(
-        'Layer identifier (RESERVED — no reader today; structural identity metadata, same role ' +
-          'as the file-format `version` field. See the file doc comment.)',
-      ),
-    blendMode: z
-      .enum(['override', 'additive'])
-      .optional()
-      .describe(
-        'How this layer composites with others. REJECTED at parse (T4.1): declared but has no ' +
-          "runtime reader — LayerRuntime never reads it, each layer's actions are weighted " +
-          'independently. Authoring this field throws. Do not author.',
-      ),
-    weight: z
-      .number()
-      .optional()
-      .describe(
-        'Overall layer weight (for compositing multiple layers). REJECTED at parse (T4.6 audit, ' +
-          'new finding): declared but has no runtime reader — AnimGraph.update() never combines ' +
-          'per-layer weights. Authoring this field throws. Do not author.',
-      ),
-    boneMask: z
-      .array(z.string())
-      .optional()
-      .describe(
-        'Bone names this layer is restricted to. REJECTED at parse (T4.1): declared but has no ' +
-          'runtime reader anywhere. Authoring this field throws. Do not author.',
-      ),
-    defaultState: z.string().describe('State name entered on graph creation'),
-    states: z.record(z.string(), AnimStateSchema).describe('Named states this layer can be in'),
-    transitions: z.array(AnimTransitionSchema).describe('State-machine transitions for this layer'),
-  })
-  .superRefine((layer, ctx) => {
-    if (layer.blendMode !== undefined) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message:
-          '`blendMode` is authored but not implemented — LayerRuntime (anim-graph.ts) never reads ' +
-          "it; each layer's actions are weighted independently with no cross-layer compositing " +
-          'mode. See T4.1/T4.6.',
-        path: ['blendMode'],
-      });
-    }
-    if (layer.weight !== undefined) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message:
-          '`weight` is authored but not implemented — no reader combines per-layer weights ' +
-          '(AnimGraph.update() ticks each layer independently). See T4.6.',
-        path: ['weight'],
-      });
-    }
-    if (layer.boneMask !== undefined) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message:
-          '`boneMask` is authored but not implemented — no reader restricts a layer to a bone ' +
-          'subset anywhere. See T4.1/T4.6.',
-        path: ['boneMask'],
-      });
-    }
-  }) as z.ZodType<AnimLayer>;
-
-/**
- * The `.animgraph.json` file format (`asset-loaders.ts`'s `loadAnimGraphData`
- * + `AnimGraph`'s constructor).
- *
- * `version` is RESERVED (no range-check reader exists yet for this format —
- * same convention `2d.version`/`InputMapFile.version` use; see
- * `schema-consumption-map.ts`).
- */
-export const AnimGraphFileSchema: z.ZodType<AnimGraphFile> = z.object({
-  version: z.number().describe('Anim graph file format version (RESERVED — no range check yet)'),
-  parameters: z
-    .record(z.string(), AnimParameterSchema)
-    .describe('Named parameters and their defaults (AnimGraph constructor)'),
-  layers: z
-    .array(AnimLayerSchema)
-    .describe('Independent animation layers, each its own state machine'),
-}) as z.ZodType<AnimGraphFile>;

package/src/audio/ambient.ts

@@ -1,300 +0,0 @@
-/**
- * Ambient sounds — continuous environmental audio.
- *
- * Each returns play/stop/dispose. These are designed to loop indefinitely.
- */
-
-function createNoiseBuffer(ctx: AudioContext, duration = 2): AudioBuffer {
-  const length = ctx.sampleRate * duration;
-  const buffer = ctx.createBuffer(1, length, ctx.sampleRate);
-  const data = buffer.getChannelData(0);
-  for (let i = 0; i < length; i++) data[i] = Math.random() * 2 - 1;
-  return buffer;
-}
-
-/** Wind — filtered noise with slow LFO modulation on cutoff frequency. */
-export function wind(
-  ctx: AudioContext,
-  dest: AudioNode,
-  options?: { volume?: number; speed?: number },
-) {
-  const volume = options?.volume ?? 0.15;
-  const speed = options?.speed ?? 0.3;
-  const noiseBuffer = createNoiseBuffer(ctx, 2);
-
-  const out = ctx.createGain();
-  out.gain.value = volume;
-  out.connect(dest);
-
-  const filter = ctx.createBiquadFilter();
-  filter.type = 'lowpass';
-  filter.frequency.value = 500;
-  filter.connect(out);
-
-  // LFO modulates filter cutoff for "gusts"
-  const lfo = ctx.createOscillator();
-  lfo.type = 'sine';
-  lfo.frequency.value = speed;
-  const lfoGain = ctx.createGain();
-  lfoGain.gain.value = 300; // ±300 Hz modulation
-  lfo.connect(lfoGain);
-  lfoGain.connect(filter.frequency);
-
-  let src: AudioBufferSourceNode | null = null;
-  let lfoStarted = false;
-
-  return {
-    play() {
-      if (src) return;
-      src = ctx.createBufferSource();
-      src.buffer = noiseBuffer;
-      src.loop = true;
-      src.connect(filter);
-      src.start();
-      if (!lfoStarted) {
-        lfo.start();
-        lfoStarted = true;
-      }
-    },
-    stop() {
-      if (!src) return;
-      const ref = src;
-      src = null;
-      try {
-        ref.stop();
-      } catch {
-        /* already stopped */
-      }
-      ref.disconnect();
-    },
-    dispose() {
-      if (src) {
-        try {
-          src.stop();
-        } catch {
-          /* already stopped */
-        }
-        src.disconnect();
-      }
-      try {
-        lfo.stop();
-      } catch {
-        /* already stopped */
-      }
-      lfo.disconnect();
-      lfoGain.disconnect();
-      filter.disconnect();
-      out.disconnect();
-    },
-  };
-}
-
-/** Rain — high-frequency filtered noise. */
-export function rain(
-  ctx: AudioContext,
-  dest: AudioNode,
-  options?: { volume?: number; intensity?: number },
-) {
-  const volume = options?.volume ?? 0.2;
-  const intensity = options?.intensity ?? 0.5;
-  const noiseBuffer = createNoiseBuffer(ctx, 2);
-
-  const out = ctx.createGain();
-  out.gain.value = 0.05 + intensity * volume;
-  out.connect(dest);
-
-  const hp = ctx.createBiquadFilter();
-  hp.type = 'highpass';
-  hp.frequency.value = 1000 + intensity * 3000;
-  hp.connect(out);
-
-  let src: AudioBufferSourceNode | null = null;
-
-  return {
-    play() {
-      if (src) return;
-      src = ctx.createBufferSource();
-      src.buffer = noiseBuffer;
-      src.loop = true;
-      src.connect(hp);
-      src.start();
-    },
-    stop() {
-      if (!src) return;
-      const ref = src;
-      src = null;
-      try {
-        ref.stop();
-      } catch {
-        /* already stopped */
-      }
-      ref.disconnect();
-    },
-    dispose() {
-      if (src) {
-        try {
-          src.stop();
-        } catch {
-          /* already stopped */
-        }
-        src.disconnect();
-      }
-      hp.disconnect();
-      out.disconnect();
-    },
-  };
-}
-
-/** Hum — low continuous drone with optional harmonics. */
-export function hum(
-  ctx: AudioContext,
-  dest: AudioNode,
-  options?: { frequency?: number; volume?: number; harmonics?: number },
-) {
-  const frequency = options?.frequency ?? 60;
-  const volume = options?.volume ?? 0.1;
-  const harmonics = options?.harmonics ?? 2;
-
-  const out = ctx.createGain();
-  out.gain.value = 0;
-  out.connect(dest);
-
-  const oscillators: OscillatorNode[] = [];
-
-  return {
-    play() {
-      if (oscillators.length > 0) return;
-      for (let h = 0; h <= harmonics; h++) {
-        const osc = ctx.createOscillator();
-        osc.type = 'sine';
-        osc.frequency.value = frequency * (h + 1);
-        const gain = ctx.createGain();
-        // Each harmonic is quieter
-        gain.gain.value = 1 / (h + 1);
-        osc.connect(gain);
-        gain.connect(out);
-        osc.start();
-        oscillators.push(osc);
-      }
-      out.gain.setTargetAtTime(volume, ctx.currentTime, 0.1);
-    },
-    stop() {
-      out.gain.setTargetAtTime(0, ctx.currentTime, 0.1);
-      setTimeout(() => {
-        for (const osc of oscillators) {
-          try {
-            osc.stop();
-          } catch {
-            /* already stopped */
-          }
-          osc.disconnect();
-        }
-        oscillators.length = 0;
-      }, 300);
-    },
-    dispose() {
-      for (const osc of oscillators) {
-        try {
-          osc.stop();
-        } catch {
-          /* already stopped */
-        }
-        osc.disconnect();
-      }
-      oscillators.length = 0;
-      out.disconnect();
-    },
-  };
-}
-
-/** Nature — gentle noise base with random bird-like sine chirps. */
-export function nature(
-  ctx: AudioContext,
-  dest: AudioNode,
-  options?: { volume?: number; birdRate?: number },
-) {
-  const volume = options?.volume ?? 0.15;
-  const birdRate = options?.birdRate ?? 0.5;
-  const noiseBuffer = createNoiseBuffer(ctx, 2);
-
-  const out = ctx.createGain();
-  out.gain.value = volume;
-  out.connect(dest);
-
-  const lp = ctx.createBiquadFilter();
-  lp.type = 'lowpass';
-  lp.frequency.value = 400;
-  lp.connect(out);
-
-  let src: AudioBufferSourceNode | null = null;
-  let birdInterval: ReturnType<typeof setInterval> | null = null;
-
-  function chirp() {
-    const now = ctx.currentTime;
-    const freq = 2000 + Math.random() * 2000;
-    const dur = 0.05 + Math.random() * 0.05;
-
-    const osc = ctx.createOscillator();
-    osc.type = 'sine';
-    osc.frequency.setValueAtTime(freq, now);
-    osc.frequency.exponentialRampToValueAtTime(freq * 1.3, now + dur * 0.5);
-    osc.frequency.exponentialRampToValueAtTime(freq * 0.8, now + dur);
-
-    const env = ctx.createGain();
-    env.gain.setValueAtTime(0.001, now);
-    env.gain.linearRampToValueAtTime(0.6, now + dur * 0.2);
-    env.gain.exponentialRampToValueAtTime(0.001, now + dur);
-
-    osc.connect(env);
-    env.connect(out);
-    osc.start(now);
-    osc.stop(now + dur + 0.01);
-  }
-
-  return {
-    play() {
-      if (src) return;
-      src = ctx.createBufferSource();
-      src.buffer = noiseBuffer;
-      src.loop = true;
-      src.connect(lp);
-      src.start();
-
-      // Schedule random chirps
-      birdInterval = setInterval(() => {
-        if (Math.random() < birdRate) chirp();
-      }, 500);
-    },
-    stop() {
-      if (birdInterval) {
-        clearInterval(birdInterval);
-        birdInterval = null;
-      }
-      if (!src) return;
-      const ref = src;
-      src = null;
-      try {
-        ref.stop();
-      } catch {
-        /* already stopped */
-      }
-      ref.disconnect();
-    },
-    dispose() {
-      if (birdInterval) {
-        clearInterval(birdInterval);
-        birdInterval = null;
-      }
-      if (src) {
-        try {
-          src.stop();
-        } catch {
-          /* already stopped */
-        }
-        src.disconnect();
-      }
-      lp.disconnect();
-      out.disconnect();
-    },
-  };
-}