negotium 0.1.6 → 0.1.8

package/dist/runtime/src/storage/runtime-events.ts

@@ -0,0 +1,130 @@
+import { db } from "#storage/forum-db";
+
+export const RUNTIME_EVENT_TYPES = [
+  "message",
+  "message-updated",
+  "ai-status",
+  "topic-created",
+  "topic-updated",
+  "topic-deleted",
+] as const;
+
+export type StoredRuntimeEventType = (typeof RUNTIME_EVENT_TYPES)[number];
+
+export interface StoredRuntimeEvent {
+  seq: number;
+  sourceId: string;
+  type: StoredRuntimeEventType;
+  topicId: string;
+  payload: unknown;
+  createdAt: string;
+}
+
+interface RuntimeEventRow {
+  seq: number | bigint;
+  source_id: string;
+  event_type: string;
+  topic_id: string;
+  payload_json: string;
+  created_at: string;
+}
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_events (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_id TEXT NOT NULL,
+    event_type TEXT NOT NULL CHECK (
+      event_type IN (
+        'message',
+        'message-updated',
+        'ai-status',
+        'topic-created',
+        'topic-updated',
+        'topic-deleted'
+      )
+    ),
+    topic_id TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )
+`);
+db.exec("CREATE INDEX IF NOT EXISTS idx_runtime_events_topic_seq ON runtime_events(topic_id, seq)");
+
+const types = new Set<string>(RUNTIME_EVENT_TYPES);
+
+function rowToEvent(row: RuntimeEventRow): StoredRuntimeEvent | null {
+  if (!types.has(row.event_type)) return null;
+  try {
+    return {
+      seq: Number(row.seq),
+      sourceId: row.source_id,
+      type: row.event_type as StoredRuntimeEventType,
+      topicId: row.topic_id,
+      payload: JSON.parse(row.payload_json),
+      createdAt: row.created_at,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function latestRuntimeEventSeq(): number {
+  const row = db
+    .query<{ seq: number | bigint | null }, []>("SELECT MAX(seq) AS seq FROM runtime_events")
+    .get();
+  return Number(row?.seq ?? 0);
+}
+
+export function appendRuntimeEvent(
+  sourceId: string,
+  event: {
+    type: StoredRuntimeEventType;
+    topicId: string;
+    payload: unknown;
+  },
+): StoredRuntimeEvent {
+  const createdAt = new Date().toISOString();
+  const result = db
+    .query(
+      `INSERT INTO runtime_events
+         (source_id, event_type, topic_id, payload_json, created_at)
+       VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(sourceId, event.type, event.topicId, JSON.stringify(event.payload ?? null), createdAt);
+  const seq = Number(result.lastInsertRowid);
+  return { seq, sourceId, ...event, createdAt };
+}
+
+export function listRuntimeEventsAfter(seq: number, limit = 500): StoredRuntimeEvent[] {
+  const rows = db
+    .query<RuntimeEventRow, [number, number]>(
+      `SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+       FROM runtime_events
+       WHERE seq > ?
+       ORDER BY seq ASC
+       LIMIT ?`,
+    )
+    .all(Math.max(0, seq), Math.max(1, Math.min(limit, 5_000)));
+  return rows.map(rowToEvent).filter((event): event is StoredRuntimeEvent => event !== null);
+}
+
+/** Recent topic history used to hydrate a newly opened channel surface. */
+export function listRecentRuntimeEventsForTopic(
+  topicId: string,
+  limit = 300,
+): StoredRuntimeEvent[] {
+  const rows = db
+    .query<RuntimeEventRow, [string, number]>(
+      `SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+       FROM (
+         SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+         FROM runtime_events
+         WHERE topic_id = ? AND event_type IN ('ai-status', 'message-updated')
+         ORDER BY seq DESC
+         LIMIT ?
+       )
+       ORDER BY seq ASC`,
+    )
+    .all(topicId, Math.max(1, Math.min(limit, 2_000)));
+  return rows.map(rowToEvent).filter((event): event is StoredRuntimeEvent => event !== null);
+}

package/dist/runtime/src/storage/runtime-leases.ts

