opencode-swarm 7.153.2 → 7.154.1

package/dist/cli/index-bmkxc6sa.js

@@ -0,0 +1,1231 @@
+// @bun
+import {
+  validateSwarmPath
+} from "./index-4cgee5vh.js";
+import {
+  atomicWriteSwarmFileSync
+} from "./index-c809a69b.js";
+import {
+  withEvidenceLock
+} from "./index-xagq35tf.js";
+import {
+  telemetry
+} from "./index-h1g8w4v0.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
+import {
+  log
+} from "./index-zgwm4ryv.js";
+
+// src/background/pr-subscriptions.ts
+init_zod();
+import * as fs from "fs";
+import * as path from "path";
+var PR_SUBSCRIPTIONS_FILE = "pr-monitor/subscriptions.jsonl";
+var PR_SUBSCRIPTIONS_CHECKPOINT_FILE = "pr-monitor/subscriptions.checkpoint.json";
+var PR_SUBSCRIPTIONS_AUDIT_FILE = "pr-monitor/subscriptions.audit.jsonl";
+var LEGACY_ARCHIVE_FILE = "pr-monitor/subscriptions.legacy.jsonl";
+var FOREIGN_CHECKPOINT_FILE = "pr-monitor/subscriptions.checkpoint.foreign.json";
+var CORRUPT_CHECKPOINT_FILE = "pr-monitor/subscriptions.checkpoint.corrupt.json";
+var STORE_LOCK_AGENT = "pr-monitor";
+var STORE_LOCK_TASK = "pr-subscriptions";
+var PR_SUBSCRIPTION_LIMITS = {
+  readChunkBytes: 64 * 1024,
+  maxRecordBytes: 64 * 1024,
+  migrationChunkBytes: 1024 * 1024,
+  legacySourceMaxBytes: 64 * 1024 * 1024,
+  defaultMaxActiveSubscriptions: 20,
+  maxCheckpointRecords: 512,
+  maxCheckpointBytes: 256 * 1024,
+  checkpointHardReadBytes: 1024 * 1024,
+  terminalRecordsHigh: 60,
+  terminalRecordsLow: 30,
+  terminalMaxAgeMs: 30 * 86400000,
+  auditMaxLinesHigh: 500,
+  auditMaxLinesLow: 250,
+  auditMaxBytesHigh: 128 * 1024,
+  auditMaxBytesLow: 64 * 1024,
+  legacyArchiveTtlMs: 7 * 86400000,
+  bootstrapLockTimeoutMs: 5000
+};
+var onSubscriptionCreated = null;
+function setOnSubscriptionCreated(callback) {
+  onSubscriptionCreated = callback;
+}
+var RecordSchema = exports_external.object({
+  correlationId: exports_external.string().min(1),
+  sessionID: exports_external.string().min(1),
+  prNumber: exports_external.number().int().positive(),
+  repoFullName: exports_external.string().regex(/^[^/]+\/[^/]+$/, "Must be owner/repo format"),
+  prUrl: exports_external.string().min(1).regex(/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/, "Must be a valid GitHub PR URL"),
+  headRefOid: exports_external.string().optional(),
+  lastCheckedAt: exports_external.number(),
+  lastCommentId: exports_external.string().optional(),
+  lastCheckRunSet: exports_external.string().optional(),
+  mergeableState: exports_external.string().optional(),
+  mergeGroupRunStatus: exports_external.string().optional(),
+  mergeGroupRunConclusion: exports_external.string().optional(),
+  mergeGroupRunHtmlUrl: exports_external.string().optional(),
+  isWatching: exports_external.boolean(),
+  hasUnaddressedEvents: exports_external.boolean(),
+  status: exports_external.enum(["active", "removed", "expired"]),
+  createdAt: exports_external.number(),
+  updatedAt: exports_external.number(),
+  errorCount: exports_external.number().int().min(0),
+  customPollIntervalSeconds: exports_external.number().int().positive().optional(),
+  customFailureThreshold: exports_external.number().int().min(0).optional(),
+  customCooldownSeconds: exports_external.number().int().positive().optional()
+}).strict();
+var TerminalSummarySchema = exports_external.object({
+  removed: exports_external.number().int().min(0),
+  expired: exports_external.number().int().min(0),
+  lastTerminalAt: exports_external.number().int().nullable()
+}).strict();
+var MigrationSchema = exports_external.object({
+  scannedBytes: exports_external.number().int().nonnegative(),
+  sourceBytes: exports_external.number().int().nonnegative(),
+  sourceMtimeMs: exports_external.number().nonnegative(),
+  corruptLines: exports_external.number().int().nonnegative(),
+  done: exports_external.boolean(),
+  archived: exports_external.boolean(),
+  startedAt: exports_external.number().int().nonnegative()
+}).strict();
+var MaintenanceSchema = exports_external.object({
+  compactions: exports_external.number().int().nonnegative(),
+  droppedAuditTransitions: exports_external.number().int().nonnegative(),
+  corruptLegacyRecords: exports_external.number().int().nonnegative(),
+  lastCompactedAt: exports_external.number().int().nullable(),
+  resets: exports_external.number().int().nonnegative()
+}).strict();
+var CheckpointSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  sequence: exports_external.number().int().positive(),
+  rootPath: exports_external.string().min(1).max(4096),
+  updatedAt: exports_external.number().int().nonnegative(),
+  records: exports_external.record(exports_external.string(), RecordSchema),
+  terminalSummary: TerminalSummarySchema,
+  migration: MigrationSchema.nullable(),
+  maintenance: MaintenanceSchema
+}).strict();
+function storePath(directory) {
+  return validateSwarmPath(directory, PR_SUBSCRIPTIONS_FILE);
+}
+function checkpointPath(directory) {
+  return validateSwarmPath(directory, PR_SUBSCRIPTIONS_CHECKPOINT_FILE);
+}
+function auditPath(directory) {
+  return validateSwarmPath(directory, PR_SUBSCRIPTIONS_AUDIT_FILE);
+}
+function legacyArchivePath(directory) {
+  return validateSwarmPath(directory, LEGACY_ARCHIVE_FILE);
+}
+function foreignSlotPath(directory) {
+  return validateSwarmPath(directory, FOREIGN_CHECKPOINT_FILE);
+}
+function corruptSlotPath(directory) {
+  return validateSwarmPath(directory, CORRUPT_CHECKPOINT_FILE);
+}
+function ensureSwarmDir(directory) {
+  fs.mkdirSync(path.resolve(directory, ".swarm", "pr-monitor"), {
+    recursive: true
+  });
+}
+function buildCorrelationId(sessionID, repoFullName, prNumber) {
+  return `${sessionID}::${repoFullName}::${prNumber}`;
+}
+function sameProjectRoot(recorded, current) {
+  const a = path.resolve(recorded);
+  const b = path.resolve(current);
+  if (process.platform === "win32")
+    return a.toLowerCase() === b.toLowerCase();
+  return a === b;
+}
+function fileSizeOrNull(filePath) {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return null;
+  }
+}
+function renameWithRetry(from, to) {
+  let lastError;
+  for (let attempt = 0;attempt < 5; attempt++) {
+    try {
+      fs.renameSync(from, to);
+      return;
+    } catch (err) {
+      lastError = err;
+      const code = err.code;
+      if (code !== "EEXIST" && code !== "EPERM" && code !== "EBUSY")
+        throw err;
+      try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 15);
+      } catch {}
+    }
+  }
+  throw lastError;
+}
+function foldLegacyRegion(filePath, startByte, maxBytes) {
+  const folded = new Map;
+  let corruptLines = 0;
+  let consumedTo = startByte;
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+  } catch {
+    return {
+      folded,
+      nextByte: startByte,
+      eof: true,
+      aborted: true,
+      corruptLines
+    };
+  }
+  const processLineBytes = (line) => {
+    if (line.length === 0)
+      return;
+    const text = line.toString("utf-8");
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      corruptLines += 1;
+      return;
+    }
+    const result = RecordSchema.safeParse(parsed);
+    if (!result.success) {
+      corruptLines += 1;
+      return;
+    }
+    const rec = result.data;
+    if (rec.correlationId !== buildCorrelationId(rec.sessionID, rec.repoFullName, rec.prNumber)) {
+      corruptLines += 1;
+      return;
+    }
+    folded.set(rec.correlationId, rec);
+  };
+  try {
+    const size = fs.fstatSync(fd).size;
+    if (startByte >= size) {
+      return {
+        folded,
+        nextByte: startByte,
+        eof: true,
+        aborted: false,
+        corruptLines
+      };
+    }
+    const chunk = Buffer.alloc(PR_SUBSCRIPTION_LIMITS.readChunkBytes);
+    let pending = [];
+    let pendingLen = 0;
+    let oversize = false;
+    let pos = startByte;
+    const flushPendingAtEof = () => {
+      if (oversize) {
+        corruptLines += 1;
+      } else if (pendingLen > 0) {
+        processLineBytes(Buffer.concat(pending));
+      }
+      consumedTo = Math.max(consumedTo, pos);
+      pending = [];
+      pendingLen = 0;
+      oversize = false;
+      return {
+        folded,
+        nextByte: consumedTo,
+        eof: true,
+        aborted: false,
+        corruptLines
+      };
+    };
+    while (true) {
+      const want = Math.min(chunk.length, size - pos);
+      if (want <= 0)
+        return flushPendingAtEof();
+      const n = fs.readSync(fd, chunk, 0, want, pos);
+      if (n <= 0)
+        return flushPendingAtEof();
+      const data = chunk.subarray(0, n);
+      const base = pos;
+      pos += n;
+      let scan = 0;
+      while (scan < data.length) {
+        const nl = data.indexOf(10, scan);
+        if (nl === -1) {
+          pending.push(Buffer.from(data.subarray(scan)));
+          pendingLen += data.length - scan;
+          break;
+        }
+        const lineLen = pendingLen + (nl - scan);
+        if (oversize || lineLen > PR_SUBSCRIPTION_LIMITS.maxRecordBytes) {
+          corruptLines += 1;
+        } else {
+          const pieces = pending.length > 0 ? [...pending, data.subarray(scan, nl)] : [data.subarray(scan, nl)];
+          processLineBytes(Buffer.concat(pieces));
+        }
+        pending = [];
+        pendingLen = 0;
+        oversize = false;
+        consumedTo = base + nl + 1;
+        scan = nl + 1;
+      }
+      if (!oversize && pendingLen > PR_SUBSCRIPTION_LIMITS.maxRecordBytes) {
+        oversize = true;
+        pending = [];
+        pendingLen = 0;
+      }
+      if (consumedTo - startByte >= maxBytes && pendingLen === 0 && !oversize) {
+        const eof = consumedTo >= size;
+        return {
+          folded,
+          nextByte: consumedTo,
+          eof,
+          aborted: false,
+          corruptLines
+        };
+      }
+    }
+  } catch (err) {
+    log(`[pr-monitor] foldLegacyRegion failed: ${err instanceof Error ? err.message : String(err)}`);
+    return {
+      folded,
+      nextByte: consumedTo,
+      eof: true,
+      aborted: true,
+      corruptLines
+    };
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {}
+  }
+}
+function mergeFoldedRecords(view, overlay) {
+  let replaced = 0;
+  for (const [key, rec] of overlay) {
+    const base = view[key];
+    if (!base || rec.updatedAt >= base.updatedAt) {
+      view[key] = rec;
+      replaced += 1;
+    }
+  }
+  return replaced;
+}
+function readCheckpoint(directory) {
+  let stat;
+  try {
+    stat = fs.statSync(checkpointPath(directory));
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { kind: "absent" };
+    }
+    return {
+      kind: "invalid",
+      reason: `unreadable (${err.code ?? "unknown"})`
+    };
+  }
+  if (stat.size > PR_SUBSCRIPTION_LIMITS.checkpointHardReadBytes) {
+    return {
+      kind: "invalid",
+      reason: `checkpoint exceeds hard read ceiling (${stat.size} > ${PR_SUBSCRIPTION_LIMITS.checkpointHardReadBytes} bytes)`
+    };
+  }
+  let raw;
+  try {
+    raw = fs.readFileSync(checkpointPath(directory), "utf-8");
+  } catch (err) {
+    return {
+      kind: "invalid",
+      reason: `unreadable (${err.code ?? "unknown"})`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return {
+      kind: "invalid",
+      reason: `malformed JSON (${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+  const result = CheckpointSchema.safeParse(parsed);
+  if (!result.success) {
+    return { kind: "invalid", reason: result.error.message };
+  }
+  const checkpoint = result.data;
+  const recordCount = Object.keys(checkpoint.records).length;
+  if (recordCount > PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords) {
+    return {
+      kind: "invalid",
+      reason: `records count ${recordCount} exceeds guard ${PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords}`
+    };
+  }
+  for (const [key, rec] of Object.entries(checkpoint.records)) {
+    if (key !== rec.correlationId || rec.correlationId !== buildCorrelationId(rec.sessionID, rec.repoFullName, rec.prNumber)) {
+      return {
+        kind: "invalid",
+        reason: `record identity mismatch at key "${key}"`
+      };
+    }
+  }
+  return { kind: "ok", value: checkpoint };
+}
+function freshCheckpoint(directory) {
+  return {
+    schemaVersion: 1,
+    sequence: 0,
+    rootPath: path.resolve(directory),
+    updatedAt: Date.now(),
+    records: {},
+    terminalSummary: { removed: 0, expired: 0, lastTerminalAt: null },
+    migration: null,
+    maintenance: {
+      compactions: 0,
+      droppedAuditTransitions: 0,
+      corruptLegacyRecords: 0,
+      lastCompactedAt: null,
+      resets: 0
+    }
+  };
+}
+function cloneCheckpoint(cp) {
+  return JSON.parse(JSON.stringify(cp));
+}
+function validateRecord(record) {
+  const result = RecordSchema.safeParse(record);
+  if (!result.success) {
+    throw new Error(`Invalid subscription record: ${result.error.message}`);
+  }
+}
+function writeCheckpointFile(directory, checkpoint) {
+  const recordCount = Object.keys(checkpoint.records).length;
+  if (recordCount > PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords) {
+    throw new Error(`PR subscription store over checkpoint capacity: ${recordCount} records > ${PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords}. The folded state exceeds the bounded checkpoint \u2014 archive or split .swarm/pr-monitor/subscriptions.jsonl (subscriptions can be re-created with /swarm pr subscribe), then remove it.`);
+  }
+  const content = `${JSON.stringify(checkpoint)}
+`;
+  const contentBytes = Buffer.byteLength(content, "utf-8");
+  if (contentBytes > PR_SUBSCRIPTION_LIMITS.checkpointHardReadBytes) {
+    throw new Error(`PR subscription store over checkpoint capacity: ${contentBytes} bytes > ${PR_SUBSCRIPTION_LIMITS.checkpointHardReadBytes}. The folded state exceeds the bounded checkpoint \u2014 archive or split .swarm/pr-monitor/subscriptions.jsonl (subscriptions can be re-created with /swarm pr subscribe), then remove it.`);
+  }
+  if (contentBytes > PR_SUBSCRIPTION_LIMITS.maxCheckpointBytes) {
+    log(`[pr-monitor] checkpoint pressure: ${contentBytes}/${PR_SUBSCRIPTION_LIMITS.maxCheckpointBytes} bytes`);
+  }
+  ensureSwarmDir(directory);
+  atomicWriteSwarmFileSync(checkpointPath(directory), content);
+}
+function quarantineCheckpoint(directory, slot) {
+  const from = checkpointPath(directory);
+  const to = slot === "foreign" ? foreignSlotPath(directory) : corruptSlotPath(directory);
+  try {
+    try {
+      fs.renameSync(to, `${to}.prev`);
+    } catch {}
+    renameWithRetry(from, to);
+    return true;
+  } catch (err) {
+    log(`[pr-monitor] checkpoint quarantine (${slot}) failed: ${err instanceof Error ? err.message : String(err)} \u2014 the next checkpoint write replaces it`);
+    return false;
+  }
+}
+function flushAuditEvents(directory, events, sequence, maintenance) {
+  if (events.length === 0)
+    return;
+  ensureSwarmDir(directory);
+  const lines = events.map((event) => JSON.stringify({
+    ts: Date.now(),
+    seq: sequence,
+    kind: event.kind,
+    ...event.correlationId ? { correlationId: event.correlationId } : {}
+  }));
+  try {
+    fs.appendFileSync(auditPath(directory), `${lines.join(`
+`)}
+`, "utf-8");
+  } catch (err) {
+    log(`[pr-monitor] audit append failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
+  compactAuditTail(directory, maintenance);
+}
+function compactAuditTail(directory, maintenance) {
+  let size;
+  try {
+    size = fs.statSync(auditPath(directory)).size;
+  } catch {
+    return;
+  }
+  if (size <= PR_SUBSCRIPTION_LIMITS.auditMaxBytesLow)
+    return;
+  const windowBytes = 2 * PR_SUBSCRIPTION_LIMITS.auditMaxBytesHigh;
+  let content;
+  try {
+    if (size > windowBytes) {
+      const fd = fs.openSync(auditPath(directory), "r");
+      try {
+        const tail = Buffer.alloc(windowBytes);
+        const n = fs.readSync(fd, tail, 0, windowBytes, size - windowBytes);
+        const text = tail.subarray(0, n).toString("utf-8");
+        const firstNl = text.indexOf(`
+`);
+        content = firstNl === -1 ? "" : text.slice(firstNl + 1);
+      } finally {
+        fs.closeSync(fd);
+      }
+    } else {
+      content = fs.readFileSync(auditPath(directory), "utf-8");
+    }
+  } catch {
+    return;
+  }
+  const all = content.split(`
+`).filter((line) => line.trim().length > 0);
+  if (all.length <= PR_SUBSCRIPTION_LIMITS.auditMaxLinesHigh && size <= PR_SUBSCRIPTION_LIMITS.auditMaxBytesHigh) {
+    return;
+  }
+  const kept = [];
+  let bytes = 0;
+  for (let i = all.length - 1;i >= 0; i--) {
+    const lineBytes = Buffer.byteLength(all[i], "utf-8") + 1;
+    if (kept.length >= PR_SUBSCRIPTION_LIMITS.auditMaxLinesLow || bytes + lineBytes > PR_SUBSCRIPTION_LIMITS.auditMaxBytesLow) {
+      break;
+    }
+    kept.unshift(all[i]);
+    bytes += lineBytes;
+  }
+  const dropped = all.length - kept.length;
+  try {
+    atomicWriteSwarmFileSync(auditPath(directory), kept.length > 0 ? `${kept.join(`
+`)}
+` : "");
+    maintenance.droppedAuditTransitions += dropped;
+  } catch (err) {
+    log(`[pr-monitor] audit compaction failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function auditStats(directory) {
+  try {
+    const stat = fs.statSync(auditPath(directory));
+    let content;
+    if (stat.size > 2 * PR_SUBSCRIPTION_LIMITS.auditMaxBytesHigh) {
+      const fd = fs.openSync(auditPath(directory), "r");
+      try {
+        const head = Buffer.alloc(2 * PR_SUBSCRIPTION_LIMITS.auditMaxBytesHigh);
+        const n = fs.readSync(fd, head, 0, head.length, 0);
+        content = head.subarray(0, n).toString("utf-8");
+      } finally {
+        fs.closeSync(fd);
+      }
+    } else {
+      content = fs.readFileSync(auditPath(directory), "utf-8");
+    }
+    return {
+      lines: content.split(`
+`).filter((line) => line.trim().length > 0).length,
+      bytes: stat.size
+    };
+  } catch {
+    return { lines: 0, bytes: 0 };
+  }
+}
+function compactTerminalRecords(view, checkpoint) {
+  const now = Date.now();
+  const terminals = Object.entries(view).filter(([, rec]) => rec.status !== "active").sort((a, b) => b[1].updatedAt - a[1].updatedAt);
+  if (terminals.length === 0)
+    return null;
+  const hasAged = terminals.some(([, rec]) => now - rec.updatedAt > PR_SUBSCRIPTION_LIMITS.terminalMaxAgeMs);
+  if (!hasAged && terminals.length <= PR_SUBSCRIPTION_LIMITS.terminalRecordsHigh) {
+    return null;
+  }
+  let kept = 0;
+  for (const [key, rec] of terminals) {
+    const aged = now - rec.updatedAt > PR_SUBSCRIPTION_LIMITS.terminalMaxAgeMs;
+    if (aged || kept >= PR_SUBSCRIPTION_LIMITS.terminalRecordsLow) {
+      if (rec.status === "removed")
+        checkpoint.terminalSummary.removed += 1;
+      else
+        checkpoint.terminalSummary.expired += 1;
+      checkpoint.terminalSummary.lastTerminalAt = Math.max(checkpoint.terminalSummary.lastTerminalAt ?? 0, rec.updatedAt);
+      delete view[key];
+    } else {
+      kept += 1;
+    }
+  }
+  checkpoint.maintenance.compactions += 1;
+  checkpoint.maintenance.lastCompactedAt = now;
+  return { kind: "compact" };
+}
+function maybeArchiveLegacy(directory, checkpoint) {
+  const migration = checkpoint.migration;
+  if (!migration || !migration.done || migration.archived)
+    return null;
+  const legacy = storePath(directory);
+  const size = fileSizeOrNull(legacy);
+  if (size === null) {
+    migration.archived = true;
+    return null;
+  }
+  if (size !== migration.sourceBytes)
+    return null;
+  try {
+    try {
+      fs.unlinkSync(legacyArchivePath(directory));
+    } catch {}
+    renameWithRetry(legacy, legacyArchivePath(directory));
+  } catch (err) {
+    log(`[pr-monitor] legacy archive deferred: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  try {
+    const now = Date.now() / 1000;
+    fs.utimesSync(legacyArchivePath(directory), now, now);
+  } catch {}
+  migration.archived = true;
+  return { kind: "archive" };
+}
+function cleanupStaleLegacyArchive(directory) {
+  try {
+    const stat = fs.statSync(legacyArchivePath(directory));
+    if (Date.now() - stat.mtimeMs > PR_SUBSCRIPTION_LIMITS.legacyArchiveTtlMs) {
+      fs.unlinkSync(legacyArchivePath(directory));
+    }
+  } catch {}
+}
+function emitHealthTelemetry(trigger, checkpoint) {
+  const records = Object.values(checkpoint.records);
+  telemetry.prSubscriptionHealth({
+    trigger,
+    active_count: records.filter((r) => r.status === "active").length,
+    terminal_count: records.filter((r) => r.status !== "active").length,
+    compactions: checkpoint.maintenance.compactions,
+    corrupt_count: checkpoint.maintenance.corruptLegacyRecords,
+    dropped_audit_count: checkpoint.maintenance.droppedAuditTransitions,
+    checkpoint_bytes: Buffer.byteLength(JSON.stringify(checkpoint), "utf-8"),
+    limit_bytes: PR_SUBSCRIPTION_LIMITS.maxCheckpointBytes,
+    recovery_resets: checkpoint.maintenance.resets
+  });
+}
+var legacyOverLimitWarned = new Map;
+function warnLegacyOverLimit(directory, size) {
+  if (legacyOverLimitWarned.has(directory))
+    return;
+  if (legacyOverLimitWarned.size >= 32) {
+    legacyOverLimitWarned.delete(legacyOverLimitWarned.keys().next().value);
+  }
+  legacyOverLimitWarned.set(directory, true);
+  log(`[pr-monitor] legacy subscriptions.jsonl is ${size} bytes (>${PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes}); refusing to fold it \u2014 archive or split the file so its subscriptions can be re-subscribed, then remove it (reported via /swarm pr status)`);
+}
+var migrationCapacityWarned = new Map;
+function warnMigrationCapacity(directory, records) {
+  if (migrationCapacityWarned.has(directory))
+    return;
+  if (migrationCapacityWarned.size >= 32) {
+    migrationCapacityWarned.delete(migrationCapacityWarned.keys().next().value);
+  }
+  migrationCapacityWarned.set(directory, true);
+  log(`[pr-monitor] legacy subscriptions.jsonl folds to ${records} records (>checkpoint capacity ${PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords}); migration refused \u2014 archive or split the file so its subscriptions can be re-subscribed, then remove it`);
+}
+function overlayLegacy(directory, checkpoint) {
+  const view = { ...checkpoint.records };
+  const legacy = storePath(directory);
+  let stat = null;
+  try {
+    stat = fs.statSync(legacy);
+  } catch {}
+  if (stat === null) {
+    return {
+      view,
+      usedLegacy: false,
+      absorbed: 0,
+      corruptLines: 0,
+      overLimit: false,
+      aborted: false
+    };
+  }
+  if (stat.size > PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes) {
+    warnLegacyOverLimit(directory, stat.size);
+    return {
+      view,
+      usedLegacy: false,
+      absorbed: 0,
+      corruptLines: 0,
+      overLimit: true,
+      aborted: false
+    };
+  }
+  const migration = checkpoint.migration;
+  if (migration === null || !migration.done) {
+    let cursor = migration?.scannedBytes ?? 0;
+    if (cursor > stat.size)
+      cursor = 0;
+    const fold2 = foldLegacyRegion(legacy, cursor, Number.MAX_SAFE_INTEGER);
+    const absorbed2 = mergeFoldedRecords(view, fold2.folded);
+    return {
+      view,
+      usedLegacy: true,
+      absorbed: absorbed2,
+      corruptLines: fold2.corruptLines,
+      overLimit: false,
+      aborted: fold2.aborted
+    };
+  }
+  if (stat.size === migration.sourceBytes && stat.mtimeMs === migration.sourceMtimeMs) {
+    return {
+      view,
+      usedLegacy: false,
+      absorbed: 0,
+      corruptLines: 0,
+      overLimit: false,
+      aborted: false
+    };
+  }
+  const fold = foldLegacyRegion(legacy, 0, Number.MAX_SAFE_INTEGER);
+  const absorbed = mergeFoldedRecords(view, fold.folded);
+  return {
+    view,
+    usedLegacy: true,
+    absorbed,
+    corruptLines: fold.corruptLines,
+    overLimit: false,
+    aborted: fold.aborted
+  };
+}
+async function loadViewForRead(directory) {
+  const read = readCheckpoint(directory);
+  if (read.kind === "ok") {
+    if (!sameProjectRoot(read.value.rootPath, directory)) {
+      return { view: {}, recoverySource: "foreign" };
+    }
+    const overlaid = overlayLegacy(directory, read.value);
+    return {
+      view: overlaid.view,
+      recoverySource: overlaid.usedLegacy ? "checkpoint+legacy" : "checkpoint"
+    };
+  }
+  if (read.kind === "invalid") {
+    const legacy = storePath(directory);
+    const view2 = {};
+    const size = fileSizeOrNull(legacy);
+    if (size !== null && size <= PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes) {
+      const fold2 = foldLegacyRegion(legacy, 0, Number.MAX_SAFE_INTEGER);
+      mergeFoldedRecords(view2, fold2.folded);
+    } else if (size !== null) {
+      warnLegacyOverLimit(directory, size);
+    }
+    return { view: view2, recoverySource: "corrupt-recovered" };
+  }
+  const legacyPath = storePath(directory);
+  const legacySize = fileSizeOrNull(legacyPath);
+  if (legacySize === null) {
+    return { view: {}, recoverySource: "empty" };
+  }
+  if (legacySize > PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes) {
+    warnLegacyOverLimit(directory, legacySize);
+    return { view: {}, recoverySource: "legacy-log" };
+  }
+  const fold = foldLegacyRegion(legacyPath, 0, Number.MAX_SAFE_INTEGER);
+  const view = {};
+  mergeFoldedRecords(view, fold.folded);
+  if (!fold.aborted) {
+    await bootstrapCheckpointFromLegacy(directory, view, fold);
+  }
+  return { view, recoverySource: "legacy-log" };
+}
+var bootstrapAttempted = new Map;
+async function bootstrapCheckpointFromLegacy(directory, foldedView, fold) {
+  if (bootstrapAttempted.has(directory))
+    return;
+  if (bootstrapAttempted.size >= 32) {
+    bootstrapAttempted.delete(bootstrapAttempted.keys().next().value);
+  }
+  bootstrapAttempted.set(directory, true);
+  try {
+    await withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      if (readCheckpoint(directory).kind !== "absent")
+        return;
+      const checkpoint = freshCheckpoint(directory);
+      checkpoint.records = { ...foldedView };
+      const terminals = Object.values(foldedView).filter((rec) => rec.status !== "active");
+      checkpoint.terminalSummary.lastTerminalAt = terminals.length ? Math.max(...terminals.map((rec) => rec.updatedAt)) : null;
+      checkpoint.maintenance.corruptLegacyRecords = fold.corruptLines;
+      let bootstrapMtime = 0;
+      try {
+        bootstrapMtime = fs.statSync(storePath(directory)).mtimeMs;
+      } catch {}
+      checkpoint.migration = {
+        scannedBytes: fold.nextByte,
+        sourceBytes: fold.nextByte,
+        sourceMtimeMs: bootstrapMtime,
+        corruptLines: fold.corruptLines,
+        done: true,
+        archived: false,
+        startedAt: Date.now()
+      };
+      checkpoint.sequence = 1;
+      checkpoint.updatedAt = Date.now();
+      writeCheckpointFile(directory, checkpoint);
+      flushAuditEvents(directory, [{ kind: "migrate-complete" }], checkpoint.sequence, checkpoint.maintenance);
+      emitHealthTelemetry("migrate-complete", checkpoint);
+    }, PR_SUBSCRIPTION_LIMITS.bootstrapLockTimeoutMs);
+  } catch (err) {
+    log(`[pr-monitor] read-bootstrap skipped: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function loadViewForWrite(directory) {
+  const audit = [];
+  let dirty = false;
+  let checkpoint;
+  const read = readCheckpoint(directory);
+  if (read.kind === "ok" && sameProjectRoot(read.value.rootPath, directory)) {
+    checkpoint = cloneCheckpoint(read.value);
+  } else if (read.kind === "ok") {
+    const displaced = Object.keys(read.value.records).length;
+    quarantineCheckpoint(directory, "foreign");
+    checkpoint = freshCheckpoint(directory);
+    checkpoint.maintenance.resets += read.value.maintenance.resets + 1;
+    audit.push({ kind: "foreign-rebind" });
+    dirty = true;
+    log(`[pr-monitor] foreign checkpoint quarantined (${displaced} displaced records, recorded root ${read.value.rootPath}); store rebound to ${directory}`);
+  } else if (read.kind === "invalid") {
+    quarantineCheckpoint(directory, "corrupt");
+    checkpoint = freshCheckpoint(directory);
+    checkpoint.maintenance.resets += 1;
+    audit.push({ kind: "corrupt-quarantine" });
+    dirty = true;
+    log(`[pr-monitor] corrupt checkpoint quarantined; store rebound to ${directory}`);
+  } else {
+    checkpoint = freshCheckpoint(directory);
+  }
+  const legacy = storePath(directory);
+  let legacyStat = null;
+  try {
+    legacyStat = fs.statSync(legacy);
+  } catch {}
+  let view;
+  if (legacyStat === null) {
+    view = { ...checkpoint.records };
+    if (checkpoint.migration?.done && !checkpoint.migration.archived) {
+      checkpoint.migration.archived = true;
+      dirty = true;
+    }
+    return { checkpoint, view, audit, dirty };
+  }
+  if (legacyStat.size > PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes) {
+    warnLegacyOverLimit(directory, legacyStat.size);
+    return { checkpoint, view: { ...checkpoint.records }, audit, dirty };
+  }
+  const legacySize = legacyStat.size;
+  const legacyMtime = legacyStat.mtimeMs;
+  const migration = checkpoint.migration;
+  if (migration === null || !migration.done) {
+    let cursor = migration?.scannedBytes ?? 0;
+    if (cursor > legacySize)
+      cursor = 0;
+    const startedAt = migration?.startedAt ?? Date.now();
+    let corruptTotal = migration?.corruptLines ?? 0;
+    view = { ...checkpoint.records };
+    let capacityRefused = false;
+    while (true) {
+      const fold = foldLegacyRegion(legacy, cursor, PR_SUBSCRIPTION_LIMITS.migrationChunkBytes);
+      mergeFoldedRecords(view, fold.folded);
+      checkpoint.maintenance.corruptLegacyRecords += fold.corruptLines;
+      corruptTotal += fold.corruptLines;
+      cursor = fold.nextByte;
+      if (fold.aborted) {
+        const progress = cloneCheckpoint(checkpoint);
+        progress.records = { ...view };
+        progress.migration = {
+          scannedBytes: cursor,
+          sourceBytes: legacySize,
+          sourceMtimeMs: legacyMtime,
+          corruptLines: corruptTotal,
+          done: false,
+          archived: false,
+          startedAt
+        };
+        progress.updatedAt = Date.now();
+        progress.sequence += 1;
+        writeCheckpointFile(directory, progress);
+        checkpoint.sequence = progress.sequence;
+        log(`[pr-monitor] legacy scan aborted by an I/O error after ${cursor} bytes \u2014 migration stays incomplete and will retry`);
+        dirty = true;
+        return { checkpoint, view, audit, dirty };
+      }
+      const compactEvent = compactTerminalRecords(view, checkpoint);
+      if (compactEvent)
+        audit.push(compactEvent);
+      if (Object.keys(view).length > PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords) {
+        capacityRefused = true;
+        warnMigrationCapacity(directory, Object.keys(view).length);
+        break;
+      }
+      if (!fold.eof) {
+        const progress = cloneCheckpoint(checkpoint);
+        progress.records = { ...view };
+        progress.migration = {
+          scannedBytes: cursor,
+          sourceBytes: legacySize,
+          sourceMtimeMs: legacyMtime,
+          corruptLines: corruptTotal,
+          done: false,
+          archived: false,
+          startedAt
+        };
+        progress.updatedAt = Date.now();
+        progress.sequence += 1;
+        writeCheckpointFile(directory, progress);
+        checkpoint.sequence = progress.sequence;
+        dirty = true;
+        continue;
+      }
+      checkpoint.migration = {
+        scannedBytes: cursor,
+        sourceBytes: legacySize,
+        sourceMtimeMs: legacyMtime,
+        corruptLines: corruptTotal,
+        done: true,
+        archived: false,
+        startedAt
+      };
+      audit.push({ kind: "migrate-complete" });
+      dirty = true;
+      break;
+    }
+    if (capacityRefused) {
+      return { checkpoint, view, audit, dirty: false };
+    }
+    return { checkpoint, view, audit, dirty };
+  }
+  const overlaid = overlayLegacy(directory, checkpoint);
+  view = overlaid.view;
+  if (overlaid.usedLegacy && !overlaid.aborted) {
+    migration.sourceBytes = legacySize;
+    migration.sourceMtimeMs = legacyMtime;
+    migration.scannedBytes = legacySize;
+    migration.archived = false;
+    checkpoint.maintenance.corruptLegacyRecords += overlaid.corruptLines;
+    dirty = true;
+  }
+  return { checkpoint, view, audit, dirty };
+}
+function finalizeWrite(directory, loaded, opAudit) {
+  const { checkpoint } = loaded;
+  const events = [...loaded.audit, ...opAudit];
+  const compactEvent = compactTerminalRecords(loaded.view, checkpoint);
+  if (compactEvent)
+    events.push(compactEvent);
+  if (!loaded.dirty && events.length === 0)
+    return;
+  checkpoint.records = loaded.view;
+  checkpoint.updatedAt = Date.now();
+  checkpoint.rootPath = path.resolve(directory);
+  checkpoint.sequence += 1;
+  flushAuditEvents(directory, events, checkpoint.sequence, checkpoint.maintenance);
+  writeCheckpointFile(directory, checkpoint);
+  const archiveEvent = maybeArchiveLegacy(directory, checkpoint);
+  if (archiveEvent) {
+    events.push(archiveEvent);
+    checkpoint.sequence += 1;
+    flushAuditEvents(directory, [archiveEvent], checkpoint.sequence, checkpoint.maintenance);
+    writeCheckpointFile(directory, checkpoint);
+  }
+  cleanupStaleLegacyArchive(directory);
+  for (const kind of [
+    "compact",
+    "migrate-complete",
+    "archive",
+    "foreign-rebind",
+    "corrupt-quarantine"
+  ]) {
+    if (events.some((event) => event.kind === kind)) {
+      emitHealthTelemetry(kind, checkpoint);
+    }
+  }
+}
+async function subscribe(directory, input) {
+  if (!directory || directory.trim() === "") {
+    throw new Error("directory is required");
+  }
+  if (!input.sessionID || input.sessionID.trim() === "") {
+    throw new Error("sessionID is required and must be non-empty");
+  }
+  if (!input.repoFullName || input.repoFullName.trim() === "") {
+    throw new Error("repoFullName is required and must be non-empty");
+  }
+  if (!input.prUrl || input.prUrl.trim() === "") {
+    throw new Error("prUrl is required and must be non-empty");
+  }
+  if (!input.prNumber || !Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("prNumber is required and must be a positive integer");
+  }
+  const correlationId = buildCorrelationId(input.sessionID, input.repoFullName, input.prNumber);
+  const now = Date.now();
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const loaded = loadViewForWrite(directory);
+    const match = Object.values(loaded.view).find((r) => r.correlationId === correlationId && r.status === "active");
+    if (match) {
+      onSubscriptionCreated?.(directory, match);
+      finalizeWrite(directory, loaded, []);
+      return match;
+    }
+    if (input.maxSubscriptions === undefined || input.maxSubscriptions > 0) {
+      const limit = input.maxSubscriptions !== undefined ? input.maxSubscriptions : PR_SUBSCRIPTION_LIMITS.defaultMaxActiveSubscriptions;
+      const activeCount = Object.values(loaded.view).filter((r) => r.status === "active").length;
+      if (activeCount >= limit) {
+        throw new Error(`PR subscription limit reached: ${activeCount}/${limit}`);
+      }
+    }
+    const record = {
+      correlationId,
+      sessionID: input.sessionID,
+      prNumber: input.prNumber,
+      repoFullName: input.repoFullName,
+      prUrl: input.prUrl,
+      lastCheckedAt: now,
+      isWatching: true,
+      hasUnaddressedEvents: false,
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      errorCount: 0
+    };
+    validateRecord(record);
+    loaded.view[correlationId] = record;
+    loaded.dirty = true;
+    finalizeWrite(directory, loaded, [{ kind: "subscribe", correlationId }]);
+    onSubscriptionCreated?.(directory, record);
+    return record;
+  });
+}
+async function unsubscribe(directory, correlationId) {
+  if (!correlationId)
+    return null;
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const loaded = loadViewForWrite(directory);
+    const match = Object.values(loaded.view).find((r) => r.correlationId === correlationId && r.status === "active");
+    if (!match) {
+      finalizeWrite(directory, loaded, []);
+      return null;
+    }
+    const now = Date.now();
+    const removed = {
+      ...match,
+      status: "removed",
+      isWatching: false,
+      updatedAt: now
+    };
+    loaded.view[correlationId] = removed;
+    loaded.dirty = true;
+    finalizeWrite(directory, loaded, [
+      { kind: "unsubscribe", correlationId }
+    ]);
+    return removed;
+  });
+}
+async function listActive(directory) {
+  const { view } = await loadViewForRead(directory);
+  return Object.values(view).filter((r) => r.status === "active");
+}
+async function lookupByPr(directory, repoFullName, prNumber) {
+  const { view } = await loadViewForRead(directory);
+  for (const record of Object.values(view)) {
+    if (record.status === "active" && record.repoFullName === repoFullName && record.prNumber === prNumber) {
+      return record;
+    }
+  }
+  return null;
+}
+async function updateSnapshot(directory, correlationId, updates) {
+  if (!correlationId)
+    return null;
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const loaded = loadViewForWrite(directory);
+    const match = Object.values(loaded.view).find((r) => r.correlationId === correlationId && r.status === "active");
+    if (!match) {
+      finalizeWrite(directory, loaded, []);
+      return null;
+    }
+    const updated = {
+      ...match,
+      ...updates,
+      correlationId,
+      sessionID: match.sessionID,
+      repoFullName: match.repoFullName,
+      prNumber: match.prNumber,
+      prUrl: match.prUrl,
+      createdAt: match.createdAt,
+      updatedAt: Date.now()
+    };
+    loaded.view[correlationId] = updated;
+    loaded.dirty = true;
+    finalizeWrite(directory, loaded, []);
+    return updated;
+  });
+}
+async function sweepStale(directory, ttlDays, mergedPrs) {
+  if (!ttlDays || ttlDays <= 0)
+    return 0;
+  const ttlMs = ttlDays * 86400000;
+  const now = Date.now();
+  try {
+    return await withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const loaded = loadViewForWrite(directory);
+      const opAudit = [];
+      let swept = 0;
+      for (const record of Object.values(loaded.view)) {
+        if (record.status !== "active")
+          continue;
+        const prKey = `${record.repoFullName}::${record.prNumber}`;
+        const isMerged = mergedPrs?.has(prKey) ?? false;
+        const isStale = now - record.updatedAt > ttlMs;
+        if (isMerged) {
+          loaded.view[record.correlationId] = {
+            ...record,
+            status: "expired",
+            isWatching: false,
+            updatedAt: now
+          };
+          swept += 1;
+          opAudit.push({
+            kind: "expired",
+            correlationId: record.correlationId
+          });
+          loaded.dirty = true;
+          log(`[pr-monitor] Swept subscription: merged/closed: ${prKey}`);
+          continue;
+        }
+        if (isStale && !record.hasUnaddressedEvents) {
+          loaded.view[record.correlationId] = {
+            ...record,
+            status: "expired",
+            isWatching: false,
+            updatedAt: now
+          };
+          swept += 1;
+          opAudit.push({
+            kind: "expired",
+            correlationId: record.correlationId
+          });
+          loaded.dirty = true;
+          log(`[pr-monitor] Swept subscription: stale (TTL ${ttlDays}d): ${prKey}`);
+        }
+      }
+      finalizeWrite(directory, loaded, opAudit);
+      return swept;
+    });
+  } catch (err) {
+    log(`[pr-monitor] sweepStale failed: ${err instanceof Error ? err.message : String(err)}`);
+    return 0;
+  }
+}
+async function getPrSubscriptionHealth(directory) {
+  try {
+    const read = readCheckpoint(directory);
+    const audit = auditStats(directory);
+    const archiveBytes = fileSizeOrNull(legacyArchivePath(directory)) ?? 0;
+    const checkpointBytes = fileSizeOrNull(checkpointPath(directory)) ?? 0;
+    const legacySize = fileSizeOrNull(storePath(directory));
+    const legacyOverLimit = legacySize !== null && legacySize > PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes;
+    let health;
+    if (read.kind === "ok" && !sameProjectRoot(read.value.rootPath, directory)) {
+      health = emptyHealth();
+      health.recoverySource = "foreign";
+    } else if (read.kind === "invalid") {
+      if (legacySize !== null && !legacyOverLimit) {
+        const fold = foldLegacyRegion(storePath(directory), 0, Number.MAX_SAFE_INTEGER);
+        const view = {};
+        mergeFoldedRecords(view, fold.folded);
+        health = healthFromView(view, freshCheckpoint(directory));
+        health.corruptLegacyRecords = fold.corruptLines;
+      } else {
+        health = emptyHealth();
+      }
+      health.recoverySource = "corrupt-recovered";
+    } else if (read.kind === "absent") {
+      if (legacySize === null || legacyOverLimit) {
+        health = emptyHealth();
+      } else {
+        const fold = foldLegacyRegion(storePath(directory), 0, Number.MAX_SAFE_INTEGER);
+        const view = {};
+        mergeFoldedRecords(view, fold.folded);
+        health = healthFromView(view, freshCheckpoint(directory));
+        health.corruptLegacyRecords = fold.corruptLines;
+      }
+      health.recoverySource = legacySize === null ? "empty" : "legacy-log";
+    } else {
+      const overlaid = overlayLegacy(directory, read.value);
+      health = healthFromView(overlaid.view, read.value);
+      health.recoverySource = overlaid.usedLegacy ? "checkpoint+legacy" : "checkpoint";
+    }
+    health.legacyOverLimit = legacyOverLimit;
+    applyFileStats(health, checkpointBytes, audit, archiveBytes);
+    return health;
+  } catch (err) {
+    log(`[pr-monitor] getPrSubscriptionHealth failed: ${err instanceof Error ? err.message : String(err)}`);
+    return emptyHealth();
+  }
+}
+function applyFileStats(health, checkpointBytes, audit, archiveBytes) {
+  health.checkpointBytes = checkpointBytes;
+  health.pressurePct = checkpointBytes === 0 ? 0 : Math.round(checkpointBytes / health.checkpointLimitBytes * 1000) / 10;
+  health.auditLines = audit.lines;
+  health.auditBytes = audit.bytes;
+  health.legacyArchiveBytes = archiveBytes;
+}
+function emptyHealth() {
+  return {
+    schemaVersion: 1,
+    sequence: 0,
+    checkpointAgeMs: null,
+    checkpointBytes: 0,
+    checkpointLimitBytes: PR_SUBSCRIPTION_LIMITS.maxCheckpointBytes,
+    pressurePct: 0,
+    activeCount: 0,
+    removedCount: 0,
+    expiredCount: 0,
+    terminalSummary: { removed: 0, expired: 0, lastTerminalAt: null },
+    auditLines: 0,
+    auditBytes: 0,
+    auditLimitBytes: PR_SUBSCRIPTION_LIMITS.auditMaxBytesHigh,
+    compactions: 0,
+    corruptLegacyRecords: 0,
+    droppedAuditTransitions: 0,
+    resets: 0,
+    recoverySource: "empty",
+    migration: null,
+    legacyArchiveBytes: 0,
+    legacyOverLimit: false
+  };
+}
+function healthFromView(view, checkpoint) {
+  const records = Object.values(view);
+  const health = emptyHealth();
+  health.sequence = checkpoint.sequence;
+  health.checkpointAgeMs = checkpoint.sequence > 0 ? Date.now() - checkpoint.updatedAt : null;
+  health.activeCount = records.filter((r) => r.status === "active").length;
+  health.removedCount = records.filter((r) => r.status === "removed").length;
+  health.expiredCount = records.filter((r) => r.status === "expired").length;
+  health.terminalSummary = { ...checkpoint.terminalSummary };
+  health.compactions = checkpoint.maintenance.compactions;
+  health.corruptLegacyRecords = checkpoint.maintenance.corruptLegacyRecords;
+  health.droppedAuditTransitions = checkpoint.maintenance.droppedAuditTransitions;
+  health.resets = checkpoint.maintenance.resets;
+  health.migration = checkpoint.migration ? {
+    done: checkpoint.migration.done,
+    scannedBytes: checkpoint.migration.scannedBytes,
+    sourceBytes: checkpoint.migration.sourceBytes
+  } : null;
+  return health;
+}
+var _internals = {
+  foldLegacyRegion,
+  mergeFoldedRecords,
+  sameProjectRoot
+};
+
+export { PR_SUBSCRIPTIONS_FILE, PR_SUBSCRIPTIONS_CHECKPOINT_FILE, PR_SUBSCRIPTIONS_AUDIT_FILE, PR_SUBSCRIPTION_LIMITS, setOnSubscriptionCreated, buildCorrelationId, subscribe, unsubscribe, listActive, lookupByPr, updateSnapshot, sweepStale, getPrSubscriptionHealth, _internals };