@hraness/dawg 0.2.0 → 0.3.0

package/src/session/port.ts

@@ -56,6 +56,8 @@ export type WindowPlayer = {
   /** Start at `beat`, or swap a playing loop in place (gapless engine). */
   play(score: TrackScore, beat?: number): Promise<void>;
   stop(): void;
+  /** Stops and releases the render worker; the player is done for good. */
+  dispose(): Promise<void>;
 };
 
 /**
@@ -65,6 +67,8 @@ export type WindowPlayer = {
  */
 export interface SessionPort<T> {
   readonly mode: "daemon" | "file";
+  /** This window's presence id, to exclude itself from `presence()`. */
+  readonly clientId: string;
   /** Human-readable status for the activity line. */
   readonly status: string;
   readonly player: WindowPlayer;
@@ -157,10 +161,12 @@ export async function openSessionPort<T>(
 const silentPlayer: WindowPlayer = {
   play: async () => undefined,
   stop: () => undefined,
+  dispose: async () => undefined,
 };
 
 class DaemonPort<T> implements SessionPort<T> {
   public readonly mode = "daemon" as const;
+  public readonly clientId: string;
   public readonly player = silentPlayer;
   public status: string;
   public sync: SyncStatus = "synced";
@@ -168,6 +174,7 @@ class DaemonPort<T> implements SessionPort<T> {
 
   public constructor(private readonly client: DaemonClient) {
     this.status = `dawgd pid ${client.daemonPid}`;
+    this.clientId = client.clientId;
   }
 
   private setSync(sync: SyncStatus): void {
@@ -303,17 +310,24 @@ class DaemonPort<T> implements SessionPort<T> {
 
 class FilePort<T> implements SessionPort<T> {
   public readonly mode = "file" as const;
+  public readonly clientId = randomUUID();
   public status = "file session";
   public readonly sync = "local" as const;
   public readonly player: WindowPlayer;
   private readonly presenceStore: FilePresence;
+  private readonly statusListeners = new Set<(update: PortUpdate<T>) => void>();
 
   private constructor(private readonly options: OpenPortOptions) {
     this.player = new AudioEngine({
       lockPath: `${options.paths.record}.audio.lock`,
+      projectRoot: dirname(options.paths.root),
+      onStatus: (status) => {
+        for (const listener of this.statusListeners)
+          listener({ type: "status", message: status.message });
+      },
     });
     this.presenceStore = new FilePresence(options.paths, {
-      clientId: randomUUID(),
+      clientId: this.clientId,
       pid: process.pid,
       label: options.label.slice(0, 128),
       focusedTrackId: options.focusedTrackId,
@@ -393,13 +407,17 @@ class FilePort<T> implements SessionPort<T> {
         });
     };
     const recordName = basename(this.options.paths.record);
+    // macOS coalesces the temp write and the rename into events named after
+    // the temp file (`<record>.<pid>.tmp`), so match that too, but not the
+    // sibling `.audio.lock` / `.daemon.log` files that share the prefix.
+    const recordFile = new RegExp(
+      `^${recordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\.\\d+\\.tmp)?$`,
+    );
     let watcher: FSWatcher | undefined;
     try {
       watcher = watch(dirname(this.options.paths.record), (_event, file) => {
-        // macOS coalesces the temp write and the rename into events named
-        // after the temp file (`<record>.<pid>.tmp`), so match the prefix and
-        // re-check shortly after in case the event preceded the rename.
-        if (file !== null && !String(file).startsWith(recordName)) return;
+        // Re-check shortly after in case the event preceded the rename.
+        if (file !== null && !recordFile.test(String(file))) return;
         check();
         setTimeout(check, 40).unref?.();
       });
@@ -412,9 +430,11 @@ class FilePort<T> implements SessionPort<T> {
       watcher = undefined;
     }
     const timer = setInterval(check, watcher ? WATCHED_POLL_MS : POLL_MS);
+    this.statusListeners.add(listener);
     check();
     return () => {
       closed = true;
+      this.statusListeners.delete(listener);
       clearInterval(timer);
       watcher?.close();
     };
@@ -455,7 +475,7 @@ class FilePort<T> implements SessionPort<T> {
   }
 
   public async close(): Promise<void> {
-    this.player.stop();
+    void this.player.dispose();
     await this.presenceStore.stop();
   }
 }

package/src/session/rebase.ts

@@ -15,6 +15,7 @@ import {
   type ScoreOperation,
   type TrackScore,
 } from "../../core/score.ts";
+import { rewindComposition, type Rewind } from "./delta.ts";
 
 /** How far behind a base may be and still be rebased. */
 export const MAX_REBASE_DISTANCE = 64;
@@ -105,6 +106,30 @@ export function rebaseOperations(
         if (base.bars !== current.bars)
           return { ok: false, reason: "loop length changed" };
         break;
+      case "setKey":
+        if (base.key !== current.key)
+          return { ok: false, reason: "key changed" };
+        break;
+      case "setMeter":
+        if (base.beatsPerBar !== current.beatsPerBar)
+          return { ok: false, reason: "meter changed" };
+        break;
+      case "removeTrack": {
+        if (added.tracks.has(operation.trackId)) break;
+        if (
+          !settingsUnchanged(operation.trackId) ||
+          !notesUnchanged(operation.trackId)
+        )
+          return { ok: false, reason: `track ${operation.trackId} changed` };
+        break;
+      }
+      case "moveTrack": {
+        const order = (score: TrackScore) =>
+          score.tracks.map((track) => track.id).join("\u0000");
+        if (order(base) !== order(current))
+          return { ok: false, reason: "track order changed" };
+        break;
+      }
       default:
         return { ok: false, reason: "unsupported operation" };
     }
@@ -123,16 +148,21 @@ export function rebaseOperations(
 }
 
 /**
- * The composition at revision `revision`, recovered from the `before` of the
- * event that replaced it. Undefined when the log cannot vouch for it.
+ * The composition at revision `revision`, recovered by rewinding the current
+ * composition through every later event's `rewind`. Undefined when the log
+ * cannot vouch for it (a gap in revisions, or a rewind compacted away).
  */
 export function compositionAt(
-  events: readonly { revision: number; payload: unknown }[],
+  record: {
+    composition: unknown;
+    events: readonly { revision: number; rewind?: Rewind | undefined }[];
+  },
   revision: number,
 ): unknown {
-  const event = events[revision];
-  if (event === undefined || event.revision !== revision + 1) return undefined;
-  const payload = event.payload;
-  if (typeof payload !== "object" || payload === null) return undefined;
-  return (payload as { before?: unknown }).before;
+  const { events } = record;
+  if (!Number.isSafeInteger(revision) || revision < 0) return undefined;
+  if (revision >= events.length) return undefined;
+  for (let index = revision; index < events.length; index += 1)
+    if (events[index]!.revision !== index + 1) return undefined;
+  return rewindComposition(record.composition, events, revision);
 }

package/src/session/store.ts

@@ -1,7 +1,8 @@
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { acquireSessionLock } from "./lock.ts";
+import { diffRewind, parseRewind, type Rewind } from "./delta.ts";
 import {
   applyMetaPatch,
   defaultSessionMeta,
@@ -14,9 +15,14 @@ import {
   type SessionMeta,
 } from "./meta.ts";
 
+/** Caller payloads; the store keeps history separately in each event's `rewind`. */
 const MAX_EVENT_BYTES = 64 * 1024;
+/** A rewind larger than this (a wholesale import) is not kept; the edit still lands. */
+const MAX_REWIND_BYTES = 1024 * 1024;
 const MAX_EVENTS = 2_000;
-const MAX_RECORD_BYTES = 4 * 1024 * 1024;
+export const MAX_RECORD_BYTES = 4 * 1024 * 1024;
+/** Oldest rewinds are dropped in batches of this size when the record fills up. */
+const COMPACT_BATCH = 64;
 const MAX_SESSION_ID_LENGTH = 64;
 const MAX_EVENT_KIND_LENGTH = 128;
 const MAX_TIMESTAMP_LENGTH = 64;
@@ -34,6 +40,14 @@ export type SessionEvent = {
   kind: string;
   payload: unknown;
   at: string;
+  /**
+   * How to recover the composition this event replaced from the one it
+   * produced (see `delta.ts`). Absent once compacted away: the store drops
+   * the oldest rewinds first when the record would exceed its size cap, so
+   * an edit never fails because of history, and undo reaches as far back as
+   * the remaining rewinds form a contiguous suffix.
+   */
+  rewind?: Rewind;
 };
 
 export type SessionRecord<T> = {
@@ -149,7 +163,7 @@ export async function ensureSession<T>(
         ),
       };
       const validated = validateSessionRecord<T>(record);
-      await writeAtomic(paths.record, JSON.stringify(validated, null, 2));
+      await writeAtomic(paths.record, JSON.stringify(validated));
       return { paths, record: validated };
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
@@ -167,13 +181,18 @@ export async function ensureSession<T>(
 export async function appendSessionEvent<T>(
   paths: SessionPaths,
   current: SessionRecord<T>,
-  event: Omit<SessionEvent, "id" | "revision" | "at"> & { id?: string },
+  event: Omit<SessionEvent, "id" | "revision" | "at" | "rewind"> & {
+    id?: string;
+  },
   composition: T,
 ): Promise<SessionRecord<T>> {
   // dawgd passes the client's idempotency key as the durable event id so a
   // retried intent stays a no-op across daemon restarts.
   if (event.id !== undefined) assertSessionId(event.id);
-  const payloadJson = stringifyJson(event.payload, "session event payload");
+  // History is the store's job: a `before` composition in the payload (the
+  // pre-rewind convention) is dropped rather than persisted in full.
+  const payload = stripBefore(event.payload);
+  const payloadJson = stringifyJson(payload, "session event payload");
   const payloadBytes = Buffer.byteLength(payloadJson, "utf8");
   if (payloadBytes > MAX_EVENT_BYTES)
     throw new Error(`session event exceeds ${MAX_EVENT_BYTES} bytes`);
@@ -183,6 +202,7 @@ export async function appendSessionEvent<T>(
     event.kind.length > MAX_EVENT_KIND_LENGTH
   )
     throw new SessionValidationError("session event kind is invalid");
+  stringifyJson(composition, "session composition");
   const release = await acquireSessionLock(paths.lock);
   try {
     const disk = await readRecord<T>(paths.record);
@@ -193,33 +213,79 @@ export async function appendSessionEvent<T>(
       throw new Error(`session event limit ${MAX_EVENTS} reached`);
     const revision = disk.revision + 1;
     const at = new Date().toISOString();
+    const appended: SessionEvent = {
+      kind: event.kind,
+      payload,
+      id: event.id ?? randomUUID(),
+      revision,
+      at,
+    };
+    const rewind = diffRewind(disk.composition, composition);
+    if (Buffer.byteLength(JSON.stringify(rewind), "utf8") <= MAX_REWIND_BYTES)
+      appended.rewind = rewind;
     const next: SessionRecord<T> = {
       sessionId: disk.sessionId,
       revision,
       updatedAt: at,
       composition,
-      events: [
-        ...disk.events,
-        {
-          kind: event.kind,
-          payload: event.payload,
-          id: event.id ?? randomUUID(),
-          revision,
-          at,
-        },
-      ],
+      events: [...disk.events, appended],
       // Metadata always comes from disk so a rename written by another window
       // between this caller's read and its write is never reverted.
       meta: disk.meta,
     };
     const validated = validateSessionRecord<T>(next);
-    await writeAtomic(paths.record, JSON.stringify(validated, null, 2));
-    return validated;
+    const { record, json } = compactRecord(validated);
+    await writeAtomic(paths.record, json);
+    return record;
   } finally {
     await release();
   }
 }
 
+/**
+ * Keeps the record under its size cap by dropping the oldest events'
+ * rewinds, oldest first, so the rewinds that remain are always the newest
+ * contiguous run. Only the composition and the bounded payloads are
+ * irreducible; a record that still does not fit is rejected as before.
+ */
+function compactRecord<T>(record: SessionRecord<T>): {
+  record: SessionRecord<T>;
+  json: string;
+} {
+  let current = record;
+  let json = JSON.stringify(current);
+  while (Buffer.byteLength(json, "utf8") > MAX_RECORD_BYTES) {
+    const first = current.events.findIndex(
+      (event) => event.rewind !== undefined,
+    );
+    if (first < 0)
+      throw new SessionValidationError(
+        `session record exceeds ${MAX_RECORD_BYTES} bytes`,
+      );
+    const events = current.events.map((event, index) => {
+      if (index < first || index >= first + COMPACT_BATCH || !event.rewind)
+        return event;
+      const { rewind: _rewind, ...rest } = event;
+      return rest;
+    });
+    current = { ...current, events };
+    json = JSON.stringify(current);
+  }
+  return { record: current, json };
+}
+
+function stripBefore(payload: unknown): unknown {
+  if (
+    typeof payload !== "object" ||
+    payload === null ||
+    Array.isArray(payload) ||
+    !("before" in payload)
+  )
+    return payload;
+  const { before: _before, ...rest } = payload as Record<string, unknown>;
+  return rest;
+}
+
 export type MetaUpdate<T> =
   | { status: "applied"; record: SessionRecord<T> }
   | { status: "stale"; record: SessionRecord<T> };
@@ -245,7 +311,7 @@ export async function updateSessionMeta<T>(
       meta: applyMetaPatch(disk.meta, patch, new Date().toISOString()),
     };
     const validated = validateSessionRecord<T>(next);
-    await writeAtomic(paths.record, JSON.stringify(validated, null, 2));
+    await writeAtomic(paths.record, JSON.stringify(validated));
     return { status: "applied", record: validated };
   } finally {
     await release();
@@ -277,7 +343,7 @@ export async function createForkSession<T>(
       forkOf: { sessionId: source.sessionId, revision: source.revision },
     },
   });
-  await writeAtomic(paths.record, JSON.stringify(record, null, 2));
+  await writeAtomic(paths.record, JSON.stringify(record));
   return record;
 }
 
@@ -348,7 +414,18 @@ async function writeAtomic(path: string, contents: string): Promise<void> {
       `session record exceeds ${MAX_RECORD_BYTES} bytes`,
     );
   const temporary = `${path}.${process.pid}.tmp`;
-  await writeFile(temporary, `${contents}\n`, "utf8");
+  // Durable before it is visible: the data reaches the disk before the
+  // rename publishes it, so a crash never leaves a truncated record behind.
+  const handle = await open(temporary, "w", 0o644);
+  try {
+    await handle.writeFile(`${contents}\n`, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close().catch(() => undefined);
+    await rm(temporary, { force: true }).catch(() => undefined);
+    throw error;
+  }
+  await handle.close();
   await rename(temporary, path);
 }
 
@@ -432,7 +509,25 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
       throw new SessionValidationError(
         `session event exceeds ${MAX_EVENT_BYTES} bytes`,
       );
-    return candidate as unknown as SessionEvent;
+    let rewind: Rewind | undefined;
+    try {
+      rewind = parseRewind(candidate.rewind);
+    } catch (error) {
+      throw new SessionValidationError(
+        error instanceof Error
+          ? error.message
+          : "session event rewind is invalid",
+      );
+    }
+    const parsed: SessionEvent = {
+      id: candidate.id,
+      revision: candidate.revision,
+      kind: candidate.kind,
+      payload: candidate.payload,
+      at: candidate.at,
+    };
+    if (rewind !== undefined) parsed.rewind = rewind;
+    return parsed;
   });
   let meta: SessionMeta;
   try {