Merge pull request #42 from gantasmo/feat/mix-overhaul

Feat/mix overhaul

Author: danieljtrujillo

docs/reports/feature-doc-coverage-report.md

@@ -1,7 +1,7 @@
 # Feature Documentation Coverage Report
 
 > [!NOTE]
-> Generated: 2026-06-04T00:03:28.008Z · Git revision: `97c1f25331f1` · Repomix tracked: **no**
+> Generated: 2026-06-04T00:59:56.920Z · Git revision: `558142ceb17c` · Repomix tracked: **no**
 
 ## Audit Dashboard
 

docs/reports/feature-doc-coverage.json

@@ -1,6 +1,6 @@
 {
-  "generatedAt": "2026-06-04T00:03:28.008Z",
-  "repoRevision": "97c1f25331f1",
+  "generatedAt": "2026-06-04T00:59:56.920Z",
+  "repoRevision": "558142ceb17c",
   "repomixContext": {
     "path": "repomix-output.md",
     "present": false,

docs/screenshots/manifest.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-06-04T00:05:28.550Z",
+  "generatedAt": "2026-06-04T01:02:35.334Z",
   "entries": [
     {
       "file": "01-shell-make.png",

frontend/src/state/djEngine.ts

@@ -130,6 +130,10 @@ let cueBus: GainNode | null = null;
 let cueDest: MediaStreamAudioDestinationNode | null = null;
 let cueAudioEl: HTMLAudioElement | null = null;
 let cueSinkId = '';
+// Sampler bank (D7): one-shot pads routed through djMaster (so they ride the DJ
+// mix + limiter + visualizer). Decoded buffers keyed by pad id.
+const samples = new Map<string, AudioBuffer>();
+let samplerGain: GainNode | null = null;
 const decks: Partial<Record<DeckId, Deck>> = {};
 let crossfade = 0; // -1 = full A, 0 = center, +1 = full B
 let rafId = 0;
@@ -169,6 +173,13 @@ function ensureCueBus(): GainNode {
   return cueBus;
 }
 
+function ensureSamplerGain(): GainNode {
+  if (samplerGain) return samplerGain;
+  samplerGain = getEngineCtx().createGain();
+  samplerGain.connect(ensureMaster());
+  return samplerGain;
+}
+
 /** The node a playing source feeds into: the key-lock pitch insert when engaged,
  *  else the deck's delay-comp input (insert bypassed). */
 function deckInputNode(d: Deck): AudioNode {
@@ -710,6 +721,32 @@ export function getCueSinkId(): string {
   return cueSinkId;
 }
 
+/* -------------------------------- sampler bank (D7) ------------------------ */
+
+/** Load a one-shot sample into a pad (decode the URL to a buffer). */
+export async function loadSample(padId: string, url: string): Promise<void> {
+  const ctx = getEngineCtx();
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`sample fetch ${r.status}`);
+  samples.set(padId, await ctx.decodeAudioData(await r.arrayBuffer()));
+}
+
+/** Fire a pad's sample as a one-shot through the DJ master (polyphonic). */
+export function triggerSample(padId: string): void {
+  const buf = samples.get(padId);
+  if (!buf) return;
+  const ctx = getEngineCtx();
+  if (ctx.state === 'suspended') void ctx.resume().catch(() => { /* retry next gesture */ });
+  const s = ctx.createBufferSource();
+  s.buffer = buf;
+  s.connect(ensureSamplerGain());
+  s.onended = () => { try { s.disconnect(); } catch { /* gone */ } };
+  s.start();
+}
+
+export function clearSample(padId: string): void { samples.delete(padId); }
+export function hasSample(padId: string): boolean { return samples.has(padId); }
+
 /** Crossfader position in [-1, 1] (equal-power). */
 export function setCrossfade(x: number): void {
   crossfade = clamp(x, -1, 1);
@@ -885,6 +922,8 @@ export function dispose(): void {
   if (cueBus) { try { cueBus.disconnect(); } catch { /* gone */ } cueBus = null; }
   if (cueAudioEl) { try { cueAudioEl.pause(); cueAudioEl.srcObject = null; } catch { /* gone */ } cueAudioEl = null; }
   cueDest = null;
+  if (samplerGain) { try { samplerGain.disconnect(); } catch { /* gone */ } samplerGain = null; }
+  samples.clear();
   if (djMaster) { try { djMaster.disconnect(); } catch { /* gone */ } djMaster = null; }
   listeners.clear();
 }

frontend/src/state/djSamplerStore.ts

@@ -0,0 +1,33 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+/* DJ sampler bank (D7) — persisted pad → library-entry assignments. The decoded
+ * one-shot buffers live in djEngine (re-decoded on mount from each entry's
+ * audioUrl); this store only remembers which track sits on which pad so the
+ * bank survives a reload. */
+
+export interface SamplerPad {
+  entryId: string;
+  name: string;
+}
+
+interface DjSamplerState {
+  pads: Record<number, SamplerPad>;
+  setPad: (i: number, pad: SamplerPad) => void;
+  clearPad: (i: number) => void;
+}
+
+export const useDjSampler = create<DjSamplerState>()(
+  persist(
+    (set) => ({
+      pads: {},
+      setPad: (i, pad) => set((s) => ({ pads: { ...s.pads, [i]: pad } })),
+      clearPad: (i) => set((s) => {
+        const p = { ...s.pads };
+        delete p[i];
+        return { pads: p };
+      }),
+    }),
+    { name: 'thedaw.dj.sampler.v1' },
+  ),
+);

frontend/src/state/djSideListStore.ts

@@ -0,0 +1,50 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+/* DJ side list (D7) — an ephemeral "prepare / play-next" staging queue, distinct
+ * from the persisted named Setlists. The DJ drags tracks here from the browser
+ * while a set is playing, reorders them into the order they want to hear them,
+ * then fires each onto a deck (→A/→B) or pushes the whole queue into the active
+ * Automix set. Only the library-entry id + a display label are stored (the
+ * browser resolves BPM/key/art live), so a staged queue survives a reload and
+ * silently drops tracks that no longer exist in the library. */
+
+export interface SideListItem {
+  entryId: string;
+  label: string;
+}
+
+interface DjSideListState {
+  items: SideListItem[];
+  /** Append a track to the end of the queue; no-ops if already staged. */
+  add: (item: SideListItem) => void;
+  /** Remove a staged track by entry id. */
+  remove: (entryId: string) => void;
+  /** Move the item at `from` to index `to` (clamped). */
+  reorder: (from: number, to: number) => void;
+  /** Empty the queue. */
+  clear: () => void;
+}
+
+export const useDjSideList = create<DjSideListState>()(
+  persist(
+    (set) => ({
+      items: [],
+      add: (item) => set((s) => (
+        s.items.some((it) => it.entryId === item.entryId)
+          ? s
+          : { items: [...s.items, item] }
+      )),
+      remove: (entryId) => set((s) => ({ items: s.items.filter((it) => it.entryId !== entryId) })),
+      reorder: (from, to) => set((s) => {
+        if (to < 0 || to >= s.items.length || from === to) return s;
+        const arr = [...s.items];
+        const [it] = arr.splice(from, 1);
+        arr.splice(to, 0, it);
+        return { items: arr };
+      }),
+      clear: () => set({ items: [] }),
+    }),
+    { name: 'thedaw.dj.sidelist.v1' },
+  ),
+);