@hraness/dawg 0.6.1 → 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/meta.ts

@@ -30,6 +30,11 @@ export type SessionMeta = {
   namedFingerprint?: string;
   /** Track-and-instrument-set hash at the last auto name. */
   namedStructure?: string;
+  /**
+   * Optional (0.7): the song's loop has wrapped once, so the one-shot
+   * `↻ first loop` moment never repeats. Session state, never the score.
+   */
+  heardLoop?: true;
 };
 
 /** Fields a client may change. `null` clears an optional field. */
@@ -38,6 +43,8 @@ export type MetaPatch = {
   nameSource?: NameSource;
   namedFingerprint?: string | null;
   namedStructure?: string | null;
+  /** Only ever set; the first loop is heard once. */
+  heardLoop?: true;
 };
 
 /** A conditional write applies only when every given field still matches. */
@@ -125,6 +132,7 @@ export function parseSessionMeta(
   if (fingerprint) result.namedFingerprint = fingerprint;
   const structure = optionalFingerprint(meta.namedStructure);
   if (structure) result.namedStructure = structure;
+  if (meta.heardLoop === true) result.heardLoop = true;
   return result;
 }
 
@@ -144,6 +152,11 @@ export function parseMetaPatch(value: unknown): MetaPatch {
     if (raw[key] === undefined) continue;
     patch[key] = raw[key] === null ? null : requireFingerprint(raw[key]);
   }
+  if (raw.heardLoop !== undefined) {
+    if (raw.heardLoop !== true)
+      throw new MetaValidationError("heardLoop is invalid");
+    patch.heardLoop = true;
+  }
   if (Object.keys(patch).length === 0)
     throw new MetaValidationError("meta patch is empty");
   return patch;
@@ -184,6 +197,7 @@ export function applyMetaPatch(
   };
   if (patch.name !== undefined) next.name = patch.name;
   if (patch.nameSource !== undefined) next.nameSource = patch.nameSource;
