@hraness/dawg 0.7.0 → 0.8.0

package/src/session/live-host.ts

@@ -0,0 +1,232 @@
+/**
+ * dawgd's live path: every pane's played notes and the click mix on the one
+ * engine this machine runs (design §12.3). A pane sends note events, never
+ * audio; dawgd renders each voice from the score it already holds, through
+ * the same `LiveSynth` a solo window uses, so a key sounds the same either
+ * way.
+ *
+ * Voice ids are window-local, so they are namespaced by client. The click is
+ * on while any pane wants it and follows dawgd's own transport clock; a
+ * count-in comes from the pane that armed last.
+ */
+import type { ClickBus } from "../audio/engine.ts";
+import { countInClicks, meterClickGrid } from "../audio/click.ts";
+import { LiveSynth, type LiveNotePcm } from "../audio/live.ts";
+import type { SampleBank } from "../audio/samples.ts";
+import { hasMeterChanges, loopTickAt } from "../../core/tempo.ts";
+import type { TrackScore } from "../../core/score.ts";
+import type { LiveClick, LiveMessage, LiveStatus } from "./protocol.ts";
+
+/** The part of AudioEngine the live host drives. */
+export interface LiveSink {
+  readonly sampleRate: number;
+  readonly canMonitor: boolean;
+  readonly leadMs: number;
+  readonly playLeadMs?: number;
+  readonly audioNote?: string;
+  monitor(on: boolean): Promise<void>;
+  setLeadMs(ms: number | undefined): void;
+  noteOn(id: number, note: LiveNotePcm): number;
+  noteOff(id: number): void;
+  voicePosition?(id: number): number | undefined;
+  setClick(click: ClickBus | undefined): void;
+}
+
+export type LiveHostOptions = {
+  sink: LiveSink;
+  score(): TrackScore;
+  samples?(): SampleBank | undefined;
+  /** Transport beat at monotonic `ms`, or undefined while stopped. */
+  transportBeatAt(ms: number): number | undefined;
+  /** Authority clock (epoch ms) to local monotonic ms. */
+  toMonotonic(epochMs: number): number;
+  log?(line: string): void;
+};
+
+/** Longest a held live note renders before its key-up arrives. */
+const MAX_SECONDS = 8;
+
+export class LiveHost {
+  private readonly monitors = new Set<string>();
+  private readonly clicks = new Map<string, LiveClick>();
+  private readonly voices = new Map<string, number>();
+  private nextVoice = 1;
+  private synth: LiveSynth | undefined;
+  /** Notes played since start, by client (tests and the log read it). */
+  public readonly played = new Map<string, number>();
+
+  public constructor(private readonly options: LiveHostOptions) {}
+
+  public status(): LiveStatus {
+    const sink = this.options.sink;
+    const status: LiveStatus = {
+      canMonitor: sink.canMonitor,
+      sampleRate: sink.sampleRate,
+      leadMs: sink.playLeadMs ?? sink.leadMs,
+    };
+    if (sink.audioNote) status.note = `shared engine · ${sink.audioNote}`;
+    return status;
+  }
+
+  public async handle(
+    client: string,
+    message: LiveMessage,
+  ): Promise<LiveStatus | undefined> {
+    if (message.action === "monitor") {
+      await this.monitor(client, message.on);
+      return this.status();
+    }
+    if (message.action === "on") this.noteOn(client, message);
+    else if (message.action === "off") this.noteOff(client, message.voice);
+    else {
+      const { on, volume } = message;
+      const click: LiveClick = { on, volume };
+      if (message.countIn) click.countIn = message.countIn;
+      if (on || click.countIn) this.clicks.set(client, click);
+      else this.clicks.delete(client);
+      this.applyClick();
+    }
+    return undefined;
+  }
+
+  /** A pane left: its voices stop, its click and monitor drop out. */
+  public async drop(client: string): Promise<void> {
+    for (const [key, id] of this.voices)
+      if (key.startsWith(`${client}:`)) {
+        this.options.sink.noteOff(id);
+        this.voices.delete(key);
+      }
+    this.clicks.delete(client);
+    this.applyClick();
+    if (this.monitors.delete(client) && this.monitors.size === 0)
+      await this.release();
+  }
+
+  public get monitoring(): number {
+    return this.monitors.size;
+  }
+
+  private async monitor(client: string, on: boolean): Promise<void> {
+    const sink = this.options.sink;
+    if (on) {
+      const first = this.monitors.size === 0;
+      this.monitors.add(client);
+      if (first) {
+        sink.setLeadMs(sink.playLeadMs);
+        await sink.monitor(true);
+        this.options.log?.("live: monitor on");
+      }
+      return;
+    }
+    if (this.monitors.delete(client) && this.monitors.size === 0)
+      await this.release();
+  }
+
+  private async release(): Promise<void> {
+    const sink = this.options.sink;
+    sink.setLeadMs(undefined);
+    await sink.monitor(false);
+    this.options.log?.("live: monitor off");
+  }
+
+  private noteOn(
+    client: string,
+    message: Extract<LiveMessage, { action: "on" }>,
+  ): void {
+    this.played.set(client, (this.played.get(client) ?? 0) + 1);
+    this.options.log?.(
+      `live: note ${client} ${message.trackId} ${message.pitch} beat ${message.beat.toFixed(2)}`,
+    );
+    const sink = this.options.sink;
+    if (!sink.canMonitor) return;
+    const score = this.options.score();
+    if (!score.tracks.some((track) => track.id === message.trackId)) return;
+    if (this.synth?.rate !== sink.sampleRate)
+      this.synth = new LiveSynth(sink.sampleRate);
+    const samples = this.options.samples?.();
+    const request = {
+      score,
+      trackId: message.trackId,
+      pitch: message.pitch,
+      velocity: message.velocity,
+      seconds: Math.min(message.seconds, MAX_SECONDS),
+      ...(samples ? { samples } : {}),
+      ...(score.time?.tempo ? { tick: loopTickAt(score, message.beat) } : {}),
+    };
+    const synth = this.synth;
+    const pcm = synth.render(request);
+    if (!pcm || pcm.fitting) return;
+    const key = `${client}:${message.voice}`;
+    const previous = this.voices.get(key);
+    const id = previous ?? this.nextVoice++;
+    this.voices.set(key, id);
+    sink.noteOn(id, pcm);
+    // A rig's first window sounds now; the whole note follows off the key
+    // path and swaps in place while the voice still sounds.
+    if (pcm.partial)
+      setTimeout(() => {
+        if (this.voices.get(key) !== id) return;
+        const full = synth.render({
+          ...request,
+          full: true,
+          ...(pcm.clock === undefined ? {} : { clock: pcm.clock }),
+        });
+        if (full && sink.voicePosition?.(id) !== undefined)
+          sink.noteOn(id, full);
+      }, 0);
+  }
+
+  private noteOff(client: string, voice: number): void {
+    const key = `${client}:${voice}`;
+    const id = this.voices.get(key);
+    if (id === undefined) return;
+    this.voices.delete(key);
+    this.options.sink.noteOff(id);
+  }
+
+  /** The one click: on while any pane wants it. */
+  private applyClick(): void {
+    const sink = this.options.sink;
+    let wanted: LiveClick | undefined;
+    for (const click of this.clicks.values())
+      if (click.on || click.countIn) wanted = click;
+    if (!wanted) {
+      sink.setClick(undefined);
+      return;
+    }
+    const score = this.options.score;
+    const count = wanted.countIn;
+    const startMs = count
+      ? this.options.toMonotonic(count.startAtMs)
+      : undefined;
+    const on = [...this.clicks.values()].some((click) => click.on);
+    let grid: ClickBus["grid"];
+    if (count && hasMeterChanges(score()))
+      grid = (from, to) =>
+        countInClicks(
+          count.startBeat,
+          count.beats / count.barBeats,
+          count.barBeats,
+          count.clickBeats,
+          from,
+          to,
+        );
+    else if (!count && hasMeterChanges(score())) grid = meterClickGrid(score);
+    sink.setClick({
+      volume: wanted.volume,
+      beatsPerBar: score().beatsPerBar,
+      subdivision: 1,
+      beatAt: (ms) => {
+        if (count && startMs !== undefined) {
+          const beat =
+            count.startBeat -
+            count.beats +
+            (ms - startMs) / (60_000 / count.bpm);
+          if (beat < count.startBeat) return beat;
+        }
+        return on ? this.options.transportBeatAt(ms) : undefined;
+      },
+      ...(grid ? { grid } : {}),
+    });
+  }
+}

