@open-tomato/rafa 0.44.0 → 0.46.0

package/dist/index-jh1r4kcn.js

@@ -0,0 +1,1067 @@
+// @bun
+import {
+  CORE_ADAPTER_REGISTRY,
+  EFFORT_KEY_PROJECTIONS,
+  MIGRATION_LOG_TABLE,
+  SQLITE_MIGRATIONS,
+  SQLITE_STORE_FILE_NAME,
+  activeStoreSettings,
+  appendRows,
+  appliedByName,
+  bringForward,
+  carryStoreIdentity,
+  collectedKeys,
+  effortStoreDir,
+  effortStoreFileName,
+  guardTestProcess,
+  isPidAlive,
+  planSchema,
+  readProjectIdentity,
+  readRuntimeIdentity,
+  readSessions,
+  readStoreMeta,
+  readStoreRows,
+  readStoreSchema,
+  refuseUnownedDevelopmentWrite,
+  sqliteCatalogue,
+  storeProjectRoot,
+  writeNames,
+  writeStoreGeneration
+} from "./index-cy98y87p.js";
+import {
+  messageOf
+} from "./index-ykggr043.js";
+
+// packages/rafa/src/effort/store/ndjson.ts
+import { join } from "path";
+function kindPath(repoRoot, kind) {
+  return join(effortStoreDir(repoRoot), effortStoreFileName(kind));
+}
+function openedKindPath(repoRoot, kind) {
+  const path = kindPath(repoRoot, kind);
+  guardTestProcess(path);
+  return path;
+}
+function readKind(repoRoot, kind) {
+  return readStoreRows(openedKindPath(repoRoot, kind));
+}
+function keysOfKind(repoRoot, kind) {
+  const path = openedKindPath(repoRoot, kind);
+  return collectedKeys(path, EFFORT_KEY_PROJECTIONS[kind]);
+}
+function appendKind(repoRoot, kind, rows) {
+  const path = openedKindPath(repoRoot, kind);
+  return appendRows(path, rows, EFFORT_KEY_PROJECTIONS[kind]);
+}
+function openNdjsonStore(repoRoot) {
+  return {
+    append: (kind, rows) => appendKind(repoRoot, kind, rows),
+    keys: (kind) => keysOfKind(repoRoot, kind),
+    read: (kind) => readKind(repoRoot, kind).rows,
+    path: (kind) => kindPath(repoRoot, kind),
+    readRows: (kind) => readKind(repoRoot, kind)
+  };
+}
+
+// packages/rafa/src/effort/store/merge-store.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync3, mkdtempSync, rmSync as rmSync3 } from "fs";
+import { tmpdir } from "os";
+import { dirname, join as join3 } from "path";
+import { Database as Database3, SQLiteError as SQLiteError2 } from "bun:sqlite";
+
+// packages/rafa/src/effort/store/copy.ts
+import { copyFileSync, constants, existsSync, mkdirSync, readdirSync, rmSync, statSync } from "fs";
+import { join as join2, resolve } from "path";
+import { Database } from "bun:sqlite";
+var NDJSON_KINDS = { sessions: true, commits: true };
+var EFFORT_COPY_FILE_NAMES = [
+  SQLITE_STORE_FILE_NAME,
+  ...Object.keys(NDJSON_KINDS).map((kind) => effortStoreFileName(kind))
+];
+
+class EffortCopyRefusal extends Error {
+  name = "EffortCopyRefusal";
+}
+
+class EffortCopyFailure extends Error {
+  name = "EffortCopyFailure";
+}
+function refuseUsedTarget(target) {
+  if (!existsSync(target))
+    return;
+  let entries;
+  try {
+    if (!statSync(target).isDirectory()) {
+      throw new EffortCopyRefusal(`${target} is a file, not a directory; name an empty or absent directory with --to=<dir>.`);
+    }
+    entries = readdirSync(target);
+  } catch (error) {
+    if (error instanceof EffortCopyRefusal)
+      throw error;
+    throw new EffortCopyFailure(`${target} cannot be read: ${String(error)}`);
+  }
+  if (entries.length === 0)
+    return;
+  throw new EffortCopyRefusal(`${target} is not empty (${String(entries.length)} entries); nothing was copied.` + " Name an empty or absent directory with --to=<dir>.");
+}
+function vacuumInto(source, target) {
+  const db = new Database(source, { readonly: true });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    db.run("VACUUM INTO ?", [target]);
+  } finally {
+    db.close();
+  }
+}
+function copyOne(name, source, target) {
+  if (name === SQLITE_STORE_FILE_NAME) {
+    vacuumInto(join2(source, name), join2(target, name));
+    return;
+  }
+  copyFileSync(join2(source, name), join2(target, name), constants.COPYFILE_EXCL);
+}
+function undo(target, written, madeDir) {
+  try {
+    if (madeDir === undefined) {
+      for (const name of written)
+        rmSync(join2(target, name), { force: true });
+    } else {
+      rmSync(madeDir, { recursive: true, force: true });
+    }
+    return "";
+  } catch (error) {
+    return ` Removing what it made failed too: ${String(error)}`;
+  }
+}
+function copyEffortStore(request) {
+  const source = resolve(request.source);
+  const target = resolve(request.target);
+  guardTestProcess(source);
+  guardTestProcess(target);
+  const files = EFFORT_COPY_FILE_NAMES.filter((name) => existsSync(join2(source, name)));
+  if (files.length === 0) {
+    throw new EffortCopyRefusal(`no effort store at ${source}: it holds none of ${EFFORT_COPY_FILE_NAMES.join(", ")}. Nothing to copy.`);
+  }
+  refuseUsedTarget(target);
+  const written = [];
+  let madeDir;
+  try {
+    madeDir = mkdirSync(target, { recursive: true });
+    for (const name of files) {
+      written.push(name);
+      copyOne(name, source, target);
+    }
+  } catch (error) {
+    const left = undo(target, written, madeDir);
+    throw new EffortCopyFailure(`copying ${source} to ${target} failed: ${String(error)}.${left}`);
+  }
+  return Object.freeze({ source, directory: target, files: Object.freeze(files) });
+}
+
+// packages/rafa/src/effort/store/fix-schema.ts
+import { Database as Database2 } from "bun:sqlite";
+
+// packages/rafa/src/effort/store/rebuild-aside.ts
+import { closeSync, existsSync as existsSync2, fsyncSync, openSync, renameSync, rmSync as rmSync2 } from "fs";
+class RebuildRefusal extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RebuildRefusal";
+  }
+}
+function quoted(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function count(db, sql) {
+  return db.query(sql).get()?.n ?? 0;
+}
+function refuseInFlight(path) {
+  for (const suffix of ["-journal", "-wal"]) {
+    if (existsSync2(`${path}${suffix}`)) {
+      throw new RebuildRefusal(`${path}${suffix} is there, so a write is in flight or was interrupted; stop whatever uses the store` + " and open it once with rafa before repairing it");
+    }
+  }
+}
+function checkedCounts(db, tables, original, added = {}) {
+  return tables.map((table) => {
+    const rows = count(db, `SELECT count(*) AS n FROM main.${quoted(table)}`);
+    const originalRows = count(db, `SELECT count(*) AS n FROM ${original}.${quoted(table)}`);
+    const addedRows = added[table] ?? 0;
+    if (rows !== originalRows + addedRows) {
+      const plus = addedRows === 0 ? "" : ` plus ${String(addedRows)} added`;
+      throw new RebuildRefusal(`the rebuilt ${table} holds ${String(rows)} rows, the store ${String(originalRows)}${plus}`);
+    }
+    return { table, rows };
+  });
+}
+function refuseCorrupt(db) {
+  const answer = db.query("PRAGMA main.integrity_check").get()?.integrity_check;
+  if (answer !== "ok")
+    throw new RebuildRefusal(`the rebuilt store failed integrity_check: ${answer ?? "no answer"}`);
+}
+function removeParallel(parallelPath) {
+  rmSync2(parallelPath, { force: true });
+  rmSync2(`${parallelPath}-journal`, { force: true });
+}
+var STEP_TEXT = {
+  backup: ({ path, backupPath }) => ({
+    doing: `writing ${path} out to the backup ${backupPath}`,
+    backup: `any part of the backup written at ${backupPath}`
+  }),
+  carry: ({ path, parallelPath, backupPath }) => ({
+    doing: `carrying the store id of ${path} onto ${parallelPath}`,
+    backup: `the whole backup at ${backupPath}`
+  }),
+  record: ({ path, parallelPath, backupPath }) => ({
+    doing: `writing the generation carried onto ${parallelPath} to the side record of ${path}`,
+    backup: `the whole backup at ${backupPath}`
+  }),
+  rename: ({ path, parallelPath, backupPath }) => ({
+    doing: `renaming ${parallelPath} over ${path}`,
+    backup: `the whole backup at ${backupPath}`
+  })
+};
+
+class SwapFailure extends RebuildRefusal {
+  step;
+  parallelPath;
+  backupPath;
+  constructor(step, files, cause) {
+    const { doing, backup } = STEP_TEXT[step](files);
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(`${doing} failed (${reason}), so ${files.path} was not replaced and is unchanged.` + ` The rebuilt store is left at ${files.parallelPath}, and ${backup}.`, { cause });
+    this.name = "SwapFailure";
+    this.step = step;
+    this.parallelPath = files.parallelPath;
+    this.backupPath = files.backupPath;
+  }
+}
+function writeBackup(path, backupPath) {
+  vacuumInto(path, backupPath);
+  const backup = openSync(backupPath, "r");
+  try {
+    fsyncSync(backup);
+  } finally {
+    closeSync(backup);
+  }
+}
+var SWAP_STEPS = {
+  backup: writeBackup,
+  carry: (path, parallelPath) => carryStoreIdentity(path, parallelPath),
+  record: writeStoreGeneration,
+  rename: renameSync
+};
+function runStep(step, files, act) {
+  try {
+    return act();
+  } catch (error) {
+    throw new SwapFailure(step, files, error);
+  }
+}
+function swapIn(path, parallelPath, backupPath, steps = {}) {
+  const { backup, carry, record, rename } = { ...SWAP_STEPS, ...steps };
+  const files = { path, parallelPath, backupPath };
+  runStep("backup", files, () => backup(path, backupPath));
+  const carried = runStep("carry", files, () => carry(path, parallelPath));
+  if (carried.action === "carried" && carried.generation !== null) {
+    const { generation } = carried;
+    runStep("record", files, () => record(path, generation));
+  }
+  runStep("rename", files, () => rename(parallelPath, path));
+}
+function refuseTaken(paths) {
+  for (const taken of paths) {
+    if (existsSync2(taken))
+      throw new RebuildRefusal(`${taken} is already there; move it aside or pass another stamp`);
+  }
+}
+function rebuildAside(options) {
+  const { path, parallelPath, backupPath, dryRun, build } = options;
+  refuseInFlight(path);
+  refuseTaken([parallelPath, backupPath]);
+  let built;
+  try {
+    built = build(parallelPath);
+  } catch (error) {
+    removeParallel(parallelPath);
+    throw error;
+  }
+  if (dryRun) {
+    removeParallel(parallelPath);
+    return { built, backupPath: null };
+  }
+  swapIn(path, parallelPath, backupPath);
+  return { built, backupPath };
+}
+// packages/rafa/src/effort/store/fix-schema.ts
+function tableNames(db, schema) {
+  return db.query(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name <> ? ORDER BY name`).all(MIGRATION_LOG_TABLE).map((row) => row.name);
+}
+function readOnlySchema(path) {
+  const db = new Database2(path, { readonly: true });
+  try {
+    return readStoreSchema(db, path);
+  } finally {
+    db.close();
+  }
+}
+function refuseUnusable(db, parallelPath, migrations) {
+  const plan = planSchema(readStoreSchema(db, parallelPath), sqliteCatalogue(migrations), "write", "open");
+  if (plan.verdict === "refuse")
+    throw new RebuildRefusal(`the rebuilt store is refused as ${plan.reason}: ${plan.message}`);
+  const needs = writeNames(plan);
+  if (needs.length > 0)
+    throw new RebuildRefusal(`the rebuilt store still needs ${needs.join(", ")}`);
+}
+
+// packages/rafa/src/effort/store/commit-stats.ts
+var MS_PER_MINUTE = 60000;
+var ELAPSED_DECIMALS = 3;
+function minutesBetween(earlier, later) {
+  const from = Date.parse(earlier);
+  const to = Date.parse(later);
+  if (Number.isNaN(from) || Number.isNaN(to))
+    return null;
+  const minutes = (to - from) / MS_PER_MINUTE;
+  return Number(minutes.toFixed(ELAPSED_DECIMALS));
+}
+
+// packages/rafa/src/effort/store/merge-commit-gaps.ts
+var GAP_FIELD = "minutesSincePrevious";
+var UPDATE_GAP = "UPDATE commits SET row_json = ? WHERE seq = ?";
+function parsedObject(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function withoutGap(rowJson) {
+  const row = parsedObject(rowJson);
+  if (row === null)
+    return rowJson;
+  const rest = Object.fromEntries(Object.entries(row).filter(([key]) => key !== GAP_FIELD));
+  return JSON.stringify(rest);
+}
+function readCommits(db) {
+  return db.query("SELECT seq, sha, row_json FROM commits").all().map(({ seq, sha, row_json: rowJson }) => {
+    const row = parsedObject(rowJson);
+    const timestamp = typeof row?.timestamp === "string" ? row.timestamp : null;
+    return { seq, sha, row, timestamp, epoch: timestamp === null ? Number.NaN : Date.parse(timestamp) };
+  });
+}
+function timeOrder(entries) {
+  return entries.filter((entry) => !Number.isNaN(entry.epoch)).sort((left, right) => left.epoch - right.epoch || compareText(left.sha, right.sha));
+}
+function compareText(left, right) {
+  if (left === right)
+    return 0;
+  return left < right ? -1 : 1;
+}
+function storedGap(entry) {
+  const value = entry.row?.[GAP_FIELD];
+  return typeof value === "number" ? value : null;
+}
+function namedRows(inserted, positions, order) {
+  const position = positions.get(inserted.seq);
+  if (position === undefined)
+    return [inserted.seq];
+  const next = order[position + 1];
+  return next === undefined ? [inserted.seq] : [inserted.seq, next.seq];
+}
+function recomputedGap(entry, positions, order) {
+  const position = positions.get(entry.seq);
+  if (position === undefined || position === 0)
+    return null;
+  const previous = order[position - 1];
+  if (previous?.timestamp == null || entry.timestamp === null)
+    return null;
+  return minutesBetween(previous.timestamp, entry.timestamp);
+}
+function recomputeCommitGaps(db, inserted) {
+  return db.transaction(() => {
+    const entries = readCommits(db);
+    const bySeq = new Map(entries.map((entry) => [entry.seq, entry]));
+    const order = timeOrder(entries);
+    const positions = new Map(order.map((entry, position) => [entry.seq, position]));
+    const named = new Set(inserted.flatMap((seq) => {
+      const entry = bySeq.get(seq);
+      return entry === undefined ? [] : namedRows(entry, positions, order);
+    }));
+    const targets = [...named].map((seq) => bySeq.get(seq)).filter((entry) => entry?.row != null).sort((left, right) => (positions.get(left.seq) ?? -1) - (positions.get(right.seq) ?? -1));
+    return targets.flatMap((entry) => {
+      const before = storedGap(entry);
+      const after = recomputedGap(entry, positions, order);
+      if (before === after && entry.row !== null && Object.hasOwn(entry.row, GAP_FIELD))
+        return [];
+      db.query(UPDATE_GAP).run(JSON.stringify({ ...entry.row, [GAP_FIELD]: after }), entry.seq);
+      return [{ seq: entry.seq, sha: entry.sha, before, after }];
+    });
+  })();
+}
+
+// packages/rafa/src/effort/store/merge-rules.ts
+var SET_ONCE = "set-once";
+var RECOMPUTED = "recomputed";
+var APPEND_ONLY = {};
+function appendOnly(...identity) {
+  return { scope: "merged", identity, edited: APPEND_ONLY };
+}
+var MERGE_RULES = {
+  sessions: appendOnly("session_id"),
+  commits: { scope: "merged", identity: ["sha"], edited: { row_json: RECOMPUTED } },
+  findings: { scope: "merged", identity: ["id"], edited: { tracker_ref: SET_ONCE } },
+  blockers: appendOnly("id"),
+  out_of_scope_bugs: appendOnly("id"),
+  report_absences: appendOnly("id"),
+  task_reports: appendOnly("id"),
+  preflight: appendOnly("run_id", "position"),
+  dispatches: appendOnly("session_id"),
+  changes: appendOnly("id"),
+  skill_invocations: appendOnly("session_id", "name", "sidechain"),
+  plan_ci: appendOnly("pr", "head_sha", "read_at"),
+  stale_docs: appendOnly("id"),
+  bug_routes: appendOnly("id"),
+  schema_migrations: { scope: "local" },
+  store_meta: { scope: "local" },
+  store_replaced: { scope: "local" },
+  merges: { scope: "local" },
+  merge_conflicts: { scope: "local" }
+};
+
+// packages/rafa/src/effort/store/merge-union.ts
+import { SQLiteError } from "bun:sqlite";
+class UnionSchemaMismatch extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnionSchemaMismatch";
+  }
+}
+var UNIQUE_REFUSAL = "SQLITE_CONSTRAINT_UNIQUE";
+function mergedTables() {
+  return Object.entries(MERGE_RULES).flatMap(([table, rule]) => rule.scope === "merged" ? [{ table, identity: rule.identity }] : []);
+}
+function carriedColumns(db, table) {
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name }) => name).filter((name) => name !== "seq");
+}
+function refuseColumnMismatch(local, other, tables) {
+  const faults = tables.flatMap(({ table }) => {
+    const here = new Set(carriedColumns(local, table));
+    const there = new Set(carriedColumns(other, table));
+    const onlyHere = [...here].filter((column) => !there.has(column)).map((column) => `${table}.${column} only here`);
+    const onlyThere = [...there].filter((column) => !here.has(column)).map((column) => `${table}.${column} only there`);
+    return [...onlyHere, ...onlyThere];
+  });
+  if (faults.length > 0) {
+    throw new UnionSchemaMismatch(`the two stores hold different columns (${faults.join(", ")}); bring both to the same migrations first`);
+  }
+}
+function valueOf(row, column) {
+  return row[column] ?? null;
+}
+function byOrigin(local, table, row) {
+  const store = valueOf(row, "origin_store");
+  const seq = valueOf(row, "origin_seq");
+  if (store === null || seq === null)
+    return null;
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE origin_store = ? AND origin_seq = ?`).get(store, seq)?.seq ?? null;
+}
+function byIdentity(local, { table, identity }, row) {
+  const where = identity.map((column) => `${quoted(column)} IS ?`).join(" AND ");
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE ${where} ORDER BY seq LIMIT 1`).get(...identity.map((column) => valueOf(row, column)))?.seq ?? null;
+}
+function insertRow(local, table, columns, row, incomingSeq) {
+  const columnList = columns.map(quoted).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const nextSeq = `(SELECT COALESCE(MAX(seq), 0) + 1 FROM ${quoted(table)})`;
+  try {
+    const inserted = local.query(`INSERT INTO ${quoted(table)} (seq, ${columnList}) VALUES (${nextSeq}, ${placeholders}) RETURNING seq`).get(...columns.map((column) => valueOf(row, column)));
+    if (inserted === null)
+      throw new Error(`the insert into ${table} returned no seq`);
+    return { kind: "added", localSeq: inserted.seq };
+  } catch (error) {
+    if (!(error instanceof SQLiteError) || error.code !== UNIQUE_REFUSAL)
+      throw error;
+    return { kind: "collided", collision: { incomingSeq, reason: error.message } };
+  }
+}
+function placeRow(local, merged, columns, row) {
+  const incomingSeq = Number(valueOf(row, "seq"));
+  const origin = byOrigin(local, merged.table, row);
+  if (origin !== null)
+    return { kind: "matched", match: { localSeq: origin, incomingSeq, by: "origin" } };
+  const identity = byIdentity(local, merged, row);
+  if (identity !== null)
+    return { kind: "matched", match: { localSeq: identity, incomingSeq, by: "identity" } };
+  return insertRow(local, merged.table, columns, row, incomingSeq);
+}
+function unionTable(local, other, merged) {
+  const columns = carriedColumns(local, merged.table);
+  const incoming = other.query(`SELECT seq, ${columns.map(quoted).join(", ")} FROM ${quoted(merged.table)} ORDER BY seq`).all();
+  const outcomes = incoming.map((row) => placeRow(local, merged, columns, row));
+  return {
+    table: merged.table,
+    added: outcomes.flatMap((outcome) => outcome.kind === "added" ? [outcome.localSeq] : []),
+    matched: outcomes.flatMap((outcome) => outcome.kind === "matched" ? [outcome.match] : []),
+    collided: outcomes.flatMap((outcome) => outcome.kind === "collided" ? [outcome.collision] : [])
+  };
+}
+function unionStores(local, other) {
+  const tables = mergedTables();
+  refuseColumnMismatch(local, other, tables);
+  return local.transaction(() => tables.map((merged) => unionTable(local, other, merged)))();
+}
+
+// packages/rafa/src/effort/store/merge-conflicts.ts
+var SET_ONCE_FILLS = {
+  "findings.tracker_ref": "UPDATE findings SET tracker_ref = ? WHERE seq = ? AND tracker_ref IS NULL"
+};
+var RECOMPUTED_COMPARISONS = {
+  "commits.row_json": withoutGap
+};
+var NOT_CONTENT = new Set(["seq", "origin_store", "origin_seq"]);
+var INSERT_CONFLICT = `INSERT INTO merge_conflicts (merge_id, table_name, local_seq, field, incoming, recorded_at)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+function rowAt(db, table, columns, seq, side) {
+  const row = db.query(`SELECT seq, ${columns.map(quoted).join(", ")} FROM ${quoted(table)} WHERE seq = ?`).get(seq);
+  if (row === null)
+    throw new Error(`the union matched ${table} row ${seq} ${side}, which that store does not hold`);
+  return row;
+}
+function sameValue(left, right) {
+  if (left instanceof Uint8Array && right instanceof Uint8Array)
+    return Buffer.from(left).equals(right);
+  return (left ?? null) === (right ?? null);
+}
+function fillStatement(table, field) {
+  const statement = SET_ONCE_FILLS[`${table}.${field}`];
+  if (statement === undefined) {
+    throw new Error(`${table}.${field} is set-once in MERGE_RULES and has no statement in SET_ONCE_FILLS`);
+  }
+  return statement;
+}
+function settleSetOnce(local, table, field, here, there) {
+  const incoming = there[field] ?? null;
+  if (incoming === null)
+    return { skipped: true, filled: [], conflictFields: [] };
+  if ((here[field] ?? null) !== null)
+    return { skipped: false, filled: [], conflictFields: [field] };
+  local.query(fillStatement(table, field)).run(incoming, Number(here.seq));
+  return { skipped: true, filled: [field], conflictFields: [] };
+}
+function settleRecomputed(table, field, here, there) {
+  const comparable = RECOMPUTED_COMPARISONS[`${table}.${field}`];
+  if (comparable === undefined) {
+    throw new Error(`${table}.${field} is recomputed in MERGE_RULES and has no entry in RECOMPUTED_COMPARISONS`);
+  }
+  const hereValue = here[field];
+  const thereValue = there[field];
+  const same = typeof hereValue === "string" && typeof thereValue === "string" && comparable(hereValue) === comparable(thereValue);
+  return same ? { skipped: true, filled: [], conflictFields: [] } : { skipped: false, filled: [], conflictFields: [null] };
+}
+function settlePair(local, table, edited, here, there) {
+  const differing = Object.keys(here).filter((column) => !NOT_CONTENT.has(column) && !sameValue(here[column], there[column]));
+  if (differing.length === 0)
+    return { skipped: true, filled: [], conflictFields: [] };
+  if (differing.some((column) => !Object.hasOwn(edited, column)))
+    return { skipped: false, filled: [], conflictFields: [null] };
+  const outcomes = differing.map((field) => {
+    if (edited[field] === SET_ONCE)
+      return settleSetOnce(local, table, field, here, there);
+    if (edited[field] === RECOMPUTED)
+      return settleRecomputed(table, field, here, there);
+    throw new Error(`${table}.${field} has the rule ${edited[field]}, which the merge does not apply`);
+  });
+  return {
+    skipped: outcomes.every((outcome) => outcome.skipped),
+    filled: outcomes.flatMap((outcome) => outcome.filled),
+    conflictFields: outcomes.flatMap((outcome) => outcome.conflictFields)
+  };
+}
+function settleTable(local, other, union, trail) {
+  const rule = MERGE_RULES[union.table];
+  if (rule?.scope !== "merged")
+    throw new Error(`${union.table} is not a merged table in MERGE_RULES`);
+  const columns = carriedColumns(local, union.table);
+  const settled = union.matched.map((match) => {
+    const here = rowAt(local, union.table, columns, match.localSeq, "here");
+    const there = rowAt(other, union.table, columns, match.incomingSeq, "in the other store");
+    const outcome = settlePair(local, union.table, rule.edited, here, there);
+    const conflicts = outcome.conflictFields.map((field) => {
+      local.query(INSERT_CONFLICT).run(trail.mergeId, union.table, match.localSeq, field, JSON.stringify(there), trail.recordedAt);
+      return { localSeq: match.localSeq, incomingSeq: match.incomingSeq, field };
+    });
+    return { match, outcome, conflicts };
+  });
+  return {
+    table: union.table,
+    skipped: settled.flatMap(({ match, outcome }) => outcome.skipped ? [match.localSeq] : []),
+    filled: settled.flatMap(({ match, outcome }) => outcome.filled.map((field) => ({ localSeq: match.localSeq, field }))),
+    conflicts: settled.flatMap(({ conflicts }) => conflicts)
+  };
+}
+function settleMatches(local, other, unions, trail) {
+  return local.transaction(() => unions.map((union) => settleTable(local, other, union, trail)))();
+}
+// packages/rafa/src/effort/store/migrate.ts
+function liveLoop(path, options, nothingDone = "Nothing was migrated.", ownSessionId = null) {
+  const root = storeProjectRoot(path);
+  if (root === null)
+    return;
+  let records;
+  try {
+    records = readSessions(root, { isAlive: options.isAlive ?? isPidAlive });
+  } catch (error) {
+    throw new RebuildRefusal(`the loop's run records cannot be read, so a live loop on ${path} cannot be ruled out` + ` (${messageOf(error)}). ${nothingDone}`);
+  }
+  return records.find((record) => (record.state === "running" || record.state === "paused") && record.sessionId !== ownSessionId);
+}
+
+// packages/rafa/src/effort/store/merge-store.ts
+var MOVE_TO_SQLITE = "rafa effort move --to=sqlite";
+
+class MergeRefusal extends RebuildRefusal {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "MergeRefusal";
+    this.reason = reason;
+  }
+}
+var LIVE = "live";
+var MERGES_TABLE = "merges";
+var INSERT_MERGE = `INSERT INTO merges (id, other_store, merged_at, rows_added, rows_skipped, rows_in_conflict)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+var NOTHING_MERGED = "Nothing was merged.";
+function refuseNdjson(backend) {
+  if (backend !== "ndjson")
+    return;
+  throw new MergeRefusal("ndjson", `REFUSED \u2014 this project keeps its sessions and commits as NDJSON (store: ndjson), and a merge needs the SQLite store. ${NOTHING_MERGED}` + ` Next safe step: ${MOVE_TO_SQLITE}`);
+}
+function refuseMissing(path, which) {
+  if (existsSync3(path))
+    return;
+  throw new MergeRefusal("missing", `REFUSED \u2014 ${which} ${path} is not there. ${NOTHING_MERGED}`);
+}
+function refuseDamaged(path) {
+  let answers;
+  try {
+    const db = new Database3(path, { readonly: true });
+    try {
+      answers = db.query("PRAGMA integrity_check").all().map((row) => row.integrity_check);
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    if (!(error instanceof SQLiteError2))
+      throw error;
+    throw new MergeRefusal("damaged", `REFUSED \u2014 ${path} cannot be read as a SQLite store (${error.message}). ${NOTHING_MERGED}` + " Take a consistent copy on its device with rafa effort copy, and merge that.");
+  }
+  if (answers.length === 1 && answers[0] === "ok")
+    return;
+  throw new MergeRefusal("damaged", `REFUSED \u2014 ${path} failed integrity_check: ${answers.join("; ")}. ${NOTHING_MERGED}` + " Take a consistent copy on its device with rafa effort copy, and merge that.");
+}
+function writablePlan(path, migrations) {
+  const plan = planSchema(readOnlySchema(path), sqliteCatalogue(migrations), "write", "open");
+  if (plan.verdict === "refuse")
+    throw new MergeRefusal("schema", `REFUSED \u2014 ${path}: ${plan.message}`);
+  return plan;
+}
+function recordedMeta(path) {
+  const db = new Database3(path, { readonly: true });
+  try {
+    const hasTable = db.query("SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = 'store_meta'").get()?.n === 1;
+    return hasTable ? readStoreMeta(db) : null;
+  } finally {
+    db.close();
+  }
+}
+function refuseOtherProject(options) {
+  const other = recordedMeta(options.otherPath);
+  const here = recordedMeta(options.path)?.projectRootCommit ?? (options.readProject ?? readProjectIdentity)(dirname(options.path)).rootCommit;
+  const there = other?.projectRootCommit ?? null;
+  if (here !== null && there !== null && here !== there) {
+    throw new MergeRefusal("other-project", `REFUSED \u2014 ${options.otherPath} is the effort store of another project (root commit ${there});` + ` this store's project has root commit ${here}. ${NOTHING_MERGED}`);
+  }
+  return other?.storeId ?? null;
+}
+function refuseLiveLoop(path, options, sessionId) {
+  const loop = liveLoop(path, options, NOTHING_MERGED, sessionId);
+  if (loop === undefined)
+    return;
+  throw new MergeRefusal("live-loop", `REFUSED \u2014 loop ${loop.sessionId} (pid ${String(loop.pid)}, plan ${loop.planStub ?? loop.plan}) is running on this store,` + ` and swapping the merged store in under it would lose what it writes. ${NOTHING_MERGED}` + " Finish or stop that loop, then run it again.");
+}
+function openOther(otherPath, plan, stamp, tempRoot) {
+  const needs = writeNames(plan);
+  if (needs.length === 0) {
+    const db = new Database3(otherPath, { readonly: true });
+    return { db, broughtForward: [], release: () => db.close() };
+  }
+  const dir = mkdtempSync(join3(tempRoot, "rafa-merge-other-"));
+  const release = (db) => {
+    db?.close();
+    rmSync3(dir, { recursive: true, force: true });
+  };
+  try {
+    const copyPath = join3(dir, "other.sqlite");
+    vacuumInto(otherPath, copyPath);
+    const db = new Database3(copyPath, { readwrite: true });
+    try {
+      bringForward(db, copyPath, "write", "open", { ...stamp, builtAside: true });
+    } catch (error) {
+      release(db);
+      throw error;
+    }
+    return { db, broughtForward: needs, release: () => release(db) };
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+function mergeInto(db, other, mergeId, otherStore, mergedAt) {
+  return db.transaction(() => {
+    const unions = unionStores(db, other);
+    const settlements = settleMatches(db, other, unions, { mergeId, recordedAt: mergedAt });
+    const gaps = recomputeCommitGaps(db, unions.find(({ table }) => table === "commits")?.added ?? []);
+    const tables = unions.map((union, index) => {
+      const settled = settlements[index];
+      return {
+        table: union.table,
+        added: union.added.length,
+        skipped: settled?.skipped.length ?? 0,
+        inConflict: settled?.conflicts.length ?? 0,
+        filled: settled?.filled.length ?? 0,
+        collided: union.collided.length
+      };
+    });
+    const sum = (field) => tables.reduce((total, entry) => total + entry[field], 0);
+    const totals = { rowsAdded: sum("added"), rowsSkipped: sum("skipped"), rowsInConflict: sum("inConflict") };
+    db.query(INSERT_MERGE).run(mergeId, otherStore, mergedAt, totals.rowsAdded, totals.rowsSkipped, totals.rowsInConflict);
+    return { tables, ...totals, gapsRewritten: gaps.length };
+  })();
+}
+function addedRows(merged) {
+  return {
+    ...Object.fromEntries(merged.tables.map(({ table, added }) => [table, added])),
+    [MERGES_TABLE]: 1,
+    merge_conflicts: merged.rowsInConflict
+  };
+}
+function buildMerged(path, parallelPath, other, merge) {
+  vacuumInto(path, parallelPath);
+  const db = new Database3(parallelPath, { readwrite: true });
+  try {
+    bringForward(db, parallelPath, "write", "open", { ...merge.stamp, builtAside: true });
+    const merged = mergeInto(db, other, merge.id, merge.otherStore, merge.stamp.now().toISOString());
+    db.run(`ATTACH DATABASE ? AS ${LIVE}`, [path]);
+    const live = new Set(tableNames(db, LIVE));
+    checkedCounts(db, tableNames(db, "main").filter((table) => live.has(table)), LIVE, addedRows(merged));
+    db.run(`DETACH DATABASE ${LIVE}`);
+    refuseCorrupt(db);
+    refuseUnusable(db, parallelPath, merge.stamp.migrations);
+    return merged;
+  } finally {
+    db.close();
+  }
+}
+function refuseUnmergeable(options, migrations) {
+  const { path, otherPath } = options;
+  refuseNdjson(options.backend);
+  refuseMissing(path, "this store");
+  refuseMissing(otherPath, "the other store");
+  refuseInFlight(path);
+  refuseInFlight(otherPath);
+  refuseDamaged(otherPath);
+  const otherPlan = writablePlan(otherPath, migrations);
+  const localPlan = writablePlan(path, migrations);
+  const otherStore = refuseOtherProject(options);
+  if (!options.dryRun) {
+    refuseUnownedDevelopmentWrite(path, [...writeNames(localPlan), MERGES_TABLE], options);
+    refuseLiveLoop(path, options, options.sessionId ?? null);
+  }
+  return { otherPlan, otherStore };
+}
+function mergeStore(options) {
+  const { path, otherPath, dryRun, stamp } = options;
+  guardTestProcess(path);
+  guardTestProcess(otherPath);
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const { otherPlan, otherStore } = refuseUnmergeable(options, migrations);
+  const mergeStamp = {
+    migrations,
+    appliedBy: appliedByName(options.identity ?? readRuntimeIdentity()),
+    now: options.now ?? (() => new Date)
+  };
+  const mergeId = (options.newMergeId ?? randomUUID)();
+  const other = openOther(otherPath, otherPlan, mergeStamp, options.tempDir ?? tmpdir());
+  try {
+    const { built, backupPath } = rebuildAside({
+      path,
+      parallelPath: `${path}.merge-${stamp}`,
+      backupPath: `${path}.before-merge-${stamp}.bak`,
+      dryRun,
+      build: (parallelPath) => buildMerged(path, parallelPath, other.db, { id: mergeId, otherStore, stamp: mergeStamp })
+    });
+    const status = dryRun ? "would-merge" : "merged";
+    return { path, otherPath, status, mergeId, otherStore, otherBroughtForward: other.broughtForward, ...built, backupPath };
+  } finally {
+    other.release();
+  }
+}
+
+// packages/rafa/src/effort/store/wire.ts
+import { existsSync as existsSync4, mkdtempSync as mkdtempSync2, rmSync as rmSync4 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+import { Database as Database4, SQLiteError as SQLiteError3 } from "bun:sqlite";
+var WIRE_FORMAT = "rafa-effort-wire";
+var WIRE_VERSION = 1;
+
+class WireFormatError extends Error {
+  name = "WireFormatError";
+}
+
+class WireExportRefusal extends Error {
+  name = "WireExportRefusal";
+}
+var MERGED_TABLES = Object.entries(MERGE_RULES).filter(([, rule]) => rule.scope === "merged").map(([table]) => table);
+var ORIGIN_COLUMNS = ["origin_store", "origin_seq"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isMergedTable(name) {
+  return MERGED_TABLES.includes(name);
+}
+function checkCursor(value) {
+  if (!isRecord(value))
+    throw new WireFormatError("wire: cursor is not an object");
+  const entries = Object.entries(value).map(([table, seq]) => {
+    if (!isMergedTable(table))
+      throw new WireFormatError(`wire: cursor names ${JSON.stringify(table)}, which is no merged table`);
+    if (!isCount(seq))
+      throw new WireFormatError(`wire: cursor for ${table} is ${JSON.stringify(seq)}, expected a whole number of 0 or more`);
+    return [table, seq];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+function checkRow(table, value, index) {
+  const where = `wire: ${table} row ${String(index)}`;
+  if (!isRecord(value))
+    throw new WireFormatError(`${where} is not an object`);
+  for (const [column, cell] of Object.entries(value)) {
+    const carried = cell === null || typeof cell === "string" || typeof cell === "number" && Number.isFinite(cell);
+    if (!carried)
+      throw new WireFormatError(`${where} holds ${JSON.stringify(cell) ?? typeof cell} in ${column}, expected a string, a number or null`);
+  }
+  const seq = value.seq;
+  if (!isCount(seq) || seq === 0)
+    throw new WireFormatError(`${where} has seq ${JSON.stringify(seq) ?? "undefined"}, expected a whole number above 0`);
+  return Object.freeze({ ...value });
+}
+function checkMigrations(value) {
+  if (!Array.isArray(value))
+    throw new WireFormatError("wire: migrations is not a list");
+  const ids = value.map((id) => {
+    if (typeof id !== "string" || id === "")
+      throw new WireFormatError(`wire: migration id ${JSON.stringify(id)} is not a name`);
+    return id;
+  });
+  const twice = ids.filter((id, index) => ids.indexOf(id) !== index);
+  if (twice.length > 0)
+    throw new WireFormatError(`wire: migrations name ${twice.join(", ")} more than once`);
+  return Object.freeze(ids);
+}
+function checkTables(value) {
+  if (!isRecord(value))
+    throw new WireFormatError("wire: tables is not an object");
+  const entries = Object.entries(value).map(([table, rows]) => {
+    if (!isMergedTable(table))
+      throw new WireFormatError(`wire: tables names ${JSON.stringify(table)}, which is no merged table`);
+    if (!Array.isArray(rows))
+      throw new WireFormatError(`wire: tables.${table} is not a list`);
+    return [table, Object.freeze(rows.map((row, index) => checkRow(table, row, index)))];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+function checkPayload(value) {
+  if (!isRecord(value))
+    throw new WireFormatError("wire: the payload is not an object");
+  if (value.format !== WIRE_FORMAT)
+    throw new WireFormatError(`wire: format is ${JSON.stringify(value.format) ?? "undefined"}, expected ${JSON.stringify(WIRE_FORMAT)}`);
+  if (value.version !== WIRE_VERSION)
+    throw new WireFormatError(`wire: version is ${JSON.stringify(value.version) ?? "undefined"}; this rafa reads version ${String(WIRE_VERSION)}`);
+  return Object.freeze({
+    format: WIRE_FORMAT,
+    version: WIRE_VERSION,
+    migrations: checkMigrations(value.migrations),
+    tables: checkTables(value.tables),
+    cursor: checkCursor(value.cursor)
+  });
+}
+function encodeWirePayload(payload) {
+  return JSON.stringify(payload);
+}
+function decodeWirePayload(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new WireFormatError(`wire: the payload is not JSON (${reason})`);
+  }
+  return checkPayload(parsed);
+}
+function readLoggedIds(db) {
+  const hasLog = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(MIGRATION_LOG_TABLE) !== null;
+  if (!hasLog)
+    return null;
+  return db.query(`SELECT id FROM ${MIGRATION_LOG_TABLE} ORDER BY seq`).all().map(({ id }) => id);
+}
+function columnsOf(db, table) {
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name }) => name);
+}
+function wireValue(value, where) {
+  if (typeof value === "bigint") {
+    const number = Number(value);
+    if (Number.isSafeInteger(number))
+      return number;
+    throw new WireExportRefusal(`wire: ${where} holds ${String(value)}, past the whole numbers JSON carries exactly`);
+  }
+  if (value instanceof Uint8Array)
+    throw new WireExportRefusal(`wire: ${where} holds a BLOB, which the wire does not carry`);
+  return value;
+}
+function readRows(db, table, columns, after, path) {
+  const named = columns.map(quoted).join(", ");
+  return db.query(`SELECT ${named} FROM ${quoted(table)} WHERE seq > ? ORDER BY seq`).all(after).map((row) => Object.freeze(Object.fromEntries(Object.entries(row).map(([column, value]) => [
+    column,
+    wireValue(value, `${path} ${table}.${column} at seq ${String(row.seq)}`)
+  ]))));
+}
+function readPayload(db, path, cursor) {
+  const migrations = readLoggedIds(db);
+  if (migrations === null) {
+    throw new WireExportRefusal(`wire: ${path} has no migration log; any rafa command that writes the store brings it forward`);
+  }
+  const tables = {};
+  const next = { ...cursor };
+  for (const table of MERGED_TABLES) {
+    const columns = columnsOf(db, table);
+    if (columns.length === 0)
+      continue;
+    const missing = ORIGIN_COLUMNS.filter((column) => !columns.includes(column));
+    if (missing.length > 0) {
+      throw new WireExportRefusal(`wire: ${path} holds no ${missing.map((column) => `${table}.${column}`).join(", ")}, so its rows carry no origin pair`);
+    }
+    const rows = readRows(db, table, columns, cursor[table] ?? 0, path);
+    tables[table] = Object.freeze(rows);
+    const last = rows[rows.length - 1];
+    next[table] = last === undefined ? cursor[table] ?? 0 : Number(last.seq);
+  }
+  return Object.freeze({
+    format: WIRE_FORMAT,
+    version: WIRE_VERSION,
+    migrations: Object.freeze([...migrations]),
+    tables: Object.freeze(tables),
+    cursor: Object.freeze(next)
+  });
+}
+function exportWirePayload(options) {
+  const { path } = options;
+  const cursor = checkCursor(options.cursor ?? {});
+  guardTestProcess(path);
+  if (!existsSync4(path))
+    throw new WireExportRefusal(`wire: ${path} is not there`);
+  const db = new Database4(path, { readonly: true, safeIntegers: true });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    return db.transaction(() => readPayload(db, path, cursor))();
+  } finally {
+    db.close();
+  }
+}
+function namedMigrations(ids, catalogue) {
+  const known = new Set(catalogue.map(({ id }) => id));
+  const unknown = ids.filter((id) => !known.has(id));
+  if (unknown.length > 0) {
+    throw new WireFormatError(`wire: the payload's store holds migration ${unknown.join(", ")}, which this rafa does not know; update rafa to take its rows`);
+  }
+  return catalogue.filter(({ id }) => ids.includes(id));
+}
+function insertRows(db, table, rows) {
+  const columns = columnsOf(db, table);
+  if (columns.length === 0)
+    throw new WireFormatError(`wire: the payload carries ${table}, which its migrations do not make`);
+  const statement = db.query(`INSERT INTO ${quoted(table)} (${columns.map(quoted).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`);
+  const expected = [...columns].sort().join(",");
+  rows.forEach((row, index) => {
+    const where = `wire: ${table} row ${String(index)}`;
+    const held = Object.keys(row);
+    if ([...held].sort().join(",") !== expected) {
+      throw new WireFormatError(`${where} holds columns ${held.join(", ")}; its migrations make ${columns.join(", ")}`);
+    }
+    try {
+      statement.run(...columns.map((column) => row[column] ?? null));
+    } catch (error) {
+      if (!(error instanceof SQLiteError3))
+        throw error;
+      throw new WireFormatError(`${where} (seq ${String(row.seq)}) is refused by the table: ${error.message}`);
+    }
+  });
+}
+function buildStore(path, payload, options) {
+  const migrations = namedMigrations(payload.migrations, options.migrations ?? SQLITE_MIGRATIONS);
+  const db = new Database4(path, { create: true, readwrite: true });
+  try {
+    bringForward(db, path, "write", "open", {
+      migrations,
+      appliedBy: appliedByName(options.identity ?? readRuntimeIdentity()),
+      now: options.now,
+      builtAside: true
+    });
+    db.transaction(() => {
+      for (const [table, rows] of Object.entries(payload.tables))
+        insertRows(db, table, rows);
+    })();
+  } finally {
+    db.close();
+  }
+}
+function materialiseWirePayload(payload, options = {}) {
+  const checked = checkPayload(payload);
+  const directory = mkdtempSync2(join4(options.tempDir ?? tmpdir2(), "rafa-wire-"));
+  const release = () => rmSync4(directory, { recursive: true, force: true });
+  const path = join4(directory, SQLITE_STORE_FILE_NAME);
+  try {
+    guardTestProcess(path);
+    buildStore(path, checked, options);
+  } catch (error) {
+    release();
+    throw error;
+  }
+  return Object.freeze({ directory, path, release });
+}
+
+// packages/rafa/src/effort/store/index.ts
+function describeValue(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "object" && value !== null)
+    return "an object";
+  return String(value);
+}
+function selectEffortStore(repoRoot, config) {
+  const adapter = CORE_ADAPTER_REGISTRY.find("store", config.store);
+  if (adapter === undefined) {
+    const expected = CORE_ADAPTER_REGISTRY.kinds("store").join(", ");
+    throw new TypeError(`effort store: store is ${describeValue(config.store)},` + ` expected one of: ${expected}`);
+  }
+  return adapter.create({ repoRoot });
+}
+
+export { openNdjsonStore, copyEffortStore, minutesBetween, MOVE_TO_SQLITE, mergeStore, WIRE_FORMAT, WIRE_VERSION, WireFormatError, WireExportRefusal, encodeWirePayload, decodeWirePayload, exportWirePayload, materialiseWirePayload, selectEffortStore };