@kuralle-syrinx/server-workers 2.1.1 → 3.1.0

package/src/durable-session-store.ts

@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import type {
-  ManagedSession,
-  ManagedSessionLease,
-  SessionStore,
-} from "@kuralle-syrinx/server-websocket/session-store";
-import type { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
-
-type SqlCursor<T> = Iterable<T>;
-
-interface SqlStorage {
-  exec(query: string, ...bindings: unknown[]): SqlCursor<Record<string, unknown>>;
-}
-
-export interface DurableSessionStorage {
-  readonly sql: SqlStorage;
-}
-
-interface SessionRow {
-  id: string;
-  current_context_id: string;
-  last_sequence: number | null;
-  retained_until_ms: number;
-  connection_count: number;
-}
-
-export class DurableObjectSessionStore implements SessionStore {
-  private readonly sessions = new Map<string, ManagedSession>();
-  private readonly pendingLeases = new Map<string, Promise<ManagedSession>>();
-
-  constructor(
-    private readonly storage: DurableSessionStorage,
-    private readonly scheduler: DurableObjectAlarmScheduler,
-  ) {
-    this.storage.sql.exec(
-      `CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        current_context_id TEXT NOT NULL,
-        last_sequence INTEGER,
-        retained_until_ms INTEGER NOT NULL DEFAULT 0,
-        connection_count INTEGER NOT NULL DEFAULT 0,
-        updated_at_ms INTEGER NOT NULL
-      )`,
-    );
-  }
-
-  async lease(sessionId: string, create: () => Promise<ManagedSession>): Promise<ManagedSessionLease> {
-    const existing = this.sessions.get(sessionId);
-    if (existing) {
-      this.attachConnection(existing);
-      return { managed: existing, resumed: true };
-    }
-
-    let pending = this.pendingLeases.get(sessionId);
-    if (!pending) {
-      pending = create().then((managed) => {
-        const row = this.row(sessionId);
-        if (row) {
-          managed.currentContextId = row.current_context_id;
-          managed.inputSequence.lastSequence = row.last_sequence;
-        }
-        this.sessions.set(sessionId, managed);
-        this.persist(managed, 0);
-        return managed;
-      }).finally(() => {
-        this.pendingLeases.delete(sessionId);
-      });
-      this.pendingLeases.set(sessionId, pending);
-    }
-
-    const row = this.row(sessionId);
-    const managed = await pending;
-    this.attachConnection(managed);
-    return { managed, resumed: Boolean(row && row.retained_until_ms > Date.now()) };
-  }
-
-  async release(sessionId: string, retainMs: number): Promise<void> {
-    const managed = this.sessions.get(sessionId);
-    if (!managed) return;
-    if (managed.connectionCount > 0) return;
-
-    if (retainMs <= 0) {
-      this.sessions.delete(sessionId);
-      this.storage.sql.exec("DELETE FROM sessions WHERE id = ?", sessionId);
-      await managed.session.close().catch(() => undefined);
-      return;
-    }
-
-    const retainedUntilMs = Date.now() + retainMs;
-    this.persist(managed, retainedUntilMs);
-    this.scheduler.schedule(`session.retain:${sessionId}`, retainMs, async () => {
-      const current = this.sessions.get(sessionId);
-      if (!current || current.connectionCount > 0) return;
-      this.sessions.delete(sessionId);
-      this.storage.sql.exec("DELETE FROM sessions WHERE id = ?", sessionId);
-      await current.session.close().catch(() => undefined);
-    });
-  }
-
-  update(sessionId: string, mutate: (managed: ManagedSession) => void): void {
-    const managed = this.sessions.get(sessionId);
-    if (!managed) return;
-    mutate(managed);
-    this.persist(managed, 0);
-  }
-
-  async get(sessionId: string): Promise<ManagedSession | null> {
-    return this.sessions.get(sessionId) ?? null;
-  }
-
-  async listAll(): Promise<readonly ManagedSession[]> {
-    return [...this.sessions.values()];
-  }
-
-  async clear(): Promise<void> {
-    for (const managed of this.sessions.values()) {
-      await managed.session.close().catch(() => undefined);
-    }
-    this.sessions.clear();
-    this.storage.sql.exec("DELETE FROM sessions");
-  }
-
-  private attachConnection(managed: ManagedSession): void {
-    this.scheduler.cancel(`session.retain:${managed.id}`);
-    managed.connectionCount += 1;
-    this.persist(managed, 0);
-  }
-
-  private persist(managed: ManagedSession, retainedUntilMs: number): void {
-    this.storage.sql.exec(
-      `INSERT OR REPLACE INTO sessions
-        (id, current_context_id, last_sequence, retained_until_ms, connection_count, updated_at_ms)
-        VALUES (?, ?, ?, ?, ?, ?)`,
-      managed.id,
-      managed.currentContextId,
-      managed.inputSequence.lastSequence,
-      retainedUntilMs,
-      managed.connectionCount,
-      Date.now(),
-    );
-  }
-
-  private row(sessionId: string): SessionRow | null {
-    const [row] = [...this.storage.sql.exec("SELECT * FROM sessions WHERE id = ?", sessionId)] as unknown as SessionRow[];
-    return row ?? null;
-  }
-}

package/src/r2-recorder.test.ts

@@ -1,100 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import { R2EdgeRecorder } from "./r2-recorder.js";
-
-interface PutCall {
-  key: string;
-  body: Uint8Array | string;
-}
-
-function fakeBucket() {
-  const puts: PutCall[] = [];
-  const bucket = {
-    async put(key: string, body: Uint8Array | string) {
-      puts.push({ key, body });
-      return {} as unknown;
-    },
-  } as unknown as R2Bucket;
-  return { bucket, puts };
-}
-
-function asString(body: Uint8Array | string): string {
-  return typeof body === "string" ? body : new TextDecoder().decode(body);
-}
-
-function wavChannels(body: Uint8Array | string): number {
-  const wav = body as Uint8Array;
-  return new DataView(wav.buffer, wav.byteOffset, wav.byteLength).getUint16(22, true);
-}
-
-describe("R2EdgeRecorder", () => {
-  it("writes a stereo conversation.wav plus user/assistant stems and manifest", async () => {
-    const { bucket, puts } = fakeBucket();
-    const rec = new R2EdgeRecorder({ bucket, sessionId: "s1", startedAtMs: 1000, now: () => 1000 });
-
-    rec.onUserAudio("c1", new Uint8Array(640), 16000);
-    rec.onAssistantAudio("c1", new Uint8Array(320), 24000);
-    await rec.finalize({ sessionId: "s1", closedAtMs: 2000 });
-
-    const keys = puts.map((p) => p.key).sort();
-    expect(keys).toEqual([
-      "recordings/s1/1000/assistant.wav",
-      "recordings/s1/1000/conversation.wav",
-      "recordings/s1/1000/manifest.json",
-      "recordings/s1/1000/user.wav",
-    ]);
-
-    const conversation = puts.find((p) => p.key.endsWith("conversation.wav"))!.body;
-    expect(asString((conversation as Uint8Array).subarray(0, 4))).toBe("RIFF");
-    expect(wavChannels(conversation)).toBe(2); // stereo: user L / assistant R
-    expect(wavChannels(puts.find((p) => p.key.endsWith("user.wav"))!.body)).toBe(1);
-
-    const manifest = JSON.parse(asString(puts.find((p) => p.key.endsWith("manifest.json"))!.body)) as {
-      conversation: { channels: number };
-    };
-    expect(manifest.conversation.channels).toBe(2);
-  });
-
-  it("time-aligns the assistant after the user instead of stacking at 0", async () => {
-    const { bucket, puts } = fakeBucket();
-    let now = 0;
-    const rec = new R2EdgeRecorder({ bucket, sessionId: "t", startedAtMs: 0, now: () => now });
-
-    now = 0;
-    rec.onUserAudio("c", new Uint8Array(640), 16000); // 20ms of user at t=0
-    now = 1000;
-    rec.onAssistantAudio("c", new Uint8Array(320), 16000); // assistant starts at t=1000ms
-    await rec.finalize({ sessionId: "t", closedAtMs: 1100 });
-
-    const manifest = JSON.parse(asString(puts.find((p) => p.key.endsWith("manifest.json"))!.body)) as {
-      conversation: { durationMs: number };
-      assistant: { durationMs: number };
-    };
-    // Assistant anchored at ~1000ms, so both the assistant stem and the merged
-    // conversation run ~1010ms — not the ~20ms they'd be if stacked at offset 0.
-    expect(manifest.assistant.durationMs).toBe(1010);
-    expect(manifest.conversation.durationMs).toBe(1010);
-  });
-
-  it("does not write anything when no audio was captured", async () => {
-    const { bucket, puts } = fakeBucket();
-    const rec = new R2EdgeRecorder({ bucket, sessionId: "empty", startedAtMs: 1 });
-    await rec.finalize({ sessionId: "empty", closedAtMs: 2 });
-    expect(puts).toHaveLength(0);
-  });
-
-  it("flags truncation past the per-stream cap instead of buffering unbounded", async () => {
-    const { bucket, puts } = fakeBucket();
-    const rec = new R2EdgeRecorder({ bucket, sessionId: "big", startedAtMs: 1, maxBytesPerStream: 1000, now: () => 1 });
-    rec.onUserAudio("c", new Uint8Array(800), 16000);
-    rec.onUserAudio("c", new Uint8Array(800), 16000); // would exceed 1000 -> dropped
-    await rec.finalize({ sessionId: "big", closedAtMs: 2 });
-
-    const manifest = JSON.parse(asString(puts.find((p) => p.key.endsWith("manifest.json"))!.body)) as {
-      user: { byteLength: number; truncated: boolean };
-    };
-    expect(manifest.user.byteLength).toBe(800);
-    expect(manifest.user.truncated).toBe(true);
-  });
-});

package/src/r2-recorder.ts

@@ -1,218 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// R2-backed implementation of the transport EdgeRecorder. Taps inbound caller
-// audio and outbound TTS audio and, on call end, writes to an R2 bucket:
-//   - conversation.wav : the FULL conversation, one stereo file (user = left,
-//                        assistant = right), time-aligned by wall-clock so the
-//                        assistant sits after the user instead of stacked at 0.
-//   - user.wav / assistant.wav : the per-speaker stems (useful for diarization).
-//   - manifest.json    : durations / byte lengths / truncation flags.
-// Mirrors the Node `voice-recorder` conversation-track approach (wall-clock byte
-// offsets + stereo interleave) but stays edge-safe (no node:fs). Cloudflare's own
-// withVoice persists transcripts to SQLite, not raw audio — this is the additive
-// piece. Buffered (memory-capped) and flushed once on finalize, off the hot path.
-
-import type { EdgeRecorder } from "@kuralle-syrinx/server-websocket/edge";
-
-export interface R2EdgeRecorderOptions {
-  readonly bucket: R2Bucket;
-  readonly sessionId: string;
-  readonly startedAtMs: number;
-  /** Object key prefix. Default "recordings". */
-  readonly keyPrefix?: string;
-  /** Per-stream memory cap; recording past it is dropped and flagged. Default 64 MiB. */
-  readonly maxBytesPerStream?: number;
-  /** Injectable clock (test seam). Defaults to Date.now. */
-  readonly now?: () => number;
-}
-
-const DEFAULT_MAX_BYTES_PER_STREAM = 64 * 1024 * 1024;
-
-interface AudioChunk {
-  offsetBytes: number;
-  data: Uint8Array;
-}
-
-interface StreamBuffer {
-  chunks: AudioChunk[];
-  cursorBytes: number; // end of the last placed chunk on the wall-clock timeline
-  dataBytes: number; // actual audio bytes captured (for the cap)
-  sampleRateHz: number;
-  truncated: boolean;
-}
-
-function emptyStream(): StreamBuffer {
-  return { chunks: [], cursorBytes: 0, dataBytes: 0, sampleRateHz: 16000, truncated: false };
-}
-
-export class R2EdgeRecorder implements EdgeRecorder {
-  readonly #user = emptyStream();
-  readonly #assistant = emptyStream();
-  readonly #maxBytes: number;
-  readonly #now: () => number;
-  #finalized = false;
-
-  constructor(private readonly opts: R2EdgeRecorderOptions) {
-    this.#maxBytes = opts.maxBytesPerStream ?? DEFAULT_MAX_BYTES_PER_STREAM;
-    this.#now = opts.now ?? Date.now;
-  }
-
-  onUserAudio(_contextId: string, audio: Uint8Array, sampleRateHz: number): void {
-    this.#append(this.#user, audio, sampleRateHz);
-  }
-
-  onAssistantAudio(_contextId: string, audio: Uint8Array, sampleRateHz: number): void {
-    this.#append(this.#assistant, audio, sampleRateHz);
-  }
-
-  async finalize(meta: { sessionId: string; closedAtMs: number }): Promise<void> {
-    if (this.#finalized) return;
-    this.#finalized = true;
-    if (this.#user.dataBytes === 0 && this.#assistant.dataBytes === 0) return;
-
-    const prefix = `${this.opts.keyPrefix ?? "recordings"}/${this.opts.sessionId}/${this.opts.startedAtMs}`;
-    const rate = this.#user.sampleRateHz; // conversation timeline runs at the user (input) rate
-
-    const userPcm = gapFill(this.#user);
-    const assistantRaw = gapFill(this.#assistant);
-    const assistantPcm =
-      this.#assistant.sampleRateHz === rate
-        ? assistantRaw
-        : resamplePcm16(assistantRaw, this.#assistant.sampleRateHz, rate);
-    const conversation = interleaveStereo(userPcm, assistantPcm);
-
-    const manifest = {
-      schemaVersion: 1 as const,
-      sessionId: meta.sessionId,
-      startedAtMs: this.opts.startedAtMs,
-      closedAtMs: meta.closedAtMs,
-      conversation: {
-        path: `${prefix}/conversation.wav`,
-        sampleRateHz: rate,
-        channels: 2 as const,
-        encoding: "pcm_s16le" as const,
-        byteLength: conversation.byteLength,
-        durationMs: rate > 0 ? Math.round((conversation.byteLength / 4 / rate) * 1000) : 0,
-      },
-      user: this.#describe(this.#user, `${prefix}/user.wav`),
-      assistant: this.#describe(this.#assistant, `${prefix}/assistant.wav`),
-    };
-
-    await Promise.all([
-      this.opts.bucket.put(`${prefix}/conversation.wav`, pcm16ToWav(conversation, rate, 2), {
-        httpMetadata: { contentType: "audio/wav" },
-      }),
-      this.opts.bucket.put(`${prefix}/user.wav`, pcm16ToWav(userPcm, this.#user.sampleRateHz, 1), {
-        httpMetadata: { contentType: "audio/wav" },
-      }),
-      this.opts.bucket.put(`${prefix}/assistant.wav`, pcm16ToWav(assistantRaw, this.#assistant.sampleRateHz, 1), {
-        httpMetadata: { contentType: "audio/wav" },
-      }),
-      this.opts.bucket.put(`${prefix}/manifest.json`, JSON.stringify(manifest, null, 2), {
-        httpMetadata: { contentType: "application/json" },
-      }),
-    ]);
-  }
-
-  #append(buf: StreamBuffer, audio: Uint8Array, sampleRateHz: number): void {
-    buf.sampleRateHz = sampleRateHz;
-    if (buf.dataBytes + audio.byteLength > this.#maxBytes) {
-      buf.truncated = true;
-      return;
-    }
-    // Anchor each chunk at its wall-clock position so the two speakers line up on a
-    // shared timeline; never overlap the previous chunk in the same stream.
-    const wallOffset = this.#wallOffsetBytes(sampleRateHz);
-    const offsetBytes = Math.max(buf.cursorBytes, wallOffset);
-    buf.chunks.push({ offsetBytes, data: audio.slice() });
-    buf.cursorBytes = offsetBytes + audio.byteLength;
-    buf.dataBytes += audio.byteLength;
-  }
-
-  #wallOffsetBytes(sampleRateHz: number): number {
-    const elapsedMs = Math.max(0, this.#now() - this.opts.startedAtMs);
-    const bytes = Math.floor((elapsedMs * sampleRateHz * 2) / 1000);
-    return bytes - (bytes % 2);
-  }
-
-  #describe(buf: StreamBuffer, path: string) {
-    return {
-      path,
-      sampleRateHz: buf.sampleRateHz,
-      encoding: "pcm_s16le" as const,
-      channels: 1 as const,
-      byteLength: buf.cursorBytes,
-      durationMs: buf.sampleRateHz > 0 ? Math.round((buf.cursorBytes / 2 / buf.sampleRateHz) * 1000) : 0,
-      truncated: buf.truncated,
-    };
-  }
-}
-
-/** Lay chunks onto a silence-filled mono timeline at their wall-clock offsets. */
-function gapFill(buf: StreamBuffer): Uint8Array {
-  const out = new Uint8Array(buf.cursorBytes); // zero = PCM16 silence
-  for (const chunk of buf.chunks) out.set(chunk.data, chunk.offsetBytes);
-  return out;
-}
-
-/** Interleave two mono PCM16 streams into stereo (left, right); pad the short one. */
-function interleaveStereo(left: Uint8Array, right: Uint8Array): Uint8Array {
-  const leftSamples = left.byteLength >> 1;
-  const rightSamples = right.byteLength >> 1;
-  const frames = Math.max(leftSamples, rightSamples);
-  const out = new Uint8Array(frames * 4);
-  const lv = new DataView(left.buffer, left.byteOffset, left.byteLength);
-  const rv = new DataView(right.buffer, right.byteOffset, right.byteLength);
-  const ov = new DataView(out.buffer);
-  for (let i = 0; i < frames; i += 1) {
-    ov.setInt16(i * 4, i < leftSamples ? lv.getInt16(i * 2, true) : 0, true);
-    ov.setInt16(i * 4 + 2, i < rightSamples ? rv.getInt16(i * 2, true) : 0, true);
-  }
-  return out;
-}
-
-function resamplePcm16(pcm: Uint8Array, fromHz: number, toHz: number): Uint8Array {
-  if (fromHz === toHz || pcm.byteLength === 0) return pcm;
-  const src = new DataView(pcm.buffer, pcm.byteOffset, pcm.byteLength);
-  const inSamples = pcm.byteLength >> 1;
-  const outSamples = Math.max(1, Math.round((inSamples * toHz) / fromHz));
-  const out = new Uint8Array(outSamples * 2);
-  const ov = new DataView(out.buffer);
-  const ratio = (inSamples - 1) / Math.max(1, outSamples - 1);
-  for (let i = 0; i < outSamples; i += 1) {
-    const x = i * ratio;
-    const i0 = Math.floor(x);
-    const i1 = Math.min(inSamples - 1, i0 + 1);
-    const frac = x - i0;
-    const s = src.getInt16(i0 * 2, true) * (1 - frac) + src.getInt16(i1 * 2, true) * frac;
-    ov.setInt16(i * 2, Math.round(s), true);
-  }
-  return out;
-}
-
-/** Wrap raw PCM16 little-endian bytes in a canonical 44-byte WAV header. */
-function pcm16ToWav(pcm: Uint8Array, sampleRateHz: number, channels: number): Uint8Array {
-  const blockAlign = channels * 2; // 16-bit
-  const byteRate = sampleRateHz * blockAlign;
-  const out = new Uint8Array(44 + pcm.byteLength);
-  const view = new DataView(out.buffer);
-  writeAscii(view, 0, "RIFF");
-  view.setUint32(4, 36 + pcm.byteLength, true);
-  writeAscii(view, 8, "WAVE");
-  writeAscii(view, 12, "fmt ");
-  view.setUint32(16, 16, true);
-  view.setUint16(20, 1, true); // PCM
-  view.setUint16(22, channels, true);
-  view.setUint32(24, sampleRateHz, true);
-  view.setUint32(28, byteRate, true);
-  view.setUint16(32, blockAlign, true);
-  view.setUint16(34, 16, true);
-  writeAscii(view, 36, "data");
-  view.setUint32(40, pcm.byteLength, true);
-  out.set(pcm, 44);
-  return out;
-}
-
-function writeAscii(view: DataView, offset: number, text: string): void {
-  for (let i = 0; i < text.length; i += 1) view.setUint8(offset + i, text.charCodeAt(i));
-}

package/src/test-storage.ts

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-interface SessionRow {
-  id: string;
-  current_context_id: string;
-  last_sequence: number | null;
-  retained_until_ms: number;
-  connection_count: number;
-  updated_at_ms: number;
-}
-
-interface TaskRow {
-  key: string;
-  deadline_ms: number;
-}
-
-export class MemoryDurableStorage {
-  readonly sessions = new Map<string, SessionRow>();
-  readonly tasks = new Map<string, TaskRow>();
-  alarm: number | null = null;
-
-  readonly sql = {
-    exec: (query: string, ...bindings: unknown[]): Iterable<Record<string, unknown>> => {
-      const normalized = query.replace(/\s+/g, " ").trim();
-      if (normalized.startsWith("CREATE TABLE")) return [];
-      if (normalized.startsWith("INSERT OR REPLACE INTO scheduled_tasks")) {
-        const key = String(bindings[0]);
-        this.tasks.set(key, { key, deadline_ms: Number(bindings[1]) });
-        return [];
-      }
-      if (normalized.startsWith("DELETE FROM scheduled_tasks WHERE key")) {
-        this.tasks.delete(String(bindings[0]));
-        return [];
-      }
-      if (normalized.startsWith("SELECT key FROM scheduled_tasks")) {
-        const now = Number(bindings[0]);
-        return [...this.tasks.values()]
-          .filter((row) => row.deadline_ms <= now)
-          .sort((a, b) => a.deadline_ms - b.deadline_ms) as unknown as Record<string, unknown>[];
-      }
-      if (normalized.startsWith("SELECT deadline_ms FROM scheduled_tasks")) {
-        const next = [...this.tasks.values()].sort((a, b) => a.deadline_ms - b.deadline_ms)[0];
-        return (next ? [{ deadline_ms: next.deadline_ms }] : []) as Record<string, unknown>[];
-      }
-      if (normalized.startsWith("INSERT OR REPLACE INTO sessions")) {
-        const row: SessionRow = {
-          id: String(bindings[0]),
-          current_context_id: String(bindings[1]),
-          last_sequence: bindings[2] === null ? null : Number(bindings[2]),
-          retained_until_ms: Number(bindings[3]),
-          connection_count: Number(bindings[4]),
-          updated_at_ms: Number(bindings[5]),
-        };
-        this.sessions.set(row.id, row);
-        return [];
-      }
-      if (normalized.startsWith("DELETE FROM sessions WHERE id")) {
-        this.sessions.delete(String(bindings[0]));
-        return [];
-      }
-      if (normalized.startsWith("DELETE FROM sessions")) {
-        this.sessions.clear();
-        return [];
-      }
-      if (normalized.startsWith("SELECT * FROM sessions WHERE id")) {
-        const row = this.sessions.get(String(bindings[0]));
-        return (row ? [row] : []) as unknown as Record<string, unknown>[];
-      }
-      throw new Error(`Unsupported test SQL: ${normalized}`);
-    },
-  };
-
-  async setAlarm(scheduledTime: number | Date): Promise<void> {
-    this.alarm = scheduledTime instanceof Date ? scheduledTime.getTime() : scheduledTime;
-  }
-
-  async deleteAlarm(): Promise<void> {
-    this.alarm = null;
-  }
-}