@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/store.js

@@ -0,0 +1,544 @@
+import { execFile } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { createReadStream, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { appendFile, link, mkdir, open, readdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { uptime } from "node:os";
+import { createInterface } from "node:readline";
+import { join } from "node:path";
+import { CODEFLOW_HOME } from "./config.js";
+import { childEnv } from "./env.js";
+import { logError, logWarn } from "./log.js";
+import { WorkQueue } from "./work-queue.js";
+const RUNS_DIR = join(CODEFLOW_HOME, "runs");
+const JOURNAL_VERSION = 2;
+const ready = mkdir(RUNS_DIR, { recursive: true });
+const writes = new WorkQueue(4), checkpoints = new WorkQueue(1);
+const runKey = (file) => file.replace(/(?:\.journal)?\.jsonl$/, "");
+let queuedBytes = 0;
+const WRITE_BUFFER_BYTES = 64 * 1024 * 1024;
+const writeQueueStats = () => ({ writes: { ...writes.stats, bytes: queuedBytes }, checkpoints: checkpoints.stats });
+const appendBatches = /* @__PURE__ */ new Map();
+const writeHealth = { failures: 0 };
+const checkpointHealth = { failures: 0 };
+const MAX_CHECKPOINT_BYTES = 16 * 1024 * 1024;
+const checkpointId = (file) => /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,199}\.jsonl$/.test(file) && !file.endsWith(".journal.jsonl") ? file.slice(0, -6) : void 0;
+const sourceIdentity = (info) => ({ size: String(info.size), mtimeNs: String(info.mtimeNs), ctimeNs: String(info.ctimeNs), dev: String(info.dev), ino: String(info.ino) });
+const checksum = (text) => createHash("sha256").update(text).digest("hex");
+async function writeRunCheckpoint(file, seq, runJson, source) {
+  const id = checkpointId(file);
+  if (!id) return;
+  const payload = `${JSON.stringify({ version: 1, source, seq }).slice(0, -1)},"run":${runJson}}`;
+  const text = `${payload.slice(0, -1)},"checksum":"${checksum(payload)}"}
+`;
+  if (Buffer.byteLength(text) > MAX_CHECKPOINT_BYTES) return;
+  const path = join(RUNS_DIR, `${id}.checkpoint.json`);
+  const temp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    await writeFile(temp, text, { mode: 384, flag: "wx" });
+    if (JSON.stringify(sourceIdentity(await stat(join(RUNS_DIR, file), { bigint: true }))) !== JSON.stringify(source)) return;
+    await rename(temp, path);
+  } finally {
+    await unlink(temp).catch(() => void 0);
+  }
+}
+async function readRunCheckpoint(id) {
+  if (checkpointId(`${id}.jsonl`) !== id) return void 0;
+  const sourcePath = join(RUNS_DIR, `${id}.jsonl`);
+  try {
+    const before = sourceIdentity(await stat(sourcePath, { bigint: true }));
+    const handle = await open(join(RUNS_DIR, `${id}.checkpoint.json`), "r");
+    let text;
+    try {
+      const size = (await handle.stat()).size;
+      if (size === 0 || size > MAX_CHECKPOINT_BYTES) return void 0;
+      text = await handle.readFile("utf8");
+    } finally {
+      await handle.close();
+    }
+    if (Buffer.byteLength(text) > MAX_CHECKPOINT_BYTES) return void 0;
+    const cached = JSON.parse(text);
+    if (cached?.version !== 1 || !Number.isSafeInteger(cached.seq) || cached.seq < 0 || !cached.source || typeof cached.checksum !== "string" || !cached.run || typeof cached.run !== "object" || Array.isArray(cached.run) || cached.run.id !== id || !Array.isArray(cached.run.steps)) return void 0;
+    const payload = JSON.stringify({ version: cached.version, source: cached.source, seq: cached.seq, run: cached.run });
+    if (checksum(payload) !== cached.checksum) return void 0;
+    const after = sourceIdentity(await stat(sourcePath, { bigint: true }));
+    if (JSON.stringify(before) !== JSON.stringify(after) || JSON.stringify(cached.source) !== JSON.stringify(after)) return void 0;
+    return { run: cached.run, seq: cached.seq };
+  } catch {
+    return void 0;
+  }
+}
+const repaired = /* @__PURE__ */ new Set();
+const unsynced = /* @__PURE__ */ new Set();
+const directorySynced = /* @__PURE__ */ new Set();
+async function endsWithNewline(path) {
+  const handle = await open(path, "r").catch(() => void 0);
+  if (!handle) return true;
+  try {
+    const { size } = await handle.stat();
+    if (!size) return true;
+    const buf = Buffer.alloc(1);
+    await handle.read(buf, 0, 1, size - 1);
+    return buf[0] === 10;
+  } finally {
+    await handle.close();
+  }
+}
+async function appendSynced(path, text) {
+  const handle = await open(path, "a");
+  try {
+    await handle.writeFile(text);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  if (!directorySynced.has(path)) {
+    if (process.platform !== "win32") {
+      const directory = await open(RUNS_DIR, "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    }
+    directorySynced.add(path);
+  }
+}
+async function truncateIncompleteTail(path) {
+  const handle = await open(path, "r+").catch((err) => {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  });
+  if (!handle) return;
+  try {
+    const { size } = await handle.stat();
+    if (!size) return;
+    let end = size;
+    const buffer = Buffer.alloc(Math.min(size, 64 * 1024));
+    while (end > 0) {
+      const start = Math.max(0, end - buffer.length);
+      const length = end - start;
+      await handle.read(buffer, 0, length, start);
+      const newline = buffer.subarray(0, length).lastIndexOf(10);
+      if (newline >= 0) {
+        const boundary = start + newline + 1;
+        if (boundary !== size) {
+          await handle.truncate(boundary);
+          await handle.sync();
+        }
+        return;
+      }
+      end = start;
+    }
+    await handle.truncate(0);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+function appendLine(file, value, opts = {}) {
+  const line = `${JSON.stringify(value)}
+`;
+  let checkpointWork;
+  let checkpoint;
+  if (opts.checkpoint && Number.isSafeInteger(opts.checkpoint.seq) && opts.checkpoint.seq >= 0 && typeof value === "object" && value && "seq" in value && value.seq === opts.checkpoint.seq) {
+    try {
+      const runJson = JSON.stringify(opts.checkpoint.run);
+      if (runJson && Buffer.byteLength(runJson) <= MAX_CHECKPOINT_BYTES) checkpoint = { seq: opts.checkpoint.seq, runJson };
+    } catch {
+    }
+  }
+  const key = runKey(file), size = Buffer.byteLength(line);
+  const previous = appendBatches.get(key);
+  const batchable = !opts.sync && !opts.strict && !opts.checkpoint;
+  let written;
+  if (queuedBytes + size > WRITE_BUFFER_BYTES) {
+    appendBatches.delete(key);
+    written = Promise.reject(new Error("Run write buffer is full; storage cannot keep up"));
+  } else if (batchable && previous?.file === file && previous.bytes + size <= 256 * 1024 && previous.count < 128) {
+    previous.text += line;
+    previous.bytes += size;
+    previous.count++;
+    queuedBytes += size;
+    written = previous.promise;
+  } else {
+    appendBatches.delete(key);
+    const batch = { file, text: line, bytes: size, count: 1, promise: Promise.resolve() };
+    queuedBytes += size;
+    written = writes.run(key, async () => {
+      if (appendBatches.get(key) === batch) appendBatches.delete(key);
+      await ready;
+      const path = join(RUNS_DIR, file);
+      if (opts.strict && !repaired.has(file)) await truncateIncompleteTail(path);
+      const prefix = repaired.has(file) || await endsWithNewline(path) ? "" : "\n";
+      try {
+        if (opts.sync) await appendSynced(path, prefix + batch.text);
+        else await appendFile(path, prefix + batch.text);
+      } catch (err) {
+        repaired.delete(file);
+        throw err;
+      }
+      repaired.add(file);
+      if (opts.sync) unsynced.delete(file);
+      else unsynced.add(file);
+      if (checkpoint && checkpoints.stats.bytes + Buffer.byteLength(checkpoint.runJson) <= 32 * 1024 * 1024) {
+        const captured = checkpoint;
+        const source = await stat(path, { bigint: true }).then(sourceIdentity).catch(() => void 0);
+        if (source) checkpointWork = checkpoints.run(key, () => writeRunCheckpoint(file, captured.seq, captured.runJson, source), Buffer.byteLength(captured.runJson)).catch((error) => {
+          checkpointHealth.failures++;
+          checkpointHealth.lastError = error.message;
+          checkpointHealth.at = Date.now();
+          if (checkpointHealth.failures === 1 || checkpointHealth.failures % 100 === 0) logWarn("couldn't save optional run checkpoint", { file, error: error.message });
+        });
+      }
+    }, size).finally(() => {
+      queuedBytes -= batch.bytes;
+    });
+    batch.promise = written;
+    if (batchable) appendBatches.set(key, batch);
+  }
+  const complete = written.then(() => checkpointWork);
+  const observed = complete.catch((err) => {
+    opts.onFailed?.();
+    writeHealth.failures++;
+    writeHealth.lastError = err.message;
+    writeHealth.at = Date.now();
+    if (writeHealth.failures === 1 || writeHealth.failures % 100 === 0) {
+      logError(`couldn't save run data (${writeHealth.failures} failed writes)`, err, { file });
+    }
+  });
+  return opts.strict ? complete : observed;
+}
+async function syncFile(file) {
+  const handle = await open(join(RUNS_DIR, file), "r+");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function flushWrites(id) {
+  if (id === void 0) appendBatches.clear();
+  else appendBatches.delete(id);
+  await writes.flush(id);
+  const files = [...unsynced].filter((file) => id === void 0 || runKey(file) === id);
+  await Promise.all(files.map((file) => writes.run(runKey(file), async () => {
+    if (!unsynced.has(file)) return;
+    await syncFile(file);
+    unsynced.delete(file);
+  })));
+  await checkpoints.flush(id);
+}
+async function waitForRunWrites(id) {
+  await writes.flush(id);
+}
+const reportedBadLines = /* @__PURE__ */ new Set();
+async function readJsonLines(file, stats) {
+  const path = join(RUNS_DIR, file);
+  if (!existsSync(path)) return [];
+  const out = [];
+  let skipped = 0;
+  const lines = createInterface({ input: createReadStream(path), crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      skipped++;
+    }
+  }
+  if (stats) stats.skipped += skipped;
+  if (skipped && !reportedBadLines.has(file)) {
+    reportedBadLines.add(file);
+    logWarn(`skipped ${skipped} unreadable line${skipped === 1 ? "" : "s"} in a run log`, { file });
+  }
+  return out;
+}
+async function visitJsonLines(file, visit) {
+  const path = join(RUNS_DIR, file);
+  if (!existsSync(path)) return;
+  const stream = createReadStream(path, { encoding: "utf8", highWaterMark: 64 * 1024 });
+  let buffer = "", skipped = 0;
+  const parse = (line) => {
+    if (!line.trim()) return;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      skipped++;
+      return;
+    }
+    visit(value);
+  };
+  try {
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let index;
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index);
+        buffer = buffer.slice(index + 1);
+        if (Buffer.byteLength(line) > 64 * 1024 * 1024) throw new Error(`Run log ${file} contains a record larger than 64 MiB`);
+        parse(line);
+      }
+      if (Buffer.byteLength(buffer) > 64 * 1024 * 1024) throw new Error(`Run log ${file} contains a record larger than 64 MiB`);
+    }
+    parse(buffer);
+  } finally {
+    stream.destroy();
+  }
+  if (skipped && !reportedBadLines.has(file)) {
+    reportedBadLines.add(file);
+    logWarn(`skipped ${skipped} unreadable line${skipped === 1 ? "" : "s"} in a run log`, { file });
+  }
+}
+async function listRunIds() {
+  if (!existsSync(RUNS_DIR)) return [];
+  const files = await readdir(RUNS_DIR);
+  const deleted = new Set(files.filter((f) => f.endsWith(".deleted")).map((f) => f.slice(0, -8)));
+  return files.filter((f) => f.endsWith(".jsonl") && !f.endsWith(".journal.jsonl") && !deleted.has(f.slice(0, -6))).map((f) => f.slice(0, -".jsonl".length));
+}
+async function listDeletedRunIds() {
+  if (!existsSync(RUNS_DIR)) return [];
+  return (await readdir(RUNS_DIR)).filter((file) => /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,199}\.deleted$/.test(file)).map((file) => file.slice(0, -8));
+}
+function deleteRunHistory(id) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,199}$/.test(id)) throw new Error("Invalid run ID");
+  appendBatches.delete(id);
+  const work = writes.run(id, async () => {
+    await ready;
+    await checkpoints.flush(id);
+    await writeFile(join(RUNS_DIR, `${id}.deleted`), "", { mode: 384, flush: true });
+    for (const suffix of [".jsonl", ".journal.jsonl", ".checkpoint.json", ".cold-index.json", ".cold-detail.json"]) {
+      await rm(join(RUNS_DIR, id + suffix), { force: true });
+      repaired.delete(id + suffix);
+      unsynced.delete(id + suffix);
+      directorySynced.delete(join(RUNS_DIR, id + suffix));
+    }
+  });
+  return work;
+}
+async function loadJournal(runId, opts = {}) {
+  if (opts.strict) {
+    let text;
+    try {
+      text = await readFile(join(RUNS_DIR, `${runId}.journal.jsonl`), "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return /* @__PURE__ */ new Map();
+      throw err;
+    }
+    const complete = text.slice(0, text.lastIndexOf("\n") + 1);
+    const journal = /* @__PURE__ */ new Map();
+    for (const [index, line] of complete.split("\n").entries()) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (typeof entry.key !== "string" || !("value" in entry) || (entry.v ?? 1) > JOURNAL_VERSION) throw new Error("invalid or unsupported record");
+        journal.set(entry.key, entry.value);
+      } catch (err) {
+        throw new Error(`Cannot recover journal ${runId}: record ${index + 1} is damaged or uses an unsupported version`, { cause: err });
+      }
+    }
+    return journal;
+  }
+  const entries = await readJsonLines(`${runId}.journal.jsonl`);
+  return new Map(entries.filter((e) => (e.v ?? 1) <= JOURNAL_VERSION).map((e) => [e.key, e.value]));
+}
+function rewriteLines(file, make) {
+  appendBatches.delete(runKey(file));
+  const done = writes.run(runKey(file), async () => {
+    await ready;
+    await checkpoints.flush(runKey(file));
+    const path = join(RUNS_DIR, file);
+    const lines = make(await readJsonLines(file));
+    if (!lines) return false;
+    const temp = `${path}.${randomBytes(4).toString("hex")}.tmp`;
+    try {
+      await appendSynced(temp, lines.map((l) => `${JSON.stringify(l)}
+`).join(""));
+      await rename(temp, path);
+    } catch (err) {
+      await unlink(temp).catch(() => {
+      });
+      throw err;
+    }
+    repaired.add(file);
+    unsynced.delete(file);
+    return true;
+  });
+  return done;
+}
+function journalEntry(runId, key, value) {
+  return appendLine(`${runId}.journal.jsonl`, { key, value, v: JOURNAL_VERSION }, { sync: true, strict: true });
+}
+const BOOT_SLACK_MS = 12e4;
+const WRITING_MS = 2e3;
+const bootTime = () => Date.now() - uptime() * 1e3;
+function startTicks(pid) {
+  if (process.platform !== "linux") return void 0;
+  try {
+    const stat2 = readFileSync(`/proc/${pid}/stat`, "utf8");
+    const ticks = Number(stat2.slice(stat2.lastIndexOf(")") + 2).split(" ")[19]);
+    return Number.isFinite(ticks) ? ticks : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function psStart(pid) {
+  return new Promise((resolve) => {
+    execFile("ps", ["-o", "lstart=", "-p", String(pid)], { timeout: 5e3, env: childEnv({ LC_ALL: "C" }) }, (err, stdout) => {
+      const ms = err ? NaN : Date.parse(String(stdout).trim());
+      resolve(Number.isFinite(ms) ? ms : void 0);
+    });
+  });
+}
+function parseLock(text) {
+  const trimmed = text.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) > 0 ? { pid: Number(trimmed), legacy: true } : void 0;
+  try {
+    const info = JSON.parse(trimmed);
+    return Number.isInteger(info?.pid) && info.pid > 0 ? { ...info, legacy: false } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function holderAlive(text, mtimeMs) {
+  const info = parseLock(text);
+  if (!info) return { live: Date.now() - mtimeMs < WRITING_MS };
+  const { pid } = info;
+  if (pid === process.pid || !alive(pid)) return { live: false, pid };
+  if (info.legacy) {
+    if (mtimeMs < bootTime() - BOOT_SLACK_MS) return { live: false, pid };
+    const started = await psStart(pid);
+    return { live: started === void 0 || started <= mtimeMs + WRITING_MS, pid };
+  }
+  if (info.ticks !== void 0) {
+    const ticks = startTicks(pid);
+    if (ticks !== void 0) return { live: ticks === info.ticks, pid };
+  }
+  if (info.started !== void 0) {
+    const started = await psStart(pid);
+    if (started !== void 0) return { live: Math.abs(started - info.started) < 5e3, pid };
+  }
+  return { live: info.boot === void 0 || Math.abs(info.boot - bootTime()) < BOOT_SLACK_MS, pid };
+}
+async function readLock(file) {
+  let handle;
+  try {
+    handle = await open(file, "r");
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw new Error(`Can't read ${file}: ${err.message}`);
+  }
+  try {
+    return { stat: await handle.stat(), text: await handle.readFile("utf8") };
+  } finally {
+    await handle.close();
+  }
+}
+async function createLock(temp, file, content) {
+  try {
+    await link(temp, file);
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") return false;
+  }
+  try {
+    await writeFile(file, content, { flag: "wx" });
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") return false;
+    throw err;
+  }
+}
+async function takeOverLock(file, temp, judged) {
+  const token = `${file}.takeover`;
+  try {
+    await link(file, token);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return false;
+    if (code === "EEXIST") {
+      const age = await stat(token).then((s) => Date.now() - s.ctimeMs, () => 0);
+      if (age > 5e3) await unlink(token).catch(() => void 0);
+      return false;
+    }
+    if (await readFile(file, "utf8").catch(() => void 0) === judged.text) await unlink(file).catch(() => void 0);
+    return false;
+  }
+  try {
+    const now = await stat(token).catch(() => void 0);
+    const text = await readFile(token, "utf8").catch(() => void 0);
+    if (!now || now.ino !== judged.stat.ino || now.dev !== judged.stat.dev || text !== judged.text) return false;
+    await rename(temp, file);
+    return true;
+  } finally {
+    await unlink(token).catch(() => void 0);
+  }
+}
+async function acquireLock(waitMs = 2e4, home = CODEFLOW_HOME) {
+  const file = join(home, "server.lock");
+  await mkdir(home, { recursive: true });
+  const info = { pid: process.pid, started: Math.round(Date.now() - process.uptime() * 1e3), ticks: startTicks(process.pid), boot: Math.round(bootTime()) };
+  const content = JSON.stringify(info);
+  const temp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  await writeFile(temp, content);
+  const deadline = Date.now() + waitMs;
+  try {
+    for (; ; ) {
+      if (await createLock(temp, file, content)) break;
+      const seen = await readLock(file);
+      if (!seen) continue;
+      const holder = await holderAlive(seen.text, seen.stat.mtimeMs);
+      if (!holder.live) {
+        if (await takeOverLock(file, temp, seen)) break;
+        if (Date.now() > deadline) throw new Error(`Couldn't replace the stale ${file}. Delete it and start code-flow again.`);
+        await new Promise((r) => setTimeout(r, 25));
+        continue;
+      }
+      if (Date.now() > deadline) {
+        throw new Error(`Another code-flow server${holder.pid ? ` (pid ${holder.pid})` : ""} is using ${home}. Stop it, or set CODEFLOW_HOME to a different folder.`);
+      }
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  } finally {
+    await unlink(temp).catch(() => void 0);
+  }
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    try {
+      if (readFileSync(file, "utf8") === content) unlinkSync(file);
+    } catch {
+    }
+  };
+  return release;
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+export {
+  JOURNAL_VERSION,
+  RUNS_DIR,
+  WRITE_BUFFER_BYTES,
+  acquireLock,
+  appendLine,
+  checkpointHealth,
+  deleteRunHistory,
+  flushWrites,
+  journalEntry,
+  listDeletedRunIds,
+  listRunIds,
+  loadJournal,
+  readJsonLines,
+  readRunCheckpoint,
+  rewriteLines,
+  visitJsonLines,
+  waitForRunWrites,
+  writeHealth,
+  writeQueueStats
+};

package/src/stream.js

@@ -0,0 +1,91 @@
+import { randomBytes } from "node:crypto";
+class TopicError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+const MAX_SUBS = 64;
+class StreamHub {
+  constructor(sources) {
+    this.sources = sources;
+  }
+  clients = /* @__PURE__ */ new Map();
+  /** A stream opened: `send` writes to it. Returns its client id; call `close` when it ends. */
+  open(send, subs) {
+    const client = { id: randomBytes(12).toString("hex"), send, subs: /* @__PURE__ */ new Map(), closed: false };
+    this.clients.set(client.id, client);
+    send({ s: 0, d: { type: "hello", client: client.id } });
+    this.update(client.id, { subscribe: subs });
+    return client.id;
+  }
+  close(id) {
+    const client = this.clients.get(id);
+    if (!client) return;
+    client.closed = true;
+    this.clients.delete(id);
+    for (const sub of client.subs.values()) this.stop(sub);
+    client.subs.clear();
+  }
+  /** Change a stream's subscriptions; false when there's no such stream (it closed). */
+  update(id, change) {
+    const client = this.clients.get(id);
+    if (!client) return false;
+    for (const subId of Array.isArray(change.unsubscribe) ? change.unsubscribe : []) {
+      const sub = client.subs.get(subId);
+      if (!sub) continue;
+      client.subs.delete(subId);
+      this.stop(sub);
+    }
+    for (const req of Array.isArray(change.subscribe) ? change.subscribe : []) void this.subscribe(client, req);
+    return true;
+  }
+  /** Open streams and their subscriptions, for tests and health. */
+  get stats() {
+    return { streams: this.clients.size, subscriptions: [...this.clients.values()].reduce((n, c) => n + c.subs.size, 0) };
+  }
+  async subscribe(client, req) {
+    const { id, topic, after } = req ?? {};
+    if (!Number.isInteger(id) || id < 1 || typeof topic !== "string" || topic.length > 200 || client.subs.has(id)) return;
+    const fail = (status, message) => client.send({ s: id, d: { type: "error", status, message } });
+    if (after !== void 0 && (typeof after !== "string" || after.length > 100)) return fail(400, "That cursor isn't one code-flow gave out");
+    if (client.subs.size >= MAX_SUBS) return fail(429, `A window watches at most ${MAX_SUBS} things at once`);
+    const colon = topic.indexOf(":");
+    const [kind, name] = colon < 0 ? [topic, ""] : [topic.slice(0, colon), topic.slice(colon + 1)];
+    const source = Object.hasOwn(this.sources, kind) ? this.sources[kind] : void 0;
+    if (!source) return fail(404, `Nothing to watch called \u201C${kind}\u201D`);
+    const sub = { topic, dropped: false };
+    client.subs.set(id, sub);
+    const deliver = (d) => {
+      if (!sub.dropped && !client.closed) client.send({ s: id, d });
+    };
+    try {
+      const stop = await source(name, after, deliver);
+      if (sub.dropped || client.closed) stop();
+      else sub.stop = stop;
+    } catch (err) {
+      if (client.subs.get(id) === sub) client.subs.delete(id);
+      if (sub.dropped || client.closed) return;
+      sub.dropped = true;
+      if (err instanceof TopicError) fail(err.status, err.message);
+      else fail(500, err.message);
+    }
+  }
+  stop(sub) {
+    sub.dropped = true;
+    try {
+      sub.stop?.();
+    } catch {
+    }
+  }
+}
+function cursorSeq(cursor, epoch) {
+  const [from, seq] = String(cursor ?? "").split(":");
+  const n = Number(seq);
+  return from === epoch && seq !== "" && seq !== void 0 && Number.isSafeInteger(n) && n >= 0 ? n : void 0;
+}
+export {
+  StreamHub,
+  TopicError,
+  cursorSeq
+};