@@ -0,0 +1,189 @@
+import { randomUUID } from "node:crypto";
+import { db } from "#storage/forum-db";
+import { TOPIC_MAINTENANCE_STALE_MS } from "#storage/runtime-topic-state";
+
+export const RUNTIME_INSTANCE_ID = `${process.pid}-${randomUUID()}`;
+export const TURN_LEASE_STALE_MS = 10_000;
+
+export interface RuntimeTurnLease {
+  topicId: string;
+  queryId: string;
+  ownerId: string;
+  origin: string;
+  startedAt: number;
+  heartbeatAt: number;
+  abortRequested: boolean;
+  abortReason?: "internal" | "external";
+}
+
+interface RuntimeTurnLeaseRow {
+  topic_id: string;
+  query_id: string;
+  owner_id: string;
+  origin: string;
+  started_at: number | bigint;
+  heartbeat_at: number | bigint;
+  abort_requested: number;
+  abort_reason: string | null;
+}
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_turn_leases (
+    topic_id TEXT PRIMARY KEY,
+    query_id TEXT NOT NULL UNIQUE,
+    owner_id TEXT NOT NULL,
+    origin TEXT NOT NULL,
+    started_at INTEGER NOT NULL,
+    heartbeat_at INTEGER NOT NULL,
+    abort_requested INTEGER NOT NULL DEFAULT 0 CHECK (abort_requested IN (0, 1)),
+    abort_reason TEXT CHECK (abort_reason IS NULL OR abort_reason IN ('internal', 'external'))
+  )
+`);
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_runtime_turn_leases_heartbeat ON runtime_turn_leases(heartbeat_at)",
+);
+
+function rowToLease(row: RuntimeTurnLeaseRow): RuntimeTurnLease {
+  const abortReason =
+    row.abort_reason === "internal" || row.abort_reason === "external"
+      ? row.abort_reason
+      : undefined;
+  return {
+    topicId: row.topic_id,
+    queryId: row.query_id,
+    ownerId: row.owner_id,
+    origin: row.origin,
+    startedAt: Number(row.started_at),
+    heartbeatAt: Number(row.heartbeat_at),
+    abortRequested: row.abort_requested !== 0,
+    abortReason,
+  };
+}
+
+export function getRuntimeTurnLease(topicId: string, now = Date.now()): RuntimeTurnLease | null {
+  const row = db
+    .query<RuntimeTurnLeaseRow, [string]>("SELECT * FROM runtime_turn_leases WHERE topic_id = ?")
+    .get(topicId);
+  if (!row) return null;
+  const lease = rowToLease(row);
+  return now - lease.heartbeatAt <= TURN_LEASE_STALE_MS ? lease : null;
+}
+
+export function listRuntimeTurnLeases(now = Date.now()): RuntimeTurnLease[] {
+  return db
+    .query<RuntimeTurnLeaseRow, []>("SELECT * FROM runtime_turn_leases ORDER BY started_at ASC")
+    .all()
+    .map(rowToLease)
+    .filter((lease) => now - lease.heartbeatAt <= TURN_LEASE_STALE_MS);
+}
+
+export function claimRuntimeTurnLease(
+  input: {
+    topicId: string;
+    queryId: string;
+    origin: string;
+    ownerId?: string;
+  },
+  now = Date.now(),
+): boolean {
+  const ownerId = input.ownerId ?? RUNTIME_INSTANCE_ID;
+  const result = db
+    .query(
+      `INSERT INTO runtime_turn_leases
+         (topic_id, query_id, owner_id, origin, started_at, heartbeat_at, abort_requested, abort_reason)
+       SELECT ?, ?, ?, ?, ?, ?, 0, NULL
+       WHERE NOT EXISTS (
+         SELECT 1 FROM runtime_topic_state
+         WHERE topic_id = ? AND maintenance = 1 AND heartbeat_at >= ?
+       )
+       ON CONFLICT(topic_id) DO UPDATE SET
+         query_id = excluded.query_id,
+         owner_id = excluded.owner_id,
+         origin = excluded.origin,
+         started_at = excluded.started_at,
+         heartbeat_at = excluded.heartbeat_at,
+         abort_requested = 0,
+         abort_reason = NULL
+       WHERE (runtime_turn_leases.owner_id = excluded.owner_id
+          OR runtime_turn_leases.heartbeat_at < ?)
+         AND NOT EXISTS (
+           SELECT 1 FROM runtime_topic_state
+           WHERE topic_id = excluded.topic_id AND maintenance = 1 AND heartbeat_at >= ?
+         )`,
+    )
+    .run(
+      input.topicId,
+      input.queryId,
+      ownerId,
+      input.origin,
+      now,
+      now,
+      input.topicId,
+      now - TOPIC_MAINTENANCE_STALE_MS,
+      now - TURN_LEASE_STALE_MS,
+      now - TOPIC_MAINTENANCE_STALE_MS,
+    );
+  return Number(result.changes ?? 0) > 0;
+}
+
+export function heartbeatRuntimeTurnLease(
+  topicId: string,
+  queryId: string,
+  ownerId = RUNTIME_INSTANCE_ID,
+  now = Date.now(),
+): { owned: boolean; abortRequested: boolean; abortReason?: "internal" | "external" } {
+  const updated = db
+    .query(
+      `UPDATE runtime_turn_leases
+       SET heartbeat_at = ?
+       WHERE topic_id = ? AND query_id = ? AND owner_id = ?`,
+    )
+    .run(now, topicId, queryId, ownerId);
+  if (Number(updated.changes ?? 0) === 0) return { owned: false, abortRequested: false };
+
+  const row = db
+    .query<{ abort_requested: number; abort_reason: string | null }, [string, string, string]>(
+      `SELECT abort_requested, abort_reason
+       FROM runtime_turn_leases
+       WHERE topic_id = ? AND query_id = ? AND owner_id = ?`,
+    )
+    .get(topicId, queryId, ownerId);
+  const abortReason =
+    row?.abort_reason === "internal" || row?.abort_reason === "external"
+      ? row.abort_reason
+      : undefined;
+  return {
+    owned: Boolean(row),
+    abortRequested: row?.abort_requested !== 0,
+    abortReason,
+  };
+}
+
+export function requestRuntimeTurnAbort(topicId: string, reason: "internal" | "external"): boolean {
+  const result = db
+    .query(
+      `UPDATE runtime_turn_leases
+       SET abort_requested = 1,
+           abort_reason = CASE
+             WHEN abort_reason = 'external' THEN abort_reason
+             ELSE ?
+           END
+       WHERE topic_id = ? AND heartbeat_at >= ?`,
+    )
+    .run(reason, topicId, Date.now() - TURN_LEASE_STALE_MS);
+  return Number(result.changes ?? 0) > 0;
+}
+
+export function releaseRuntimeTurnLease(
+  topicId: string,
+  queryId: string,
+  ownerId = RUNTIME_INSTANCE_ID,
+): boolean {
+  const result = db
+    .query(
+      `DELETE FROM runtime_turn_leases
+       WHERE topic_id = ? AND query_id = ? AND owner_id = ?`,
+    )
+    .run(topicId, queryId, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}

package/dist/runtime/src/storage/runtime-process-leases.ts

@@ -0,0 +1,216 @@
+import { db } from "#storage/forum-db";
+import { RUNTIME_INSTANCE_ID } from "#storage/runtime-leases";
+
+export const PROCESS_LEASE_STALE_MS = 5_000;
+export const PROCESS_LEASE_HEARTBEAT_MS = 1_000;
+
+export interface RuntimeProcessLease {
+  role: string;
+  ownerId: string;
+  pid: number;
+  startedAt: number;
+  heartbeatAt: number;
+}
+
+export interface RuntimeProcessLeaseHandle extends RuntimeProcessLease {
+  stop(): void;
+}
+
+export interface AcquireRuntimeProcessLeaseOptions {
+  ownerId?: string;
+  pid?: number;
+  now?: number;
+  staleMs?: number;
+  heartbeatMs?: number;
+  onLost?: () => void;
+}
+
+export interface WaitForRuntimeProcessLeaseOptions extends AcquireRuntimeProcessLeaseOptions {
+  waitMs?: number;
+  retryMs?: number;
+}
+
+export interface WaitForRequiredRuntimeProcessLeaseOptions
+  extends WaitForRuntimeProcessLeaseOptions {
+  workloadName?: string;
+}
+
+interface RuntimeProcessLeaseRow {
+  role: string;
+  owner_id: string;
+  pid: number | bigint;
+  started_at: number | bigint;
+  heartbeat_at: number | bigint;
+}
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_process_leases (
+    role TEXT PRIMARY KEY,
+    owner_id TEXT NOT NULL UNIQUE,
+    pid INTEGER NOT NULL,
+    started_at INTEGER NOT NULL,
+    heartbeat_at INTEGER NOT NULL
+  )
+`);
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_runtime_process_leases_heartbeat ON runtime_process_leases(heartbeat_at)",
+);
+
+function rowToLease(row: RuntimeProcessLeaseRow): RuntimeProcessLease {
+  return {
+    role: row.role,
+    ownerId: row.owner_id,
+    pid: Number(row.pid),
+    startedAt: Number(row.started_at),
+    heartbeatAt: Number(row.heartbeat_at),
+  };
+}
+
+function isProcessAlive(pid: number): boolean {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code !== "ESRCH";
+  }
+}
+
+function removeDeadRuntimeProcessLease(role: string): void {
+  const row = db
+    .query<RuntimeProcessLeaseRow, [string]>("SELECT * FROM runtime_process_leases WHERE role = ?")
+    .get(role);
+  if (!row) return;
+  const lease = rowToLease(row);
+  if (isProcessAlive(lease.pid)) return;
+  db.query(
+    `DELETE FROM runtime_process_leases
+     WHERE role = ? AND owner_id = ? AND pid = ? AND heartbeat_at = ?`,
+  ).run(lease.role, lease.ownerId, lease.pid, lease.heartbeatAt);
+}
+
+export function getRuntimeProcessLease(
+  role: string,
+  now = Date.now(),
+  staleMs = PROCESS_LEASE_STALE_MS,
+): RuntimeProcessLease | null {
+  const row = db
+    .query<RuntimeProcessLeaseRow, [string]>("SELECT * FROM runtime_process_leases WHERE role = ?")
+    .get(role);
+  if (!row) return null;
+  const lease = rowToLease(row);
+  return now - lease.heartbeatAt <= staleMs ? lease : null;
+}
+
+export function heartbeatRuntimeProcessLease(
+  role: string,
+  ownerId: string,
+  now = Date.now(),
+): boolean {
+  const result = db
+    .query(
+      `UPDATE runtime_process_leases
+       SET heartbeat_at = ?
+       WHERE role = ? AND owner_id = ?`,
+    )
+    .run(now, role, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+
+export function releaseRuntimeProcessLease(role: string, ownerId: string): boolean {
+  const result = db
+    .query("DELETE FROM runtime_process_leases WHERE role = ? AND owner_id = ?")
+    .run(role, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+
+/**
+ * Claim one cross-process role and keep it alive with a SQLite heartbeat.
+ * A process that exits without cleanup is replaceable after `staleMs`.
+ */
+export function acquireRuntimeProcessLease(
+  role: string,
+  options: AcquireRuntimeProcessLeaseOptions = {},
+): RuntimeProcessLeaseHandle | null {
+  const normalizedRole = role.trim();
+  if (!normalizedRole) throw new Error("runtime process lease role must not be empty");
+  removeDeadRuntimeProcessLease(normalizedRole);
+  const ownerId = options.ownerId ?? `${RUNTIME_INSTANCE_ID}:${normalizedRole}`;
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now();
+  const staleMs = options.staleMs ?? PROCESS_LEASE_STALE_MS;
+  const result = db
+    .query(
+      `INSERT INTO runtime_process_leases (role, owner_id, pid, started_at, heartbeat_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(role) DO UPDATE SET
+         owner_id = excluded.owner_id,
+         pid = excluded.pid,
+         started_at = excluded.started_at,
+         heartbeat_at = excluded.heartbeat_at
+       WHERE runtime_process_leases.heartbeat_at < ?`,
+    )
+    .run(normalizedRole, ownerId, pid, now, now, now - staleMs);
+  if (Number(result.changes ?? 0) === 0) return null;
+
+  let stopped = false;
+  const heartbeatMs = options.heartbeatMs ?? PROCESS_LEASE_HEARTBEAT_MS;
+  const timer = setInterval(() => {
+    if (stopped) return;
+    if (heartbeatRuntimeProcessLease(normalizedRole, ownerId)) return;
+    stopped = true;
+    clearInterval(timer);
+    options.onLost?.();
+  }, heartbeatMs);
+  timer.unref?.();
+
+  return {
+    role: normalizedRole,
+    ownerId,
+    pid,
+    startedAt: now,
+    heartbeatAt: now,
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      releaseRuntimeProcessLease(normalizedRole, ownerId);
+    },
+  };
+}
+
+/**
+ * Wait through a graceful handoff or stale-heartbeat window instead of making
+ * process supervisors burn through their restart budget on a transient clash.
+ */
+export async function waitForRuntimeProcessLease(
+  role: string,
+  options: WaitForRuntimeProcessLeaseOptions = {},
+): Promise<RuntimeProcessLeaseHandle | null> {
+  const {
+    waitMs = PROCESS_LEASE_STALE_MS + PROCESS_LEASE_HEARTBEAT_MS,
+    retryMs = 100,
+    ...acquireOptions
+  } = options;
+  const deadline = Date.now() + Math.max(0, waitMs);
+  const interval = Math.max(1, retryMs);
+  while (true) {
+    const lease = acquireRuntimeProcessLease(role, acquireOptions);
+    if (lease) return lease;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return null;
+    await new Promise<void>((resolve) => setTimeout(resolve, Math.min(interval, remaining)));
+  }
+}
+
+/** Claim a process role or report the live owner in a user-facing error. */
+export async function waitForRequiredRuntimeProcessLease(
+  role: string,
+  options: WaitForRequiredRuntimeProcessLeaseOptions = {},
+): Promise<RuntimeProcessLeaseHandle> {
+  const { workloadName = role, ...leaseOptions } = options;
+  const lease = await waitForRuntimeProcessLease(role, leaseOptions);
+  if (lease) return lease;
+  const current = getRuntimeProcessLease(role);
+  throw new Error(`${workloadName} is already running${current ? ` (pid ${current.pid})` : ""}`);
+}

package/dist/runtime/src/storage/runtime-topic-state.ts

@@ -0,0 +1,148 @@
+import { randomUUID } from "node:crypto";
+import { db } from "#storage/forum-db";
+
+export const TOPIC_MAINTENANCE_STALE_MS = 30_000;
+export const TOPIC_MAINTENANCE_HEARTBEAT_MS = 1_000;
+
+export interface RuntimeTopicState {
+  topicId: string;
+  epoch: number;
+  maintenance: boolean;
+  maintenanceOwner?: string;
+  heartbeatAt?: number;
+}
+
+export interface RuntimeTopicMaintenanceHandle {
+  topicId: string;
+  epoch: number;
+  ownerId: string;
+  isOwned(): boolean;
+  finish(options?: { deleteState?: boolean }): void;
+}
+
+interface RuntimeTopicStateRow {
+  topic_id: string;
+  epoch: number | bigint;
+  maintenance: number;
+  maintenance_owner: string | null;
+  heartbeat_at: number | bigint | null;
+}
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_topic_state (
+    topic_id TEXT PRIMARY KEY,
+    epoch INTEGER NOT NULL DEFAULT 0,
+    maintenance INTEGER NOT NULL DEFAULT 0 CHECK (maintenance IN (0, 1)),
+    maintenance_owner TEXT,
+    heartbeat_at INTEGER
+  )
+`);
+
+function rowToState(row: RuntimeTopicStateRow, now = Date.now()): RuntimeTopicState {
+  const heartbeatAt = row.heartbeat_at === null ? undefined : Number(row.heartbeat_at);
+  const maintenance =
+    row.maintenance !== 0 &&
+    heartbeatAt !== undefined &&
+    now - heartbeatAt <= TOPIC_MAINTENANCE_STALE_MS;
+  return {
+    topicId: row.topic_id,
+    epoch: Number(row.epoch),
+    maintenance,
+    maintenanceOwner: maintenance ? (row.maintenance_owner ?? undefined) : undefined,
+    heartbeatAt,
+  };
+}
+
+export function getRuntimeTopicState(topicId: string, now = Date.now()): RuntimeTopicState {
+  const row = db
+    .query<RuntimeTopicStateRow, [string]>("SELECT * FROM runtime_topic_state WHERE topic_id = ?")
+    .get(topicId);
+  return row ? rowToState(row, now) : { topicId, epoch: 0, maintenance: false };
+}
+
+export function getRuntimeTopicEpoch(topicId: string): number {
+  return getRuntimeTopicState(topicId).epoch;
+}
+
+export function isRuntimeTopicMaintenance(topicId: string, now = Date.now()): boolean {
+  return getRuntimeTopicState(topicId, now).maintenance;
+}
+
+/**
+ * Advance the topic execution epoch and hold an exclusive maintenance fence.
+ * Turns from an older epoch can be identified and discarded in every process.
+ */
+export function beginRuntimeTopicMaintenance(
+  topicId: string,
+  options: { ownerId?: string; now?: number; heartbeatMs?: number } = {},
+): RuntimeTopicMaintenanceHandle | null {
+  const ownerId = options.ownerId ?? `${process.pid}-${randomUUID()}`;
+  const now = options.now ?? Date.now();
+  const result = db
+    .query(
+      `INSERT INTO runtime_topic_state
+         (topic_id, epoch, maintenance, maintenance_owner, heartbeat_at)
+       VALUES (?, 1, 1, ?, ?)
+       ON CONFLICT(topic_id) DO UPDATE SET
+         epoch = runtime_topic_state.epoch + 1,
+         maintenance = 1,
+         maintenance_owner = excluded.maintenance_owner,
+         heartbeat_at = excluded.heartbeat_at
+       WHERE runtime_topic_state.maintenance = 0
+          OR runtime_topic_state.heartbeat_at IS NULL
+          OR runtime_topic_state.heartbeat_at < ?`,
+    )
+    .run(topicId, ownerId, now, now - TOPIC_MAINTENANCE_STALE_MS);
+  if (Number(result.changes ?? 0) === 0) return null;
+
+  const epoch = getRuntimeTopicEpoch(topicId);
+  let finished = false;
+  const heartbeatMs = options.heartbeatMs ?? TOPIC_MAINTENANCE_HEARTBEAT_MS;
+  const timer = setInterval(() => {
+    if (finished) return;
+    const updated = db
+      .query(
+        `UPDATE runtime_topic_state
+         SET heartbeat_at = ?
+         WHERE topic_id = ? AND epoch = ? AND maintenance_owner = ? AND maintenance = 1`,
+      )
+      .run(Date.now(), topicId, epoch, ownerId);
+    if (Number(updated.changes ?? 0) > 0) return;
+    finished = true;
+    clearInterval(timer);
+  }, heartbeatMs);
+  timer.unref?.();
+
+  return {
+    topicId,
+    epoch,
+    ownerId,
+    isOwned() {
+      if (finished) return false;
+      const row = db
+        .query<{ owned: number }, [string, number, string]>(
+          `SELECT 1 AS owned FROM runtime_topic_state
+           WHERE topic_id = ? AND epoch = ? AND maintenance_owner = ? AND maintenance = 1`,
+        )
+        .get(topicId, epoch, ownerId);
+      return Boolean(row);
+    },
+    finish(finishOptions = {}) {
+      if (finished) return;
+      finished = true;
+      clearInterval(timer);
+      if (finishOptions.deleteState) {
+        db.query(
+          `DELETE FROM runtime_topic_state
+           WHERE topic_id = ? AND epoch = ? AND maintenance_owner = ?`,
+        ).run(topicId, epoch, ownerId);
+        return;
+      }
+      db.query(
+        `UPDATE runtime_topic_state
+         SET maintenance = 0, maintenance_owner = NULL, heartbeat_at = NULL
+         WHERE topic_id = ? AND epoch = ? AND maintenance_owner = ?`,
+      ).run(topicId, epoch, ownerId);
+    },
+  };
+}