negotium 0.1.6 → 0.1.8

package/dist/chunk-sm6fh5c5.js

@@ -0,0 +1,569 @@
+// @bun
+import {
+  cancelAskCallbacksForTopic
+} from "./chunk-jc0at0tc.js";
+import {
+  deletePendingAsksForTopic
+} from "./chunk-sgsz2fpq.js";
+import"./chunk-1k7t7bnx.js";
+import {
+  archiveTopicMessages,
+  cancelIdleArchiveForTopic,
+  cancelRuntimeUserTurnRequests,
+  cancelRuntimeUserTurnRequestsBeforeEpoch,
+  cancelSubagentWatchForDeletedTopic,
+  clearQueryState,
+  clearQueryUsageAlert,
+  deleteFilesForTopic,
+  deleteTopicArchiveState,
+  deleteTopicBrief,
+  deleteTopicVisuals,
+  killBgBash,
+  runArchiverTurn
+} from "./chunk-fgrme9tr.js";
+import {
+  WsHub,
+  closeBrowserOwnerTabs,
+  delay,
+  deleteMessagesForTopic,
+  deleteTopicProfileDir,
+  getBrowserProfileOwner,
+  getTopicBrowserProfile
+} from "./chunk-0ay6cjdy.js";
+import {
+  GENERAL_TOPIC_ID,
+  deleteTopic,
+  getTopicMemoryOrigin,
+  getTopicSessionId,
+  listTopics,
+  reparentTopicChildren
+} from "./chunk-xfq68rch.js";
+import {
+  deleteApiTopicConfig
+} from "./chunk-gmy11efb.js";
+import {
+  TOPIC_MAINTENANCE_STALE_MS,
+  TURN_LEASE_STALE_MS,
+  abortRoom,
+  beginRuntimeTopicMaintenance,
+  getRoomQuery,
+  getRuntimeTurnLease,
+  interSessionQueue
+} from "./chunk-t9zcg8f1.js";
+import {
+  db
+} from "./chunk-7xqj7aex.js";
+import {
+  getRegistry
+} from "./chunk-5ahkew9c.js";
+import {
+  getConversationPath,
+  readConversation
+} from "./chunk-6cpn7ht2.js";
+import {
+  SESSION_INBOX_DIR,
+  SUPPORTED_AGENTS,
+  logger,
+  resolveTopicWorkspaceDir
+} from "./chunk-k9z47mab.js";
+import"./chunk-hwy3n31w.js";
+
+// ../../packages/core/src/topics/lifecycle.ts
+import { rmSync } from "fs";
+
+// ../../packages/core/src/agents/topic-cleanup.ts
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function collectSessionIdsByAgent(entries, extraSessions = []) {
+  const out = new Map;
+  for (const e of entries) {
+    if (e.event.type !== "session")
+      continue;
+    const set = out.get(e.agent) ?? new Set;
+    set.add(e.event.sessionId);
+    out.set(e.agent, set);
+  }
+  for (const { agent, sessionId } of extraSessions) {
+    if (!sessionId)
+      continue;
+    const set = out.get(agent) ?? new Set;
+    set.add(sessionId);
+    out.set(agent, set);
+  }
+  return out;
+}
+async function cleanupSessionRollouts(opts, entries) {
+  const { userId, topicName, cwd, extraSessions = [] } = opts;
+  const idsByAgent = collectSessionIdsByAgent(entries, extraSessions);
+  let cleanupFailed = false;
+  await Promise.all(SUPPORTED_AGENTS.map(async (agent) => {
+    const ids = idsByAgent.get(agent);
+    if (!ids || ids.size === 0)
+      return;
+    try {
+      await getRegistry(agent).cleanupRollouts({
+        cwd,
+        sessionIds: Array.from(ids)
+      });
+    } catch (e) {
+      logger.warn({ err: e, userId, topicName, agent, count: ids.size }, "topic logs: agent cleanup failed");
+      cleanupFailed = true;
+    }
+  }));
+  return !cleanupFailed;
+}
+async function cleanupTopicRollouts(opts) {
+  return cleanupSessionRollouts(opts, readConversation(opts.userId, opts.topicName));
+}
+async function rotateTopicLogs(opts) {
+  const retainTurns = Math.max(0, Math.floor(opts.retainTurns));
+  const entries = readConversation(opts.userId, opts.topicName);
+  const userEntryIndexes = entries.flatMap((entry, index) => entry.event.type === "user_message" ? [index] : []);
+  const totalTurns = userEntryIndexes.length;
+  const firstRetainedIndex = retainTurns === 0 ? entries.length : userEntryIndexes[Math.max(0, totalTurns - retainTurns)] ?? 0;
+  const retained = entries.slice(firstRetainedIndex).filter((entry) => entry.event.type !== "session");
+  if (!await cleanupSessionRollouts(opts, entries)) {
+    logger.warn({ userId: opts.userId, topicName: opts.topicName }, "rotateTopicLogs: keeping current context because rollout cleanup failed");
+    return {
+      rotated: false,
+      totalTurns,
+      retainedTurns: Math.min(totalTurns, retainTurns),
+      retainedEntries: retained.length
+    };
+  }
+  const path = getConversationPath(opts.userId, opts.topicName);
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(tempPath, retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join(`
+`)}
+` : "", { flag: "wx" });
+    renameSync(tempPath, path);
+  } catch (e) {
+    try {
+      unlinkSync(tempPath);
+    } catch {}
+    logger.warn({ err: e, path }, "rotateTopicLogs: conversation replacement failed");
+    return {
+      rotated: false,
+      totalTurns,
+      retainedTurns: Math.min(totalTurns, retainTurns),
+      retainedEntries: retained.length
+    };
+  }
+  return {
+    rotated: true,
+    totalTurns,
+    retainedTurns: Math.min(totalTurns, retainTurns),
+    retainedEntries: retained.length
+  };
+}
+async function purgeTopicLogs(opts) {
+  const { userId, topicName } = opts;
+  const entries = readConversation(userId, topicName);
+  if (!await cleanupSessionRollouts(opts, entries)) {
+    logger.warn({ userId, topicName }, "purgeTopicLogs: keeping unified log because one or more rollout cleanups failed");
+    return;
+  }
+  const path = getConversationPath(userId, topicName);
+  try {
+    unlinkSync(path);
+  } catch (e) {
+    if (e?.code !== "ENOENT") {
+      logger.warn({ err: e, path }, "purgeTopicLogs: unified log unlink failed");
+    }
+  }
+}
+
+// ../../packages/core/src/query/session-inbox-cleanup.ts
+import { unlinkSync as unlinkSync2 } from "fs";
+import { basename, join as join2 } from "path";
+
+// ../../packages/core/src/query/session-inbox-path.ts
+import { join } from "path";
+var TOPIC_ID_FILE_PREFIX = "topic-id-";
+var JSONL_SUFFIX = ".jsonl";
+var SCHEDULE_SUFFIX = ".schedule";
+function sessionInboxPath(userId, topicId) {
+  const key = Buffer.from(topicId, "utf8").toString("base64url");
+  return join(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
+}
+function scheduledSessionInboxPath(userId, topicId) {
+  const key = Buffer.from(topicId, "utf8").toString("base64url");
+  return join(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${SCHEDULE_SUFFIX}`);
+}
+function decodeTopicIdFileName(fileName, suffix) {
+  if (!fileName.startsWith(TOPIC_ID_FILE_PREFIX) || !fileName.endsWith(suffix))
+    return null;
+  const encoded = fileName.slice(TOPIC_ID_FILE_PREFIX.length, -suffix.length);
+  if (!encoded || !/^[A-Za-z0-9_-]+$/.test(encoded))
+    return null;
+  try {
+    return Buffer.from(encoded, "base64url").toString("utf8") || null;
+  } catch {
+    return null;
+  }
+}
+function topicIdFromSessionInboxFileName(fileName) {
+  return decodeTopicIdFileName(fileName, JSONL_SUFFIX);
+}
+function topicIdFromScheduledSessionInboxFileName(fileName) {
+  const base = fileName.endsWith(".processing") ? fileName.slice(0, -".processing".length) : fileName;
+  return decodeTopicIdFileName(base, SCHEDULE_SUFFIX);
+}
+
+// ../../packages/core/src/query/session-inbox-cleanup.ts
+function cleanupSessionInboxFiles(userId, topicId, legacyTopicTitle) {
+  const live = sessionInboxPath(userId, topicId);
+  const scheduled = scheduledSessionInboxPath(userId, topicId);
+  const candidates = new Set([live, `${live}.processing`, scheduled, `${scheduled}.processing`]);
+  if (legacyTopicTitle && legacyTopicTitle !== "." && legacyTopicTitle !== ".." && basename(legacyTopicTitle) === legacyTopicTitle) {
+    const legacyBase = join2(SESSION_INBOX_DIR, userId, legacyTopicTitle);
+    for (const suffix of [".jsonl", ".jsonl.processing", ".schedule", ".schedule.processing"]) {
+      candidates.add(`${legacyBase}${suffix}`);
+    }
+  }
+  let deleted = 0;
+  for (const path of candidates) {
+    try {
+      unlinkSync2(path);
+      deleted++;
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        logger.warn({ err, path, topicId, userId }, "topic cleanup: inbox unlink failed");
+      }
+    }
+  }
+  return deleted;
+}
+
+// ../../packages/core/src/storage/self-schedules.ts
+import { randomUUID } from "crypto";
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_self_schedules (
+    id TEXT PRIMARY KEY,
+    topic_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    message TEXT NOT NULL,
+    deliver_at INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running')),
+    claimed_by TEXT,
+    claimed_at INTEGER,
+    running_query_id TEXT
+  )
+`);
+db.exec(`
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_runtime_self_schedules_one_pending
+  ON runtime_self_schedules(topic_id)
+  WHERE status = 'pending'
+`);
+db.exec(`
+  CREATE INDEX IF NOT EXISTS idx_runtime_self_schedules_due
+  ON runtime_self_schedules(status, deliver_at)
+`);
+function rowToSchedule(row) {
+  return {
+    id: row.id,
+    topicId: row.topic_id,
+    userId: row.user_id,
+    message: row.message,
+    deliverAt: Number(row.deliver_at),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    status: row.status === "running" ? "running" : "pending",
+    claimedBy: row.claimed_by ?? undefined,
+    claimedAt: row.claimed_at === null ? undefined : Number(row.claimed_at),
+    runningQueryId: row.running_query_id ?? undefined
+  };
+}
+function createPendingSelfSchedule(input) {
+  return db.transaction(() => {
+    const existing = getPendingSelfSchedule(input.topicId);
+    if (existing)
+      return { ok: false, existing };
+    const now = input.now ?? Date.now();
+    const schedule = {
+      id: `scheduled-${randomUUID()}`,
+      topicId: input.topicId,
+      userId: input.userId,
+      message: input.message,
+      deliverAt: input.deliverAt,
+      createdAt: now,
+      updatedAt: now,
+      status: "pending"
+    };
+    db.query(`INSERT INTO runtime_self_schedules
+           (id, topic_id, user_id, message, deliver_at, created_at, updated_at, status)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 'pending')`).run(schedule.id, schedule.topicId, schedule.userId, schedule.message, schedule.deliverAt, schedule.createdAt, schedule.updatedAt);
+    return { ok: true, schedule };
+  }).immediate();
+}
+function getPendingSelfSchedule(topicId) {
+  const row = db.query("SELECT * FROM runtime_self_schedules WHERE topic_id = ? AND status = 'pending'").get(topicId);
+  return row ? rowToSchedule(row) : null;
+}
+function updatePendingSelfSchedule(input) {
+  const existing = getPendingSelfSchedule(input.topicId);
+  if (!existing || existing.id !== input.scheduleId)
+    return null;
+  const result = db.query(`UPDATE runtime_self_schedules
+       SET message = ?, deliver_at = ?, updated_at = ?
+       WHERE id = ? AND topic_id = ? AND status = 'pending'`).run(input.message ?? existing.message, input.deliverAt ?? existing.deliverAt, input.now ?? Date.now(), input.scheduleId, input.topicId);
+  return Number(result.changes ?? 0) > 0 ? getPendingSelfSchedule(input.topicId) : null;
+}
+function cancelPendingSelfSchedule(topicId, scheduleId) {
+  const result = db.query("DELETE FROM runtime_self_schedules WHERE id = ? AND topic_id = ? AND status = 'pending'").run(scheduleId, topicId);
+  return Number(result.changes ?? 0) > 0;
+}
+function claimNextDueSelfSchedule(ownerId, now = Date.now()) {
+  const staleBefore = now - TURN_LEASE_STALE_MS;
+  return db.transaction(() => {
+    const row = db.query(`SELECT s.*
+           FROM runtime_self_schedules s
+           LEFT JOIN runtime_turn_leases l ON l.topic_id = s.topic_id
+           LEFT JOIN runtime_topic_state t ON t.topic_id = s.topic_id
+           WHERE (l.topic_id IS NULL OR l.heartbeat_at < ?)
+             AND (t.topic_id IS NULL OR t.maintenance = 0 OR t.heartbeat_at < ?)
+             AND (
+               (s.status = 'pending' AND s.deliver_at <= ?)
+               OR (s.status = 'running' AND (s.claimed_at IS NULL OR s.claimed_at < ?))
+             )
+           ORDER BY CASE s.status WHEN 'running' THEN 0 ELSE 1 END, s.deliver_at ASC
+           LIMIT 1`).get(staleBefore, now - TOPIC_MAINTENANCE_STALE_MS, now, staleBefore);
+    if (!row)
+      return null;
+    const result = db.query(`UPDATE runtime_self_schedules
+           SET status = 'running', claimed_by = ?, claimed_at = ?, running_query_id = NULL
+           WHERE id = ? AND (
+             (status = 'pending' AND deliver_at <= ?)
+             OR (status = 'running' AND (claimed_at IS NULL OR claimed_at < ?))
+           )`).run(ownerId, now, row.id, now, staleBefore);
+    if (Number(result.changes ?? 0) === 0)
+      return null;
+    return rowToSchedule({
+      ...row,
+      status: "running",
+      claimed_by: ownerId,
+      claimed_at: now,
+      running_query_id: null
+    });
+  }).immediate();
+}
+function markSelfScheduleRunning(scheduleId, ownerId, queryId) {
+  const result = db.query(`UPDATE runtime_self_schedules
+       SET running_query_id = ?, claimed_at = ?
+       WHERE id = ? AND status = 'running' AND claimed_by = ?`).run(queryId, Date.now(), scheduleId, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+function heartbeatSelfScheduleClaim(scheduleId, ownerId, now = Date.now()) {
+  const result = db.query(`UPDATE runtime_self_schedules
+       SET claimed_at = ?
+       WHERE id = ? AND status = 'running' AND claimed_by = ?`).run(now, scheduleId, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+function releaseSelfScheduleClaim(scheduleId, ownerId) {
+  return db.transaction(() => {
+    const row = db.query("SELECT * FROM runtime_self_schedules WHERE id = ? AND status = 'running' AND claimed_by = ?").get(scheduleId, ownerId);
+    if (!row)
+      return "dropped";
+    const newer = getPendingSelfSchedule(row.topic_id);
+    if (newer) {
+      db.query("DELETE FROM runtime_self_schedules WHERE id = ?").run(scheduleId);
+      return "dropped";
+    }
+    db.query(`UPDATE runtime_self_schedules
+         SET status = 'pending', claimed_by = NULL, claimed_at = NULL,
+             running_query_id = NULL, updated_at = ?
+         WHERE id = ? AND claimed_by = ?`).run(Date.now(), scheduleId, ownerId);
+    return "released";
+  }).immediate();
+}
+function completeSelfSchedule(scheduleId, ownerId) {
+  const result = ownerId ? db.query("DELETE FROM runtime_self_schedules WHERE id = ? AND claimed_by = ?").run(scheduleId, ownerId) : db.query("DELETE FROM runtime_self_schedules WHERE id = ?").run(scheduleId);
+  return Number(result.changes ?? 0) > 0;
+}
+function deleteSelfSchedulesForTopic(topicId) {
+  const result = db.query("DELETE FROM runtime_self_schedules WHERE topic_id = ?").run(topicId);
+  return Number(result.changes ?? 0);
+}
+
+// ../../packages/core/src/topics/lifecycle.ts
+var DELETE_TURN_WAIT_MS = 5000;
+async function abortAndWaitForTopic(topicId) {
+  interSessionQueue.drop(topicId);
+  cancelIdleArchiveForTopic(topicId);
+  const aborted = abortRoom(topicId);
+  if (!aborted)
+    return true;
+  logger.info({ topicId }, "deleteTopicCascade: aborted in-flight turn");
+  const deadline = Date.now() + DELETE_TURN_WAIT_MS;
+  while ((getRoomQuery(topicId) || getRuntimeTurnLease(topicId)) && Date.now() < deadline) {
+    await delay(50);
+  }
+  if (getRoomQuery(topicId) || getRuntimeTurnLease(topicId)) {
+    logger.warn({ topicId, timeoutMs: DELETE_TURN_WAIT_MS }, "deleteTopicCascade: timed out waiting for in-flight turn cleanup");
+    return false;
+  }
+  return true;
+}
+function currentSessionRef(topic, sessionId) {
+  return topic.agent && sessionId ? [{ agent: topic.agent, sessionId }] : [];
+}
+async function cleanupParticipantResources(topic, userIds, sessionId, cwd) {
+  for (const [index, participantUserId] of userIds.entries()) {
+    try {
+      await purgeTopicLogs({
+        userId: participantUserId,
+        topicName: topic.title,
+        cwd,
+        extraSessions: index === 0 ? currentSessionRef(topic, sessionId) : []
+      });
+    } catch (err) {
+      logger.warn({ err, topicId: topic.id, userId: participantUserId }, "deleteTopicCascade: participant rollout cleanup failed");
+    }
+    cleanupSessionInboxFiles(participantUserId, topic.id, topic.title);
+    clearQueryState(participantUserId, topic.title);
+    clearQueryUsageAlert(participantUserId, topic.id);
+    deletePendingAsksForTopic({ userId: participantUserId, topicName: topic.title });
+  }
+}
+
+class TopicArchiveRequiredError extends Error {
+  code = "TOPIC_ARCHIVE_FAILED";
+  topicId;
+  constructor(topicId, cause) {
+    super("Topic archive failed; deletion was blocked to avoid losing conversation history.");
+    this.name = "TopicArchiveRequiredError";
+    this.topicId = topicId;
+    this.cause = cause;
+  }
+}
+
+class TopicTurnStillActiveError extends Error {
+  code = "TOPIC_TURN_STILL_ACTIVE";
+  topicId;
+  constructor(topicId) {
+    super("The active turn did not stop in time; deletion was blocked. Use force-delete explicitly.");
+    this.name = "TopicTurnStillActiveError";
+    this.topicId = topicId;
+  }
+}
+async function deleteTopicCascade(topic, userId, options = {}) {
+  await deleteTopicCascadeImpl(topic, userId, options, new Set);
+}
+async function deleteTopicCascadeImpl(topic, userId, options, deletingAncestorIds) {
+  const topicId = topic.id;
+  if (topicId === GENERAL_TOPIC_ID || topic.kind === "manager" && !options.allowManager) {
+    logger.warn({ topicId }, "deleteTopicCascade: refused to delete essential topic");
+    return;
+  }
+  const deletingTopicIds = new Set(deletingAncestorIds);
+  deletingTopicIds.add(topicId);
+  const force = options.force === true;
+  const maintenance = beginRuntimeTopicMaintenance(topicId);
+  if (!maintenance)
+    throw new Error("Topic maintenance is already in progress.");
+  let deleted = false;
+  const cancelledQueryIds = cancelRuntimeUserTurnRequestsBeforeEpoch(topicId, maintenance.epoch);
+  for (const queryId of cancelledQueryIds) {
+    WsHub.get().broadcastAborted(topicId, queryId, "stopped");
+  }
+  try {
+    const turnStopped = await abortAndWaitForTopic(topicId);
+    if (!turnStopped && !force)
+      throw new TopicTurnStillActiveError(topicId);
+    if (!maintenance.isOwned())
+      throw new Error("Topic maintenance ownership was lost.");
+    let archived = null;
+    if (!options.skipArchive) {
+      try {
+        archived = archiveTopicMessages(topicId, topic.title);
+      } catch (err) {
+        if (!force) {
+          logger.warn({ err, topicId }, "deleteTopicCascade: archive failed - blocking delete unless force=true");
+          throw new TopicArchiveRequiredError(topicId, err);
+        }
+        logger.warn({ err, topicId }, "deleteTopicCascade: archive failed but force=true - continuing with hard delete");
+      }
+    }
+    if (archived) {
+      try {
+        const memoryTopic = getTopicMemoryOrigin(topicId) ?? topic;
+        runArchiverTurn({
+          userId,
+          ...memoryTopic.id !== topicId && !deletingTopicIds.has(memoryTopic.id) ? { topicId: memoryTopic.id } : {},
+          topicTitle: memoryTopic.title,
+          archivePath: archived.path,
+          messageCount: archived.messageCount
+        });
+      } catch (err) {
+        logger.warn({ err, topicId, archive: archived.path }, "deleteTopicCascade: background archiver launch failed - raw archive preserved");
+      }
+    }
+    cancelSubagentWatchForDeletedTopic(topicId);
+    const spawnedChildren = listTopics().filter((candidate) => candidate.parentTopicId === topicId && candidate.isSubagent && !deletingTopicIds.has(candidate.id));
+    for (const child of spawnedChildren) {
+      await deleteTopicCascadeImpl(child, userId, options, deletingTopicIds);
+    }
+    const sessionId = getTopicSessionId(topicId);
+    const cwd = resolveTopicWorkspaceDir(topicId);
+    const participantUserIds = Array.from(new Set([userId, ...topic.participants.map((participant) => participant.userId)]));
+    killBgBash(userId, topicId);
+    const browserProfileOwner = getBrowserProfileOwner(topicId, userId);
+    const browserProfile = getTopicBrowserProfile(topicId);
+    try {
+      await closeBrowserOwnerTabs(browserProfileOwner, browserProfile, `topic:${topicId}`);
+    } catch (err) {
+      logger.warn({ err, topicId }, "deleteTopicCascade: browser owner cleanup failed");
+    }
+    deleteTopicProfileDir(userId, topicId);
+    cancelAskCallbacksForTopic(topicId);
+    deleteSelfSchedulesForTopic(topicId);
+    await cleanupParticipantResources(topic, participantUserIds, sessionId, cwd);
+    try {
+      await deleteFilesForTopic(topicId);
+    } catch (err) {
+      logger.warn({ err, topicId }, "deleteTopicCascade: host file cleanup failed");
+    }
+    try {
+      rmSync(cwd, { recursive: true, force: true });
+    } catch (err) {
+      logger.warn({ err, topicId, cwd }, "deleteTopicCascade: workspace cleanup failed");
+    }
+    deleteTopicVisuals(topicId);
+    deleteTopicArchiveState(topicId);
+    deleteMessagesForTopic(topicId);
+    deleteApiTopicConfig(topicId);
+    deleteTopicBrief(topicId);
+    const reparentedChildIds = reparentTopicChildren(topicId, topic.parentTopicId ?? null);
+    const rowDeleted = deleteTopic(topicId, { allowManager: options.allowManager });
+    if (!rowDeleted) {
+      logger.warn({ topicId }, "deleteTopicCascade: topic row was not deleted");
+      return;
+    }
+    deleted = true;
+    WsHub.get().broadcastTopicDeleted(topicId);
+    for (const childId of reparentedChildIds)
+      WsHub.get().broadcastTopicUpdated(childId);
+  } finally {
+    if (deleted) {
+      for (const queryId of cancelRuntimeUserTurnRequests(topicId)) {
+        WsHub.get().broadcastAborted(topicId, queryId, "stopped");
+      }
+      maintenance.finish({ deleteState: true });
+    } else {
+      maintenance.finish();
+    }
+  }
+}
+export {
+  deleteTopicCascade,
+  TopicTurnStillActiveError,
+  TopicArchiveRequiredError
+};
+
+export { createPendingSelfSchedule, getPendingSelfSchedule, updatePendingSelfSchedule, cancelPendingSelfSchedule, claimNextDueSelfSchedule, markSelfScheduleRunning, heartbeatSelfScheduleClaim, releaseSelfScheduleClaim, completeSelfSchedule, cleanupTopicRollouts, rotateTopicLogs, purgeTopicLogs, sessionInboxPath, topicIdFromSessionInboxFileName, topicIdFromScheduledSessionInboxFileName, TopicArchiveRequiredError, TopicTurnStillActiveError, deleteTopicCascade };
+
+//# debugId=CD7A49E8BD3277ED64756E2164756E21