@wenathlan/debonair 2.0.89 → 2.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenathlan/debonair",
-  "version": "2.0.89",
+  "version": "2.0.93",
   "repository": {
     "type": "git",
     "url": "https://github.com/wenathlan/devthink"
@@ -37,7 +37,8 @@
     "build": "vite build",
     "start": "vite preview --host",
     "preview": "vite preview --host",
-    "check": "tsc --noEmit"
+    "check": "tsc --noEmit",
+    "test": "vitest run"
   },
   "dependencies": {
     "@hono/node-server": "^2.1.3",

package/tests/beatgrid.test.ts

@@ -1,10 +1,10 @@
 // # beatgrid.test — honest unit tests for the beat grid (tempo detection, beat
-// tracking, quantize/swing, tempo map integration), runnable with the node
-// built-in runner (no dependencies, no install):
-//   node --test tests/beatgrid.test.ts
+// tracking, quantize/swing, tempo map integration), runnable with the
+// vitest runner:
+//   pnpm test
 // The fixtures synthesise a 120 BPM click track and piecewise tempo curves.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   beatCount,
   beatsElapsed,

package/tests/ducking.test.ts

@@ -1,10 +1,10 @@
 // # ducking.test — honest unit tests for the sidechain ducking logic (level
 // envelope, activity regions, per-sample follower gain, keyframes), runnable
-// with the node built-in runner (no dependencies, no install):
-//   node --test tests/ducking.test.ts
+// with the vitest runner:
+//   pnpm test
 // The fixtures synthesise a 1 kHz voice-like trigger with two speech bursts.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   activityRegions,
   autoDuckRegions,

package/tests/loudness.test.ts

@@ -1,11 +1,11 @@
 // # loudness.test — honest unit tests for the loudness meter (K-weighting,
-// gating, LRA, peaks, normalisation gain), runnable with the node built-in
-// runner (no dependencies, no install):
-//   node --test tests/loudness.test.ts
+// gating, LRA, peaks, normalisation gain), runnable with the vitest
+// runner:
+//   pnpm test
 // The fixtures synthesise a 1 kHz sine at known amplitudes; every expected
 // number is derived from the meter itself, never from a lookup table.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   analyzeLoudness,
   applyGain,

package/tests/mixergraph.test.ts

@@ -1,9 +1,9 @@
 // # mixergraph.test — honest unit tests for the mixing graph model, runnable
-// with the node built-in runner (no dependencies, no install):
-//   node --test tests/mixergraph.test.ts
+// with the vitest runner:
+//   pnpm test
 // The desk fixtures reuse the real mixer strips the site seed serves.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   assertAcyclic,
   assertGraph,
@@ -12,10 +12,10 @@ import {
   effectiveGains,
   graphFromStrips,
   linearToDb,
+  type MixerChannel,
   MixerGraphError,
   patchChannel,
   resolvePaths,
-  type MixerChannel,
 } from "../mixergraph.ts";
 import { seedMixerStrips } from "../seed.ts";
 
@@ -29,34 +29,46 @@ describe("mixer graph construction", () => {
 
   it("refuses a desk without a master row", () => {
     const orphans = seedMixerStrips.map((strip) => ({ ...strip, master: false }));
-    assert.throws(() => graphFromStrips(orphans), (error: unknown) => {
-      assert.ok(error instanceof MixerGraphError);
-      assert.equal(error.code, "missing-master");
-      return true;
-    });
+    assert.throws(
+      () => graphFromStrips(orphans),
+      (error: unknown) => {
+        assert.ok(error instanceof MixerGraphError);
+        assert.equal(error.code, "missing-master");
+        return true;
+      },
+    );
     assert.throws(() => graphFromStrips([]), MixerGraphError);
   });
 
   it("validates duplicate ids, unknown sends and non finite gains", () => {
     const graph = graphFromStrips(seedMixerStrips);
     const duplicated: MixerChannel = { id: "Drums", name: "Drums", gaindb: 0, mute: false, solo: false, sends: [] };
-    assert.throws(() => assertGraph({ ...graph, channels: [...graph.channels, duplicated] }), (error: unknown) => {
-      assert.ok(error instanceof MixerGraphError);
-      assert.equal(error.code, "duplicate-channel");
-      return true;
-    });
+    assert.throws(
+      () => assertGraph({ ...graph, channels: [...graph.channels, duplicated] }),
+      (error: unknown) => {
+        assert.ok(error instanceof MixerGraphError);
+        assert.equal(error.code, "duplicate-channel");
+        return true;
+      },
+    );
     const withbadsend = patchChannel(graph, "Drums", { sends: [{ targetid: "ghost", gaindb: -3 }] });
-    assert.throws(() => assertGraph(withbadsend), (error: unknown) => {
-      assert.ok(error instanceof MixerGraphError);
-      assert.equal(error.code, "unknown-send");
-      return true;
-    });
+    assert.throws(
+      () => assertGraph(withbadsend),
+      (error: unknown) => {
+        assert.ok(error instanceof MixerGraphError);
+        assert.equal(error.code, "unknown-send");
+        return true;
+      },
+    );
     const withnangain = patchChannel(graph, "Drums", { gaindb: Number.NaN });
-    assert.throws(() => assertGraph(withnangain), (error: unknown) => {
-      assert.ok(error instanceof MixerGraphError);
-      assert.equal(error.code, "bad-gain");
-      return true;
-    });
+    assert.throws(
+      () => assertGraph(withnangain),
+      (error: unknown) => {
+        assert.ok(error instanceof MixerGraphError);
+        assert.equal(error.code, "bad-gain");
+        return true;
+      },
+    );
   });
 });
 
@@ -64,17 +76,18 @@ describe("mixer graph cycles", () => {
   const graph = graphFromStrips(seedMixerStrips);
 
   it("rejects a send loop between two strips", () => {
-    const looped = patchChannel(
-      patchChannel(graph, "Drums", { sends: [{ targetid: "Bass", gaindb: -3 }] }),
-      "Bass",
-      { sends: [{ targetid: "Drums", gaindb: -3 }] },
-    );
-    assert.throws(() => assertAcyclic(looped), (error: unknown) => {
-      assert.ok(error instanceof MixerGraphError);
-      assert.equal(error.code, "cycle");
-      assert.equal(error.channelid, "Drums");
-      return true;
+    const looped = patchChannel(patchChannel(graph, "Drums", { sends: [{ targetid: "Bass", gaindb: -3 }] }), "Bass", {
+      sends: [{ targetid: "Drums", gaindb: -3 }],
     });
+    assert.throws(
+      () => assertAcyclic(looped),
+      (error: unknown) => {
+        assert.ok(error instanceof MixerGraphError);
+        assert.equal(error.code, "cycle");
+        assert.equal(error.channelid, "Drums");
+        return true;
+      },
+    );
   });
 
   it("rejects a strip that sends to itself", () => {
@@ -94,7 +107,10 @@ describe("mixer graph gains", () => {
     assert.ok(Math.abs(dbToLinear(-6) - 0.501) < 0.001);
     assert.equal(dbToLinear(Number.NEGATIVE_INFINITY), 0);
     assert.equal(linearToDb(1), 0);
-    assert.ok(Math.abs(linearToDb(dbToLinear(-6)) - -6) < 1e-9, `expected the -6 dB roundtrip to hold, got ${linearToDb(dbToLinear(-6))}`);
+    assert.ok(
+      Math.abs(linearToDb(dbToLinear(-6)) - -6) < 1e-9,
+      `expected the -6 dB roundtrip to hold, got ${linearToDb(dbToLinear(-6))}`,
+    );
     assert.equal(linearToDb(0), Number.NEGATIVE_INFINITY);
   });
 
@@ -139,7 +155,9 @@ describe("mixer graph routing paths", () => {
   });
 
   it("resolves the send path with the send and master gains chained", () => {
-    const graph = patchChannel(graphFromStrips(seedMixerStrips), "Drums", { sends: [{ targetid: "Master", gaindb: -6 }] });
+    const graph = patchChannel(graphFromStrips(seedMixerStrips), "Drums", {
+      sends: [{ targetid: "Master", gaindb: -6 }],
+    });
     const paths = resolvePaths(graph, "Drums");
     assert.equal(paths.length, 2);
     assert.ok(Math.abs(paths[0].gaindb - -6) < 1e-9); // direct: -4 + -2
@@ -156,10 +174,13 @@ describe("mixer graph routing paths", () => {
 
   it("refuses an unknown channel", () => {
     const graph = graphFromStrips(seedMixerStrips);
-    assert.throws(() => resolvePaths(graph, "ghost"), (error: unknown) => {
-      assert.ok(error instanceof MixerGraphError);
-      assert.equal(error.code, "unknown-channel");
-      return true;
-    });
+    assert.throws(
+      () => resolvePaths(graph, "ghost"),
+      (error: unknown) => {
+        assert.ok(error instanceof MixerGraphError);
+        assert.equal(error.code, "unknown-channel");
+        return true;
+      },
+    );
   });
 });

package/tests/remixplan.test.ts

@@ -1,10 +1,10 @@
 // # remixplan.test — honest unit tests for the remix planner (beat similarity,
-// joint scoring, piece plans, crossfade gains), runnable with the node
-// built-in runner (no dependencies, no install):
-//   node --test tests/remixplan.test.ts
+// joint scoring, piece plans, crossfade gains), runnable with the
+// vitest runner:
+//   pnpm test
 // The fixtures synthesise a 32-beat loop whose features repeat every 3 beats.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   beatSimilarity,
   bestTargetBeat,

package/tests/speechalign.test.ts

@@ -1,13 +1,12 @@
 // # speechalign.test — honest unit tests for the speech alignment logic (RMS
 // framing, silence threshold, phrase segmentation, grid fitting with stretch
-// limits), runnable with the node built-in runner (no dependencies, no
-// install):
-//   node --test tests/speechalign.test.ts
+// limits), runnable with the vitest runner:
+//   pnpm test
 // The fixture synthesises a 3 s "voice": two sine phrases (0.2–0.8 s and
 // 1.2–1.7 s) with 50 ms fades over digital silence, so every phrase boundary
 // the logic reports is checkable by hand.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   alignSpeech,
   beatGridTimes,

package/tests/timelinemodel.test.ts

@@ -1,9 +1,9 @@
 // # timelinemodel.test — honest unit tests for the arrangement timeline
-// model (snap, overlap, split, trim, move), runnable with the node runner:
-//   node --test tests/timelinemodel.test.ts
+// model (snap, overlap, split, trim, move), runnable with the vitest runner:
+//   pnpm test
 // The clip fixtures mirror the shapes the studio timeline serves.
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { describe, it } from "vitest";
 import {
   activeAt,
   clipsOverlap,
@@ -12,11 +12,11 @@ import {
   snapClip,
   snapToGrid,
   splitClip,
+  type TimelineClip,
   TimelineModelError,
   totalDuration,
   trimClip,
   validatePlacement,
-  type TimelineClip,
 } from "../timelinemodel.ts";
 
 const GRID = { stepseconds: 0.25 };
@@ -46,11 +46,14 @@ describe("timeline grid snap", () => {
 
   it("refuses a bad time or a bad grid", () => {
     assert.throws(() => snapToGrid(-1, GRID), TimelineModelError);
-    assert.throws(() => snapToGrid(1, { stepseconds: 0 }), (error: unknown) => {
-      assert.ok(error instanceof TimelineModelError);
-      assert.equal(error.code, "bad-grid");
-      return true;
-    });
+    assert.throws(
+      () => snapToGrid(1, { stepseconds: 0 }),
+      (error: unknown) => {
+        assert.ok(error instanceof TimelineModelError);
+        assert.equal(error.code, "bad-grid");
+        return true;
+      },
+    );
   });
 });
 
@@ -67,12 +70,15 @@ describe("timeline overlap", () => {
   it("validates the placement and reports the offending pair", () => {
     const arrangement = [clip("a", "Drums", 0, 2), clip("b", "Bass", 0, 4)];
     assert.doesNotThrow(() => validatePlacement(clip("c", "Bass", 5, 1), arrangement));
-    assert.throws(() => validatePlacement(clip("c", "Drums", 1, 2), arrangement), (error: unknown) => {
-      assert.ok(error instanceof TimelineModelError);
-      assert.equal(error.code, "overlap");
-      assert.equal(error.clipid, "c");
-      return true;
-    });
+    assert.throws(
+      () => validatePlacement(clip("c", "Drums", 1, 2), arrangement),
+      (error: unknown) => {
+        assert.ok(error instanceof TimelineModelError);
+        assert.equal(error.code, "overlap");
+        assert.equal(error.clipid, "c");
+        return true;
+      },
+    );
   });
 
   it("skips the clip itself and honors the allowoverlap escape hatch", () => {
@@ -96,12 +102,15 @@ describe("timeline split", () => {
 
   it("refuses a split on the edges or outside the span", () => {
     const target = clip("c1", "Bass", 2, 1.5);
-    assert.throws(() => splitClip(target, 2), (error: unknown) => {
-      assert.ok(error instanceof TimelineModelError);
-      assert.equal(error.code, "split-outside");
-      assert.equal(error.clipid, "c1");
-      return true;
-    });
+    assert.throws(
+      () => splitClip(target, 2),
+      (error: unknown) => {
+        assert.ok(error instanceof TimelineModelError);
+        assert.equal(error.code, "split-outside");
+        assert.equal(error.clipid, "c1");
+        return true;
+      },
+    );
     assert.throws(() => splitClip(target, 3.5), TimelineModelError);
     assert.throws(() => splitClip(target, 9), TimelineModelError);
   });
@@ -122,11 +131,14 @@ describe("timeline trim", () => {
 
   it("refuses a trim that leaves the span or breaks the minimum duration", () => {
     const target = clip("c1", "Drums", 2, 1.5);
-    assert.throws(() => trimClip(target, "start", 1.9), (error: unknown) => {
-      assert.ok(error instanceof TimelineModelError);
-      assert.equal(error.code, "trim-invalid");
-      return true;
-    });
+    assert.throws(
+      () => trimClip(target, "start", 1.9),
+      (error: unknown) => {
+        assert.ok(error instanceof TimelineModelError);
+        assert.equal(error.code, "trim-invalid");
+        return true;
+      },
+    );
     assert.throws(() => trimClip(target, "start", 3.5 - MINIMUMDURATION + 0.01), TimelineModelError);
     assert.throws(() => trimClip(target, "end", 2 + MINIMUMDURATION - 0.01), TimelineModelError);
     assert.throws(() => trimClip(target, "end", 9), TimelineModelError);
@@ -147,11 +159,14 @@ describe("timeline move", () => {
   });
 
   it("rejects the landing on an occupied spot", () => {
-    assert.throws(() => moveClip(clip("d", "Drums", 2, 1), 1.5, arrangement), (error: unknown) => {
-      assert.ok(error instanceof TimelineModelError);
-      assert.equal(error.code, "overlap");
-      return true;
-    });
+    assert.throws(
+      () => moveClip(clip("d", "Drums", 2, 1), 1.5, arrangement),
+      (error: unknown) => {
+        assert.ok(error instanceof TimelineModelError);
+        assert.equal(error.code, "overlap");
+        return true;
+      },
+    );
   });
 
   it("snaps the landing when a grid is passed and moves across tracks", () => {
@@ -166,8 +181,14 @@ describe("timeline queries", () => {
   const arrangement = [clip("a", "Drums", 0, 1), clip("b", "Bass", 0.5, 2), clip("c", "Lead", 5, 1)];
 
   it("answers the clips playing at one instant", () => {
-    assert.deepEqual(activeAt(arrangement, 0.75).map((row) => row.id), ["a", "b"]);
-    assert.deepEqual(activeAt(arrangement, 1).map((row) => row.id), ["b"]);
+    assert.deepEqual(
+      activeAt(arrangement, 0.75).map((row) => row.id),
+      ["a", "b"],
+    );
+    assert.deepEqual(
+      activeAt(arrangement, 1).map((row) => row.id),
+      ["b"],
+    );
     assert.deepEqual(activeAt(arrangement, 10), []);
   });