package/src/session/origin.ts

@@ -152,3 +152,23 @@ export function editedTrack(
   }
   return changed.size === 1 ? [...changed][0] : undefined;
 }
+
+/**
+ * The pane letters that authored `events` (dawgd stamps each event's
+ * clientId), in event order, excluding this pane. Empty when no author is a
+ * live lettered pane (file sessions, v1 daemons, a pane that already left).
+ */
+export function paneLetters(
+  events: readonly Pick<SessionEvent, "actor">[],
+  clients: readonly { clientId: string; pane?: string }[],
+  selfId: string,
+): string[] {
+  const letters: string[] = [];
+  for (const event of events) {
+    const id = event.actor?.clientId;
+    if (!id || id === selfId) continue;
+    const pane = clients.find((client) => client.clientId === id)?.pane;
+    if (pane && !letters.includes(pane)) letters.push(pane);
+  }
+  return letters;
+}

package/src/session/port.ts

@@ -5,10 +5,13 @@ import type { TrackScore } from "../../core/score.ts";
 import { AudioEngine } from "../audio/engine.ts";
 import { DaemonClient, type DaemonClientOptions } from "./client.ts";
 import { FilePresence } from "./presence.ts";
-import type {
-  PresenceEntry,
-  TransportAction,
-  TransportState,
+import type { LiveLink } from "./shared-live.ts";
+import {
+  toLocalTransport,
+  type PaneView,
+  type PresenceEntry,
+  type TransportAction,
+  type TransportState,
 } from "./protocol.ts";
 import type { MetaExpect, MetaPatch, SessionMeta } from "./meta.ts";
 import {
@@ -16,6 +19,7 @@ import {
   loadSession,
   SessionConflictError,
   updateSessionMeta,
+  type EventActor,
   type SessionEvent,
   type SessionPaths,
   type SessionRecord,
@@ -113,6 +117,15 @@ export interface SessionPort<T> {
     preferred?: string,
   ): Promise<{ trackId: string; draft: boolean }>;
   presence(): Promise<PresenceEntry[]>;
+  /** This pane's letter (daemon mode, assigned by dawgd). */
+  readonly pane: string | undefined;
+  /** Reports what this pane shows; others see it in presence. */
+  setView(view: PaneView): void;
+  /**
+   * The machine's shared live engine (daemon with the `live` capability),
+   * or undefined: the pane then plays through its own monitor engine.
+   */
+  liveLink(): LiveLink | undefined;
   /**
    * Conditional metadata write: applies only while `expect` matches the
    * stored metadata, so a user rename always beats an in-flight auto-name.
@@ -126,6 +139,8 @@ export type OpenPortOptions = {
   sessionId: string;
   label: string;
   focusedTrackId: string | null;
+  /** Who is at this window; stamped on events and presence. */
+  actor?: { id: string; name: string };
   /** Set false for one-shot commands (demo, export) that must not spawn dawgd. */
   daemon?: boolean;
   daemonArgs?: string[];
@@ -148,6 +163,7 @@ export async function openSessionPort<T>(
         label: options.label,
         focusedTrackId: options.focusedTrackId,
       };
+      if (options.actor) clientOptions.actor = options.actor;
       if (options.daemonArgs) clientOptions.daemonArgs = options.daemonArgs;
       const client = await DaemonClient.connect(clientOptions);
       return new DaemonPort<T>(client);
@@ -176,6 +192,12 @@ class DaemonPort<T> implements SessionPort<T> {
   public status: string;
   public sync: SyncStatus = "synced";
   private readonly syncListeners = new Set<(sync: SyncStatus) => void>();
+  /**
+   * (authority clock - this machine's clock), applied to every transport
+   * `atMs` before the window sees it. Always 0 on one machine; the hook a
+   * future relay fills from its clock-sync exchange.
+   */
+  public clockOffsetMs = 0;
 
   public constructor(private readonly client: DaemonClient) {
     this.status = `dawgd pid ${client.daemonPid}`;
@@ -257,7 +279,10 @@ class DaemonPort<T> implements SessionPort<T> {
   }
 
   public subscribe(listener: (update: PortUpdate<T>) => void): () => void {
-    listener({ type: "transport", transport: this.client.transport });
+    listener({
+      type: "transport",
+      transport: toLocalTransport(this.client.transport, this.clockOffsetMs),
+    });
     const onSync = (sync: SyncStatus) => listener({ type: "sync", sync });
     this.syncListeners.add(onSync);
     const unsubscribe = this.client.subscribe((update) => {
@@ -269,7 +294,12 @@ class DaemonPort<T> implements SessionPort<T> {
         this.status = update.message;
         this.setSync(update.connected ? "synced" : "offline");
         listener({ type: "status", message: update.message });
-      } else listener(update);
+      } else if (update.type === "transport")
+        listener({
+          type: "transport",
+          transport: toLocalTransport(update.transport, this.clockOffsetMs),
+        });
+      else listener(update);
     });
     return () => {
       this.syncListeners.delete(onSync);
@@ -300,6 +330,28 @@ class DaemonPort<T> implements SessionPort<T> {
     return this.client.presence;
   }
 
+  public get pane(): string | undefined {
+    return this.client.self?.pane;
+  }
+
+  public setView(view: PaneView): void {
+    if (this.client.caps.includes("panes")) this.client.setView(view);
+  }
+
+  public liveLink(): LiveLink | undefined {
+    if (!this.client.sharedLive) return undefined;
+    const client = this.client;
+    const port = this;
+    return (this.link ??= {
+      liveMonitor: (on) => client.liveMonitor(on),
+      live: (message) => client.live(message),
+      get clockOffsetMs() {
+        return port.clockOffsetMs;
+      },
+    });
+  }
+  private link: LiveLink | undefined;
+
   public async updateMeta(
     patch: MetaPatch,
     expect?: MetaExpect,
@@ -331,6 +383,14 @@ class FilePort<T> implements SessionPort<T> {
   public readonly player: WindowPlayer;
   private readonly presenceStore: FilePresence;
   private readonly statusListeners = new Set<(update: PortUpdate<T>) => void>();
+  /** File sessions have no pane letters or shared engine (§12.3). */
+  public readonly pane = undefined;
+
+  public setView(_view: PaneView): void {}
+
+  public liveLink(): LiveLink | undefined {
+    return undefined;
+  }
 
   private constructor(private readonly options: OpenPortOptions) {
     this.player = new AudioEngine({
@@ -346,6 +406,7 @@ class FilePort<T> implements SessionPort<T> {
       pid: process.pid,
       label: options.label.slice(0, 128),
       focusedTrackId: options.focusedTrackId,
+      ...(options.actor ? { actorId: options.actor.id } : {}),
     });
   }
 
@@ -361,17 +422,33 @@ class FilePort<T> implements SessionPort<T> {
     event: Omit<SessionEvent, "id" | "revision" | "at">,
     composition: T,
   ): Promise<SessionRecord<T>> {
-    return appendSessionEvent(this.options.paths, current, event, composition);
+    const actor: EventActor = { clientId: this.clientId };
+    if (this.options.actor) actor.actorId = this.options.actor.id;
+    return appendSessionEvent(
+      this.options.paths,
+      current,
+      { ...event, actor },
+      composition,
+    );
   }
 
-  /** No daemon to rebase against: commit the full composition. */
+  /**
+   * No daemon to rebase against: commit the full composition, and keep the
+   * operations on the event so the log still replays as ops.
+   */
   public appendOperations(
     current: SessionRecord<T>,
     event: Omit<SessionEvent, "id" | "revision" | "at">,
-    _operations: readonly unknown[],
+    operations: readonly unknown[],
     composition: T,
   ): Promise<SessionRecord<T>> {
-    return this.append(current, event, composition);
+    return this.append(
+      current,
+      operations.length > 0 && operations.length <= MAX_INTENT_OPERATIONS
+        ? { ...event, ops: [...operations] }
+        : event,
+      composition,
+    );
   }
 
   public load(): Promise<SessionRecord<T>> {