@wenathlan/debonair 2.0.94 → 2.0.118

package/tests/solcss.test.ts

@@ -0,0 +1,148 @@
+// # solcss.test — the theme contract of the Sol stylesheet (the reform wave):
+//   the trylle foundation wearing the windows hands, pinned as CI guards over
+//   the real file the app ships. Zero banned hues, zero pills, zero
+//   transition:all, zero scale(0) entries OUTSIDE the windows pin law (the
+//   dtPopIntro bounce is the one lawful scale-from-zero), the reduced-motion
+//   hard stop and the reduced-transparency floors present, the in-session
+//   data-motion mirror, the tabular-nums discipline, the trylle type stacks
+//   and the two-accent contract (the brass identity beside the windows
+//   accent) all verified verbatim. The stylesheet is read as text — no
+//   browser, no DOM.
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { describe, it } from "vitest";
+
+const css = readFileSync(new URL("../Sol/sol.css", import.meta.url), "utf8");
+
+/** Strips comments so the guards read rules, not the doctrine prose. */
+function rules(source: string): string {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+
+/** The stylesheet with the windows pin law lifted out (the one lawful scale(0)). */
+function withoutPinLaw(source: string): string {
+  return rules(source).replace(/@keyframes dtPopIntro \{(?:[^{}]|\{[^}]*\})*\}/g, "");
+}
+
+describe("sol.css — the banned palette", () => {
+  it("never ships the banned blues or the tailwind orange", () => {
+    for (const banned of ["#3b82f6", "#2563eb", "#f97316"]) {
+      assert.ok(!rules(css).toLowerCase().includes(banned), `${banned} rides in the stylesheet`);
+    }
+  });
+
+  it("never ships the pill radius on buttons, badges, tabs or chips", () => {
+    assert.ok(!rules(css).includes("999px"), "a 999px pill rides in the stylesheet");
+    assert.ok(!rules(css).includes("rounded-full"), "rounded-full rides in the stylesheet");
+    // true circles stay legal: avatars, dots and indicators use 50%
+    assert.ok(rules(css).includes("border-radius: 50%"), "true circles use the 50% radius");
+  });
+});
+
+describe("sol.css — the motion law", () => {
+  it("never ships transition: all", () => {
+    assert.ok(!/transition\s*:\s*all/.test(rules(css)), "transition: all rides in the stylesheet");
+  });
+
+  it("never enters an element from scale(0) outside the windows pin law", () => {
+    assert.ok(!/scale\(0\)/.test(withoutPinLaw(css)), "a scale(0) entry rides outside dtPopIntro");
+    // the pin law itself: 0 → 1.125 (40%) → 0.725 (70%) → 1 (the bounce)
+    const pin = rules(css).match(/@keyframes dtPopIntro \{(?:[^{}]|\{[^}]*\})*\}/);
+    assert.ok(pin !== null, "the dtPopIntro keyframe is missing");
+    assert.ok(
+      pin[0].includes("scale(1.125)") && pin[0].includes("scale(0.725)"),
+      "the dtPopIntro bounce left the pin law",
+    );
+  });
+
+  it("carries the reduced-motion hard stop as the last word", () => {
+    assert.match(
+      css,
+      /@media \(prefers-reduced-motion: reduce\) \{\s*\*,\s*\*::before,\s*\*::after \{[^}]*animation-duration: 0\.01ms !important/,
+      "the universal hard stop is missing",
+    );
+    const hardStop = css.indexOf("@media (prefers-reduced-motion: reduce)");
+    const lastBlock = css.lastIndexOf("@media");
+    assert.ok(lastBlock >= hardStop, "a media block rides after the reduced-motion stop");
+  });
+
+  it("carries the reduced-transparency floors", () => {
+    const floors = css.match(/@media \(prefers-reduced-transparency: reduce\)/g) ?? [];
+    assert.ok(floors.length >= 1, "the transparency floors are missing");
+    assert.match(css, /backdrop-filter: none/, "the acrylic blur never dies under the floor");
+  });
+
+  it("mirrors the media kills into the in-session data-motion switch", () => {
+    assert.ok(css.includes('[data-motion="reduced"]'), "the settings switch has no stylesheet guards");
+    assert.match(
+      css,
+      /\[data-motion="reduced"\] \*,\s*\[data-motion="reduced"\] \*::before,\s*\[data-motion="reduced"\] \*::after \{[^}]*animation-duration: 0\.01ms !important/,
+      "the in-session hard stop is missing",
+    );
+  });
+});
+
+describe("sol.css — the trylle foundation", () => {
+  it("keeps the trylle canvas and the surface ladder", () => {
+    // the v2 foundation: the windows-11 canvas and the exact 8-step ladder
+    assert.ok(css.includes("--color-canvas: #202020"), "the trylle canvas left the tokens");
+    assert.ok(css.includes("--color-deep: #191919"), "the deep floor left the tokens");
+    assert.ok(css.includes("--color-s0: #242424"), "the ladder foot left the tokens");
+    assert.ok(css.includes("--color-s7: #494949"), "the ladder head left the tokens");
+  });
+
+  it("keeps the trylle type stacks (Inter Variable · Geist Mono)", () => {
+    assert.ok(css.includes('"Inter Variable"'), "the trylle sans left the tokens");
+    assert.ok(css.includes('"Geist Mono Variable"'), "the trylle mono left the tokens");
+    assert.ok(css.includes("font-size: 13px"), "the trylle body size left the base");
+    assert.ok(css.includes("--sol-track-display: -0.02em"), "the display tracking left the tokens");
+    assert.ok(css.includes("--sol-track-label: 0.14em"), "the label tracking left the tokens");
+  });
+
+  it("keeps the two-accent contract (the brass identity beside the windows accent)", () => {
+    assert.ok(css.includes("--accent: var(--color-signal)"), "the brass identity left the identity slot");
+    assert.ok(css.includes("--color-signal: #d9962e"), "the latão signal left the tokens");
+    assert.ok(css.includes("--color-win: #4cc2ff"), "the windows accent left the chrome slot");
+    assert.ok(css.includes("--color-focus: #4cc2ff"), "focus no longer answers the windows accent");
+  });
+
+  it("keeps the trylle shadow ladder and the fluent window float", () => {
+    assert.ok(css.includes("--shadow-8"), "the trylle shadow ladder left the tokens");
+    assert.ok(css.includes("0 96px 96px -48px"), "the doubling ladder head left the tokens");
+    assert.ok(
+      css.includes("--shadow-window: 0 32px 64px rgb(0 0 0 / 24%), 0 0 8px rgb(0 0 0 / 20%)"),
+      "the fluent window shadow left the tokens",
+    );
+    assert.ok(css.includes("--ease-window: cubic-bezier(0.85, 0.14, 0.14, 0.85)"), "the window curve left the tokens");
+  });
+
+  it("keeps the numeric discipline: the readouts ride tabular-nums", () => {
+    assert.ok(css.includes("font-variant-numeric: tabular-nums"), "tabular-nums left the stylesheet");
+  });
+
+  it("defines every custom property its own rules read (--dbn-line aliases)", () => {
+    for (const token of ["--dbn-line", "--dbn-line-strong"]) {
+      const defined = new RegExp(`${token.replace("-", "\\-")}\\s*:`).test(css);
+      assert.ok(defined, `${token} is read but never defined`);
+    }
+  });
+
+  it("keeps the sticky footer contract (the stage is a column, the footer glues)", () => {
+    assert.match(css, /\.winapp__stage \{[^}]*flex-direction: column/, "the stage is not a column");
+    assert.match(css, /\.meta-quad \{[^}]*margin-top: auto/, "the footer no longer glues to the floor");
+  });
+
+  it("keeps the windows hands on the chrome", () => {
+    assert.ok(css.includes("grayscale(80%)"), "the inactive window law left the stylesheet");
+    assert.ok(css.includes("rgb(232 17 35)"), "the fluent red close left the stylesheet");
+    assert.ok(css.includes("rgb(139 10 20)"), "the deep close hover left the stylesheet");
+    assert.ok(css.includes(".winapp__rz[data-edge="), "the eight resize handles left the stylesheet");
+    assert.match(css, /\.railnav__item:active \{ transform: scale\(0\.7\)/, "the pin press law left the rail");
+    assert.match(
+      css,
+      /\.winapp \{[^}]*animation: winappOpen var\(--dur-2\) var\(--ease-window\)/,
+      "the window curve left the frame",
+    );
+  });
+});

package/tests/spectrum.test.ts

@@ -0,0 +1,59 @@
+// # spectrum.test — the spectral kernel: the fft answers known magnitudes,
+// the hann window is unitary, the chroma folds a sine into its pitch class
+// and the key correlation answers the scale it hears.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { chromaOf, fftInPlace, frameSpectrum, keyOf } from "../spectrum.ts";
+
+/** The KK minor profile rotated so the tonic (6.33) sits on pc 9 (A). */
+const KK_MINOR_ROTATED: readonly number[] = Array.from(
+  { length: 12 },
+  (_, i) => [6.33, 2.68, 3.52, 5.38, 2.6, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17][(i - 9 + 12) % 12],
+);
+
+describe("spectrum — fftInPlace", () => {
+  it("recovers a pure sine's magnitude at the right bin", () => {
+    const n = 4096;
+    const bin = 100;
+    const re = Array.from({ length: n }, (_, i) => Math.sin((2 * Math.PI * bin * i) / n));
+    const im = new Array<number>(n).fill(0);
+    fftInPlace(re, im);
+    const half = n / 2;
+    const peak = Array.from({ length: half }, (_, b) => Math.hypot(re[b], im[b]));
+    const bestBin = peak.indexOf(Math.max(...peak));
+    assert.ok(Math.abs(bestBin - bin) <= 1, `peak bin ${bestBin} != ${bin}`);
+  });
+
+  it("answers zero imaginary energy for a real cosine symmetric input", () => {
+    const n = 512;
+    const re = Array.from({ length: n }, (_, i) => Math.cos((2 * Math.PI * 8 * i) / n));
+    const im = new Array<number>(n).fill(0);
+    fftInPlace(re, im);
+    assert.ok(Math.abs(im[8]) < 1e-9, "dc-adjacent imaginary leaked");
+  });
+});
+
+describe("spectrum — frameSpectrum + chroma", () => {
+  it("folds a 440hz sine into the A pitch class", () => {
+    const sine = Array.from({ length: 4096 }, (_, i) => Math.sin((2 * Math.PI * 440 * i) / 44100));
+    const frame = frameSpectrum(sine);
+    const chroma = chromaOf(frame.magnitudes, frame.binHz);
+    const best = chroma.indexOf(Math.max(...chroma));
+    assert.equal(best, 9, "440hz must fold to pc 9 (A)");
+  });
+
+  it("correlates a C-major chroma to the C major key", () => {
+    const chroma = [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88];
+    const key = keyOf(chroma);
+    assert.equal(key.tonic, 0);
+    assert.equal(key.mode, "major");
+  });
+
+  it("correlates an A-minor profile to the A minor key", () => {
+    // the chroma of an A-minor piece: the KK minor window starts at pc 9
+    const chroma = Array.from({ length: 12 }, (_, i) => KK_MINOR_ROTATED[i]);
+    const key = keyOf(chroma);
+    assert.equal(key.tonic, 9);
+    assert.equal(key.mode, "minor");
+  });
+});

package/tests/stems.test.ts

@@ -0,0 +1,127 @@
+// # stems.test — the stem planner contract: the canonical partition order,
+// the conservation invariant (the sum of the stem events equals the schedule
+// total, per role and overall), the determinism of the partition, the
+// schema v1 manifest with the take identity and the mastering rate, the
+// desk faders the bounce rides and the hard failures with their codes.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { planTake } from "../arranger.ts";
+import { MASTERING } from "../katexis.ts";
+import {
+  planStems,
+  STEM_ROLES,
+  STEMS_SCHEMA_VERSION,
+  StemsError,
+  stemFile,
+  stemsManifest,
+  validateStems,
+} from "../stems.ts";
+import { type NoteEvent, scheduleTake, type TakeSchedule } from "../takeevents.ts";
+
+describe("stems — planStems", () => {
+  const plan = planTake({ prompt: "midnight techno, dark sub bass, hypnotic arp", seed: "k4-stems" });
+  const schedule = scheduleTake(plan);
+  const stems = planStems(schedule, plan);
+
+  it("partitions the schedule one stem per role in canonical order", () => {
+    assert.equal(stems.length, STEM_ROLES.length);
+    assert.deepEqual(
+      stems.map((stem) => stem.role),
+      STEM_ROLES.map((policy) => policy.role),
+    );
+  });
+
+  it("conserves every scheduled event (the sum of the stems equals the take)", () => {
+    const total = stems.reduce((sum, stem) => sum + stem.events.length, 0);
+    assert.equal(total, schedule.events.length);
+    for (const stem of stems) assert.equal(stem.events.length, schedule.perRole[stem.role]);
+  });
+
+  it("keeps each stem time-ascending and inside its span", () => {
+    for (const stem of stems) {
+      for (let index = 1; index < stem.events.length; index++) {
+        assert.ok(stem.events[index].time >= stem.events[index - 1].time);
+      }
+      for (const event of stem.events) assert.ok(event.time + event.seconds <= stem.seconds + 1e-6);
+    }
+  });
+
+  it("is deterministic for the same schedule", () => {
+    assert.deepEqual(planStems(scheduleTake(plan), plan), stems);
+  });
+
+  it("names the files after the take and the role", () => {
+    for (const stem of stems) assert.equal(stem.file, stemFile(plan.id, stem.role));
+    assert.equal(stemFile("abc123", "drums"), "abc123-drums.wav");
+  });
+
+  it("rides the desk faders the plan opened with", () => {
+    for (const stem of stems) {
+      const strip = plan.strips.find((row) => row.name === stem.role);
+      assert.ok(strip);
+      assert.equal(stem.gainDb, strip.faderDb);
+      assert.ok(stem.channelkind === "mono" || stem.channelkind === "stereo");
+    }
+  });
+
+  it("refuses an empty schedule and an unknown role", () => {
+    const empty: TakeSchedule = { events: [], perRole: { drums: 0, bass: 0, keys: 0, lead: 0 }, duration: 1 };
+    assert.throws(
+      () => planStems(empty, plan),
+      (error: unknown) => error instanceof StemsError && error.code === "empty-schedule",
+    );
+    const stranger = {
+      lane: "guitar",
+      role: "guitar",
+      time: 0,
+      seconds: 0.1,
+      velocity: 0.5,
+      midi: 60,
+    } as unknown as NoteEvent;
+    assert.throws(
+      () => planStems({ ...schedule, events: [...schedule.events, stranger] }, plan),
+      (error: unknown) => error instanceof StemsError && error.code === "unknown-role",
+    );
+  });
+});
+
+describe("stems — manifest", () => {
+  const plan = planTake({ prompt: "smooth house, warm sub", seed: "k4-manifest" });
+  const schedule = scheduleTake(plan);
+  const stems = planStems(schedule, plan);
+  const manifest = stemsManifest({ plan, stems });
+
+  it("declares schema v1 with the take identity and the mastering rate", () => {
+    assert.equal(STEMS_SCHEMA_VERSION, "debonair.stems/1");
+    assert.equal(manifest.schemaVersion, "debonair.stems/1");
+    assert.equal(manifest.takeId, plan.id);
+    assert.equal(manifest.sampleRate, 48000);
+    assert.equal(manifest.sampleRate, MASTERING.sampleRateHz);
+    assert.equal(manifest.lufsTarget, plan.lufsTarget);
+  });
+
+  it("mirrors the partition into counted rows", () => {
+    assert.equal(manifest.stems.length, stems.length);
+    for (const row of manifest.stems) {
+      const stem = stems.find((candidate) => candidate.role === row.role);
+      assert.ok(stem);
+      assert.equal(row.file, stem.file);
+      assert.equal(row.events, stem.events.length);
+      assert.equal(row.seconds, stem.seconds);
+    }
+    assert.equal(Number.isNaN(Date.parse(manifest.generatedAt)), false);
+  });
+
+  it("validates clean and flags a robbed event, a foreign take and a shuffled order", () => {
+    assert.deepEqual(validateStems(schedule, plan, manifest), []);
+    const robbed = {
+      ...manifest,
+      stems: manifest.stems.map((row, index) => (index === 0 ? { ...row, events: row.events - 1 } : row)),
+    };
+    assert.ok(validateStems(schedule, plan, robbed).some((problem) => problem.code === "conservation"));
+    const foreign = { ...manifest, takeId: "other-take" };
+    assert.ok(validateStems(schedule, plan, foreign).some((problem) => problem.code === "bad-manifest"));
+    const shuffled = { ...manifest, stems: [...manifest.stems].reverse() };
+    assert.ok(validateStems(schedule, plan, shuffled).some((problem) => problem.code === "bad-order"));
+  });
+});

package/tests/takeevents.test.ts

@@ -0,0 +1,129 @@
+// # takeevents.test — the event scheduler of the katexis engine: every test
+// watches the contract the transport and the rack ride — the expansion is
+// deterministic, the events sit inside the take and ascend in time, the
+// velocities stay in range with the section energy applied, the bass locks
+// to the kick steps, the lead stays in the key, the position maps an instant
+// onto the 16-step grid and the window slice cuts cleanly.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { planTake } from "../arranger.ts";
+import { scalePcs } from "../musictheory.ts";
+import { eventsInWindow, positionAt, scheduleTake, sectionAt, validateSchedule } from "../takeevents.ts";
+
+describe("takeevents — scheduleTake", () => {
+  const plan = planTake({ prompt: "midnight techno, dark sub bass, hypnotic arp", seed: "demo-1" });
+  const schedule = scheduleTake(plan);
+
+  it("is deterministic for the same plan", () => {
+    const again = scheduleTake(plan);
+    assert.deepEqual(again, schedule);
+  });
+
+  it("answers events for every role and sorts them ascending", () => {
+    assert.ok(schedule.perRole.drums > 0);
+    assert.ok(schedule.perRole.bass > 0);
+    assert.ok(schedule.perRole.keys > 0);
+    assert.ok(schedule.perRole.lead > 0);
+    for (let index = 1; index < schedule.events.length; index++) {
+      assert.ok(schedule.events[index].time >= schedule.events[index - 1].time);
+    }
+  });
+
+  it("keeps every event inside the take with a velocity in range", () => {
+    assert.deepEqual(validateSchedule(schedule), []);
+    for (const event of schedule.events) {
+      assert.ok(event.time >= 0 && event.time < schedule.duration);
+      assert.ok(event.velocity >= 0 && event.velocity <= 1);
+      assert.ok(event.seconds > 0);
+    }
+  });
+
+  it("carries the drop louder than the intro (the section energy rides)", () => {
+    const intro = schedule.events.filter((event) => event.time < plan.sections[0].bars * plan.barSeconds);
+    const drop = plan.sections.find((section) => section.name === "drop");
+    assert.ok(drop);
+    const dropStart = drop.bar * plan.barSeconds;
+    const dropEvents = schedule.events.filter(
+      (event) =>
+        event.time >= dropStart && event.time < dropStart + drop.bars * plan.barSeconds && event.role === "drums",
+    );
+    const loudestIntro = Math.max(...intro.filter((event) => event.role === "drums").map((event) => event.velocity));
+    const loudestDrop = Math.max(...dropEvents.map((event) => event.velocity));
+    assert.ok(loudestDrop > loudestIntro);
+  });
+
+  it("locks the bass to the kick steps of the same bar", () => {
+    const eps = 1e-6;
+    for (let bar = 0; bar < plan.bars; bar++) {
+      const section = sectionAt(plan, bar);
+      if (!section.voices.includes("bass")) continue;
+      const barStart = bar * plan.barSeconds;
+      const stepSec = 60 / plan.bpm / 4;
+      const bassSteps = schedule.events
+        .filter(
+          (event) =>
+            event.role === "bass" && event.time >= barStart - eps && event.time < barStart + plan.barSeconds - eps,
+        )
+        .map((event) => Math.round((event.time - barStart) / stepSec));
+      const kickSteps = plan.grid.lanes.kick
+        .map((velocity, step) => (velocity > 0 ? step : -1))
+        .filter((step) => step >= 0);
+      assert.deepEqual(
+        [...bassSteps].sort((a, b) => a - b),
+        [...kickSteps].sort((a, b) => a - b),
+      );
+    }
+  });
+
+  it("holds one pad voicing per bar on the keys lane", () => {
+    const keysByBar = new Map<number, number>();
+    for (const event of schedule.events) {
+      if (event.role !== "keys") continue;
+      const bar = Math.floor(event.time / plan.barSeconds);
+      keysByBar.set(bar, (keysByBar.get(bar) ?? 0) + 1);
+    }
+    for (const [, count] of keysByBar) assert.ok(count >= 3, "a pad voicing carries at least a triad");
+  });
+
+  it("keeps the lead on the key's pitch classes", () => {
+    const allowed = new Set(scalePcs(plan.key));
+    for (const event of schedule.events) {
+      if (event.role !== "lead") continue;
+      assert.ok(allowed.has(event.midi % 12));
+    }
+  });
+
+  it("cuts a clean window slice", () => {
+    const window = eventsInWindow(schedule, 0, 1);
+    for (const event of window) assert.ok(event.time >= 0 && event.time < 1);
+    assert.equal(eventsInWindow(schedule, 0, 0).length, 0);
+    assert.equal(eventsInWindow(schedule, schedule.duration, schedule.duration + 5).length, 0);
+  });
+});
+
+describe("takeevents — positionAt", () => {
+  const plan = planTake({ prompt: "smooth house, warm sub", seed: "grid-1" });
+
+  it("maps the top of the take onto bar 1 step 1", () => {
+    assert.deepEqual(positionAt(plan, 0), { bar: 0, step: 0 });
+  });
+
+  it("maps a mid-take instant onto its bar and step", () => {
+    const stepSec = 60 / plan.bpm / 4;
+    const time = 9 * plan.barSeconds + 5 * stepSec;
+    const { bar, step } = positionAt(plan, time);
+    assert.equal(bar, 9);
+    assert.equal(step, 5);
+  });
+
+  it("clamps past the end onto the last bar", () => {
+    const { bar } = positionAt(plan, plan.durationSeconds + 30);
+    assert.equal(bar, plan.bars - 1);
+  });
+
+  it("never answers a negative position", () => {
+    const { bar, step } = positionAt(plan, -4);
+    assert.equal(bar, 0);
+    assert.equal(step, 0);
+  });
+});

package/tests/takestore.test.ts

@@ -0,0 +1,93 @@
+// # takestore.test — the session take store: the seam stays injectable (the
+// tests run on a memory stub), the ids dedupe (a re-render replaces its
+// earlier take), the order is newest first, broken documents answer empty
+// and a removal keeps the rest.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { planTake } from "../arranger.ts";
+import {
+  findTakeRecord,
+  loadTakeRecords,
+  memoryStorage,
+  removeTakePlan,
+  saveTakePlan,
+  TAKE_SELECT_KEY,
+  TAKE_STORE_KEY,
+} from "../takestore.ts";
+
+describe("takestore", () => {
+  it("stores a take and reads it back with its timestamp", () => {
+    const storage = memoryStorage();
+    const plan = planTake({ prompt: "midnight techno", seed: "s1" });
+    const records = saveTakePlan(plan, storage);
+    assert.equal(records.length, 1);
+    assert.ok(records[0].savedAt.length > 0);
+    assert.equal(loadTakeRecords(storage).length, 1);
+    assert.equal(loadTakeRecords(storage)[0].plan.id, plan.id);
+  });
+
+  it("replaces the record of the same plan id (the seed lock dedupes)", () => {
+    const storage = memoryStorage();
+    const first = planTake({ prompt: "midnight techno", seed: "s1" });
+    const again = planTake({ prompt: "midnight techno", seed: "s1" });
+    saveTakePlan(first, storage);
+    const records = saveTakePlan(again, storage);
+    assert.equal(records.length, 1);
+    assert.equal(findTakeRecord(first.id, storage)?.plan.id, again.id);
+  });
+
+  it("orders the shelf newest first", () => {
+    const storage = memoryStorage();
+    const early = planTake({ prompt: "early techno", seed: "a" });
+    const late = planTake({ prompt: "late house", seed: "b" });
+    const afterFirst = saveTakePlan(early, storage);
+    // force the second record to read later than the first
+    const clock = Date.now();
+    const realNow = Date.now;
+    Date.now = () => clock + 5;
+    const afterSecond = saveTakePlan(late, storage);
+    Date.now = realNow;
+    assert.equal(afterSecond[0].plan.id, late.id);
+    assert.equal(afterSecond.length, 2);
+    assert.ok(afterFirst.length === 1);
+  });
+
+  it("removes one take and keeps the rest", () => {
+    const storage = memoryStorage();
+    const one = planTake({ prompt: "one techno", seed: "a" });
+    const two = planTake({ prompt: "two house", seed: "b" });
+    saveTakePlan(one, storage);
+    saveTakePlan(two, storage);
+    const records = removeTakePlan(one.id, storage);
+    assert.equal(records.length, 1);
+    assert.equal(records[0].plan.id, two.id);
+    assert.equal(findTakeRecord(one.id, storage), undefined);
+  });
+
+  it("answers empty for a broken or missing document", () => {
+    const storage = memoryStorage();
+    assert.deepEqual(loadTakeRecords(storage), []);
+    storage.setItem(TAKE_STORE_KEY, "{not json");
+    assert.deepEqual(loadTakeRecords(storage), []);
+    storage.setItem(TAKE_STORE_KEY, JSON.stringify({ nope: true }));
+    assert.deepEqual(loadTakeRecords(storage), []);
+  });
+
+  it("drops records without a plan id or bpm", () => {
+    const storage = memoryStorage();
+    const plan = planTake({ prompt: "keeps techno", seed: "a" });
+    saveTakePlan(plan, storage);
+    storage.setItem(
+      TAKE_STORE_KEY,
+      JSON.stringify([{ plan: { id: "x" } }, ...JSON.parse(storage.getItem(TAKE_STORE_KEY) ?? "[]")]),
+    );
+    const records = loadTakeRecords(storage);
+    assert.equal(records.length, 1);
+    assert.equal(records[0].plan.id, plan.id);
+  });
+
+  it("keeps the studio hand-off key beside the shelf key", () => {
+    assert.equal(TAKE_STORE_KEY, "debonair.takes");
+    assert.equal(TAKE_SELECT_KEY, "debonair.studio.take");
+  });
+});

package/tests/tuning.test.ts

@@ -0,0 +1,27 @@
+// # tuning.test — the midi-to-hertz conversion the studio transport reads:
+// A4 anchors the table, every semitone is the 12th root of two, and an
+// octave doubles. The recipes ride this one function; the tests pin it.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { A4_MIDI, CONCERT_PITCH, midiToHz } from "../Sol/studio/tuning.ts";
+
+describe("tuning — midiToHz", () => {
+  it("anchors A4 at the concert pitch", () => {
+    assert.equal(A4_MIDI, 69);
+    assert.equal(CONCERT_PITCH, 440);
+    assert.equal(midiToHz(A4_MIDI), 440);
+  });
+
+  it("doubles every octave and halves below", () => {
+    assert.ok(Math.abs(midiToHz(A4_MIDI + 12) - 880) < 1e-9);
+    assert.ok(Math.abs(midiToHz(A4_MIDI - 12) - 220) < 1e-9);
+  });
+
+  it("walks the chromatic steps of the equal temperament", () => {
+    const semitone = 2 ** (1 / 12);
+    assert.ok(Math.abs(midiToHz(A4_MIDI + 0.5) - 440 * 2 ** (1 / 24)) < 1e-9); // fractional bends
+    assert.ok(Math.abs(midiToHz(60) - 261.6256) < 1e-4); // middle C
+    assert.ok(Math.abs(midiToHz(24) - 32.7032) < 1e-4); // the sub bass floor
+    assert.ok(Math.abs(midiToHz(A4_MIDI + 1) - 440 * semitone) < 1e-9);
+  });
+});