+  if (patch.heardLoop) next.heardLoop = true;
   for (const key of ["namedFingerprint", "namedStructure"] as const) {
     if (patch[key] === null) delete next[key];
     else if (patch[key] !== undefined) next[key] = patch[key];

package/src/session/origin.ts

@@ -0,0 +1,174 @@
+import { WRITTEN_REVISION, type SessionPort } from "./port.ts";
+import type { SessionEvent, SessionRecord } from "./store.ts";
+
+/**
+ * Remembers the events this window wrote, so the "synced" card shows only
+ * for revisions that came from another client (design C12). Session events
+ * carry no writer id, so the tracker records the id of the event each of
+ * this window's appends produced, and holds a decision while a write is in
+ * flight (a watcher update can land before the append resolves).
+ */
+export class OwnWrites {
+  private readonly ids = new Set<string>();
+  private inflight = 0;
+  private waiters: (() => void)[] = [];
+
+  /** Wraps one append: records the event it produced. */
+  public async track<T>(
+    write: Promise<SessionRecord<T>>,
+  ): Promise<SessionRecord<T>> {
+    this.inflight++;
+    try {
+      const record = await write;
+      const revision = WRITTEN_REVISION.get(record);
+      const own =
+        revision === undefined
+          ? record.events[record.events.length - 1]
+          : record.events.find((event) => event.revision === revision);
+      if (own) this.remember(own.id);
+      return record;
+    } finally {
+      this.inflight--;
+      if (this.inflight === 0) {
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const wake of waiters) wake();
+      }
+    }
+  }
+
+  public remember(id: string): void {
+    this.ids.add(id);
+    // Bounded: only recent ids matter for the next watcher update.
+    if (this.ids.size > 512) {
+      const oldest = this.ids.values().next().value;
+      if (oldest !== undefined) this.ids.delete(oldest);
+    }
+  }
+
+  public isOwn(id: string): boolean {
+    return this.ids.has(id);
+  }
+
+  /** Resolves once no append from this window is in flight. */
+  public settled(): Promise<void> {
+    if (this.inflight === 0) return Promise.resolve();
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+
+  /**
+   * Patches a port's append methods in place so every write it commits is
+   * tracked. Idempotent per port.
+   */
+  public attach<T>(port: SessionPort<T>): void {
+    const marked = port as SessionPort<T> & { [TRACKED]?: true };
+    if (marked[TRACKED]) return;
+    marked[TRACKED] = true;
+    const append = port.append.bind(port);
+    const appendOperations = port.appendOperations.bind(port);
+    port.append = (...args) => this.track(append(...args));
+    port.appendOperations = (...args) => this.track(appendOperations(...args));
+  }
+}
+
+const TRACKED = Symbol("dawg.ownWrites");
+
+/** Events in `latest` past `fromRevision` that this window did not write. */
+export function foreignEvents(
+  latest: Pick<SessionRecord<unknown>, "events">,
+  fromRevision: number,
+  own: Pick<OwnWrites, "isOwn">,
+): SessionEvent[] {
+  return latest.events.filter(
+    (event) => event.revision > fromRevision && !own.isOwn(event.id),
+  );
+}
+
+/**
+ * Names the other window for the sync card by the track it has open, the
+ * word that window's own header shows (`synced · lead window`), never by a
+ * number taken from the presence list's order. With several other windows
+ * the one whose track the edit touched is named; before presence arrives
+ * the edited track names it. Otherwise `another window`.
+ */
+export function otherWindowName(
+  clients: readonly { clientId: string; focusedTrackId?: string | null }[],
+  selfId: string,
+  options: {
+    /** The one track the foreign revision changed, when exactly one. */
+    editedTrackId?: string | undefined;
+    /** Display name for a track id. */
+    trackName?: (trackId: string) => string;
+  } = {},
+): string {
+  const name = options.trackName ?? ((trackId: string) => trackId);
+  const others = clients.filter(
+    (client) => client.clientId !== selfId && client.focusedTrackId,
+  );
+  const edited = options.editedTrackId;
+  const owner =
+    (edited && others.find((client) => client.focusedTrackId === edited)) ||
+    (others.length === 1 ? others[0] : undefined);
+  if (owner?.focusedTrackId) return `${name(owner.focusedTrackId)} window`;
+  if (edited) return `${name(edited)} window`;
+  return "another window";
+}
+
+/** The single track whose notes or settings differ, or undefined. */
+export function editedTrack(
+  before: {
+    tracks: readonly { id: string }[];
+    notes: readonly { trackId: string }[];
+  },
+  after: {
+    tracks: readonly { id: string }[];
+    notes: readonly { trackId: string }[];
+  },
+): string | undefined {
+  const changed = new Set<string>();
+  const byTrack = (value: typeof before) => {
+    const map = new Map<string, string[]>();
+    for (const note of value.notes) {
+      const list = map.get(note.trackId) ?? [];
+      list.push(JSON.stringify(note));
+      map.set(note.trackId, list);
+    }
+    return map;
+  };
+  const left = byTrack(before);
+  const right = byTrack(after);
+  const ids = new Set([
+    ...before.tracks.map((track) => track.id),
+    ...after.tracks.map((track) => track.id),
+  ]);
+  for (const id of ids) {
+    const a = before.tracks.find((track) => track.id === id);
+    const b = after.tracks.find((track) => track.id === id);
+    if (
+      JSON.stringify(a) !== JSON.stringify(b) ||
+      (left.get(id) ?? []).join("\n") !== (right.get(id) ?? []).join("\n")
+    )
+      changed.add(id);
+  }
+  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,9 +139,16 @@ 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[];
+  /**
+   * File sessions: the backstop poll while fs.watch is live (default 1 s).
+   * Tests raise it to prove a change arrived through the watcher.
+   */
+  watchedPollMs?: number;
 };
 
 /** Connects to (or starts) dawgd, falling back to the file-lock path. */
@@ -143,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);
@@ -171,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}`;
@@ -225,7 +252,11 @@ class DaemonPort<T> implements SessionPort<T> {
     }
     if (result.status === "accepted" || result.status === "duplicate") {
       this.setSync("synced");
-      return this.record();
+      // The client's record can already hold a later write from another
+      // window; mark which revision is this one's (OwnWrites reads it).
+      const record = { ...this.record() };
+      WRITTEN_REVISION.set(record, result.revision);
+      return record;
     }
     if (result.status === "rebase") {
       this.setSync("conflict");
@@ -248,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) => {
@@ -260,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);
@@ -291,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,
@@ -308,6 +369,12 @@ class DaemonPort<T> implements SessionPort<T> {
   }
 }
 
+/**
+ * The revision an append produced, for records whose last event may be a
+ * newer write from elsewhere (a daemon window's record follows the log).
+ */
+export const WRITTEN_REVISION = new WeakMap<object, number>();
+
 class FilePort<T> implements SessionPort<T> {
   public readonly mode = "file" as const;
   public readonly clientId = randomUUID();
@@ -316,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({
@@ -331,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 } : {}),
     });
   }
 
@@ -346,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>> {
@@ -408,10 +500,10 @@ 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
+    // the temp file (`<record>.<pid>.<n>.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)?$`,
+      `^${recordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:(?:\\.\\d+)+\\.tmp)?$`,
     );
     let watcher: FSWatcher | undefined;
     try {
@@ -429,7 +521,10 @@ class FilePort<T> implements SessionPort<T> {
     } catch {
       watcher = undefined;
     }
-    const timer = setInterval(check, watcher ? WATCHED_POLL_MS : POLL_MS);
+    const timer = setInterval(
+      check,
+      watcher ? (this.options.watchedPollMs ?? WATCHED_POLL_MS) : POLL_MS,
+    );
     this.statusListeners.add(listener);
     check();
     return () => {