datanotes 3.4.0 → 3.4.2

package/dist/datanotes.cjs

@@ -26440,7 +26440,9 @@ var init_hints = __esm({
       manageTokens: "/guides/security/tokens.md#manage-your-tokens",
       tokenAutolink: "/guides/security/tokens.md#turn-automatic-links-off-for-a-sync-program",
       tokenRead: "/guides/security/tokens.md#limit-what-a-token-can-read",
+      tokenWrite: "/guides/security/tokens.md#a-write-into-another-table-needs-write-too",
       reportAgents: "/guides/security/who-did-what.md#report-what-an-agent-does",
+      sessionOwner: "/guides/security/who-did-what.md#a-session-belongs-to-one-token",
       auth: "/develop/http-api.md#authenticate-your-requests",
       routes: "/develop/http-api.md#call-the-engines-routes",
       store: "/administration/run-the-service.md#where-the-engine-keeps-its-store",
@@ -29755,2004 +29757,2088 @@ var init_inverse = __esm({
   }
 });
 
-// src/core/unreadable.ts
-function frontmatterError(text5) {
+// src/core/changeset.ts
+function createdHash(text5) {
   try {
-    readOrderedFromMarkdown(text5);
-    return null;
-  } catch (e) {
-    return messageOf(e);
-  }
-}
-function rawFrontmatterValue(text5, key2) {
-  const split2 = splitFrontmatter(text5);
-  if (!split2) return void 0;
-  for (const line of split2.yamlText.split(/\r?\n/)) {
-    const head = [`${key2}:`, `"${key2}":`, `'${key2}':`].find((h) => line.startsWith(h));
-    if (!head) continue;
-    const rest = line.slice(head.length).trim();
-    try {
-      return (0, import_yaml3.parse)(rest);
-    } catch {
-      return rest;
-    }
-  }
-  return void 0;
-}
-function unreadableMessage(error2) {
-  return `the front matter cannot be read, so the row is left out of every read: ${error2.split("\n")[0].trim()}`;
-}
-function excludedFolders(model, settings) {
-  const out2 = /* @__PURE__ */ new Map();
-  for (const { ref: ref2, entry } of catalogTables(model)) {
-    try {
-      const options = parseTableOptions(entryToOrdered(ref2, entry, settings).find(([k]) => k === TABLE_KEY)?.[1]);
-      out2.set(ref2.full, [...options.exclude ?? [], catalogLayout(normalizeDatabaseFolder(settings.databaseFolder), ref2, options).archive]);
-    } catch {
-    }
-  }
-  return out2;
-}
-function unreadableRowOf(model, settings, path23, text5, excluded) {
-  if (!text5.startsWith("---")) return null;
-  const error2 = frontmatterError(text5);
-  if (error2 === null) return null;
-  const table = rowTableFull(model, rawFrontmatterValue(text5, settings.tableKey));
-  if (!table) return null;
-  const folders = (excluded ?? excludedFolders(model, settings)).get(table) ?? [];
-  if (folders.some((dir) => path23.startsWith(`${dir}/`))) return null;
-  return { path: path23, table, error: error2 };
-}
-async function unreadableRows(app, settings, model, table) {
-  const excluded = excludedFolders(model, settings);
-  const out2 = [];
-  const idx = vaultIndex(app, settings);
-  const notes = idx ? [...idx.allNotes()].filter((n) => n.bare).map((n) => n.file) : app.vault.getMarkdownFiles();
-  for (const f of notes) {
-    let cached2;
-    try {
-      cached2 = idx ? void 0 : app.metadataCache.getFileCache(f)?.frontmatter;
-    } catch {
-      cached2 = void 0;
-    }
-    if (cached2) continue;
-    let text5;
-    try {
-      text5 = (await readHashed(app, f)).content;
-    } catch {
-      continue;
-    }
-    const u = unreadableRowOf(model, settings, f.path, text5, excluded);
-    if (u && (table === void 0 || u.table === table)) out2.push(u);
+    const { ordered, body } = readOrderedFromMarkdown(text5);
+    return contentHash(JSON.stringify([ordered, body]));
+  } catch {
+    return contentHash(text5);
   }
-  return out2.sort((a, b) => a.path.localeCompare(b.path));
 }
-var import_yaml3;
-var init_unreadable = __esm({
-  "src/core/unreadable.ts"() {
-    "use strict";
-    init_file_cache();
-    import_yaml3 = __toESM(require_dist(), 1);
-    init_frontmatter();
-    init_metastore();
-    init_table_loader();
-    init_types_table();
-    init_message();
-    init_db_paths();
-    init_vault_index();
-  }
-});
-
-// src/core/log-files.ts
-function holdsVersions(path23) {
-  return COMMIT_RE.test(path23) || SEGMENT_RE.test(path23);
+function bodyChanges(e) {
+  return e.bodyAfter !== void 0 && e.bodyAfter !== e.bodyBefore;
 }
-function tocsOf(app) {
-  let m = TOCS.get(app);
-  if (!m) TOCS.set(app, m = /* @__PURE__ */ new Map());
-  return m;
+function bodyOf(text5) {
+  const split2 = splitFrontmatter(text5);
+  return split2 ? split2.body : text5;
 }
-function latestOf(toc) {
-  return toc.versions.length > 0 ? toc.versions[toc.versions.length - 1] : -1;
+function replaceBody(text5, body) {
+  const split2 = splitFrontmatter(text5);
+  if (!split2) return body;
+  return text5.slice(0, text5.length - split2.body.length) + body;
 }
-function parseSegment(text5) {
-  const commits = [];
-  let pos = 0;
-  while (pos < text5.length) {
-    const nl = text5.indexOf("\n", pos);
-    if (nl < 0) break;
-    let head;
-    try {
-      head = JSON.parse(text5.slice(pos, nl)).commit;
-    } catch {
-      break;
-    }
-    if (!head || !Number.isInteger(head.version) || !Number.isInteger(head.lines) || head.lines < 1) break;
-    let end = nl + 1;
-    let whole = true;
-    for (let i = 0; i < head.lines; i++) {
-      const e = text5.indexOf("\n", end);
-      if (e < 0) {
-        whole = false;
-        break;
-      }
-      end = e + 1;
-    }
-    if (!whole) break;
-    if (typeof head.hash === "string" && contentHash(text5.slice(nl + 1, end)) !== head.hash) break;
-    const prev = commits[commits.length - 1];
-    if (prev && head.version !== prev.version + 1) break;
-    commits.push({ version: head.version, start: nl + 1, end });
-    pos = end;
-  }
-  return { commits, validEnd: pos };
+async function writeBody(app, file, expected, next) {
+  await app.vault.process(file, (text5) => {
+    if (bodyOf(text5) !== expected) throw new Error("note body changed since it was read");
+    return replaceBody(text5, next);
+  });
 }
-function framed(version2, text5) {
-  const lines = text5.split("\n").length - 1;
-  return `${JSON.stringify({ commit: { version: version2, lines, hash: contentHash(text5) } })}
-${text5}`;
+function emptyChangeSet(op2, summary, schema) {
+  return {
+    op: op2,
+    summary,
+    ...schema !== void 0 ? { schema } : {},
+    edits: [],
+    creates: [],
+    moves: [],
+    deletes: [],
+    texts: []
+  };
 }
-async function segmentText(app, seg) {
-  let cache = SEGMENT_TEXTS.get(app);
-  if (!cache) SEGMENT_TEXTS.set(app, cache = /* @__PURE__ */ new Map());
-  const key2 = `${seg.path}\0${seg.sealed ? "" : `${seg.chars}/${seg.last}`}\0${storeGeneration(app, seg.path)}`;
-  const hit = cache.get(key2);
-  if (hit) {
-    cache.delete(key2);
-    cache.set(key2, hit);
-    return hit;
-  }
-  const text5 = await storeReadFile(app, seg.path);
-  const index = /* @__PURE__ */ new Map();
-  for (const c of parseSegment(text5).commits) index.set(c.version, [c.start, c.end]);
-  const out2 = { text: text5, index };
-  cache.set(key2, out2);
-  for (const k of cache.keys()) {
-    if (cache.size <= SEGMENT_TEXTS_KEPT) break;
-    cache.delete(k);
-  }
-  return out2;
+function same(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
 }
-async function buildToc(app, dir) {
-  const gen = storeGeneration(app, dir);
-  const stat = await storeStat(app, dir);
-  const toc = { dir, versions: [], files: /* @__PURE__ */ new Map(), segments: [], checkpoints: [], torn: null, gen, mtime: stat ? stat.mtime : null };
-  for (const f of (await storeList(app, dir)).files) {
-    let m;
-    if (m = COMMIT_RE.exec(f)) toc.files.set(Number(m[1]), f);
-    else if (m = CHECKPOINT_RE.exec(f)) toc.checkpoints.push({ version: Number(m[1]), kind: 1, path: f });
-    else if (m = MANIFEST_RE.exec(f)) toc.checkpoints.push({ version: Number(m[1]), kind: 2, path: f });
-    else if (m = SEGMENT_RE.exec(f)) toc.segments.push({ path: f, first: Number(m[1]), last: m[2] !== void 0 ? Number(m[2]) : Number(m[1]) - 1, sealed: m[2] !== void 0 });
-  }
-  toc.segments.sort((a, b) => a.first - b.first);
-  toc.checkpoints.sort((a, b) => a.version - b.version || b.kind - a.kind);
-  for (const seg of toc.segments) {
-    if (seg.sealed) continue;
-    const text5 = await storeReadFile(app, seg.path);
-    const { commits, validEnd } = parseSegment(text5);
-    seg.last = commits.length > 0 ? commits[commits.length - 1].version : seg.first - 1;
-    seg.chars = text5.length;
-    if (validEnd < text5.length) seg.tornAt = validEnd;
-    const st = await storeStat(app, seg.path);
-    if (st) seg.bytes = st.size;
-  }
-  const versions = new Set(toc.files.keys());
-  for (const seg of toc.segments) for (let v = seg.first; v <= seg.last; v++) versions.add(v);
-  toc.versions = [...versions].sort((a, b) => a - b);
-  const newest = latestOf(toc);
-  const file = toc.files.get(newest);
-  if (file !== void 0 && !inSegment(toc, newest)) {
-    const text5 = await storeRead(app, file);
-    if (text5 === null || text5.trim() === "" || !wholeVersion(text5)) {
-      toc.torn = file;
-      toc.files.delete(newest);
-      toc.versions.pop();
+function diffOrdered(before, after) {
+  const b = new Map(before);
+  const a = new Map(after);
+  const d = {
+    set: [],
+    remove: [],
+    beforeValues: {},
+    beforeAbsent: [],
+    afterValues: {},
+    afterAbsent: []
+  };
+  const keys = /* @__PURE__ */ new Set([...b.keys(), ...a.keys()]);
+  for (const k of keys) {
+    const inB = b.has(k);
+    const inA = a.has(k);
+    if (inB && inA && same(b.get(k), a.get(k))) continue;
+    if (inB) d.beforeValues[k] = b.get(k);
+    else d.beforeAbsent.push(k);
+    if (inA) {
+      d.afterValues[k] = a.get(k);
+      d.set.push([k, a.get(k)]);
+    } else {
+      d.afterAbsent.push(k);
+      d.remove.push(k);
     }
   }
-  return toc;
-}
-function wholeVersion(text5) {
-  try {
-    const lines = text5.split("\n").filter((l) => l.trim() !== "");
-    if (lines.length === 0 || !JSON.parse(lines[0]).commitInfo) return false;
-    for (const l of lines.slice(1)) JSON.parse(l);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function inSegment(toc, v) {
-  for (let i = toc.segments.length - 1; i >= 0; i--) {
-    const s = toc.segments[i];
-    if (v >= s.first && v <= s.last) return s;
-  }
-  return void 0;
-}
-async function logToc(app, dir) {
-  const tocs = tocsOf(app);
-  const kept2 = tocs.get(dir);
-  if (kept2 && kept2.gen === storeGeneration(app, dir)) {
-    const stat = await storeStat(app, dir);
-    if (stat !== void 0 ? (stat ? stat.mtime : null) === kept2.mtime : await stillNewest(app, kept2)) return kept2;
-  }
-  const toc = await buildToc(app, dir);
-  tocs.set(dir, toc);
-  return toc;
-}
-async function stillNewest(app, toc) {
-  const latest = latestOf(toc);
-  const where = latest < 0 ? null : inSegment(toc, latest)?.path ?? toc.files.get(latest);
-  if (where !== null && !await storeExists(app, where)) return false;
-  const next = commitPath(toc.dir, latest + 1);
-  if (next !== toc.torn && await storeExists(app, next)) return false;
-  return !await storeExists(app, segmentPath(toc.dir, latest + 1));
-}
-async function settled(app, toc) {
-  toc.gen = storeGeneration(app, toc.dir);
-  const stat = await storeStat(app, toc.dir);
-  toc.mtime = stat ? stat.mtime : null;
+  return d;
 }
-async function versionText(app, toc, v) {
-  const segments = segmentsWith(toc, v);
-  for (const seg of segments) {
-    const s = await segmentText(app, seg);
-    const at = s.index.get(v);
-    if (at) return s.text.slice(at[0], at[1]);
-  }
-  const file = toc.files.get(v);
-  if (file !== void 0) return storeReadFile(app, file);
-  if (segments.length === 0) throw new HistoryError(`${toc.dir} has no version ${v}`);
-  throw new HistoryError(
-    `${segments[0].path} does not hold version ${v} whole`,
-    guide(`A crash lost version ${v}: no file of the log holds it whole. Restore the store from its backup (datanotes store restore --from <backup url> --database <folder> --force), then run the command again.`, "restoreStore")
+function editIsNoop(e) {
+  const d = diffOrdered(e.before, e.after);
+  const orderChanged = !same(
+    e.before.map(([k]) => k),
+    e.after.map(([k]) => k)
   );
+  return d.set.length === 0 && d.remove.length === 0 && !orderChanged && !bodyChanges(e);
 }
-async function wholeVersions(app, seg) {
-  return new Set((await segmentText(app, seg)).index.keys());
+function applyDiff(current2, set, remove3, order) {
+  let out2 = current2;
+  for (const k of remove3) out2 = fmDelete(out2, k);
+  for (const [k, v] of set) out2 = fmSet(out2, k, v);
+  return fmReorder(out2, order);
 }
-function segmentsWith(toc, v) {
-  return toc.segments.filter((s) => v >= s.first && v <= s.last).reverse();
+function fileOrNull(app, path23) {
+  const f = app.vault.getAbstractFileByPath(path23);
+  return f != null && "extension" in f ? f : null;
 }
-async function versionTexts(app, toc, versions) {
-  const out2 = new Array(versions.length);
-  const files = [];
-  for (let i = 0; i < versions.length; i++) {
-    const v = versions[i];
-    if (inSegment(toc, v)) out2[i] = await versionText(app, toc, v);
-    else files.push(i);
-  }
-  for (let i = 0; i < files.length; i += READ_AHEAD) {
-    const chunk = files.slice(i, i + READ_AHEAD);
-    const texts = await Promise.all(chunk.map((j) => versionText(app, toc, versions[j])));
-    texts.forEach((t, k) => out2[chunk[k]] = t);
-  }
-  return out2;
+function parentFolder(path23) {
+  const i = path23.lastIndexOf("/");
+  return i < 0 ? "" : path23.slice(0, i);
 }
-async function setAside(app, path23) {
-  const to = `${path23}.torn-${Date.now()}`;
-  await storeRename(app, path23, to);
-  return to;
+async function ensureFolder(app, folder) {
+  if (folder === "") return;
+  if (app.vault.getAbstractFileByPath(folder) != null) return;
+  await ensureFolder(app, parentFolder(folder));
+  await app.vault.createFolder(folder);
 }
-async function appendVersion(app, dir, v, text5, format) {
-  const toc = await logToc(app, dir);
-  if (latestOf(toc) !== v - 1) {
-    const file = toc.files.get(v);
-    throw new HistoryError(file !== void 0 ? `log file exists: ${file}` : `log moved on: ${dir} is at version ${latestOf(toc)}, not ${v - 1}`);
-  }
-  const repaired = [];
-  if (toc.torn) {
-    repaired.push(`${toc.torn} set aside as ${await setAside(app, toc.torn)}`);
-    toc.torn = null;
-  }
-  for (const seg of toc.segments) {
-    if (seg.sealed || seg.tornAt === void 0 && seg.chars > 0) continue;
-    const whole = (await storeReadFile(app, seg.path)).slice(0, seg.tornAt ?? 0);
-    repaired.push(`${seg.path}: ${seg.chars - whole.length} characters of a torn version cut${whole === "" ? ", the file removed" : ""}`);
-    if (whole === "") await storeRemove(app, seg.path);
-    else await storeWrite(app, seg.path, whole);
-    seg.chars = whole.length;
-    delete seg.tornAt;
-    const st = await storeStat(app, seg.path);
-    if (st) seg.bytes = st.size;
-  }
-  toc.segments = toc.segments.filter((s) => s.sealed || s.chars > 0);
-  if (format === "files") {
-    const path23 = commitPath(dir, v);
-    if (await storeExists(app, path23)) throw new HistoryError(`log file exists: ${path23}`);
-    await storeWrite(app, path23, text5);
-    toc.files.set(v, path23);
-  } else await appendToSegment(app, toc, v, text5);
-  toc.versions.push(v);
-  await settled(app, toc);
-  return repaired;
+async function readOrderedFor(app, file) {
+  return readOrderedFromMarkdown(await app.vault.read(file)).ordered;
 }
-async function appendToSegment(app, toc, v, text5) {
-  const chunk = framed(v, text5);
-  const open2 = toc.segments.filter((s) => !s.sealed);
-  const active = open2[open2.length - 1];
-  const fits = active && active.last === v - 1 && active.chars < SEGMENT_POLICY.maxBytes && active.last - active.first + 1 < SEGMENT_POLICY.maxVersions;
-  for (const seg of open2) if (!(fits && seg === active)) await seal(app, toc, seg);
-  if (fits) {
-    const st2 = await storeStat(app, active.path);
-    if (st2 && active.bytes !== void 0 && st2.size !== active.bytes) throw new HistoryError(`log moved on: ${active.path} changed`);
-    await storeAppend(app, active.path, chunk);
-    active.last = v;
-    active.chars += chunk.length;
-    const after = await storeStat(app, active.path);
-    if (after) active.bytes = after.size;
-    return;
-  }
-  const path23 = segmentPath(toc.dir, v);
-  if (await storeExists(app, path23)) throw new HistoryError(`log file exists: ${path23}`);
-  await storeWrite(app, path23, chunk);
-  const st = await storeStat(app, path23);
-  toc.segments.push({ path: path23, first: v, last: v, sealed: false, chars: chunk.length, ...st ? { bytes: st.size } : {} });
+async function fileExists(app, path23) {
+  return inStore(path23) ? storeExists(app, path23) : fileOrNull(app, path23) != null;
 }
-async function seal(app, toc, seg) {
-  const to = segmentPath(toc.dir, seg.first, seg.last);
-  await storeRename(app, seg.path, to);
-  seg.path = to;
-  seg.sealed = true;
-  delete seg.bytes;
-  delete seg.chars;
+async function occupied(app, path23) {
+  return inStore(path23) ? storeExists(app, path23) : app.vault.getAbstractFileByPath(path23) != null;
 }
-async function writeSealedSegments(app, dir, versions) {
+async function storeFilesSince(app, moves) {
+  const folders = /* @__PURE__ */ new Map();
+  for (const m of moves) if (inStore(m.from) && inStore(m.to)) folders.set(parentFolder(m.to), parentFolder(m.from));
+  const moved = new Set(moves.map((m) => m.to));
   const out2 = [];
-  let run2 = [];
-  let chars = 0;
-  const flush2 = async () => {
-    if (run2.length === 0) return;
-    const path23 = segmentPath(dir, run2[0].version, run2[run2.length - 1].version);
-    if (await holdsWhole(app, path23, run2.map((r) => r.version))) storeSyncNext(app, path23);
-    else await storeWrite(app, path23, run2.map((r) => framed(r.version, r.text)).join(""));
-    out2.push(path23);
-    run2 = [];
-    chars = 0;
-  };
-  for (const r of versions) {
-    const last = run2[run2.length - 1];
-    if (last && (r.version !== last.version + 1 || chars >= SEGMENT_POLICY.maxBytes || run2.length >= SEGMENT_POLICY.maxVersions)) await flush2();
-    run2.push(r);
-    chars += r.text.length;
+  for (const [to, from] of folders) {
+    for (const f of (await storeList(app, to)).files) {
+      if (!moved.has(f)) out2.push({ from: `${from}/${f.slice(to.length + 1)}`, to: f });
+    }
   }
-  await flush2();
   return out2;
 }
-async function holdsWhole(app, path23, versions) {
-  const text5 = await storeRead(app, path23);
-  if (text5 === null) return false;
-  const { commits, validEnd } = parseSegment(text5);
-  return validEnd === text5.length && commits.length === versions.length && commits.every((c, i) => c.version === versions[i]);
-}
-async function gzip(text5) {
-  const stream = new Blob([text5]).stream().pipeThrough(new CompressionStream("gzip"));
-  return new Response(stream).arrayBuffer();
-}
-async function gunzip(data) {
-  const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream("gzip"));
-  return new Response(stream).text();
+function atOnceFor(count2) {
+  return count2 >= WRITE_CONCURRENCY.from ? WRITE_CONCURRENCY.atOnce : 1;
 }
-function chunked(lines) {
-  const out2 = [];
-  let cur = [];
-  let chars = 0;
-  for (const l of lines) {
-    if (cur.length > 0 && chars + l.length + 1 > CHECKPOINT_PART.maxChars) {
-      out2.push(cur);
-      cur = [];
-      chars = 0;
+async function inOrder(items3, pathOf, fn, limit = atOnceFor(items3.length)) {
+  const results = new Array(items3.length);
+  let next = 0;
+  let stop = false;
+  const worker = async () => {
+    while (!stop && next < items3.length) {
+      const i = next++;
+      try {
+        results[i] = { ok: true, written: await fn(items3[i]) };
+      } catch (e) {
+        results[i] = { ok: false, error: messageOf(e) };
+        stop = true;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items3.length) }, worker));
+  const first2 = results.findIndex((r) => r !== void 0 && !r.ok);
+  const kept2 = /* @__PURE__ */ new Set();
+  if (first2 >= 0) {
+    for (let i = results.length - 1; i > first2; i--) {
+      const r = results[i];
+      if (!r?.ok) continue;
+      try {
+        await r.written.undo();
+      } catch {
+        kept2.add(i);
+      }
     }
-    cur.push(l);
-    chars += l.length + 1;
   }
-  if (cur.length > 0 || out2.length === 0) out2.push(cur);
-  return out2;
+  const done = [];
+  results.forEach((r, i) => {
+    if (r?.ok && (first2 < 0 || i < first2 || kept2.has(i))) done.push(r.written.value);
+  });
+  const f = first2 >= 0 ? results[first2] : null;
+  return { done, failed: f ? { path: pathOf(items3[first2]), error: f.error } : null };
 }
-async function writeManifestCheckpoint(app, dir, head, rows) {
-  const main6 = manifestPath(dir, head.version);
-  if (await wholeManifest(app, dir, main6)) return [];
-  const binary = storeHoldsBinary(app);
-  const written2 = [];
-  const textLines = rows.map((r) => JSON.stringify([r.path, r.content]));
-  const partOf = [];
-  const parts = chunked(textLines);
-  let row = 0;
-  const partNames = [];
-  for (const [i, lines] of parts.entries()) {
-    const name = `${pad2(head.version)}.part-${i}.jsonl${binary ? ".gz" : ""}`;
-    const text5 = lines.length > 0 ? `${lines.join("\n")}
-` : "";
-    if (binary) await storeWriteBinary(app, `${dir}/${name}`, await gzip(text5));
-    else await storeWrite(app, `${dir}/${name}`, text5);
-    written2.push(`${dir}/${name}`);
-    partNames.push(name);
-    for (let k = 0; k < lines.length; k++) partOf[row++] = i;
-  }
-  const entries = rows.map((r, i) => JSON.stringify([r.path, r.hash, r.content.length, partOf[i]]));
-  const pieces = chunked(entries);
-  const more = pieces.slice(1).map((_, i) => `${pad2(head.version)}.manifest-${i + 1}.jsonl`);
-  for (const [i, lines] of pieces.slice(1).entries()) {
-    await storeWrite(app, `${dir}/${more[i]}`, `${lines.join("\n")}
-`);
-    written2.push(`${dir}/${more[i]}`);
-  }
-  const header2 = { format: 2, version: head.version, timestamp: head.timestamp, entry: head.entry, ...head.moves ? { moves: head.moves } : {}, rows: rows.length, parts: partNames, ...more.length > 0 ? { more } : {} };
-  await storeWrite(app, main6, `${JSON.stringify({ checkpoint: header2 })}
-${pieces[0].length > 0 ? `${pieces[0].join("\n")}
-` : ""}`);
-  written2.push(main6);
-  return written2;
+async function moveFile(app, from, to) {
+  if (inStore(from)) return storeRename(app, from, to);
+  const f = fileOrNull(app, from);
+  if (!f) throw new Error(`file not found: ${from}`);
+  if (app.vault.getAbstractFileByPath(to) != null) throw new Error(`target exists: ${to}`);
+  await ensureFolder(app, parentFolder(to));
+  await app.fileManager.renameFile(f, to);
 }
-async function readManifest(app, dir, path23) {
-  try {
-    const text5 = await storeRead(app, path23);
-    if (text5 == null) return null;
-    const lines = text5.split("\n").filter((l) => l !== "");
-    const head = JSON.parse(lines[0] ?? "null")?.checkpoint;
-    if (!head || head.format !== 2) return null;
-    const rows = lines.slice(1).map((l) => JSON.parse(l));
-    for (const name of head.more ?? []) {
-      const more = await storeRead(app, `${dir}/${name}`);
-      if (more == null) return null;
-      for (const l of more.split("\n")) if (l !== "") rows.push(JSON.parse(l));
+async function applyChangeSetImpl(app, settings, cs, now = /* @__PURE__ */ new Date()) {
+  const rows = [];
+  const creates = [];
+  const moves = [];
+  const references = [];
+  const deleted = [];
+  const failed2 = [];
+  let referencesUpdated = 0;
+  const fail2 = (path23, e) => {
+    failed2.push({ path: path23, error: messageOf(e) });
+  };
+  run: {
+    const folders = /* @__PURE__ */ new Map();
+    const folderOnce = (folder) => {
+      if (folder === "") return Promise.resolve();
+      let p = folders.get(folder);
+      if (!p) {
+        p = folderOnce(parentFolder(folder)).then(async () => {
+          if (app.vault.getAbstractFileByPath(folder) == null) await app.vault.createFolder(folder);
+        });
+        folders.set(folder, p);
+      }
+      return p;
+    };
+    const created = await inOrder(cs.creates, (c) => c.path, async (c) => {
+      if (app.vault.getAbstractFileByPath(c.path) != null) throw new Error(`file exists: ${c.path}`);
+      await folderOnce(parentFolder(c.path));
+      const file = await app.vault.create(c.path, c.content);
+      return { value: c.path, undo: () => app.vault.delete(file, true) };
+    });
+    creates.push(...created.done);
+    if (created.failed) {
+      failed2.push(created.failed);
+      break run;
+    }
+    for (const t of cs.texts) {
+      try {
+        const existing = app.vault.getAbstractFileByPath(t.path);
+        if (existing == null) {
+          if (t.before !== "") throw new Error("file not found");
+          if (t.path === metastorePath(settings)) {
+            t.after = withNewDatabaseConfig(t.after);
+            if (settings.databaseId) t.after = withMetastoreId(t.after, settings.databaseId);
+          }
+          await ensureFolder(app, parentFolder(t.path));
+          await app.vault.create(t.path, t.after);
+        } else {
+          await app.vault.process(existing, (current2) => {
+            if (current2 !== t.before) throw new Error("file changed since it was read");
+            return t.after;
+          });
+        }
+        references.push({ path: t.path, before_text: t.before, after_text: t.after });
+      } catch (err) {
+        fail2(t.path, err);
+        break run;
+      }
+    }
+    const edits = cs.edits.filter((e) => !editIsNoop(e));
+    const distinct = new Set(edits.map((e) => e.path)).size === edits.length;
+    const atOnce = distinct ? atOnceFor(edits.length) : 1;
+    const edited = await inOrder(edits, (e) => e.path, async (e) => {
+      const file = fileOrNull(app, e.path);
+      if (!file) throw new Error("file not found");
+      const was = atOnce > 1 ? (await readHashed(app, file)).content : "";
+      const d = diffOrdered(e.before, e.after);
+      const order = e.after.map(([k]) => k);
+      const fmChanged = d.set.length > 0 || d.remove.length > 0 || !same(e.before.map(([k]) => k), order);
+      if (fmChanged) {
+        await writeFrontmatter(app, file, (fm) => applyDiff(fm, d.set, d.remove, order));
+      }
+      if (bodyChanges(e)) await writeBody(app, file, e.bodyBefore, e.bodyAfter);
+      const row = {
+        path: e.path,
+        before: d.beforeValues,
+        before_absent: d.beforeAbsent,
+        before_order: e.before.map(([k]) => k),
+        after: d.afterValues,
+        after_absent: d.afterAbsent,
+        ...bodyChanges(e) ? { body_before: e.bodyBefore, body_after: e.bodyAfter } : {}
+      };
+      return { value: row, undo: async () => void await app.vault.process(file, () => was) };
+    }, atOnce);
+    rows.push(...edited.done);
+    if (edited.failed) {
+      failed2.push(edited.failed);
+      break run;
+    }
+    for (const m of cs.moves) {
+      try {
+        await moveFile(app, m.from, m.to);
+        moves.push(m);
+      } catch (err) {
+        fail2(m.from, err);
+        break run;
+      }
+    }
+    for (const p of cs.deletes) {
+      const file = fileOrNull(app, p);
+      try {
+        if (!file) throw new Error("file not found");
+        const content = await app.vault.read(file);
+        await trash(app, file);
+        deleted.push({ path: p, content });
+      } catch (err) {
+        fail2(p, err);
+        break run;
+      }
     }
-    if (rows.length !== head.rows) return null;
-    return { head, rows };
-  } catch {
-    return null;
   }
-}
-async function wholeManifest(app, dir, path23) {
-  const m = await readManifest(app, dir, path23);
-  if (!m) return false;
-  for (const name of m.head.parts) if (!await readPart(app, dir, name)) return false;
-  return true;
-}
-async function readPart(app, dir, name) {
-  try {
-    let text5;
-    if (name.endsWith(".gz")) {
-      const data = await storeReadBinary(app, `${dir}/${name}`);
-      text5 = data ? await gunzip(data) : null;
-    } else text5 = await storeRead(app, `${dir}/${name}`);
-    if (text5 == null) return null;
-    const out2 = /* @__PURE__ */ new Map();
-    for (const l of text5.split("\n")) {
-      if (l === "") continue;
-      const [path23, content] = JSON.parse(l);
-      out2.set(path23, content);
+  const createdHashes = [];
+  const movedTo = new Map(moves.map((m) => [m.from, m.to]));
+  for (const p of creates) {
+    const f = fileOrNull(app, movedTo.get(p) ?? p);
+    if (!f) continue;
+    try {
+      createdHashes.push({ path: p, hash: createdHash(await app.vault.read(f)) });
+    } catch {
     }
-    return out2;
-  } catch {
-    return null;
   }
+  const journal = await writeJournal(
+    app,
+    settings,
+    {
+      op: cs.op,
+      ...cs.schema !== void 0 ? { schema: cs.schema } : {},
+      ...currentActor() ? { actor: currentActor() } : {},
+      summary: cs.summary,
+      executed_at: now.toISOString(),
+      rows,
+      creates,
+      ...createdHashes.length > 0 ? { created_hashes: createdHashes } : {},
+      moves,
+      references,
+      deleted,
+      failed: failed2
+    },
+    now
+  );
+  return {
+    ok: failed2.length === 0,
+    migrationId: journal.id,
+    journalPath: journal.path,
+    notesChanged: rows.length,
+    filesCreated: creates.length,
+    filesMoved: moves.length,
+    filesDeleted: deleted.length,
+    referencesUpdated,
+    failed: failed2
+  };
 }
-function manifestFiles(dir, path23, head) {
-  return [path23, ...(head?.more ?? []).map((n) => `${dir}/${n}`), ...(head?.parts ?? []).map((n) => `${dir}/${n}`)];
+async function trash(app, file) {
+  const fm = app.fileManager;
+  if (typeof fm.trashFile === "function") {
+    await fm.trashFile(file);
+  } else {
+    await app.vault.trash(file, true);
+  }
 }
-var HistoryError, SEGMENT_POLICY, CHECKPOINT_PART, pad2, commitPath, checkpointPath, manifestPath, segmentPath, COMMIT_RE, CHECKPOINT_RE, MANIFEST_RE, SEGMENT_RE, TOCS, SEGMENT_TEXTS, SEGMENT_TEXTS_KEPT, READ_AHEAD;
-var init_log_files = __esm({
-  "src/core/log-files.ts"() {
-    "use strict";
-    init_hints();
-    init_file_cache();
-    init_store();
-    HistoryError = class extends GuidedError {
-      constructor() {
-        super(...arguments);
-        this.name = "HistoryError";
+async function undoChangeSet(app, entries, summary = `undo ${entries.map((e) => e.migration_id).join(", ")}`) {
+  const state = /* @__PURE__ */ new Map();
+  const texts = /* @__PURE__ */ new Map();
+  const origin = /* @__PURE__ */ new Map();
+  const vaultNote = async (path23) => {
+    const f = fileOrNull(app, path23);
+    if (!f) return null;
+    const text5 = await app.vault.read(f);
+    return { ordered: readOrderedFromMarkdown(text5).ordered, body: bodyOf(text5) };
+  };
+  const read3 = async (path23) => state.has(path23) ? state.get(path23) : vaultNote(path23);
+  for (const entry of entries) {
+    const movedTo = new Map(entry.moves.map((m) => [m.from, m.to]));
+    const currentPath = (p) => movedTo.get(p) ?? p;
+    for (const ref2 of entry.references) {
+      const path23 = currentPath(ref2.path);
+      if (/\.md$/i.test(path23)) {
+        const { ordered } = readOrderedFromMarkdown(ref2.before_text);
+        state.set(path23, { ordered, body: bodyOf(ref2.before_text) });
+      } else {
+        texts.set(path23, { before: texts.get(path23)?.before ?? ref2.after_text, after: ref2.before_text });
       }
-    };
-    SEGMENT_POLICY = { maxBytes: 8 * 1024 * 1024, maxVersions: 1e3 };
-    CHECKPOINT_PART = { maxChars: 4 * 1024 * 1024 };
-    pad2 = (v) => String(v).padStart(20, "0");
-    commitPath = (dir, v) => `${dir}/${pad2(v)}.json`;
-    checkpointPath = (dir, v) => `${dir}/${pad2(v)}.checkpoint.json`;
-    manifestPath = (dir, v) => `${dir}/${pad2(v)}.manifest.jsonl`;
-    segmentPath = (dir, first2, last) => `${dir}/${pad2(first2)}${last === void 0 ? "" : `-${pad2(last)}`}.segment.jsonl`;
-    COMMIT_RE = /\/(\d{20})\.json$/;
-    CHECKPOINT_RE = /\/(\d{20})\.checkpoint\.json$/;
-    MANIFEST_RE = /\/(\d{20})\.manifest\.jsonl$/;
-    SEGMENT_RE = /\/(\d{20})(?:-(\d{20}))?\.segment\.jsonl$/;
-    TOCS = /* @__PURE__ */ new WeakMap();
-    SEGMENT_TEXTS = /* @__PURE__ */ new WeakMap();
-    SEGMENT_TEXTS_KEPT = 3;
-    READ_AHEAD = 16;
-  }
-});
-
-// src/core/transaction-log.ts
-async function unreadableNow(app, path23) {
-  const f = app.vault.getAbstractFileByPath(path23);
-  if (f == null || !("extension" in f)) return false;
-  try {
-    return frontmatterError((await readHashed(app, f)).content) !== null;
-  } catch {
-    return false;
+    }
+    for (const r of entry.rows) {
+      const path23 = currentPath(r.path);
+      const cur = await read3(path23);
+      if (!cur) continue;
+      state.set(path23, { ...cur, ordered: applyDiff(cur.ordered, Object.entries(r.before), r.before_absent, r.before_order) });
+    }
+    for (const m of [...entry.moves].reverse()) {
+      state.set(m.from, await read3(m.to));
+      state.set(m.to, null);
+      origin.set(m.from, origin.get(m.to) ?? m.to);
+      origin.delete(m.to);
+    }
+    for (const c of entry.creates) state.set(c, null);
+    for (const d of entry.deleted) state.set(d.path, { ordered: readOrderedFromMarkdown(d.content).ordered, body: bodyOf(d.content) });
   }
-}
-function transactionLogRoot(_settings) {
-  return storePath(TRANSACTION_LOG_FOLDER);
-}
-function transactionLogDir(settings, full) {
-  return `${transactionLogRoot(settings)}/${full}`;
-}
-function entryHash(entry) {
-  if (entry == null) return "";
-  let h = ENTRY_HASHES.get(entry);
-  if (h === void 0) ENTRY_HASHES.set(entry, h = contentHash(JSON.stringify(entry)));
-  return h;
-}
-async function loggedTables(app, settings, among) {
-  const base = `${transactionLogRoot(settings)}/`;
-  const out2 = [];
-  for (const dir of (await storeList(app, transactionLogRoot(settings))).folders) {
-    const full = dir.slice(base.length);
-    if (among && !among(full)) continue;
-    if ((await storeList(app, dir)).files.some(holdsVersions)) out2.push(full);
+  const cs = emptyChangeSet("undo_migration", summary);
+  const moved = /* @__PURE__ */ new Set();
+  for (const [to, from] of origin) {
+    const final = state.get(to);
+    if (to === from || !final || !fileOrNull(app, from)) continue;
+    moved.add(to).add(from);
+    cs.moves.push({ from, to });
+    cs.edits.push({ path: from, before: (await vaultNote(from)).ordered, after: final.ordered });
   }
-  return out2.sort();
-}
-function tocOf(app, settings, full) {
-  return logToc(app, transactionLogDir(settings, full));
-}
-async function listVersions(app, settings, full) {
-  return [...(await tocOf(app, settings, full)).versions];
-}
-function parseCommit(text5) {
-  const commit = { commitInfo: void 0, add: [], remove: [] };
-  for (const line of text5.split("\n")) {
-    if (line.trim() === "") continue;
-    const action = JSON.parse(line);
-    if (action.commitInfo) commit.commitInfo = action.commitInfo;
-    else if ("metaData" in action) commit.metaData = action.metaData;
-    else if (action.add) commit.add.push(action.add);
-    else if (action.remove) commit.remove.push(action.remove);
+  for (const [path23, final] of state) {
+    if (moved.has(path23)) continue;
+    const now = fileOrNull(app, path23) ? await vaultNote(path23) : null;
+    if (now && final) cs.edits.push({ path: path23, before: now.ordered, after: final.ordered });
+    else if (now) cs.deletes.push(path23);
+    else if (final) cs.creates.push({ path: path23, content: buildMarkdownWithFrontmatter(final.ordered, final.body) });
   }
-  if (!commit.commitInfo) throw new HistoryError("log commit without commitInfo");
-  return commit;
-}
-function serializeCommit(c) {
-  const lines = [JSON.stringify({ commitInfo: c.commitInfo })];
-  if (c.metaData !== void 0) lines.push(JSON.stringify({ metaData: c.metaData }));
-  for (const r of c.remove) lines.push(JSON.stringify({ remove: r }));
-  for (const a of c.add) lines.push(JSON.stringify({ add: a }));
-  return `${lines.join("\n")}
-`;
-}
-async function readCommit(app, settings, full, version2) {
-  const toc = await tocOf(app, settings, full);
-  if (!toc.versions.includes(version2)) throw new HistoryError(`${full} has no version ${version2}`);
-  return movedCommit(parseCommit(await versionText(app, toc, version2)), await databaseMoves(app));
+  for (const [path23, t] of texts) if (t.before !== t.after) cs.texts.push({ path: path23, ...t });
+  return cs;
 }
-function movedCommit(c, moves) {
-  let out2 = c;
-  for (const m of moves) {
-    if (m.at <= c.commitInfo.timestamp) continue;
-    out2 = {
-      ...out2,
-      ...out2.metaData !== void 0 ? { metaData: { entry: moveEntryPaths(out2.metaData.entry, m.from, m.to, m.entries) } } : {},
-      add: out2.add.map((a) => ({ ...a, path: movePath(a.path, m.from, m.to, m.entries), content: moveLinks(a.content, m.from, m.to, m.entries) })),
-      remove: out2.remove.map((r) => ({ ...r, path: movePath(r.path, m.from, m.to, m.entries) }))
+async function undoMigration(app, settings, migrationId, now = /* @__PURE__ */ new Date(), check2, op2 = "undo_migration") {
+  const { entry, path: journalPath, undone } = await readJournal(app, settings, migrationId);
+  const conflicts = [];
+  const partial2 = entry.failed.length > 0;
+  const back = /* @__PURE__ */ new Set();
+  const why = RECORD_ONLY_OPS[entry.op];
+  if (why) return { ok: false, undoes: migrationId, conflicts: [{ path: journalPath, message: why }], failed: [] };
+  if (undone) {
+    return {
+      ok: false,
+      undoes: migrationId,
+      conflicts: [{ path: journalPath, message: "migration already undone" }],
+      failed: []
     };
   }
-  return out2;
-}
-function moveState(state, m) {
-  const files = /* @__PURE__ */ new Map();
-  for (const [path23, f] of state.files) {
-    const content = moveLinks(f.content, m.from, m.to, m.entries);
-    files.set(movePath(path23, m.from, m.to, m.entries), content === f.content ? f : { ...f, hash: contentHash(content), content });
+  const movedTo = new Map(entry.moves.map((m) => [m.from, m.to]));
+  const currentPath = (p) => movedTo.get(p) ?? p;
+  for (const r of entry.rows) {
+    const f = fileOrNull(app, currentPath(r.path));
+    if (!f) {
+      conflicts.push({ path: r.path, message: "note no longer exists" });
+      continue;
+    }
+    const cur = new Map(await readOrderedFor(app, f));
+    if (partial2 && Object.entries(r.before).every(([k, v]) => cur.has(k) && same(cur.get(k), v)) && r.before_absent.every((k) => !cur.has(k)) && (r.body_before === void 0 || bodyOf(await app.vault.read(f)) === r.body_before)) {
+      back.add(r);
+      continue;
+    }
+    for (const [k, v] of Object.entries(r.after)) {
+      if (!cur.has(k) || !same(cur.get(k), v)) {
+        conflicts.push({ path: r.path, message: `"${k}" changed since the operation` });
+      }
+    }
+    for (const k of r.after_absent) {
+      if (cur.has(k)) conflicts.push({ path: r.path, message: `"${k}" was added since the operation` });
+    }
+    if (r.body_after !== void 0 && bodyOf(await app.vault.read(f)) !== r.body_after) {
+      conflicts.push({ path: r.path, message: "body changed since the operation" });
+    }
   }
-  state.files = files;
-  state.entry = moveEntryPaths(state.entry, m.from, m.to, m.entries);
-}
-function emptyState(full) {
-  return { full, version: -1, timestamp: "", entry: null, files: /* @__PURE__ */ new Map() };
-}
-function applyCommit(state, c) {
-  const files = state.files;
-  const at = c.commitInfo.version;
-  for (const r of c.remove) files.delete(r.path);
-  for (const a of c.add) files.set(a.path, { hash: a.hash, content: a.content, at });
-  return {
-    full: state.full,
-    version: c.commitInfo.version,
-    timestamp: c.commitInfo.timestamp,
-    entry: c.metaData !== void 0 ? c.metaData.entry : state.entry,
-    files
-  };
-}
-function applyLogged(state, c) {
-  const at = c.commitInfo.version;
-  for (const r of c.remove) {
-    const old = state.files.get(r.path);
-    if (old) state.bytes -= old.size;
-    state.files.delete(r.path);
+  for (const ref2 of entry.references) {
+    const f = fileOrNull(app, currentPath(ref2.path));
+    const text5 = f ? await app.vault.read(f) : null;
+    if (partial2 && text5 === ref2.before_text) back.add(ref2);
+    else if (text5 !== ref2.after_text) {
+      conflicts.push({ path: ref2.path, message: "text changed since the operation" });
+    }
   }
-  for (const a of c.add) {
-    const old = state.files.get(a.path);
-    if (old) state.bytes -= old.size;
-    const size = a.content.length;
-    state.files.set(a.path, { hash: a.hash, size, at });
-    state.bytes += size;
+  const since = await storeFilesSince(app, entry.moves);
+  const vacuumed = /* @__PURE__ */ new Set();
+  for (const m of entry.moves) {
+    if (!await fileExists(app, m.to)) {
+      if (inStore(m.to)) vacuumed.add(m.to);
+      else if (partial2 && await fileExists(app, m.from)) back.add(m);
+      else conflicts.push({ path: m.to, message: "moved file no longer exists" });
+    } else if (await occupied(app, m.from)) {
+      conflicts.push({ path: m.from, message: "original path is occupied" });
+    }
   }
-  state.version = at;
-  state.timestamp = c.commitInfo.timestamp;
-  if (c.metaData !== void 0) state.entry = c.metaData.entry;
-}
-function parseCheckpoint(text5) {
+  for (const m of since) {
+    if (await occupied(app, m.from)) conflicts.push({ path: m.from, message: "original path is occupied" });
+  }
+  const hashOfCreated = new Map((entry.created_hashes ?? []).map((h) => [h.path, h.hash]));
+  for (const c of entry.creates) {
+    const f = fileOrNull(app, currentPath(c));
+    if (f) {
+      const was = hashOfCreated.get(c);
+      if (!partial2 && was !== void 0 && createdHash(await app.vault.read(f)) !== was) {
+        conflicts.push({ path: currentPath(c), message: "created note changed since the operation" });
+      }
+      continue;
+    }
+    if (partial2) back.add(c);
+    else conflicts.push({ path: c, message: "created file no longer exists" });
+  }
+  for (const d of entry.deleted) {
+    const f = fileOrNull(app, d.path);
+    if (partial2 && f && await app.vault.read(f) === d.content) back.add(d);
+    else if (app.vault.getAbstractFileByPath(d.path) != null) {
+      conflicts.push({ path: d.path, message: "deleted path is occupied" });
+    }
+  }
+  if (conflicts.length > 0) return { ok: false, undoes: migrationId, conflicts, failed: [] };
+  if (check2) {
+    const refused2 = await check2(await undoChangeSet(app, [entry], `undo ${migrationId}`));
+    if (refused2.length > 0) return { ok: false, undoes: migrationId, conflicts: refused2, failed: [] };
+  }
+  const failed2 = [];
+  const undoRows = [];
+  const undoMoves = [];
+  const undoReferences = [];
+  const undoCreates = [];
+  const undoCreatedHashes = [];
+  const undoDeleted = [];
+  const steps = [];
+  for (const ref2 of entry.references) {
+    if (back.has(ref2)) continue;
+    steps.push({
+      path: currentPath(ref2.path),
+      run: async () => {
+        const f = fileOrNull(app, currentPath(ref2.path));
+        await app.vault.process(f, () => ref2.before_text);
+        undoReferences.push({ path: currentPath(ref2.path), before_text: ref2.after_text, after_text: ref2.before_text });
+      }
+    });
+  }
+  for (const r of entry.rows) {
+    if (back.has(r)) continue;
+    steps.push({
+      path: currentPath(r.path),
+      run: async () => {
+        const f = fileOrNull(app, currentPath(r.path));
+        const order = (await readOrderedFor(app, f)).map(([k]) => k);
+        if (Object.keys(r.after).length > 0 || r.after_absent.length > 0 || Object.keys(r.before).length > 0) {
+          await writeFrontmatter(
+            app,
+            f,
+            (fm) => applyDiff(fm, Object.entries(r.before), r.before_absent, r.before_order)
+          );
+        }
+        if (r.body_after !== void 0) await writeBody(app, f, r.body_after, r.body_before);
+        undoRows.push({
+          path: currentPath(r.path),
+          before: r.after,
+          before_absent: r.after_absent,
+          before_order: order,
+          after: r.before,
+          after_absent: r.before_absent,
+          ...r.body_after !== void 0 ? { body_before: r.body_after, body_after: r.body_before } : {}
+        });
+      }
+    });
+  }
+  for (const m of [...[...entry.moves].reverse().filter((x) => !vacuumed.has(x.to) && !back.has(x)), ...since]) {
+    steps.push({
+      path: m.to,
+      run: async () => {
+        await moveFile(app, m.to, m.from);
+        undoMoves.push({ from: m.to, to: m.from });
+      }
+    });
+  }
+  for (const c of entry.creates) {
+    if (back.has(c)) continue;
+    steps.push({
+      path: c,
+      run: async () => {
+        const f = fileOrNull(app, c);
+        const content = await app.vault.read(f);
+        await trash(app, f);
+        undoDeleted.push({ path: c, content });
+      }
+    });
+  }
+  for (const d of entry.deleted) {
+    if (back.has(d)) continue;
+    steps.push({
+      path: d.path,
+      run: async () => {
+        await ensureFolder(app, parentFolder(d.path));
+        await app.vault.create(d.path, d.content);
+        undoCreates.push(d.path);
+        undoCreatedHashes.push({ path: d.path, hash: createdHash(d.content) });
+      }
+    });
+  }
+  let done = 0;
   try {
-    const c = JSON.parse(text5);
-    return c !== null && typeof c === "object" && Number.isInteger(c.version) && Array.isArray(c.files) ? c : null;
-  } catch {
-    return null;
+    for (const s of steps) {
+      await s.run();
+      done++;
+    }
+  } catch (e) {
+    failed2.push({ path: "undo", error: messageOf(e) });
   }
-}
-async function readCheckpoint(app, dir, cp) {
-  if (cp.kind === 1) {
-    const text5 = await storeRead(app, cp.path);
-    if (text5 == null) return null;
-    const c = parseCheckpoint(text5);
-    if (!c) return null;
-    return { version: c.version, timestamp: c.timestamp, entry: c.entry, ...c.moves !== void 0 ? { moves: c.moves } : {}, files: new Map(c.files.map((f) => [f.path, { hash: f.hash, content: f.content, at: c.version, cp: true }])) };
+  const journal = await writeJournal(
+    app,
+    settings,
+    {
+      op: op2,
+      ...entry.schema !== void 0 ? { schema: entry.schema } : {},
+      ...currentActor() ? { actor: currentActor() } : {},
+      summary: `undo ${migrationId}`,
+      executed_at: now.toISOString(),
+      rows: undoRows,
+      creates: undoCreates,
+      ...undoCreatedHashes.length > 0 ? { created_hashes: undoCreatedHashes } : {},
+      moves: undoMoves,
+      references: undoReferences,
+      deleted: undoDeleted,
+      failed: failed2,
+      undoes: migrationId
+    },
+    now
+  );
+  if (failed2.length === 0) {
+    await markUndone(app, settings, migrationId, journal.id, now);
   }
-  const m = await readManifest(app, dir, cp.path);
-  if (!m) return null;
-  const texts = /* @__PURE__ */ new Map();
-  for (const name of m.head.parts) {
-    const part = await readPart(app, dir, name);
-    if (!part) return null;
-    for (const [p, t] of part) texts.set(p, t);
+  return {
+    ok: failed2.length === 0,
+    undoes: migrationId,
+    migration_id: journal.id,
+    conflicts: [],
+    failed: failed2,
+    ...failed2.length > 0 ? { left: [...new Set(steps.slice(done).map((s) => s.path))] } : {},
+    touched: [
+      ...entry.rows.map((r) => r.path),
+      ...entry.creates,
+      ...[...entry.moves, ...since].flatMap((m) => [m.from, m.to]),
+      ...entry.references.map((r) => r.path),
+      ...entry.deleted.map((d) => d.path)
+    ]
+  };
+}
+function applyChangeSet(...args) {
+  const cs = args[2];
+  return phase("engine.apply", async (span) => {
+    const r = await applyChangeSetImpl(...args);
+    span.setAttributes({ "datanotes.notes_changed": r.notesChanged, "datanotes.files_created": r.filesCreated, "datanotes.files_moved": r.filesMoved, "datanotes.files_deleted": r.filesDeleted, "datanotes.failed": r.failed.length });
+    if (!r.ok) span.setAttribute("error.type", "write_failed").setStatus("error", "the write failed partway");
+    return r;
+  }, { "datanotes.edits": cs.edits.length, "datanotes.creates": cs.creates.length, "datanotes.moves": cs.moves.length, "datanotes.deletes": cs.deletes.length });
+}
+var inStore, WRITE_CONCURRENCY, RECORD_ONLY_OPS;
+var init_changeset = __esm({
+  "src/core/changeset.ts"() {
+    "use strict";
+    init_frontmatter();
+    init_actor();
+    init_journal();
+    init_store();
+    init_metastore();
+    init_database_id();
+    init_message();
+    init_file_cache();
+    init_tracing();
+    init_journal();
+    inStore = isStorePath;
+    WRITE_CONCURRENCY = { atOnce: 16, from: 32 };
+    RECORD_ONLY_OPS = {
+      move_database: "a move of the database folder cannot be undone: move it back with configure_database (root)",
+      set_database_id: "the database's id cannot be taken back: the engine finds its store by it",
+      rollback: "the rollback of a failed write cannot be undone: it put the database back as it was; run the write again instead"
+    };
   }
-  const files = /* @__PURE__ */ new Map();
-  for (const [path23, hash] of m.rows) {
-    const content = texts.get(path23);
-    if (content === void 0) return null;
-    files.set(path23, { hash, content, at: m.head.version, cp: true });
+});
+
+// src/core/write-scope.ts
+function runWithWriteScope(scope, fn) {
+  if (!storage3) {
+    if (scope) throw new Error("write permissions need Node's AsyncLocalStorage");
+    return fn();
   }
-  return { version: m.head.version, timestamp: m.head.timestamp, entry: m.head.entry, ...m.head.moves !== void 0 ? { moves: m.head.moves } : {}, files };
+  if (!scope && !storage3.getStore()) return fn();
+  return storage3.run({ scope }, fn);
 }
-async function tableStateAt(app, settings, full, asOf2 = {}) {
-  const known = LAST.get(app)?.get(full);
-  if (known && known.version >= 0 && isLatest(known, asOf2) && await stillLatest(app, settings, known)) {
-    const fromNotes = await stateFromLogged(app, settings, known);
-    if (fromNotes) return fromNotes;
-  }
-  return replayState(app, settings, full, asOf2);
+function currentWriteScope() {
+  return storage3?.getStore()?.scope ?? null;
 }
-function isLatest(known, asOf2) {
-  if (asOf2.version !== void 0) return asOf2.version === known.version && asOf2.timestamp === void 0;
-  if (asOf2.timestamp === void 0) return true;
-  const at = Date.parse(asOf2.timestamp);
-  return !Number.isNaN(at) && at >= Date.parse(known.timestamp);
+function tableOfFrontmatter(model, settings, fm) {
+  return rowTableFull(model, fmGet(fm, settings.tableKey));
 }
-async function replayState(app, settings, full, asOf2 = {}) {
-  const dir = transactionLogDir(settings, full);
-  const toc = await logToc(app, dir);
-  const versions = toc.versions;
-  if (versions.length === 0) {
-    if (asOf2.version !== void 0 || asOf2.timestamp !== void 0) {
-      throw new HistoryError(
-        `${full} has no history: time travel is off for it (turn it on with configure_database(history=true) or alter_table(history=true))`
-      );
-    }
-    return emptyState(full);
-  }
-  let target = versions[versions.length - 1];
-  if (asOf2.version !== void 0) {
-    if (!versions.includes(asOf2.version)) {
-      throw new HistoryError(`${full} has no version ${asOf2.version} (available: ${versions[0]}..${target})`);
-    }
-    target = asOf2.version;
-  }
-  const limitMs = asOf2.timestamp !== void 0 ? Date.parse(asOf2.timestamp) : void 0;
-  if (limitMs !== void 0 && Number.isNaN(limitMs)) throw new HistoryError(`"timestamp" is not a date-time: ${asOf2.timestamp}`);
-  const moves = await databaseMoves(app);
-  let applied = 0;
-  const moveUpTo = (timestamp) => {
-    while (applied < moves.length && (timestamp === null || moves[applied].at <= timestamp)) moveState(state, moves[applied++]);
+function changeSetTables(app, settings, model, cs) {
+  const out2 = /* @__PURE__ */ new Set();
+  const add = (full) => {
+    if (full !== null) out2.add(full);
   };
-  let state = emptyState(full);
-  for (const cp of [...toc.checkpoints].reverse()) {
-    if (cp.version > target) continue;
-    const c = await readCheckpoint(app, dir, cp);
-    if (!c) continue;
-    if (limitMs !== void 0 && Date.parse(c.timestamp) > limitMs) continue;
-    state = { full, version: c.version, timestamp: c.timestamp, entry: c.entry, files: c.files };
-    applied = Math.min(c.moves ?? moves.filter((m) => m.at <= c.timestamp).length, moves.length);
-    break;
-  }
-  const since = { versions: 0, bytes: 0 };
-  const replay = versions.filter((v) => v > state.version && v <= target);
-  const texts = await versionTexts(app, toc, replay);
-  for (const text5 of texts) {
-    const c = parseCommit(text5);
-    if (limitMs !== void 0 && Date.parse(c.commitInfo.timestamp) > limitMs) break;
-    moveUpTo(c.commitInfo.timestamp);
-    state = applyCommit(state, c);
-    since.versions++;
-    since.bytes += text5.length;
+  const keep = /* @__PURE__ */ new Set([settings.tableKey]);
+  for (const e of cs.edits) {
+    if (editIsNoop(e)) continue;
+    add(tableOfFrontmatter(model, settings, e.before) ?? tableOfPath(app, settings, e.path));
+    add(tableOfFrontmatter(model, settings, e.after));
   }
-  moveUpTo(null);
-  state.sinceCheckpoint = since;
-  state.movesApplied = applied;
-  if (state.version < 0) throw new AbsentTableError(`${full} did not exist at ${asOf2.timestamp}`);
-  return state;
+  for (const c of cs.creates) add(tableOfFrontmatter(model, settings, readOrderedFromMarkdown(c.content, keep).ordered));
+  for (const m of cs.moves) add(tableOfPath(app, settings, m.from));
+  for (const d of cs.deletes) add(tableOfPath(app, settings, d));
+  return out2;
 }
-async function replayLogged(app, settings, full) {
-  const dir = transactionLogDir(settings, full);
-  const toc = await logToc(app, dir);
-  const empty = { full, version: -1, timestamp: "", entry: null, files: /* @__PURE__ */ new Map(), sinceCheckpoint: { versions: 0, bytes: 0 }, bytes: 0 };
-  if (toc.versions.length === 0) return empty;
-  const moves = await databaseMoves(app);
-  let state = empty;
-  let applied = 0;
-  for (const cp of [...toc.checkpoints].reverse()) {
-    if (cp.kind === 2) {
-      const m = await readManifest(app, dir, cp.path);
-      if (!m || !await partsThere(app, dir, m.head.parts)) continue;
-      const files = /* @__PURE__ */ new Map();
-      let bytes = 0;
-      for (const [path23, hash, size] of m.rows) {
-        files.set(path23, { hash, size, at: m.head.version, cp: true });
-        bytes += size;
-      }
-      state = { full, version: m.head.version, timestamp: m.head.timestamp, entry: m.head.entry, files, sinceCheckpoint: { versions: 0, bytes: 0 }, bytes };
-      applied = Math.min(m.head.moves ?? moves.filter((x) => x.at <= m.head.timestamp).length, moves.length);
-    } else {
-      const c = await readCheckpoint(app, dir, cp);
-      if (!c) continue;
-      const files = /* @__PURE__ */ new Map();
-      let bytes = 0;
-      for (const [path23, f] of c.files) {
-        files.set(path23, { hash: f.hash, size: f.content.length, at: c.version, cp: true });
-        bytes += f.content.length;
-      }
-      state = { full, version: c.version, timestamp: c.timestamp, entry: c.entry, files, sinceCheckpoint: { versions: 0, bytes: 0 }, bytes };
-      applied = Math.min(c.moves ?? moves.filter((x) => x.at <= c.timestamp).length, moves.length);
+async function assertChangeSetWritable(app, settings, cs) {
+  const scope = currentWriteScope();
+  if (!scope || !ROW_WRITE_OPS.has(cs.op)) return;
+  const model = (await loadMetastore(app, settings))?.model;
+  if (!model) return;
+  const denied = [...changeSetTables(app, settings, model, cs)].filter((t) => !matchesTablePattern(t, scope.patterns)).sort();
+  if (denied.length === 0) return;
+  const named = denied.find((t) => tableReadable(t));
+  throw new WriteDeniedError(scope.token, named ?? null);
+}
+var storage3, ROW_WRITE_OPS, WriteDeniedError;
+var init_write_scope = __esm({
+  "src/core/write-scope.ts"() {
+    "use strict";
+    init_changeset();
+    init_frontmatter();
+    init_hints();
+    init_metastore();
+    init_read_scope();
+    storage3 = null;
+    try {
+      const { AsyncLocalStorage: AsyncLocalStorage2 } = require("node:async_hooks");
+      storage3 = new AsyncLocalStorage2();
+    } catch {
+      storage3 = null;
     }
-    break;
+    ROW_WRITE_OPS = /* @__PURE__ */ new Set([
+      "insert_row",
+      "update_row",
+      "update_rows",
+      "delete_rows",
+      "move_rows",
+      "adopt_rows",
+      "merge_rows",
+      "recompute_columns",
+      "align_relations"
+    ]);
+    WriteDeniedError = class extends GuidedError {
+      constructor(token, table) {
+        super(
+          table === null ? `token ${token} may not write a table it may not read: this write changes rows of it` : `token ${token} may not write ${table}: this write changes rows of it`,
+          guide(
+            table === null ? `Nothing was written. The write changes rows of a table this token may not read (set_null, an inverse link or align_relations). The owner can add that table to the token's "read" and "write" with tokens/update/. Or change the write so it leaves that table alone.` : `Nothing was written. The write changes rows of ${table} (set_null, an inverse link or align_relations), so the token needs write on it too: the owner adds "${table}" (or a wider pattern) to the token's "write" with tokens/update/. Or change the write so it leaves that table alone.`,
+            "tokenWrite"
+          )
+        );
+        this.name = "WriteDeniedError";
+        this.table = table;
+      }
+    };
   }
-  if (applied < moves.length) return loggedOf(await replayState(app, settings, full));
-  const replay = toc.versions.filter((v) => v > state.version);
-  for (const text5 of await versionTexts(app, toc, replay)) {
-    applyLogged(state, parseCommit(text5));
-    state.sinceCheckpoint.versions++;
-    state.sinceCheckpoint.bytes += text5.length;
+});
+
+// src/core/unreadable.ts
+function frontmatterError(text5) {
+  try {
+    readOrderedFromMarkdown(text5);
+    return null;
+  } catch (e) {
+    return messageOf(e);
   }
-  if (moves.length > 0) state.movesApplied = applied;
-  return state;
-}
-async function partsThere(app, dir, parts) {
-  const { files } = await storeList(app, dir);
-  const there = new Set(files);
-  return parts.every((n) => there.has(`${dir}/${n}`));
 }
-function loggedOf(state) {
-  const files = /* @__PURE__ */ new Map();
-  let bytes = 0;
-  for (const [path23, f] of state.files) {
-    files.set(path23, { hash: f.hash, size: f.content.length, at: f.at, cp: f.cp });
-    bytes += f.content.length;
+function rawFrontmatterValue(text5, key2) {
+  const split2 = splitFrontmatter(text5);
+  if (!split2) return void 0;
+  for (const line of split2.yamlText.split(/\r?\n/)) {
+    const head = [`${key2}:`, `"${key2}":`, `'${key2}':`].find((h) => line.startsWith(h));
+    if (!head) continue;
+    const rest = line.slice(head.length).trim();
+    try {
+      return (0, import_yaml3.parse)(rest);
+    } catch {
+      return rest;
+    }
   }
-  return {
-    full: state.full,
-    version: state.version,
-    timestamp: state.timestamp,
-    entry: state.entry,
-    files,
-    sinceCheckpoint: state.sinceCheckpoint,
-    movesApplied: state.movesApplied,
-    bytes
-  };
+  return void 0;
 }
-async function loggedTexts(app, settings, state, paths) {
+function unreadableMessage(error2) {
+  return `the front matter cannot be read, so the row is left out of every read: ${error2.split("\n")[0].trim()}`;
+}
+function excludedFolders(model, settings) {
   const out2 = /* @__PURE__ */ new Map();
-  const fromCommit = /* @__PURE__ */ new Map();
-  const fromCheckpoint = /* @__PURE__ */ new Map();
-  for (const path23 of paths) {
-    const f = state.files.get(path23);
-    const note = app.vault.getAbstractFileByPath(path23);
-    if (note && "extension" in note) {
-      try {
-        const h = await readHashed(app, note);
-        if (h.hash === f.hash) {
-          out2.set(path23, h.content);
-          continue;
-        }
-      } catch {
-      }
+  for (const { ref: ref2, entry } of catalogTables(model)) {
+    try {
+      const options = parseTableOptions(entryToOrdered(ref2, entry, settings).find(([k]) => k === TABLE_KEY)?.[1]);
+      out2.set(ref2.full, [...options.exclude ?? [], catalogLayout(normalizeDatabaseFolder(settings.databaseFolder), ref2, options).archive]);
+    } catch {
     }
-    const by = f.cp ? fromCheckpoint : fromCommit;
-    const list4 = by.get(f.at);
-    if (list4) list4.push(path23);
-    else by.set(f.at, [path23]);
   }
-  for (const [v, list4] of fromCommit) {
-    let c;
+  return out2;
+}
+function unreadableRowOf(model, settings, path23, text5, excluded) {
+  if (!text5.startsWith("---")) return null;
+  const error2 = frontmatterError(text5);
+  if (error2 === null) return null;
+  const table = rowTableFull(model, rawFrontmatterValue(text5, settings.tableKey));
+  if (!table) return null;
+  const folders = (excluded ?? excludedFolders(model, settings)).get(table) ?? [];
+  if (folders.some((dir) => path23.startsWith(`${dir}/`))) return null;
+  return { path: path23, table, error: error2 };
+}
+async function unreadableRows(app, settings, model, table) {
+  const excluded = excludedFolders(model, settings);
+  const out2 = [];
+  const idx = vaultIndex(app, settings);
+  const notes = idx ? [...idx.allNotes()].filter((n) => n.bare).map((n) => n.file) : app.vault.getMarkdownFiles();
+  for (const f of notes) {
+    let cached2;
     try {
-      c = await readCommit(app, settings, state.full, v);
+      cached2 = idx ? void 0 : app.metadataCache.getFileCache(f)?.frontmatter;
     } catch {
-      continue;
+      cached2 = void 0;
     }
-    const want = new Set(list4);
-    for (const a of c.add) if (want.has(a.path) && contentHash(a.content) === state.files.get(a.path).hash) out2.set(a.path, a.content);
-  }
-  for (const [v, list4] of fromCheckpoint) await textsFromCheckpoint(app, settings, state, v, list4, out2);
-  const missing = [...fromCommit.values(), ...fromCheckpoint.values()].flat().filter((p) => !out2.has(p));
-  if (missing.length > 0) {
+    if (cached2) continue;
+    let text5;
     try {
-      const whole = await replayState(app, settings, state.full, { version: state.version });
-      for (const p of missing) {
-        const x = whole.files.get(p);
-        if (x && x.hash === state.files.get(p).hash) out2.set(p, x.content);
-      }
+      text5 = (await readHashed(app, f)).content;
     } catch {
+      continue;
     }
+    const u = unreadableRowOf(model, settings, f.path, text5, excluded);
+    if (u && (table === void 0 || u.table === table)) out2.push(u);
   }
-  return out2;
+  return out2.sort((a, b) => a.path.localeCompare(b.path));
 }
-async function textsFromCheckpoint(app, settings, state, version2, paths, out2) {
-  const dir = transactionLogDir(settings, state.full);
-  const toc = await logToc(app, dir);
-  const cp = [...toc.checkpoints].reverse().find((c) => c.version === version2);
-  if (!cp) return;
-  const want = new Set(paths);
-  const keep = (path23, content) => {
-    if (want.has(path23) && contentHash(content) === state.files.get(path23).hash) out2.set(path23, content);
-  };
-  if (cp.kind === 1) {
-    const c = await readCheckpoint(app, dir, cp).catch(() => null);
-    for (const [path23, f] of c?.files ?? []) keep(path23, f.content);
-    return;
-  }
-  const m = await readManifest(app, dir, cp.path);
-  if (!m) return;
-  const partOf = new Map(m.rows.map(([path23, , , part]) => [path23, part]));
-  const parts = new Set(paths.map((p) => partOf.get(p)).filter((x) => x !== void 0));
-  for (const i of parts) {
-    const part = await readPart(app, dir, m.head.parts[i]);
-    for (const [path23, content] of part ?? []) keep(path23, content);
+var import_yaml3;
+var init_unreadable = __esm({
+  "src/core/unreadable.ts"() {
+    "use strict";
+    init_file_cache();
+    import_yaml3 = __toESM(require_dist(), 1);
+    init_frontmatter();
+    init_metastore();
+    init_table_loader();
+    init_types_table();
+    init_message();
+    init_db_paths();
+    init_vault_index();
   }
+});
+
+// src/core/log-files.ts
+function holdsVersions(path23) {
+  return COMMIT_RE.test(path23) || SEGMENT_RE.test(path23);
 }
-async function stateFromLogged(app, settings, state) {
-  const texts = await loggedTexts(app, settings, state, state.files.keys());
-  if (texts.size !== state.files.size) return null;
-  const files = /* @__PURE__ */ new Map();
-  for (const [path23, f] of state.files) files.set(path23, { hash: f.hash, content: texts.get(path23), at: f.at, cp: f.cp });
-  return {
-    full: state.full,
-    version: state.version,
-    timestamp: state.timestamp,
-    entry: state.entry,
-    files,
-    sinceCheckpoint: { ...state.sinceCheckpoint },
-    movesApplied: state.movesApplied
-  };
-}
-function infoOf(text5) {
-  return JSON.parse(text5.slice(0, text5.indexOf("\n"))).commitInfo;
+function tocsOf(app) {
+  let m = TOCS.get(app);
+  if (!m) TOCS.set(app, m = /* @__PURE__ */ new Map());
+  return m;
 }
-async function commitInfos(app, settings, full) {
-  const toc = await tocOf(app, settings, full);
-  return (await versionTexts(app, toc, toc.versions)).map(infoOf);
+function latestOf(toc) {
+  return toc.versions.length > 0 ? toc.versions[toc.versions.length - 1] : -1;
 }
-async function newestCommitInfos(app, settings, full, limit, from) {
-  const toc = await tocOf(app, settings, full);
-  const out2 = [];
-  for (const v of [...toc.versions].reverse()) {
-    if (out2.length >= limit) break;
-    const info = infoOf(await versionText(app, toc, v));
-    if (from !== void 0 && Date.parse(info.timestamp) < from) break;
-    out2.push(info);
+function parseSegment(text5) {
+  const commits = [];
+  let pos = 0;
+  while (pos < text5.length) {
+    const nl = text5.indexOf("\n", pos);
+    if (nl < 0) break;
+    let head;
+    try {
+      head = JSON.parse(text5.slice(pos, nl)).commit;
+    } catch {
+      break;
+    }
+    if (!head || !Number.isInteger(head.version) || !Number.isInteger(head.lines) || head.lines < 1) break;
+    let end = nl + 1;
+    let whole = true;
+    for (let i = 0; i < head.lines; i++) {
+      const e = text5.indexOf("\n", end);
+      if (e < 0) {
+        whole = false;
+        break;
+      }
+      end = e + 1;
+    }
+    if (!whole) break;
+    if (typeof head.hash === "string" && contentHash(text5.slice(nl + 1, end)) !== head.hash) break;
+    const prev = commits[commits.length - 1];
+    if (prev && head.version !== prev.version + 1) break;
+    commits.push({ version: head.version, start: nl + 1, end });
+    pos = end;
   }
-  return out2;
-}
-async function history(app, settings, full, limit = 50) {
-  const versions = (await listVersions(app, settings, full)).reverse().slice(0, Math.max(limit, 0));
-  const out2 = [];
-  for (const v of versions) out2.push((await readCommit(app, settings, full, v)).commitInfo);
-  return out2;
+  return { commits, validEnd: pos };
 }
-function catalogEntryOptions(full, entry, settings) {
-  const [c, s, t] = full.split(".");
-  const ref2 = refOf(c, s, t);
-  const options = parseTableOptions(entryToOrdered(ref2, entry, settings).find(([k]) => k === TABLE_KEY)?.[1]);
-  const layout = catalogLayout(normalizeDatabaseFolder(settings.databaseFolder), ref2, options);
-  return [...options.exclude ?? [], layout.archive, transactionLogRoot(settings)];
+function framed(version2, text5) {
+  const lines = text5.split("\n").length - 1;
+  return `${JSON.stringify({ commit: { version: version2, lines, hash: contentHash(text5) } })}
+${text5}`;
 }
-async function readCurrentStates(app, settings, model, touched, only) {
-  const out2 = /* @__PURE__ */ new Map();
-  const excludes = /* @__PURE__ */ new Map();
-  for (const { ref: ref2, entry } of catalogTables(model)) {
-    if (only && !only.has(ref2.full)) continue;
-    out2.set(ref2.full, { entry, files: /* @__PURE__ */ new Map() });
-    excludes.set(ref2.full, catalogEntryOptions(ref2.full, entry, settings));
-  }
-  if (out2.size === 0) return out2;
-  const candidates = /* @__PURE__ */ new Map();
-  for (const p of touched) if (p.endsWith(".md")) candidates.set(p, null);
-  for (const f of app.vault.getMarkdownFiles()) {
-    const fm = app.metadataCache.getFileCache(f)?.frontmatter;
-    if (fm && fm[settings.tableKey] != null) candidates.set(f.path, f);
+async function segmentText(app, seg) {
+  let cache = SEGMENT_TEXTS.get(app);
+  if (!cache) SEGMENT_TEXTS.set(app, cache = /* @__PURE__ */ new Map());
+  const key2 = `${seg.path}\0${seg.sealed ? "" : `${seg.chars}/${seg.last}`}\0${storeGeneration(app, seg.path)}`;
+  const hit = cache.get(key2);
+  if (hit) {
+    cache.delete(key2);
+    cache.set(key2, hit);
+    return hit;
   }
-  const reader = rowStateReader(app, settings, model, out2, excludes);
-  for (const path23 of [...candidates.keys()].sort()) {
-    const r = await reader(path23, candidates.get(path23) ?? null);
-    if (r) out2.get(r.table).files.set(path23, r.state);
+  const text5 = await storeReadFile(app, seg.path);
+  const index = /* @__PURE__ */ new Map();
+  for (const c of parseSegment(text5).commits) index.set(c.version, [c.start, c.end]);
+  const out2 = { text: text5, index };
+  cache.set(key2, out2);
+  for (const k of cache.keys()) {
+    if (cache.size <= SEGMENT_TEXTS_KEPT) break;
+    cache.delete(k);
   }
   return out2;
 }
-function rowStateReader(app, settings, model, tables, excludes) {
-  const resolved = /* @__PURE__ */ new Map();
-  return async (path23, given) => {
-    const file = given ?? app.vault.getAbstractFileByPath(path23);
-    if (file == null || !("extension" in file)) return null;
-    let raw;
-    try {
-      raw = await readFrontmatterValue(app, file, NO_KEYS, (ordered) => fmGet(ordered, settings.tableKey));
-    } catch {
-      return null;
-    }
-    const rawKey = typeof raw === "string" ? raw : JSON.stringify(raw ?? null);
-    if (!resolved.has(rawKey)) resolved.set(rawKey, rowTableFull(model, raw));
-    const full = resolved.get(rawKey);
-    if (full == null || !tables.has(full)) return null;
-    if (excludes.get(full).some((dir) => path23.startsWith(`${dir}/`))) return null;
-    return { table: full, state: await readHashed(app, file) };
-  };
-}
-function forgetCurrentStates(app) {
-  LIVE.delete(app);
-}
-async function currentStates(app, settings, model, touched, only) {
-  const idx = vaultIndex(app, settings);
-  if (!idx || idx.hasFailures) return readCurrentStates(app, settings, model, touched, only);
-  let live = LIVE.get(app);
-  const kept2 = JSON.stringify([...only].sort());
-  const changed2 = live && live.model === model && live.only === kept2 && live.epoch === idx.epoch && live.tableKey === settings.tableKey && live.databaseFolder === settings.databaseFolder ? idx.changedSince(live.cursor, idx.epoch) : null;
-  const cursor = idx.cursor;
-  if (!live || !changed2) {
-    const tables = await readCurrentStates(app, settings, model, touched, only);
-    const excludes = /* @__PURE__ */ new Map();
-    const tableOf = /* @__PURE__ */ new Map();
-    for (const [full, t] of tables) {
-      excludes.set(full, catalogEntryOptions(full, t.entry, settings));
-      for (const p of t.files.keys()) tableOf.set(p, full);
-    }
-    const touchedOnly = new Set([...tableOf.keys()].filter((p) => !(idx.note(p)?.tableValue != null)));
-    live = { epoch: idx.epoch, cursor, model, only: kept2, tableKey: settings.tableKey, databaseFolder: settings.databaseFolder, tables, excludes, tableOf, touchedOnly };
-    LIVE.set(app, live);
-  } else {
-    const named = new Set(touched.filter((p) => p.endsWith(".md")));
-    const reader = rowStateReader(app, settings, model, live.tables, live.excludes);
-    for (const path23 of /* @__PURE__ */ new Set([...changed2, ...named, ...live.touchedOnly])) {
-      const was = live.tableOf.get(path23);
-      if (was !== void 0) live.tables.get(was).files.delete(path23);
-      live.tableOf.delete(path23);
-      live.touchedOnly.delete(path23);
-      const n = idx.note(path23);
-      const listed = n !== void 0 && n.tableValue != null;
-      if (!listed && !named.has(path23)) continue;
-      const r = await reader(path23, n?.file ?? null);
-      if (!r) continue;
-      live.tables.get(r.table).files.set(path23, r.state);
-      live.tableOf.set(path23, r.table);
-      if (!listed) live.touchedOnly.add(path23);
+async function buildToc(app, dir) {
+  const gen = storeGeneration(app, dir);
+  const stat = await storeStat(app, dir);
+  const toc = { dir, versions: [], files: /* @__PURE__ */ new Map(), segments: [], checkpoints: [], torn: null, gen, mtime: stat ? stat.mtime : null };
+  for (const f of (await storeList(app, dir)).files) {
+    let m;
+    if (m = COMMIT_RE.exec(f)) toc.files.set(Number(m[1]), f);
+    else if (m = CHECKPOINT_RE.exec(f)) toc.checkpoints.push({ version: Number(m[1]), kind: 1, path: f });
+    else if (m = MANIFEST_RE.exec(f)) toc.checkpoints.push({ version: Number(m[1]), kind: 2, path: f });
+    else if (m = SEGMENT_RE.exec(f)) toc.segments.push({ path: f, first: Number(m[1]), last: m[2] !== void 0 ? Number(m[2]) : Number(m[1]) - 1, sealed: m[2] !== void 0 });
+  }
+  toc.segments.sort((a, b) => a.first - b.first);
+  toc.checkpoints.sort((a, b) => a.version - b.version || b.kind - a.kind);
+  for (const seg of toc.segments) {
+    if (seg.sealed) continue;
+    const text5 = await storeReadFile(app, seg.path);
+    const { commits, validEnd } = parseSegment(text5);
+    seg.last = commits.length > 0 ? commits[commits.length - 1].version : seg.first - 1;
+    seg.chars = text5.length;
+    if (validEnd < text5.length) seg.tornAt = validEnd;
+    const st = await storeStat(app, seg.path);
+    if (st) seg.bytes = st.size;
+  }
+  const versions = new Set(toc.files.keys());
+  for (const seg of toc.segments) for (let v = seg.first; v <= seg.last; v++) versions.add(v);
+  toc.versions = [...versions].sort((a, b) => a - b);
+  const newest = latestOf(toc);
+  const file = toc.files.get(newest);
+  if (file !== void 0 && !inSegment(toc, newest)) {
+    const text5 = await storeRead(app, file);
+    if (text5 === null || text5.trim() === "" || !wholeVersion(text5)) {
+      toc.torn = file;
+      toc.files.delete(newest);
+      toc.versions.pop();
     }
-    live.cursor = cursor;
   }
-  return live.tables;
+  return toc;
 }
-async function verifyCurrentStates(app, settings, repair = false) {
-  const ms = await loadMetastore(app, settings);
-  const live = LIVE.get(app);
-  if (!ms || !live) return [];
-  const only = new Set(JSON.parse(live.only));
-  const kept2 = await currentStates(app, settings, ms.model, [], only);
-  const now = await readCurrentStates(app, settings, ms.model, [], only);
-  const out2 = [];
-  for (const [full, t] of now) {
-    const a = kept2.get(full).files;
-    const b = t.files;
-    for (const p of /* @__PURE__ */ new Set([...a.keys(), ...b.keys()])) if (a.get(p)?.hash !== b.get(p)?.hash) out2.push(`${full}: ${p}`);
+function wholeVersion(text5) {
+  try {
+    const lines = text5.split("\n").filter((l) => l.trim() !== "");
+    if (lines.length === 0 || !JSON.parse(lines[0]).commitInfo) return false;
+    for (const l of lines.slice(1)) JSON.parse(l);
+    return true;
+  } catch {
+    return false;
   }
-  if (out2.length > 0 && repair) forgetCurrentStates(app);
-  return out2.sort();
-}
-function checkpointDue(state, format) {
-  const since = state.sinceCheckpoint;
-  if (since.bytes >= Math.max(CHECKPOINT_POLICY.bytesFactor * state.bytes, CHECKPOINT_POLICY.minBytes)) return true;
-  if (format === "segments") return false;
-  return since.versions >= Math.max(CHECKPOINT_POLICY.maxVersions, Math.ceil(state.bytes / CHECKPOINT_POLICY.versionBytes));
-}
-async function checkpointRows(app, settings, state) {
-  const texts = await loggedTexts(app, settings, state, state.files.keys());
-  if (texts.size !== state.files.size) return null;
-  return [...state.files].sort(([a], [b]) => a < b ? -1 : 1).map(([path23, f]) => ({ path: path23, hash: f.hash, content: texts.get(path23) }));
-}
-async function writeDueCheckpoint(app, settings, full) {
-  const state = LAST.get(app)?.get(full);
-  if (!state || !checkpointDue(state, formatOf(settings))) return false;
-  if (!await stillLatest(app, settings, state)) return false;
-  const rows = await checkpointRows(app, settings, state);
-  if (!rows) return false;
-  await writeManifestCheckpoint(app, transactionLogDir(settings, full), { version: state.version, timestamp: state.timestamp, entry: state.entry, ...state.movesApplied ? { moves: state.movesApplied } : {} }, rows);
-  state.sinceCheckpoint = { versions: 0, bytes: 0 };
-  return true;
-}
-function formatOf(settings) {
-  return settings.transactionLogFormat === "files" ? "files" : "segments";
-}
-function setCheckpointRunner(app, run2) {
-  if (run2) CHECKPOINT_RUNNERS.set(app, run2);
-  else CHECKPOINT_RUNNERS.delete(app);
 }
-async function writeDueCheckpoints(app, stopped = () => false) {
-  let n = 0;
-  for (; ; ) {
-    const due = DUE.get(app);
-    const next = due ? [...due][0] : void 0;
-    if (!next || stopped()) break;
-    const [full, settings] = next;
-    due.delete(full);
-    if (await withLogLock(app, () => writeDueCheckpoint(app, settings, full))) n++;
+function inSegment(toc, v) {
+  for (let i = toc.segments.length - 1; i >= 0; i--) {
+    const s = toc.segments[i];
+    if (v >= s.first && v <= s.last) return s;
   }
-  return n;
-}
-async function wholeCheckpoint(app, dir, v) {
-  return parseCheckpoint(await storeRead(app, checkpointPath(dir, v)) ?? "")?.version === v;
+  return void 0;
 }
-async function writeCheckpoint(app, dir, state, format) {
-  const files = [...state.files.entries()].sort(([a], [b]) => a.localeCompare(b));
-  if (format === "files") {
-    const cp = {
-      version: state.version,
-      timestamp: state.timestamp,
-      entry: state.entry,
-      files: files.map(([path23, f]) => ({ path: path23, hash: f.hash, content: f.content })),
-      ...state.movesApplied ? { moves: state.movesApplied } : {}
-    };
-    const text5 = JSON.stringify(cp);
-    if (text5.length <= LEGACY_CHECKPOINT.maxChars) {
-      const path23 = checkpointPath(dir, state.version);
-      if (!await wholeCheckpoint(app, dir, state.version)) await storeWrite(app, path23, text5);
-      return;
-    }
+async function logToc(app, dir) {
+  const tocs = tocsOf(app);
+  const kept2 = tocs.get(dir);
+  if (kept2 && kept2.gen === storeGeneration(app, dir)) {
+    const stat = await storeStat(app, dir);
+    if (stat !== void 0 ? (stat ? stat.mtime : null) === kept2.mtime : await stillNewest(app, kept2)) return kept2;
   }
-  await writeManifestCheckpoint(app, dir, { version: state.version, timestamp: state.timestamp, entry: state.entry, ...state.movesApplied ? { moves: state.movesApplied } : {} }, files.map(([path23, f]) => ({ path: path23, hash: f.hash, content: f.content })));
+  const toc = await buildToc(app, dir);
+  tocs.set(dir, toc);
+  return toc;
 }
-function forgetLoggedStates(app) {
-  LAST.delete(app);
+async function stillNewest(app, toc) {
+  const latest = latestOf(toc);
+  const where = latest < 0 ? null : inSegment(toc, latest)?.path ?? toc.files.get(latest);
+  if (where !== null && !await storeExists(app, where)) return false;
+  const next = commitPath(toc.dir, latest + 1);
+  if (next !== toc.torn && await storeExists(app, next)) return false;
+  return !await storeExists(app, segmentPath(toc.dir, latest + 1));
 }
-async function knownState(app, settings, full) {
-  return LAST.get(app)?.get(full) ?? readLastState(app, settings, full);
+async function settled(app, toc) {
+  toc.gen = storeGeneration(app, toc.dir);
+  const stat = await storeStat(app, toc.dir);
+  toc.mtime = stat ? stat.mtime : null;
 }
-async function readLastState(app, settings, full) {
-  let byTable = LAST.get(app);
-  if (!byTable) LAST.set(app, byTable = /* @__PURE__ */ new Map());
-  const state = await replayLogged(app, settings, full);
-  byTable.set(full, state);
-  return state;
+async function versionText(app, toc, v) {
+  const segments = segmentsWith(toc, v);
+  for (const seg of segments) {
+    const s = await segmentText(app, seg);
+    const at = s.index.get(v);
+    if (at) return s.text.slice(at[0], at[1]);
+  }
+  const file = toc.files.get(v);
+  if (file !== void 0) return storeReadFile(app, file);
+  if (segments.length === 0) throw new HistoryError(`${toc.dir} has no version ${v}`);
+  throw new HistoryError(
+    `${segments[0].path} does not hold version ${v} whole`,
+    guide(`A crash lost version ${v}: no file of the log holds it whole. Restore the store from its backup (datanotes store restore --from <backup url> --database <folder> --force), then run the command again.`, "restoreStore")
+  );
 }
-async function stillLatest(app, settings, state) {
-  return latestOf(await tocOf(app, settings, state.full)) === state.version;
+async function wholeVersions(app, seg) {
+  return new Set((await segmentText(app, seg)).index.keys());
 }
-async function latestVersion(app, settings, full) {
-  const latest = latestOf(await tocOf(app, settings, full));
-  return latest >= 0 ? latest : null;
+function segmentsWith(toc, v) {
+  return toc.segments.filter((s) => v >= s.first && v <= s.last).reverse();
 }
-async function warmLoggedStates(app, settings, stopped = () => false) {
-  let n = 0;
-  for (const full of await loggedTables(app, settings)) {
-    if (stopped()) break;
-    await withLogLock(app, async () => {
-      if (LAST.get(app)?.has(full)) return;
-      await readLastState(app, settings, full);
-      n++;
-    });
+async function versionTexts(app, toc, versions) {
+  const out2 = new Array(versions.length);
+  const files = [];
+  for (let i = 0; i < versions.length; i++) {
+    const v = versions[i];
+    if (inSegment(toc, v)) out2[i] = await versionText(app, toc, v);
+    else files.push(i);
   }
-  return n;
+  for (let i = 0; i < files.length; i += READ_AHEAD) {
+    const chunk = files.slice(i, i + READ_AHEAD);
+    const texts = await Promise.all(chunk.map((j) => versionText(app, toc, versions[j])));
+    texts.forEach((t, k) => out2[chunk[k]] = t);
+  }
+  return out2;
 }
-async function changesSince(app, prev, cur) {
-  const entry = cur?.entry ?? null;
-  let files = cur?.files ?? /* @__PURE__ */ new Map();
-  const remove3 = [];
-  const add = [];
-  if (cur) {
-    for (const [path23, f] of prev.files) {
-      if (files.has(path23) || !await unreadableNow(app, path23)) continue;
-      if (files === cur.files) files = new Map(files);
-      files.set(path23, f);
-    }
+async function setAside(app, path23) {
+  const to = `${path23}.torn-${Date.now()}`;
+  await storeRename(app, path23, to);
+  return to;
+}
+async function appendVersion(app, dir, v, text5, format) {
+  const toc = await logToc(app, dir);
+  if (latestOf(toc) !== v - 1) {
+    const file = toc.files.get(v);
+    throw new HistoryError(file !== void 0 ? `log file exists: ${file}` : `log moved on: ${dir} is at version ${latestOf(toc)}, not ${v - 1}`);
   }
-  for (const [path23, f] of prev.files) {
-    const now = files.get(path23);
-    if (!now || now.hash !== f.hash) remove3.push({ path: path23, hash: f.hash });
+  const repaired = [];
+  if (toc.torn) {
+    repaired.push(`${toc.torn} set aside as ${await setAside(app, toc.torn)}`);
+    toc.torn = null;
   }
-  for (const [path23, f] of files) {
-    const was = prev.files.get(path23);
-    if (!was || was.hash !== f.hash) add.push({ path: path23, hash: f.hash, size: f.content.length, content: f.content });
+  for (const seg of toc.segments) {
+    if (seg.sealed || seg.tornAt === void 0 && seg.chars > 0) continue;
+    const whole = (await storeReadFile(app, seg.path)).slice(0, seg.tornAt ?? 0);
+    repaired.push(`${seg.path}: ${seg.chars - whole.length} characters of a torn version cut${whole === "" ? ", the file removed" : ""}`);
+    if (whole === "") await storeRemove(app, seg.path);
+    else await storeWrite(app, seg.path, whole);
+    seg.chars = whole.length;
+    delete seg.tornAt;
+    const st = await storeStat(app, seg.path);
+    if (st) seg.bytes = st.size;
   }
-  add.sort((a, b) => a.path < b.path ? -1 : 1);
-  const metadataChanged = prev.version < 0 || entryHash(prev.entry) !== entryHash(entry);
-  return { entry, add, remove: remove3, metadataChanged };
+  toc.segments = toc.segments.filter((s) => s.sealed || s.chars > 0);
+  if (format === "files") {
+    const path23 = commitPath(dir, v);
+    if (await storeExists(app, path23)) throw new HistoryError(`log file exists: ${path23}`);
+    await storeWrite(app, path23, text5);
+    toc.files.set(v, path23);
+  } else await appendToSegment(app, toc, v, text5);
+  toc.versions.push(v);
+  await settled(app, toc);
+  return repaired;
 }
-function historyEnabled(model, entry) {
-  const own2 = entry.options?.history;
-  return typeof own2 === "boolean" ? own2 : model.config.history === true;
+async function appendToSegment(app, toc, v, text5) {
+  const chunk = framed(v, text5);
+  const open2 = toc.segments.filter((s) => !s.sealed);
+  const active = open2[open2.length - 1];
+  const fits = active && active.last === v - 1 && active.chars < SEGMENT_POLICY.maxBytes && active.last - active.first + 1 < SEGMENT_POLICY.maxVersions;
+  for (const seg of open2) if (!(fits && seg === active)) await seal(app, toc, seg);
+  if (fits) {
+    const st2 = await storeStat(app, active.path);
+    if (st2 && active.bytes !== void 0 && st2.size !== active.bytes) throw new HistoryError(`log moved on: ${active.path} changed`);
+    await storeAppend(app, active.path, chunk);
+    active.last = v;
+    active.chars += chunk.length;
+    const after = await storeStat(app, active.path);
+    if (after) active.bytes = after.size;
+    return;
+  }
+  const path23 = segmentPath(toc.dir, v);
+  if (await storeExists(app, path23)) throw new HistoryError(`log file exists: ${path23}`);
+  await storeWrite(app, path23, chunk);
+  const st = await storeStat(app, path23);
+  toc.segments.push({ path: path23, first: v, last: v, sealed: false, chars: chunk.length, ...st ? { bytes: st.size } : {} });
 }
-async function syncTransactionLogs(app, settings, options) {
-  const ms = await loadMetastore(app, settings);
-  if (!ms) return [];
-  const tables = catalogTables(ms.model);
-  const enabled = new Set(tables.filter(({ entry }) => historyEnabled(ms.model, entry)).map(({ ref: ref2 }) => ref2.full));
-  const defined = new Set(tables.map(({ ref: ref2 }) => ref2.full));
-  const orphans = await loggedTables(app, settings, (full) => !defined.has(full));
-  if (enabled.size === 0 && orphans.length === 0) return [];
-  const current2 = await currentStates(app, settings, ms.model, options.touched ?? [], enabled);
-  const names2 = /* @__PURE__ */ new Set([...enabled, ...orphans]);
+async function seal(app, toc, seg) {
+  const to = segmentPath(toc.dir, seg.first, seg.last);
+  await storeRename(app, seg.path, to);
+  seg.path = to;
+  seg.sealed = true;
+  delete seg.bytes;
+  delete seg.chars;
+}
+async function writeSealedSegments(app, dir, versions) {
   const out2 = [];
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const format = formatOf(settings);
-  const planned = [];
-  for (const full of [...names2].sort()) {
-    if (options.tables && !options.tables.includes(full)) continue;
-    let prev = await knownState(app, settings, full);
-    const cur = current2.get(full);
-    if (prev.version < 0 && !cur) continue;
-    const due = (c) => c.metadataChanged || c.add.length > 0 || c.remove.length > 0 || options.always === true && cur !== void 0;
-    let changes = await changesSince(app, prev, cur);
-    if (!due(changes)) continue;
-    if (!await stillLatest(app, settings, prev)) {
-      prev = await readLastState(app, settings, full);
-      changes = await changesSince(app, prev, cur);
-      if (!due(changes)) continue;
-    }
-    const { entry, add, remove: remove3, metadataChanged } = changes;
-    const operation = prev.version < 0 && options.operation === EXTERNAL_EDIT ? "CREATE TABLE" : options.operation;
-    planned.push({ table: full, add, remove: remove3, metadataChanged, entry, prev, operation });
-  }
-  const external = planned.filter((p) => p.operation === EXTERNAL_EDIT);
-  let counts;
-  if (options.check && external.length > 0) {
-    const added = new Set(external.flatMap((p) => p.add.map((a) => a.path)));
-    const changes = [];
-    for (const p of external) {
-      const wanted = /* @__PURE__ */ new Set([...p.remove.map((r) => r.path), ...[...added].filter((x) => p.prev.files.has(x))]);
-      const texts = await loggedTexts(app, settings, p.prev, wanted);
-      const before = /* @__PURE__ */ new Map();
-      for (const x of wanted) if (texts.has(x)) before.set(x, { hash: p.prev.files.get(x).hash, content: texts.get(x) });
-      const { prev: _prev, operation: _op, ...change } = p;
-      changes.push({ ...change, before });
-    }
-    counts = await options.check(changes);
-  }
-  for (const { table: full, add, remove: remove3, metadataChanged, entry, prev, operation } of planned) {
-    const version2 = prev.version + 1;
-    const violations = operation === EXTERNAL_EDIT ? counts?.get(full) : void 0;
-    const commit = {
-      commitInfo: {
-        version: version2,
-        timestamp: now.toISOString(),
-        operation,
-        ...options.parameters && Object.keys(options.parameters).length > 0 ? { operationParameters: options.parameters } : {},
-        ...options.migrationId ? { migrationId: options.migrationId } : {},
-        operationMetrics: { numAddedFiles: add.length, numRemovedFiles: remove3.length, metadataChanged, ...violations !== void 0 ? { violations } : {} },
-        engineInfo: "datanotes",
-        ...options.actor ? { userName: actorName(options.actor), actor: options.actor } : {}
-      },
-      ...metadataChanged ? { metaData: { entry } } : {},
-      add: [...add].sort((a, b) => a.path.localeCompare(b.path)),
-      remove: [...remove3].sort((a, b) => a.path.localeCompare(b.path))
-    };
-    const text5 = serializeCommit(commit);
-    const repaired = await appendVersion(app, transactionLogDir(settings, full), version2, text5, format);
-    for (const r of repaired) telemetry().log("WARN", "datanotes transaction log repaired a version torn by a crash", { table: full, repair: r });
-    applyLogged(prev, commit);
-    prev.sinceCheckpoint = { versions: prev.sinceCheckpoint.versions + 1, bytes: prev.sinceCheckpoint.bytes + text5.length };
-    if (version2 > 0 && checkpointDue(prev, format)) {
-      let due = DUE.get(app);
-      if (!due) DUE.set(app, due = /* @__PURE__ */ new Map());
-      due.set(full, settings);
-    }
-    out2.push({ table: full, version: version2, operation: commit.commitInfo.operation });
-  }
-  if (DUE.get(app)?.size) {
-    const runner = CHECKPOINT_RUNNERS.get(app);
-    if (runner) runner();
-    else {
-      const due = DUE.get(app);
-      for (const [full, s] of [...due]) {
-        due.delete(full);
-        await writeDueCheckpoint(app, s, full);
-      }
-    }
+  let run2 = [];
+  let chars = 0;
+  const flush2 = async () => {
+    if (run2.length === 0) return;
+    const path23 = segmentPath(dir, run2[0].version, run2[run2.length - 1].version);
+    if (await holdsWhole(app, path23, run2.map((r) => r.version))) storeSyncNext(app, path23);
+    else await storeWrite(app, path23, run2.map((r) => framed(r.version, r.text)).join(""));
+    out2.push(path23);
+    run2 = [];
+    chars = 0;
+  };
+  for (const r of versions) {
+    const last = run2[run2.length - 1];
+    if (last && (r.version !== last.version + 1 || chars >= SEGMENT_POLICY.maxBytes || run2.length >= SEGMENT_POLICY.maxVersions)) await flush2();
+    run2.push(r);
+    chars += r.text.length;
   }
+  await flush2();
   return out2;
 }
-function withLogLock(app, fn) {
-  let activity = ACTIVITY.get(app);
-  if (!activity) ACTIVITY.set(app, activity = { pending: 0, lastEnd: 0 });
-  const a = activity;
-  a.pending++;
-  const prev = LOCKS.get(app) ?? Promise.resolve();
-  const wait = startSpan("engine.lock.acquire", { attributes: { "datanotes.lock.queued": a.pending - 1 } });
-  const held = () => {
-    wait.end();
-    return phase("engine.lock.hold", async () => {
-      try {
-        return await fn();
-      } finally {
-        await storeFlush(app).catch((e) => telemetry().log("WARN", "datanotes could not sync the store's files", { error: messageOf(e) }));
-      }
-    });
-  };
-  const run2 = prev.then(held, held);
-  const settled2 = run2.then(
-    () => void 0,
-    () => void 0
-  );
-  LOCKS.set(app, settled2);
-  void settled2.then(() => {
-    a.pending--;
-    a.lastEnd = Date.now();
-  });
-  return run2;
+async function holdsWhole(app, path23, versions) {
+  const text5 = await storeRead(app, path23);
+  if (text5 === null) return false;
+  const { commits, validEnd } = parseSegment(text5);
+  return validEnd === text5.length && commits.length === versions.length && commits.every((c, i) => c.version === versions[i]);
 }
-function logLockActivity(app) {
-  const a = ACTIVITY.get(app);
-  return { busy: (a?.pending ?? 0) > 0, lastEnd: a?.lastEnd ?? 0 };
+async function gzip(text5) {
+  const stream = new Blob([text5]).stream().pipeThrough(new CompressionStream("gzip"));
+  return new Response(stream).arrayBuffer();
 }
-async function checkpointFiles(app, dir, toc) {
-  const out2 = /* @__PURE__ */ new Map();
-  for (const cp of toc.checkpoints) {
-    const files = cp.kind === 1 ? [cp.path] : manifestFiles(dir, cp.path, (await readManifest(app, dir, cp.path))?.head ?? null);
-    out2.set(cp.version, [...out2.get(cp.version) ?? [], ...files]);
-  }
-  return out2;
+async function gunzip(data) {
+  const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return new Response(stream).text();
 }
-async function vacuum(app, settings, full, retainFrom, dryRun) {
-  const dir = transactionLogDir(settings, full);
-  const toc = await logToc(app, dir);
-  const versions = toc.versions;
-  if (versions.length === 0) throw new HistoryError(`${full} has no history`);
-  const latest = versions[versions.length - 1];
-  const keep = retainFrom ?? latest;
-  if (!versions.includes(keep)) throw new HistoryError(`${full} has no version ${keep} (available: ${versions[0]}..${latest})`);
-  const doomed = [...toc.files].filter(([v]) => v < keep).map(([, p]) => p);
-  const straddling = toc.segments.filter((s) => s.first < keep && s.last >= keep);
-  for (const s of toc.segments) if (s.last < keep || straddling.includes(s)) doomed.push(s.path);
-  for (const [v, files] of await checkpointFiles(app, dir, toc)) if (v < keep) doomed.push(...files);
-  doomed.sort();
-  if (!dryRun) {
-    await writeCheckpoint(app, dir, await tableStateAt(app, settings, full, { version: keep }), formatOf(settings));
-    for (const s of straddling) {
-      const kept2 = [];
-      for (let v = keep; v <= s.last; v++) kept2.push({ version: v, text: await versionText(app, toc, v) });
-      await writeSealedSegments(app, dir, kept2);
+function chunked(lines) {
+  const out2 = [];
+  let cur = [];
+  let chars = 0;
+  for (const l of lines) {
+    if (cur.length > 0 && chars + l.length + 1 > CHECKPOINT_PART.maxChars) {
+      out2.push(cur);
+      cur = [];
+      chars = 0;
     }
-    await storeFlush(app);
-    for (const p of doomed) await storeRemove(app, p);
-    forgetLoggedStates(app);
+    cur.push(l);
+    chars += l.length + 1;
   }
-  return { table: full, retained_from: keep, deleted: doomed, dry_run: dryRun };
+  if (cur.length > 0 || out2.length === 0) out2.push(cur);
+  return out2;
 }
-async function convertLog(app, settings, full, to) {
-  const dir = transactionLogDir(settings, full);
-  const toc = await logToc(app, dir);
-  const result = { table: full, versions: toc.versions.length, written: 0, removed: 0 };
-  if (to === "segments") {
-    for (const s of toc.segments) {
-      if (!s.sealed || (await wholeVersions(app, s)).size === s.last - s.first + 1) {
-        storeSyncNext(app, s.path);
-        continue;
-      }
-      const range = Array.from({ length: s.last - s.first + 1 }, (_, i) => s.first + i);
-      const texts2 = await versionTexts(app, toc, range);
-      await storeWrite(app, s.path, range.map((v, i) => framed(v, texts2[i])).join(""));
-      result.written++;
-    }
-    const loose = toc.versions.filter((v) => toc.files.has(v) && !toc.segments.some((s) => v >= s.first && v <= s.last));
-    const texts = await versionTexts(app, toc, loose);
-    const written2 = await writeSealedSegments(app, dir, loose.map((version2, i) => ({ version: version2, text: texts[i] })));
-    result.written += written2.length;
-    await storeFlush(app);
-    for (const v of toc.files.keys()) {
-      await storeRemove(app, toc.files.get(v));
-      result.removed++;
-    }
-  } else {
-    for (const seg of toc.segments) {
-      for (let v = seg.first; v <= seg.last; v++) {
-        const path23 = `${dir}/${pad2(v)}.json`;
-        const file = toc.files.get(v);
-        if (file === void 0) {
-          await storeWrite(app, path23, await versionText(app, toc, v));
-          result.written++;
-        } else storeSyncNext(app, file);
-      }
-    }
-    const oldest = toc.versions[0];
-    if (oldest !== void 0 && oldest > 0) {
-      if (await wholeCheckpoint(app, dir, oldest)) storeSyncNext(app, checkpointPath(dir, oldest));
-      else {
-        await writeCheckpoint(app, dir, await replayState(app, settings, full, { version: oldest }), "files");
-        result.written++;
-      }
+async function writeManifestCheckpoint(app, dir, head, rows) {
+  const main6 = manifestPath(dir, head.version);
+  if (await wholeManifest(app, dir, main6)) return [];
+  const binary = storeHoldsBinary(app);
+  const written2 = [];
+  const textLines = rows.map((r) => JSON.stringify([r.path, r.content]));
+  const partOf = [];
+  const parts = chunked(textLines);
+  let row = 0;
+  const partNames = [];
+  for (const [i, lines] of parts.entries()) {
+    const name = `${pad2(head.version)}.part-${i}.jsonl${binary ? ".gz" : ""}`;
+    const text5 = lines.length > 0 ? `${lines.join("\n")}
+` : "";
+    if (binary) await storeWriteBinary(app, `${dir}/${name}`, await gzip(text5));
+    else await storeWrite(app, `${dir}/${name}`, text5);
+    written2.push(`${dir}/${name}`);
+    partNames.push(name);
+    for (let k = 0; k < lines.length; k++) partOf[row++] = i;
+  }
+  const entries = rows.map((r, i) => JSON.stringify([r.path, r.hash, r.content.length, partOf[i]]));
+  const pieces = chunked(entries);
+  const more = pieces.slice(1).map((_, i) => `${pad2(head.version)}.manifest-${i + 1}.jsonl`);
+  for (const [i, lines] of pieces.slice(1).entries()) {
+    await storeWrite(app, `${dir}/${more[i]}`, `${lines.join("\n")}
+`);
+    written2.push(`${dir}/${more[i]}`);
+  }
+  const header2 = { format: 2, version: head.version, timestamp: head.timestamp, entry: head.entry, ...head.moves ? { moves: head.moves } : {}, rows: rows.length, parts: partNames, ...more.length > 0 ? { more } : {} };
+  await storeWrite(app, main6, `${JSON.stringify({ checkpoint: header2 })}
+${pieces[0].length > 0 ? `${pieces[0].join("\n")}
+` : ""}`);
+  written2.push(main6);
+  return written2;
+}
+async function readManifest(app, dir, path23) {
+  try {
+    const text5 = await storeRead(app, path23);
+    if (text5 == null) return null;
+    const lines = text5.split("\n").filter((l) => l !== "");
+    const head = JSON.parse(lines[0] ?? "null")?.checkpoint;
+    if (!head || head.format !== 2) return null;
+    const rows = lines.slice(1).map((l) => JSON.parse(l));
+    for (const name of head.more ?? []) {
+      const more = await storeRead(app, `${dir}/${name}`);
+      if (more == null) return null;
+      for (const l of more.split("\n")) if (l !== "") rows.push(JSON.parse(l));
     }
-    await storeFlush(app);
-    for (const seg of toc.segments) {
-      await storeRemove(app, seg.path);
-      result.removed++;
+    if (rows.length !== head.rows) return null;
+    return { head, rows };
+  } catch {
+    return null;
+  }
+}
+async function wholeManifest(app, dir, path23) {
+  const m = await readManifest(app, dir, path23);
+  if (!m) return false;
+  for (const name of m.head.parts) if (!await readPart(app, dir, name)) return false;
+  return true;
+}
+async function readPart(app, dir, name) {
+  try {
+    let text5;
+    if (name.endsWith(".gz")) {
+      const data = await storeReadBinary(app, `${dir}/${name}`);
+      text5 = data ? await gunzip(data) : null;
+    } else text5 = await storeRead(app, `${dir}/${name}`);
+    if (text5 == null) return null;
+    const out2 = /* @__PURE__ */ new Map();
+    for (const l of text5.split("\n")) {
+      if (l === "") continue;
+      const [path23, content] = JSON.parse(l);
+      out2.set(path23, content);
     }
+    return out2;
+  } catch {
+    return null;
   }
-  forgetLoggedStates(app);
-  return result;
 }
-var TRANSACTION_LOG_FOLDER, CHECKPOINT_POLICY, LEGACY_CHECKPOINT, EXTERNAL_EDIT, AbsentTableError, ENTRY_HASHES, NO_KEYS, LIVE, DUE, CHECKPOINT_RUNNERS, LAST, LOCKS, ACTIVITY;
-var init_transaction_log = __esm({
-  "src/core/transaction-log.ts"() {
+function manifestFiles(dir, path23, head) {
+  return [path23, ...(head?.more ?? []).map((n) => `${dir}/${n}`), ...(head?.parts ?? []).map((n) => `${dir}/${n}`)];
+}
+var HistoryError, SEGMENT_POLICY, CHECKPOINT_PART, pad2, commitPath, checkpointPath, manifestPath, segmentPath, COMMIT_RE, CHECKPOINT_RE, MANIFEST_RE, SEGMENT_RE, TOCS, SEGMENT_TEXTS, SEGMENT_TEXTS_KEPT, READ_AHEAD;
+var init_log_files = __esm({
+  "src/core/log-files.ts"() {
     "use strict";
+    init_hints();
     init_file_cache();
-    init_frontmatter();
-    init_metastore();
-    init_actor();
     init_store();
-    init_table_loader();
-    init_types_table();
-    init_database_move();
-    init_db_paths();
-    init_unreadable();
-    init_tracing();
-    init_vault_index();
-    init_telemetry();
-    init_message();
-    init_log_files();
-    TRANSACTION_LOG_FOLDER = "transaction_log";
-    CHECKPOINT_POLICY = { bytesFactor: 2, minBytes: 256 * 1024, maxVersions: 1e3, versionBytes: 16 * 1024 };
-    LEGACY_CHECKPOINT = { maxChars: 32 * 1024 * 1024 };
-    EXTERNAL_EDIT = "EXTERNAL_EDIT";
-    AbsentTableError = class extends HistoryError {
+    HistoryError = class extends GuidedError {
+      constructor() {
+        super(...arguments);
+        this.name = "HistoryError";
+      }
     };
-    ENTRY_HASHES = /* @__PURE__ */ new WeakMap();
-    NO_KEYS = /* @__PURE__ */ new Set();
-    LIVE = /* @__PURE__ */ new WeakMap();
-    DUE = /* @__PURE__ */ new WeakMap();
-    CHECKPOINT_RUNNERS = /* @__PURE__ */ new WeakMap();
-    LAST = /* @__PURE__ */ new WeakMap();
-    LOCKS = /* @__PURE__ */ new WeakMap();
-    ACTIVITY = /* @__PURE__ */ new WeakMap();
+    SEGMENT_POLICY = { maxBytes: 8 * 1024 * 1024, maxVersions: 1e3 };
+    CHECKPOINT_PART = { maxChars: 4 * 1024 * 1024 };
+    pad2 = (v) => String(v).padStart(20, "0");
+    commitPath = (dir, v) => `${dir}/${pad2(v)}.json`;
+    checkpointPath = (dir, v) => `${dir}/${pad2(v)}.checkpoint.json`;
+    manifestPath = (dir, v) => `${dir}/${pad2(v)}.manifest.jsonl`;
+    segmentPath = (dir, first2, last) => `${dir}/${pad2(first2)}${last === void 0 ? "" : `-${pad2(last)}`}.segment.jsonl`;
+    COMMIT_RE = /\/(\d{20})\.json$/;
+    CHECKPOINT_RE = /\/(\d{20})\.checkpoint\.json$/;
+    MANIFEST_RE = /\/(\d{20})\.manifest\.jsonl$/;
+    SEGMENT_RE = /\/(\d{20})(?:-(\d{20}))?\.segment\.jsonl$/;
+    TOCS = /* @__PURE__ */ new WeakMap();
+    SEGMENT_TEXTS = /* @__PURE__ */ new WeakMap();
+    SEGMENT_TEXTS_KEPT = 3;
+    READ_AHEAD = 16;
   }
 });
 
-// src/core/changeset.ts
-function createdHash(text5) {
+// src/core/transaction-log.ts
+async function unreadableNow(app, path23) {
+  const f = app.vault.getAbstractFileByPath(path23);
+  if (f == null || !("extension" in f)) return false;
   try {
-    const { ordered, body } = readOrderedFromMarkdown(text5);
-    return contentHash(JSON.stringify([ordered, body]));
+    return frontmatterError((await readHashed(app, f)).content) !== null;
   } catch {
-    return contentHash(text5);
+    return false;
   }
 }
-function bodyChanges(e) {
-  return e.bodyAfter !== void 0 && e.bodyAfter !== e.bodyBefore;
+function transactionLogRoot(_settings) {
+  return storePath(TRANSACTION_LOG_FOLDER);
 }
-function bodyOf(text5) {
-  const split2 = splitFrontmatter(text5);
-  return split2 ? split2.body : text5;
+function transactionLogDir(settings, full) {
+  return `${transactionLogRoot(settings)}/${full}`;
 }
-function replaceBody(text5, body) {
-  const split2 = splitFrontmatter(text5);
-  if (!split2) return body;
-  return text5.slice(0, text5.length - split2.body.length) + body;
+function entryHash(entry) {
+  if (entry == null) return "";
+  let h = ENTRY_HASHES.get(entry);
+  if (h === void 0) ENTRY_HASHES.set(entry, h = contentHash(JSON.stringify(entry)));
+  return h;
 }
-async function writeBody(app, file, expected, next) {
-  await app.vault.process(file, (text5) => {
-    if (bodyOf(text5) !== expected) throw new Error("note body changed since it was read");
-    return replaceBody(text5, next);
-  });
+async function loggedTables(app, settings, among) {
+  const base = `${transactionLogRoot(settings)}/`;
+  const out2 = [];
+  for (const dir of (await storeList(app, transactionLogRoot(settings))).folders) {
+    const full = dir.slice(base.length);
+    if (among && !among(full)) continue;
+    if ((await storeList(app, dir)).files.some(holdsVersions)) out2.push(full);
+  }
+  return out2.sort();
 }
-function emptyChangeSet(op2, summary, schema) {
-  return {
-    op: op2,
-    summary,
-    ...schema !== void 0 ? { schema } : {},
-    edits: [],
-    creates: [],
-    moves: [],
-    deletes: [],
-    texts: []
-  };
+function tocOf(app, settings, full) {
+  return logToc(app, transactionLogDir(settings, full));
 }
-function same(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
+async function listVersions(app, settings, full) {
+  return [...(await tocOf(app, settings, full)).versions];
 }
-function diffOrdered(before, after) {
-  const b = new Map(before);
-  const a = new Map(after);
-  const d = {
-    set: [],
-    remove: [],
-    beforeValues: {},
-    beforeAbsent: [],
-    afterValues: {},
-    afterAbsent: []
-  };
-  const keys = /* @__PURE__ */ new Set([...b.keys(), ...a.keys()]);
-  for (const k of keys) {
-    const inB = b.has(k);
-    const inA = a.has(k);
-    if (inB && inA && same(b.get(k), a.get(k))) continue;
-    if (inB) d.beforeValues[k] = b.get(k);
-    else d.beforeAbsent.push(k);
-    if (inA) {
-      d.afterValues[k] = a.get(k);
-      d.set.push([k, a.get(k)]);
-    } else {
-      d.afterAbsent.push(k);
-      d.remove.push(k);
-    }
+function parseCommit(text5) {
+  const commit = { commitInfo: void 0, add: [], remove: [] };
+  for (const line of text5.split("\n")) {
+    if (line.trim() === "") continue;
+    const action = JSON.parse(line);
+    if (action.commitInfo) commit.commitInfo = action.commitInfo;
+    else if ("metaData" in action) commit.metaData = action.metaData;
+    else if (action.add) commit.add.push(action.add);
+    else if (action.remove) commit.remove.push(action.remove);
   }
-  return d;
+  if (!commit.commitInfo) throw new HistoryError("log commit without commitInfo");
+  return commit;
 }
-function editIsNoop(e) {
-  const d = diffOrdered(e.before, e.after);
-  const orderChanged = !same(
-    e.before.map(([k]) => k),
-    e.after.map(([k]) => k)
-  );
-  return d.set.length === 0 && d.remove.length === 0 && !orderChanged && !bodyChanges(e);
+function serializeCommit(c) {
+  const lines = [JSON.stringify({ commitInfo: c.commitInfo })];
+  if (c.metaData !== void 0) lines.push(JSON.stringify({ metaData: c.metaData }));
+  for (const r of c.remove) lines.push(JSON.stringify({ remove: r }));
+  for (const a of c.add) lines.push(JSON.stringify({ add: a }));
+  return `${lines.join("\n")}
+`;
 }
-function applyDiff(current2, set, remove3, order) {
-  let out2 = current2;
-  for (const k of remove3) out2 = fmDelete(out2, k);
-  for (const [k, v] of set) out2 = fmSet(out2, k, v);
-  return fmReorder(out2, order);
+async function readCommit(app, settings, full, version2) {
+  const toc = await tocOf(app, settings, full);
+  if (!toc.versions.includes(version2)) throw new HistoryError(`${full} has no version ${version2}`);
+  return movedCommit(parseCommit(await versionText(app, toc, version2)), await databaseMoves(app));
 }
-function fileOrNull(app, path23) {
-  const f = app.vault.getAbstractFileByPath(path23);
-  return f != null && "extension" in f ? f : null;
+function movedCommit(c, moves) {
+  let out2 = c;
+  for (const m of moves) {
+    if (m.at <= c.commitInfo.timestamp) continue;
+    out2 = {
+      ...out2,
+      ...out2.metaData !== void 0 ? { metaData: { entry: moveEntryPaths(out2.metaData.entry, m.from, m.to, m.entries) } } : {},
+      add: out2.add.map((a) => ({ ...a, path: movePath(a.path, m.from, m.to, m.entries), content: moveLinks(a.content, m.from, m.to, m.entries) })),
+      remove: out2.remove.map((r) => ({ ...r, path: movePath(r.path, m.from, m.to, m.entries) }))
+    };
+  }
+  return out2;
 }
-function parentFolder(path23) {
-  const i = path23.lastIndexOf("/");
-  return i < 0 ? "" : path23.slice(0, i);
+function moveState(state, m) {
+  const files = /* @__PURE__ */ new Map();
+  for (const [path23, f] of state.files) {
+    const content = moveLinks(f.content, m.from, m.to, m.entries);
+    files.set(movePath(path23, m.from, m.to, m.entries), content === f.content ? f : { ...f, hash: contentHash(content), content });
+  }
+  state.files = files;
+  state.entry = moveEntryPaths(state.entry, m.from, m.to, m.entries);
 }
-async function ensureFolder(app, folder) {
-  if (folder === "") return;
-  if (app.vault.getAbstractFileByPath(folder) != null) return;
-  await ensureFolder(app, parentFolder(folder));
-  await app.vault.createFolder(folder);
+function emptyState(full) {
+  return { full, version: -1, timestamp: "", entry: null, files: /* @__PURE__ */ new Map() };
 }
-async function readOrderedFor(app, file) {
-  return readOrderedFromMarkdown(await app.vault.read(file)).ordered;
+function applyCommit(state, c) {
+  const files = state.files;
+  const at = c.commitInfo.version;
+  for (const r of c.remove) files.delete(r.path);
+  for (const a of c.add) files.set(a.path, { hash: a.hash, content: a.content, at });
+  return {
+    full: state.full,
+    version: c.commitInfo.version,
+    timestamp: c.commitInfo.timestamp,
+    entry: c.metaData !== void 0 ? c.metaData.entry : state.entry,
+    files
+  };
 }
-async function fileExists(app, path23) {
-  return inStore(path23) ? storeExists(app, path23) : fileOrNull(app, path23) != null;
+function applyLogged(state, c) {
+  const at = c.commitInfo.version;
+  for (const r of c.remove) {
+    const old = state.files.get(r.path);
+    if (old) state.bytes -= old.size;
+    state.files.delete(r.path);
+  }
+  for (const a of c.add) {
+    const old = state.files.get(a.path);
+    if (old) state.bytes -= old.size;
+    const size = a.content.length;
+    state.files.set(a.path, { hash: a.hash, size, at });
+    state.bytes += size;
+  }
+  state.version = at;
+  state.timestamp = c.commitInfo.timestamp;
+  if (c.metaData !== void 0) state.entry = c.metaData.entry;
 }
-async function occupied(app, path23) {
-  return inStore(path23) ? storeExists(app, path23) : app.vault.getAbstractFileByPath(path23) != null;
+function parseCheckpoint(text5) {
+  try {
+    const c = JSON.parse(text5);
+    return c !== null && typeof c === "object" && Number.isInteger(c.version) && Array.isArray(c.files) ? c : null;
+  } catch {
+    return null;
+  }
 }
-async function storeFilesSince(app, moves) {
-  const folders = /* @__PURE__ */ new Map();
-  for (const m of moves) if (inStore(m.from) && inStore(m.to)) folders.set(parentFolder(m.to), parentFolder(m.from));
-  const moved = new Set(moves.map((m) => m.to));
-  const out2 = [];
-  for (const [to, from] of folders) {
-    for (const f of (await storeList(app, to)).files) {
-      if (!moved.has(f)) out2.push({ from: `${from}/${f.slice(to.length + 1)}`, to: f });
-    }
+async function readCheckpoint(app, dir, cp) {
+  if (cp.kind === 1) {
+    const text5 = await storeRead(app, cp.path);
+    if (text5 == null) return null;
+    const c = parseCheckpoint(text5);
+    if (!c) return null;
+    return { version: c.version, timestamp: c.timestamp, entry: c.entry, ...c.moves !== void 0 ? { moves: c.moves } : {}, files: new Map(c.files.map((f) => [f.path, { hash: f.hash, content: f.content, at: c.version, cp: true }])) };
   }
-  return out2;
+  const m = await readManifest(app, dir, cp.path);
+  if (!m) return null;
+  const texts = /* @__PURE__ */ new Map();
+  for (const name of m.head.parts) {
+    const part = await readPart(app, dir, name);
+    if (!part) return null;
+    for (const [p, t] of part) texts.set(p, t);
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const [path23, hash] of m.rows) {
+    const content = texts.get(path23);
+    if (content === void 0) return null;
+    files.set(path23, { hash, content, at: m.head.version, cp: true });
+  }
+  return { version: m.head.version, timestamp: m.head.timestamp, entry: m.head.entry, ...m.head.moves !== void 0 ? { moves: m.head.moves } : {}, files };
 }
-function atOnceFor(count2) {
-  return count2 >= WRITE_CONCURRENCY.from ? WRITE_CONCURRENCY.atOnce : 1;
+async function tableStateAt(app, settings, full, asOf2 = {}) {
+  const known = LAST.get(app)?.get(full);
+  if (known && known.version >= 0 && isLatest(known, asOf2) && await stillLatest(app, settings, known)) {
+    const fromNotes = await stateFromLogged(app, settings, known);
+    if (fromNotes) return fromNotes;
+  }
+  return replayState(app, settings, full, asOf2);
 }
-async function inOrder(items3, pathOf, fn, limit = atOnceFor(items3.length)) {
-  const results = new Array(items3.length);
-  let next = 0;
-  let stop = false;
-  const worker = async () => {
-    while (!stop && next < items3.length) {
-      const i = next++;
-      try {
-        results[i] = { ok: true, written: await fn(items3[i]) };
-      } catch (e) {
-        results[i] = { ok: false, error: messageOf(e) };
-        stop = true;
-      }
+function isLatest(known, asOf2) {
+  if (asOf2.version !== void 0) return asOf2.version === known.version && asOf2.timestamp === void 0;
+  if (asOf2.timestamp === void 0) return true;
+  const at = Date.parse(asOf2.timestamp);
+  return !Number.isNaN(at) && at >= Date.parse(known.timestamp);
+}
+async function replayState(app, settings, full, asOf2 = {}) {
+  const dir = transactionLogDir(settings, full);
+  const toc = await logToc(app, dir);
+  const versions = toc.versions;
+  if (versions.length === 0) {
+    if (asOf2.version !== void 0 || asOf2.timestamp !== void 0) {
+      throw new HistoryError(
+        `${full} has no history: time travel is off for it (turn it on with configure_database(history=true) or alter_table(history=true))`
+      );
     }
-  };
-  await Promise.all(Array.from({ length: Math.min(limit, items3.length) }, worker));
-  const first2 = results.findIndex((r) => r !== void 0 && !r.ok);
-  const kept2 = /* @__PURE__ */ new Set();
-  if (first2 >= 0) {
-    for (let i = results.length - 1; i > first2; i--) {
-      const r = results[i];
-      if (!r?.ok) continue;
-      try {
-        await r.written.undo();
-      } catch {
-        kept2.add(i);
-      }
+    return emptyState(full);
+  }
+  let target = versions[versions.length - 1];
+  if (asOf2.version !== void 0) {
+    if (!versions.includes(asOf2.version)) {
+      throw new HistoryError(`${full} has no version ${asOf2.version} (available: ${versions[0]}..${target})`);
     }
+    target = asOf2.version;
   }
-  const done = [];
-  results.forEach((r, i) => {
-    if (r?.ok && (first2 < 0 || i < first2 || kept2.has(i))) done.push(r.written.value);
-  });
-  const f = first2 >= 0 ? results[first2] : null;
-  return { done, failed: f ? { path: pathOf(items3[first2]), error: f.error } : null };
-}
-async function moveFile(app, from, to) {
-  if (inStore(from)) return storeRename(app, from, to);
-  const f = fileOrNull(app, from);
-  if (!f) throw new Error(`file not found: ${from}`);
-  if (app.vault.getAbstractFileByPath(to) != null) throw new Error(`target exists: ${to}`);
-  await ensureFolder(app, parentFolder(to));
-  await app.fileManager.renameFile(f, to);
-}
-async function applyChangeSetImpl(app, settings, cs, now = /* @__PURE__ */ new Date()) {
-  const rows = [];
-  const creates = [];
-  const moves = [];
-  const references = [];
-  const deleted = [];
-  const failed2 = [];
-  let referencesUpdated = 0;
-  const fail2 = (path23, e) => {
-    failed2.push({ path: path23, error: messageOf(e) });
+  const limitMs = asOf2.timestamp !== void 0 ? Date.parse(asOf2.timestamp) : void 0;
+  if (limitMs !== void 0 && Number.isNaN(limitMs)) throw new HistoryError(`"timestamp" is not a date-time: ${asOf2.timestamp}`);
+  const moves = await databaseMoves(app);
+  let applied = 0;
+  const moveUpTo = (timestamp) => {
+    while (applied < moves.length && (timestamp === null || moves[applied].at <= timestamp)) moveState(state, moves[applied++]);
   };
-  run: {
-    const folders = /* @__PURE__ */ new Map();
-    const folderOnce = (folder) => {
-      if (folder === "") return Promise.resolve();
-      let p = folders.get(folder);
-      if (!p) {
-        p = folderOnce(parentFolder(folder)).then(async () => {
-          if (app.vault.getAbstractFileByPath(folder) == null) await app.vault.createFolder(folder);
-        });
-        folders.set(folder, p);
-      }
-      return p;
-    };
-    const created = await inOrder(cs.creates, (c) => c.path, async (c) => {
-      if (app.vault.getAbstractFileByPath(c.path) != null) throw new Error(`file exists: ${c.path}`);
-      await folderOnce(parentFolder(c.path));
-      const file = await app.vault.create(c.path, c.content);
-      return { value: c.path, undo: () => app.vault.delete(file, true) };
-    });
-    creates.push(...created.done);
-    if (created.failed) {
-      failed2.push(created.failed);
-      break run;
-    }
-    for (const t of cs.texts) {
-      try {
-        const existing = app.vault.getAbstractFileByPath(t.path);
-        if (existing == null) {
-          if (t.before !== "") throw new Error("file not found");
-          if (t.path === metastorePath(settings)) {
-            t.after = withNewDatabaseConfig(t.after);
-            if (settings.databaseId) t.after = withMetastoreId(t.after, settings.databaseId);
-          }
-          await ensureFolder(app, parentFolder(t.path));
-          await app.vault.create(t.path, t.after);
-        } else {
-          await app.vault.process(existing, (current2) => {
-            if (current2 !== t.before) throw new Error("file changed since it was read");
-            return t.after;
-          });
-        }
-        references.push({ path: t.path, before_text: t.before, after_text: t.after });
-      } catch (err) {
-        fail2(t.path, err);
-        break run;
+  let state = emptyState(full);
+  for (const cp of [...toc.checkpoints].reverse()) {
+    if (cp.version > target) continue;
+    const c = await readCheckpoint(app, dir, cp);
+    if (!c) continue;
+    if (limitMs !== void 0 && Date.parse(c.timestamp) > limitMs) continue;
+    state = { full, version: c.version, timestamp: c.timestamp, entry: c.entry, files: c.files };
+    applied = Math.min(c.moves ?? moves.filter((m) => m.at <= c.timestamp).length, moves.length);
+    break;
+  }
+  const since = { versions: 0, bytes: 0 };
+  const replay = versions.filter((v) => v > state.version && v <= target);
+  const texts = await versionTexts(app, toc, replay);
+  for (const text5 of texts) {
+    const c = parseCommit(text5);
+    if (limitMs !== void 0 && Date.parse(c.commitInfo.timestamp) > limitMs) break;
+    moveUpTo(c.commitInfo.timestamp);
+    state = applyCommit(state, c);
+    since.versions++;
+    since.bytes += text5.length;
+  }
+  moveUpTo(null);
+  state.sinceCheckpoint = since;
+  state.movesApplied = applied;
+  if (state.version < 0) throw new AbsentTableError(`${full} did not exist at ${asOf2.timestamp}`);
+  return state;
+}
+async function replayLogged(app, settings, full) {
+  const dir = transactionLogDir(settings, full);
+  const toc = await logToc(app, dir);
+  const empty = { full, version: -1, timestamp: "", entry: null, files: /* @__PURE__ */ new Map(), sinceCheckpoint: { versions: 0, bytes: 0 }, bytes: 0 };
+  if (toc.versions.length === 0) return empty;
+  const moves = await databaseMoves(app);
+  let state = empty;
+  let applied = 0;
+  for (const cp of [...toc.checkpoints].reverse()) {
+    if (cp.kind === 2) {
+      const m = await readManifest(app, dir, cp.path);
+      if (!m || !await partsThere(app, dir, m.head.parts)) continue;
+      const files = /* @__PURE__ */ new Map();
+      let bytes = 0;
+      for (const [path23, hash, size] of m.rows) {
+        files.set(path23, { hash, size, at: m.head.version, cp: true });
+        bytes += size;
       }
-    }
-    const edits = cs.edits.filter((e) => !editIsNoop(e));
-    const distinct = new Set(edits.map((e) => e.path)).size === edits.length;
-    const atOnce = distinct ? atOnceFor(edits.length) : 1;
-    const edited = await inOrder(edits, (e) => e.path, async (e) => {
-      const file = fileOrNull(app, e.path);
-      if (!file) throw new Error("file not found");
-      const was = atOnce > 1 ? (await readHashed(app, file)).content : "";
-      const d = diffOrdered(e.before, e.after);
-      const order = e.after.map(([k]) => k);
-      const fmChanged = d.set.length > 0 || d.remove.length > 0 || !same(e.before.map(([k]) => k), order);
-      if (fmChanged) {
-        await writeFrontmatter(app, file, (fm) => applyDiff(fm, d.set, d.remove, order));
+      state = { full, version: m.head.version, timestamp: m.head.timestamp, entry: m.head.entry, files, sinceCheckpoint: { versions: 0, bytes: 0 }, bytes };
+      applied = Math.min(m.head.moves ?? moves.filter((x) => x.at <= m.head.timestamp).length, moves.length);
+    } else {
+      const c = await readCheckpoint(app, dir, cp);
+      if (!c) continue;
+      const files = /* @__PURE__ */ new Map();
+      let bytes = 0;
+      for (const [path23, f] of c.files) {
+        files.set(path23, { hash: f.hash, size: f.content.length, at: c.version, cp: true });
+        bytes += f.content.length;
       }
-      if (bodyChanges(e)) await writeBody(app, file, e.bodyBefore, e.bodyAfter);
-      const row = {
-        path: e.path,
-        before: d.beforeValues,
-        before_absent: d.beforeAbsent,
-        before_order: e.before.map(([k]) => k),
-        after: d.afterValues,
-        after_absent: d.afterAbsent,
-        ...bodyChanges(e) ? { body_before: e.bodyBefore, body_after: e.bodyAfter } : {}
-      };
-      return { value: row, undo: async () => void await app.vault.process(file, () => was) };
-    }, atOnce);
-    rows.push(...edited.done);
-    if (edited.failed) {
-      failed2.push(edited.failed);
-      break run;
+      state = { full, version: c.version, timestamp: c.timestamp, entry: c.entry, files, sinceCheckpoint: { versions: 0, bytes: 0 }, bytes };
+      applied = Math.min(c.moves ?? moves.filter((x) => x.at <= c.timestamp).length, moves.length);
     }
-    for (const m of cs.moves) {
+    break;
+  }
+  if (applied < moves.length) return loggedOf(await replayState(app, settings, full));
+  const replay = toc.versions.filter((v) => v > state.version);
+  for (const text5 of await versionTexts(app, toc, replay)) {
+    applyLogged(state, parseCommit(text5));
+    state.sinceCheckpoint.versions++;
+    state.sinceCheckpoint.bytes += text5.length;
+  }
+  if (moves.length > 0) state.movesApplied = applied;
+  return state;
+}
+async function partsThere(app, dir, parts) {
+  const { files } = await storeList(app, dir);
+  const there = new Set(files);
+  return parts.every((n) => there.has(`${dir}/${n}`));
+}
+function loggedOf(state) {
+  const files = /* @__PURE__ */ new Map();
+  let bytes = 0;
+  for (const [path23, f] of state.files) {
+    files.set(path23, { hash: f.hash, size: f.content.length, at: f.at, cp: f.cp });
+    bytes += f.content.length;
+  }
+  return {
+    full: state.full,
+    version: state.version,
+    timestamp: state.timestamp,
+    entry: state.entry,
+    files,
+    sinceCheckpoint: state.sinceCheckpoint,
+    movesApplied: state.movesApplied,
+    bytes
+  };
+}
+async function loggedTexts(app, settings, state, paths) {
+  const out2 = /* @__PURE__ */ new Map();
+  const fromCommit = /* @__PURE__ */ new Map();
+  const fromCheckpoint = /* @__PURE__ */ new Map();
+  for (const path23 of paths) {
+    const f = state.files.get(path23);
+    const note = app.vault.getAbstractFileByPath(path23);
+    if (note && "extension" in note) {
       try {
-        await moveFile(app, m.from, m.to);
-        moves.push(m);
-      } catch (err) {
-        fail2(m.from, err);
-        break run;
+        const h = await readHashed(app, note);
+        if (h.hash === f.hash) {
+          out2.set(path23, h.content);
+          continue;
+        }
+      } catch {
       }
     }
-    for (const p of cs.deletes) {
-      const file = fileOrNull(app, p);
-      try {
-        if (!file) throw new Error("file not found");
-        const content = await app.vault.read(file);
-        await trash(app, file);
-        deleted.push({ path: p, content });
-      } catch (err) {
-        fail2(p, err);
-        break run;
-      }
+    const by = f.cp ? fromCheckpoint : fromCommit;
+    const list4 = by.get(f.at);
+    if (list4) list4.push(path23);
+    else by.set(f.at, [path23]);
+  }
+  for (const [v, list4] of fromCommit) {
+    let c;
+    try {
+      c = await readCommit(app, settings, state.full, v);
+    } catch {
+      continue;
     }
+    const want = new Set(list4);
+    for (const a of c.add) if (want.has(a.path) && contentHash(a.content) === state.files.get(a.path).hash) out2.set(a.path, a.content);
   }
-  const createdHashes = [];
-  const movedTo = new Map(moves.map((m) => [m.from, m.to]));
-  for (const p of creates) {
-    const f = fileOrNull(app, movedTo.get(p) ?? p);
-    if (!f) continue;
+  for (const [v, list4] of fromCheckpoint) await textsFromCheckpoint(app, settings, state, v, list4, out2);
+  const missing = [...fromCommit.values(), ...fromCheckpoint.values()].flat().filter((p) => !out2.has(p));
+  if (missing.length > 0) {
     try {
-      createdHashes.push({ path: p, hash: createdHash(await app.vault.read(f)) });
+      const whole = await replayState(app, settings, state.full, { version: state.version });
+      for (const p of missing) {
+        const x = whole.files.get(p);
+        if (x && x.hash === state.files.get(p).hash) out2.set(p, x.content);
+      }
     } catch {
     }
   }
-  const journal = await writeJournal(
-    app,
-    settings,
-    {
-      op: cs.op,
-      ...cs.schema !== void 0 ? { schema: cs.schema } : {},
-      ...currentActor() ? { actor: currentActor() } : {},
-      summary: cs.summary,
-      executed_at: now.toISOString(),
-      rows,
-      creates,
-      ...createdHashes.length > 0 ? { created_hashes: createdHashes } : {},
-      moves,
-      references,
-      deleted,
-      failed: failed2
-    },
-    now
-  );
+  return out2;
+}
+async function textsFromCheckpoint(app, settings, state, version2, paths, out2) {
+  const dir = transactionLogDir(settings, state.full);
+  const toc = await logToc(app, dir);
+  const cp = [...toc.checkpoints].reverse().find((c) => c.version === version2);
+  if (!cp) return;
+  const want = new Set(paths);
+  const keep = (path23, content) => {
+    if (want.has(path23) && contentHash(content) === state.files.get(path23).hash) out2.set(path23, content);
+  };
+  if (cp.kind === 1) {
+    const c = await readCheckpoint(app, dir, cp).catch(() => null);
+    for (const [path23, f] of c?.files ?? []) keep(path23, f.content);
+    return;
+  }
+  const m = await readManifest(app, dir, cp.path);
+  if (!m) return;
+  const partOf = new Map(m.rows.map(([path23, , , part]) => [path23, part]));
+  const parts = new Set(paths.map((p) => partOf.get(p)).filter((x) => x !== void 0));
+  for (const i of parts) {
+    const part = await readPart(app, dir, m.head.parts[i]);
+    for (const [path23, content] of part ?? []) keep(path23, content);
+  }
+}
+async function stateFromLogged(app, settings, state) {
+  const texts = await loggedTexts(app, settings, state, state.files.keys());
+  if (texts.size !== state.files.size) return null;
+  const files = /* @__PURE__ */ new Map();
+  for (const [path23, f] of state.files) files.set(path23, { hash: f.hash, content: texts.get(path23), at: f.at, cp: f.cp });
   return {
-    ok: failed2.length === 0,
-    migrationId: journal.id,
-    journalPath: journal.path,
-    notesChanged: rows.length,
-    filesCreated: creates.length,
-    filesMoved: moves.length,
-    filesDeleted: deleted.length,
-    referencesUpdated,
-    failed: failed2
+    full: state.full,
+    version: state.version,
+    timestamp: state.timestamp,
+    entry: state.entry,
+    files,
+    sinceCheckpoint: { ...state.sinceCheckpoint },
+    movesApplied: state.movesApplied
   };
 }
-async function trash(app, file) {
-  const fm = app.fileManager;
-  if (typeof fm.trashFile === "function") {
-    await fm.trashFile(file);
-  } else {
-    await app.vault.trash(file, true);
+function infoOf(text5) {
+  return JSON.parse(text5.slice(0, text5.indexOf("\n"))).commitInfo;
+}
+async function commitInfos(app, settings, full) {
+  const toc = await tocOf(app, settings, full);
+  return (await versionTexts(app, toc, toc.versions)).map(infoOf);
+}
+async function newestCommitInfos(app, settings, full, limit, from) {
+  const toc = await tocOf(app, settings, full);
+  const out2 = [];
+  for (const v of [...toc.versions].reverse()) {
+    if (out2.length >= limit) break;
+    const info = infoOf(await versionText(app, toc, v));
+    if (from !== void 0 && Date.parse(info.timestamp) < from) break;
+    out2.push(info);
   }
+  return out2;
 }
-async function undoChangeSet(app, entries, summary = `undo ${entries.map((e) => e.migration_id).join(", ")}`) {
-  const state = /* @__PURE__ */ new Map();
-  const texts = /* @__PURE__ */ new Map();
-  const origin = /* @__PURE__ */ new Map();
-  const vaultNote = async (path23) => {
-    const f = fileOrNull(app, path23);
-    if (!f) return null;
-    const text5 = await app.vault.read(f);
-    return { ordered: readOrderedFromMarkdown(text5).ordered, body: bodyOf(text5) };
-  };
-  const read3 = async (path23) => state.has(path23) ? state.get(path23) : vaultNote(path23);
-  for (const entry of entries) {
-    const movedTo = new Map(entry.moves.map((m) => [m.from, m.to]));
-    const currentPath = (p) => movedTo.get(p) ?? p;
-    for (const ref2 of entry.references) {
-      const path23 = currentPath(ref2.path);
-      if (/\.md$/i.test(path23)) {
-        const { ordered } = readOrderedFromMarkdown(ref2.before_text);
-        state.set(path23, { ordered, body: bodyOf(ref2.before_text) });
-      } else {
-        texts.set(path23, { before: texts.get(path23)?.before ?? ref2.after_text, after: ref2.before_text });
-      }
+async function history(app, settings, full, limit = 50) {
+  const versions = (await listVersions(app, settings, full)).reverse().slice(0, Math.max(limit, 0));
+  const out2 = [];
+  for (const v of versions) out2.push((await readCommit(app, settings, full, v)).commitInfo);
+  return out2;
+}
+function catalogEntryOptions(full, entry, settings) {
+  const [c, s, t] = full.split(".");
+  const ref2 = refOf(c, s, t);
+  const options = parseTableOptions(entryToOrdered(ref2, entry, settings).find(([k]) => k === TABLE_KEY)?.[1]);
+  const layout = catalogLayout(normalizeDatabaseFolder(settings.databaseFolder), ref2, options);
+  return [...options.exclude ?? [], layout.archive, transactionLogRoot(settings)];
+}
+async function readCurrentStates(app, settings, model, touched, only) {
+  const out2 = /* @__PURE__ */ new Map();
+  const excludes = /* @__PURE__ */ new Map();
+  for (const { ref: ref2, entry } of catalogTables(model)) {
+    if (only && !only.has(ref2.full)) continue;
+    out2.set(ref2.full, { entry, files: /* @__PURE__ */ new Map() });
+    excludes.set(ref2.full, catalogEntryOptions(ref2.full, entry, settings));
+  }
+  if (out2.size === 0) return out2;
+  const candidates = /* @__PURE__ */ new Map();
+  for (const p of touched) if (p.endsWith(".md")) candidates.set(p, null);
+  for (const f of app.vault.getMarkdownFiles()) {
+    const fm = app.metadataCache.getFileCache(f)?.frontmatter;
+    if (fm && fm[settings.tableKey] != null) candidates.set(f.path, f);
+  }
+  const reader = rowStateReader(app, settings, model, out2, excludes);
+  for (const path23 of [...candidates.keys()].sort()) {
+    const r = await reader(path23, candidates.get(path23) ?? null);
+    if (r) out2.get(r.table).files.set(path23, r.state);
+  }
+  return out2;
+}
+function rowStateReader(app, settings, model, tables, excludes) {
+  const resolved = /* @__PURE__ */ new Map();
+  return async (path23, given) => {
+    const file = given ?? app.vault.getAbstractFileByPath(path23);
+    if (file == null || !("extension" in file)) return null;
+    let raw;
+    try {
+      raw = await readFrontmatterValue(app, file, NO_KEYS, (ordered) => fmGet(ordered, settings.tableKey));
+    } catch {
+      return null;
     }
-    for (const r of entry.rows) {
-      const path23 = currentPath(r.path);
-      const cur = await read3(path23);
-      if (!cur) continue;
-      state.set(path23, { ...cur, ordered: applyDiff(cur.ordered, Object.entries(r.before), r.before_absent, r.before_order) });
+    const rawKey = typeof raw === "string" ? raw : JSON.stringify(raw ?? null);
+    if (!resolved.has(rawKey)) resolved.set(rawKey, rowTableFull(model, raw));
+    const full = resolved.get(rawKey);
+    if (full == null || !tables.has(full)) return null;
+    if (excludes.get(full).some((dir) => path23.startsWith(`${dir}/`))) return null;
+    return { table: full, state: await readHashed(app, file) };
+  };
+}
+function forgetCurrentStates(app) {
+  LIVE.delete(app);
+}
+async function currentStates(app, settings, model, touched, only) {
+  const idx = vaultIndex(app, settings);
+  if (!idx || idx.hasFailures) return readCurrentStates(app, settings, model, touched, only);
+  let live = LIVE.get(app);
+  const kept2 = JSON.stringify([...only].sort());
+  const changed2 = live && live.model === model && live.only === kept2 && live.epoch === idx.epoch && live.tableKey === settings.tableKey && live.databaseFolder === settings.databaseFolder ? idx.changedSince(live.cursor, idx.epoch) : null;
+  const cursor = idx.cursor;
+  if (!live || !changed2) {
+    const tables = await readCurrentStates(app, settings, model, touched, only);
+    const excludes = /* @__PURE__ */ new Map();
+    const tableOf = /* @__PURE__ */ new Map();
+    for (const [full, t] of tables) {
+      excludes.set(full, catalogEntryOptions(full, t.entry, settings));
+      for (const p of t.files.keys()) tableOf.set(p, full);
     }
-    for (const m of [...entry.moves].reverse()) {
-      state.set(m.from, await read3(m.to));
-      state.set(m.to, null);
-      origin.set(m.from, origin.get(m.to) ?? m.to);
-      origin.delete(m.to);
+    const touchedOnly = new Set([...tableOf.keys()].filter((p) => !(idx.note(p)?.tableValue != null)));
+    live = { epoch: idx.epoch, cursor, model, only: kept2, tableKey: settings.tableKey, databaseFolder: settings.databaseFolder, tables, excludes, tableOf, touchedOnly };
+    LIVE.set(app, live);
+  } else {
+    const named = new Set(touched.filter((p) => p.endsWith(".md")));
+    const reader = rowStateReader(app, settings, model, live.tables, live.excludes);
+    for (const path23 of /* @__PURE__ */ new Set([...changed2, ...named, ...live.touchedOnly])) {
+      const was = live.tableOf.get(path23);
+      if (was !== void 0) live.tables.get(was).files.delete(path23);
+      live.tableOf.delete(path23);
+      live.touchedOnly.delete(path23);
+      const n = idx.note(path23);
+      const listed = n !== void 0 && n.tableValue != null;
+      if (!listed && !named.has(path23)) continue;
+      const r = await reader(path23, n?.file ?? null);
+      if (!r) continue;
+      live.tables.get(r.table).files.set(path23, r.state);
+      live.tableOf.set(path23, r.table);
+      if (!listed) live.touchedOnly.add(path23);
     }
-    for (const c of entry.creates) state.set(c, null);
-    for (const d of entry.deleted) state.set(d.path, { ordered: readOrderedFromMarkdown(d.content).ordered, body: bodyOf(d.content) });
+    live.cursor = cursor;
   }
-  const cs = emptyChangeSet("undo_migration", summary);
-  const moved = /* @__PURE__ */ new Set();
-  for (const [to, from] of origin) {
-    const final = state.get(to);
-    if (to === from || !final || !fileOrNull(app, from)) continue;
-    moved.add(to).add(from);
-    cs.moves.push({ from, to });
-    cs.edits.push({ path: from, before: (await vaultNote(from)).ordered, after: final.ordered });
+  return live.tables;
+}
+async function verifyCurrentStates(app, settings, repair = false) {
+  const ms = await loadMetastore(app, settings);
+  const live = LIVE.get(app);
+  if (!ms || !live) return [];
+  const only = new Set(JSON.parse(live.only));
+  const kept2 = await currentStates(app, settings, ms.model, [], only);
+  const now = await readCurrentStates(app, settings, ms.model, [], only);
+  const out2 = [];
+  for (const [full, t] of now) {
+    const a = kept2.get(full).files;
+    const b = t.files;
+    for (const p of /* @__PURE__ */ new Set([...a.keys(), ...b.keys()])) if (a.get(p)?.hash !== b.get(p)?.hash) out2.push(`${full}: ${p}`);
   }
-  for (const [path23, final] of state) {
-    if (moved.has(path23)) continue;
-    const now = fileOrNull(app, path23) ? await vaultNote(path23) : null;
-    if (now && final) cs.edits.push({ path: path23, before: now.ordered, after: final.ordered });
-    else if (now) cs.deletes.push(path23);
-    else if (final) cs.creates.push({ path: path23, content: buildMarkdownWithFrontmatter(final.ordered, final.body) });
+  if (out2.length > 0 && repair) forgetCurrentStates(app);
+  return out2.sort();
+}
+function checkpointDue(state, format) {
+  const since = state.sinceCheckpoint;
+  if (since.bytes >= Math.max(CHECKPOINT_POLICY.bytesFactor * state.bytes, CHECKPOINT_POLICY.minBytes)) return true;
+  if (format === "segments") return false;
+  return since.versions >= Math.max(CHECKPOINT_POLICY.maxVersions, Math.ceil(state.bytes / CHECKPOINT_POLICY.versionBytes));
+}
+async function checkpointRows(app, settings, state) {
+  const texts = await loggedTexts(app, settings, state, state.files.keys());
+  if (texts.size !== state.files.size) return null;
+  return [...state.files].sort(([a], [b]) => a < b ? -1 : 1).map(([path23, f]) => ({ path: path23, hash: f.hash, content: texts.get(path23) }));
+}
+async function writeDueCheckpoint(app, settings, full) {
+  const state = LAST.get(app)?.get(full);
+  if (!state || !checkpointDue(state, formatOf(settings))) return false;
+  if (!await stillLatest(app, settings, state)) return false;
+  const rows = await checkpointRows(app, settings, state);
+  if (!rows) return false;
+  await writeManifestCheckpoint(app, transactionLogDir(settings, full), { version: state.version, timestamp: state.timestamp, entry: state.entry, ...state.movesApplied ? { moves: state.movesApplied } : {} }, rows);
+  state.sinceCheckpoint = { versions: 0, bytes: 0 };
+  return true;
+}
+function formatOf(settings) {
+  return settings.transactionLogFormat === "files" ? "files" : "segments";
+}
+function setCheckpointRunner(app, run2) {
+  if (run2) CHECKPOINT_RUNNERS.set(app, run2);
+  else CHECKPOINT_RUNNERS.delete(app);
+}
+async function writeDueCheckpoints(app, stopped = () => false) {
+  let n = 0;
+  for (; ; ) {
+    const due = DUE.get(app);
+    const next = due ? [...due][0] : void 0;
+    if (!next || stopped()) break;
+    const [full, settings] = next;
+    due.delete(full);
+    if (await withLogLock(app, () => writeDueCheckpoint(app, settings, full))) n++;
   }
-  for (const [path23, t] of texts) if (t.before !== t.after) cs.texts.push({ path: path23, ...t });
-  return cs;
+  return n;
 }
-async function undoMigration(app, settings, migrationId, now = /* @__PURE__ */ new Date(), check2, op2 = "undo_migration") {
-  const { entry, path: journalPath, undone } = await readJournal(app, settings, migrationId);
-  const conflicts = [];
-  const partial2 = entry.failed.length > 0;
-  const back = /* @__PURE__ */ new Set();
-  const why = RECORD_ONLY_OPS[entry.op];
-  if (why) return { ok: false, undoes: migrationId, conflicts: [{ path: journalPath, message: why }], failed: [] };
-  if (undone) {
-    return {
-      ok: false,
-      undoes: migrationId,
-      conflicts: [{ path: journalPath, message: "migration already undone" }],
-      failed: []
+async function wholeCheckpoint(app, dir, v) {
+  return parseCheckpoint(await storeRead(app, checkpointPath(dir, v)) ?? "")?.version === v;
+}
+async function writeCheckpoint(app, dir, state, format) {
+  const files = [...state.files.entries()].sort(([a], [b]) => a.localeCompare(b));
+  if (format === "files") {
+    const cp = {
+      version: state.version,
+      timestamp: state.timestamp,
+      entry: state.entry,
+      files: files.map(([path23, f]) => ({ path: path23, hash: f.hash, content: f.content })),
+      ...state.movesApplied ? { moves: state.movesApplied } : {}
     };
-  }
-  const movedTo = new Map(entry.moves.map((m) => [m.from, m.to]));
-  const currentPath = (p) => movedTo.get(p) ?? p;
-  for (const r of entry.rows) {
-    const f = fileOrNull(app, currentPath(r.path));
-    if (!f) {
-      conflicts.push({ path: r.path, message: "note no longer exists" });
-      continue;
-    }
-    const cur = new Map(await readOrderedFor(app, f));
-    if (partial2 && Object.entries(r.before).every(([k, v]) => cur.has(k) && same(cur.get(k), v)) && r.before_absent.every((k) => !cur.has(k)) && (r.body_before === void 0 || bodyOf(await app.vault.read(f)) === r.body_before)) {
-      back.add(r);
-      continue;
-    }
-    for (const [k, v] of Object.entries(r.after)) {
-      if (!cur.has(k) || !same(cur.get(k), v)) {
-        conflicts.push({ path: r.path, message: `"${k}" changed since the operation` });
-      }
-    }
-    for (const k of r.after_absent) {
-      if (cur.has(k)) conflicts.push({ path: r.path, message: `"${k}" was added since the operation` });
-    }
-    if (r.body_after !== void 0 && bodyOf(await app.vault.read(f)) !== r.body_after) {
-      conflicts.push({ path: r.path, message: "body changed since the operation" });
+    const text5 = JSON.stringify(cp);
+    if (text5.length <= LEGACY_CHECKPOINT.maxChars) {
+      const path23 = checkpointPath(dir, state.version);
+      if (!await wholeCheckpoint(app, dir, state.version)) await storeWrite(app, path23, text5);
+      return;
     }
   }
-  for (const ref2 of entry.references) {
-    const f = fileOrNull(app, currentPath(ref2.path));
-    const text5 = f ? await app.vault.read(f) : null;
-    if (partial2 && text5 === ref2.before_text) back.add(ref2);
-    else if (text5 !== ref2.after_text) {
-      conflicts.push({ path: ref2.path, message: "text changed since the operation" });
-    }
+  await writeManifestCheckpoint(app, dir, { version: state.version, timestamp: state.timestamp, entry: state.entry, ...state.movesApplied ? { moves: state.movesApplied } : {} }, files.map(([path23, f]) => ({ path: path23, hash: f.hash, content: f.content })));
+}
+function forgetLoggedStates(app) {
+  LAST.delete(app);
+}
+async function knownState(app, settings, full) {
+  return LAST.get(app)?.get(full) ?? readLastState(app, settings, full);
+}
+async function readLastState(app, settings, full) {
+  let byTable = LAST.get(app);
+  if (!byTable) LAST.set(app, byTable = /* @__PURE__ */ new Map());
+  const state = await replayLogged(app, settings, full);
+  byTable.set(full, state);
+  return state;
+}
+async function stillLatest(app, settings, state) {
+  return latestOf(await tocOf(app, settings, state.full)) === state.version;
+}
+async function latestVersion(app, settings, full) {
+  const latest = latestOf(await tocOf(app, settings, full));
+  return latest >= 0 ? latest : null;
+}
+async function warmLoggedStates(app, settings, stopped = () => false) {
+  let n = 0;
+  for (const full of await loggedTables(app, settings)) {
+    if (stopped()) break;
+    await withLogLock(app, async () => {
+      if (LAST.get(app)?.has(full)) return;
+      await readLastState(app, settings, full);
+      n++;
+    });
   }
-  const since = await storeFilesSince(app, entry.moves);
-  const vacuumed = /* @__PURE__ */ new Set();
-  for (const m of entry.moves) {
-    if (!await fileExists(app, m.to)) {
-      if (inStore(m.to)) vacuumed.add(m.to);
-      else if (partial2 && await fileExists(app, m.from)) back.add(m);
-      else conflicts.push({ path: m.to, message: "moved file no longer exists" });
-    } else if (await occupied(app, m.from)) {
-      conflicts.push({ path: m.from, message: "original path is occupied" });
+  return n;
+}
+async function changesSince(app, prev, cur) {
+  const entry = cur?.entry ?? null;
+  let files = cur?.files ?? /* @__PURE__ */ new Map();
+  const remove3 = [];
+  const add = [];
+  if (cur) {
+    for (const [path23, f] of prev.files) {
+      if (files.has(path23) || !await unreadableNow(app, path23)) continue;
+      if (files === cur.files) files = new Map(files);
+      files.set(path23, f);
     }
   }
-  for (const m of since) {
-    if (await occupied(app, m.from)) conflicts.push({ path: m.from, message: "original path is occupied" });
+  for (const [path23, f] of prev.files) {
+    const now = files.get(path23);
+    if (!now || now.hash !== f.hash) remove3.push({ path: path23, hash: f.hash });
   }
-  const hashOfCreated = new Map((entry.created_hashes ?? []).map((h) => [h.path, h.hash]));
-  for (const c of entry.creates) {
-    const f = fileOrNull(app, currentPath(c));
-    if (f) {
-      const was = hashOfCreated.get(c);
-      if (!partial2 && was !== void 0 && createdHash(await app.vault.read(f)) !== was) {
-        conflicts.push({ path: currentPath(c), message: "created note changed since the operation" });
-      }
-      continue;
+  for (const [path23, f] of files) {
+    const was = prev.files.get(path23);
+    if (!was || was.hash !== f.hash) add.push({ path: path23, hash: f.hash, size: f.content.length, content: f.content });
+  }
+  add.sort((a, b) => a.path < b.path ? -1 : 1);
+  const metadataChanged = prev.version < 0 || entryHash(prev.entry) !== entryHash(entry);
+  return { entry, add, remove: remove3, metadataChanged };
+}
+function historyEnabled(model, entry) {
+  const own2 = entry.options?.history;
+  return typeof own2 === "boolean" ? own2 : model.config.history === true;
+}
+async function syncTransactionLogs(app, settings, options) {
+  const ms = await loadMetastore(app, settings);
+  if (!ms) return [];
+  const tables = catalogTables(ms.model);
+  const enabled = new Set(tables.filter(({ entry }) => historyEnabled(ms.model, entry)).map(({ ref: ref2 }) => ref2.full));
+  const defined = new Set(tables.map(({ ref: ref2 }) => ref2.full));
+  const orphans = await loggedTables(app, settings, (full) => !defined.has(full));
+  if (enabled.size === 0 && orphans.length === 0) return [];
+  const current2 = await currentStates(app, settings, ms.model, options.touched ?? [], enabled);
+  const names2 = /* @__PURE__ */ new Set([...enabled, ...orphans]);
+  const out2 = [];
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const format = formatOf(settings);
+  const planned = [];
+  for (const full of [...names2].sort()) {
+    if (options.tables && !options.tables.includes(full)) continue;
+    let prev = await knownState(app, settings, full);
+    const cur = current2.get(full);
+    if (prev.version < 0 && !cur) continue;
+    const due = (c) => c.metadataChanged || c.add.length > 0 || c.remove.length > 0 || options.always === true && cur !== void 0;
+    let changes = await changesSince(app, prev, cur);
+    if (!due(changes)) continue;
+    if (!await stillLatest(app, settings, prev)) {
+      prev = await readLastState(app, settings, full);
+      changes = await changesSince(app, prev, cur);
+      if (!due(changes)) continue;
     }
-    if (partial2) back.add(c);
-    else conflicts.push({ path: c, message: "created file no longer exists" });
+    const { entry, add, remove: remove3, metadataChanged } = changes;
+    const operation = prev.version < 0 && options.operation === EXTERNAL_EDIT ? "CREATE TABLE" : options.operation;
+    planned.push({ table: full, add, remove: remove3, metadataChanged, entry, prev, operation });
   }
-  for (const d of entry.deleted) {
-    const f = fileOrNull(app, d.path);
-    if (partial2 && f && await app.vault.read(f) === d.content) back.add(d);
-    else if (app.vault.getAbstractFileByPath(d.path) != null) {
-      conflicts.push({ path: d.path, message: "deleted path is occupied" });
+  const external = planned.filter((p) => p.operation === EXTERNAL_EDIT);
+  let counts;
+  if (options.check && external.length > 0) {
+    const added = new Set(external.flatMap((p) => p.add.map((a) => a.path)));
+    const changes = [];
+    for (const p of external) {
+      const wanted = /* @__PURE__ */ new Set([...p.remove.map((r) => r.path), ...[...added].filter((x) => p.prev.files.has(x))]);
+      const texts = await loggedTexts(app, settings, p.prev, wanted);
+      const before = /* @__PURE__ */ new Map();
+      for (const x of wanted) if (texts.has(x)) before.set(x, { hash: p.prev.files.get(x).hash, content: texts.get(x) });
+      const { prev: _prev, operation: _op, ...change } = p;
+      changes.push({ ...change, before });
     }
+    counts = await options.check(changes);
   }
-  if (conflicts.length > 0) return { ok: false, undoes: migrationId, conflicts, failed: [] };
-  if (check2) {
-    const refused2 = await check2(await undoChangeSet(app, [entry], `undo ${migrationId}`));
-    if (refused2.length > 0) return { ok: false, undoes: migrationId, conflicts: refused2, failed: [] };
+  for (const { table: full, add, remove: remove3, metadataChanged, entry, prev, operation } of planned) {
+    const version2 = prev.version + 1;
+    const violations = operation === EXTERNAL_EDIT ? counts?.get(full) : void 0;
+    const commit = {
+      commitInfo: {
+        version: version2,
+        timestamp: now.toISOString(),
+        operation,
+        ...options.parameters && Object.keys(options.parameters).length > 0 ? { operationParameters: options.parameters } : {},
+        ...options.migrationId ? { migrationId: options.migrationId } : {},
+        operationMetrics: { numAddedFiles: add.length, numRemovedFiles: remove3.length, metadataChanged, ...violations !== void 0 ? { violations } : {} },
+        engineInfo: "datanotes",
+        ...options.actor ? { userName: actorName(options.actor), actor: options.actor } : {}
+      },
+      ...metadataChanged ? { metaData: { entry } } : {},
+      add: [...add].sort((a, b) => a.path.localeCompare(b.path)),
+      remove: [...remove3].sort((a, b) => a.path.localeCompare(b.path))
+    };
+    const text5 = serializeCommit(commit);
+    const repaired = await appendVersion(app, transactionLogDir(settings, full), version2, text5, format);
+    for (const r of repaired) telemetry().log("WARN", "datanotes transaction log repaired a version torn by a crash", { table: full, repair: r });
+    applyLogged(prev, commit);
+    prev.sinceCheckpoint = { versions: prev.sinceCheckpoint.versions + 1, bytes: prev.sinceCheckpoint.bytes + text5.length };
+    if (version2 > 0 && checkpointDue(prev, format)) {
+      let due = DUE.get(app);
+      if (!due) DUE.set(app, due = /* @__PURE__ */ new Map());
+      due.set(full, settings);
+    }
+    out2.push({ table: full, version: version2, operation: commit.commitInfo.operation });
   }
-  const failed2 = [];
-  const undoRows = [];
-  const undoMoves = [];
-  const undoReferences = [];
-  const undoCreates = [];
-  const undoCreatedHashes = [];
-  const undoDeleted = [];
-  const steps = [];
-  for (const ref2 of entry.references) {
-    if (back.has(ref2)) continue;
-    steps.push({
-      path: currentPath(ref2.path),
-      run: async () => {
-        const f = fileOrNull(app, currentPath(ref2.path));
-        await app.vault.process(f, () => ref2.before_text);
-        undoReferences.push({ path: currentPath(ref2.path), before_text: ref2.after_text, after_text: ref2.before_text });
+  if (DUE.get(app)?.size) {
+    const runner = CHECKPOINT_RUNNERS.get(app);
+    if (runner) runner();
+    else {
+      const due = DUE.get(app);
+      for (const [full, s] of [...due]) {
+        due.delete(full);
+        await writeDueCheckpoint(app, s, full);
       }
-    });
+    }
   }
-  for (const r of entry.rows) {
-    if (back.has(r)) continue;
-    steps.push({
-      path: currentPath(r.path),
-      run: async () => {
-        const f = fileOrNull(app, currentPath(r.path));
-        const order = (await readOrderedFor(app, f)).map(([k]) => k);
-        if (Object.keys(r.after).length > 0 || r.after_absent.length > 0 || Object.keys(r.before).length > 0) {
-          await writeFrontmatter(
-            app,
-            f,
-            (fm) => applyDiff(fm, Object.entries(r.before), r.before_absent, r.before_order)
-          );
-        }
-        if (r.body_after !== void 0) await writeBody(app, f, r.body_after, r.body_before);
-        undoRows.push({
-          path: currentPath(r.path),
-          before: r.after,
-          before_absent: r.after_absent,
-          before_order: order,
-          after: r.before,
-          after_absent: r.before_absent,
-          ...r.body_after !== void 0 ? { body_before: r.body_after, body_after: r.body_before } : {}
-        });
+  return out2;
+}
+function withLogLock(app, fn) {
+  let activity = ACTIVITY.get(app);
+  if (!activity) ACTIVITY.set(app, activity = { pending: 0, lastEnd: 0 });
+  const a = activity;
+  a.pending++;
+  const prev = LOCKS.get(app) ?? Promise.resolve();
+  const wait = startSpan("engine.lock.acquire", { attributes: { "datanotes.lock.queued": a.pending - 1 } });
+  const held = () => {
+    wait.end();
+    return phase("engine.lock.hold", async () => {
+      try {
+        return await fn();
+      } finally {
+        await storeFlush(app).catch((e) => telemetry().log("WARN", "datanotes could not sync the store's files", { error: messageOf(e) }));
       }
     });
+  };
+  const run2 = prev.then(held, held);
+  const settled2 = run2.then(
+    () => void 0,
+    () => void 0
+  );
+  LOCKS.set(app, settled2);
+  void settled2.then(() => {
+    a.pending--;
+    a.lastEnd = Date.now();
+  });
+  return run2;
+}
+function logLockActivity(app) {
+  const a = ACTIVITY.get(app);
+  return { busy: (a?.pending ?? 0) > 0, lastEnd: a?.lastEnd ?? 0 };
+}
+async function checkpointFiles(app, dir, toc) {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const cp of toc.checkpoints) {
+    const files = cp.kind === 1 ? [cp.path] : manifestFiles(dir, cp.path, (await readManifest(app, dir, cp.path))?.head ?? null);
+    out2.set(cp.version, [...out2.get(cp.version) ?? [], ...files]);
   }
-  for (const m of [...[...entry.moves].reverse().filter((x) => !vacuumed.has(x.to) && !back.has(x)), ...since]) {
-    steps.push({
-      path: m.to,
-      run: async () => {
-        await moveFile(app, m.to, m.from);
-        undoMoves.push({ from: m.to, to: m.from });
-      }
-    });
+  return out2;
+}
+async function vacuum(app, settings, full, retainFrom, dryRun) {
+  const dir = transactionLogDir(settings, full);
+  const toc = await logToc(app, dir);
+  const versions = toc.versions;
+  if (versions.length === 0) throw new HistoryError(`${full} has no history`);
+  const latest = versions[versions.length - 1];
+  const keep = retainFrom ?? latest;
+  if (!versions.includes(keep)) throw new HistoryError(`${full} has no version ${keep} (available: ${versions[0]}..${latest})`);
+  const doomed = [...toc.files].filter(([v]) => v < keep).map(([, p]) => p);
+  const straddling = toc.segments.filter((s) => s.first < keep && s.last >= keep);
+  for (const s of toc.segments) if (s.last < keep || straddling.includes(s)) doomed.push(s.path);
+  for (const [v, files] of await checkpointFiles(app, dir, toc)) if (v < keep) doomed.push(...files);
+  doomed.sort();
+  if (!dryRun) {
+    await writeCheckpoint(app, dir, await tableStateAt(app, settings, full, { version: keep }), formatOf(settings));
+    for (const s of straddling) {
+      const kept2 = [];
+      for (let v = keep; v <= s.last; v++) kept2.push({ version: v, text: await versionText(app, toc, v) });
+      await writeSealedSegments(app, dir, kept2);
+    }
+    await storeFlush(app);
+    for (const p of doomed) await storeRemove(app, p);
+    forgetLoggedStates(app);
   }
-  for (const c of entry.creates) {
-    if (back.has(c)) continue;
-    steps.push({
-      path: c,
-      run: async () => {
-        const f = fileOrNull(app, c);
-        const content = await app.vault.read(f);
-        await trash(app, f);
-        undoDeleted.push({ path: c, content });
+  return { table: full, retained_from: keep, deleted: doomed, dry_run: dryRun };
+}
+async function convertLog(app, settings, full, to) {
+  const dir = transactionLogDir(settings, full);
+  const toc = await logToc(app, dir);
+  const result = { table: full, versions: toc.versions.length, written: 0, removed: 0 };
+  if (to === "segments") {
+    for (const s of toc.segments) {
+      if (!s.sealed || (await wholeVersions(app, s)).size === s.last - s.first + 1) {
+        storeSyncNext(app, s.path);
+        continue;
       }
-    });
-  }
-  for (const d of entry.deleted) {
-    if (back.has(d)) continue;
-    steps.push({
-      path: d.path,
-      run: async () => {
-        await ensureFolder(app, parentFolder(d.path));
-        await app.vault.create(d.path, d.content);
-        undoCreates.push(d.path);
-        undoCreatedHashes.push({ path: d.path, hash: createdHash(d.content) });
+      const range = Array.from({ length: s.last - s.first + 1 }, (_, i) => s.first + i);
+      const texts2 = await versionTexts(app, toc, range);
+      await storeWrite(app, s.path, range.map((v, i) => framed(v, texts2[i])).join(""));
+      result.written++;
+    }
+    const loose = toc.versions.filter((v) => toc.files.has(v) && !toc.segments.some((s) => v >= s.first && v <= s.last));
+    const texts = await versionTexts(app, toc, loose);
+    const written2 = await writeSealedSegments(app, dir, loose.map((version2, i) => ({ version: version2, text: texts[i] })));
+    result.written += written2.length;
+    await storeFlush(app);
+    for (const v of toc.files.keys()) {
+      await storeRemove(app, toc.files.get(v));
+      result.removed++;
+    }
+  } else {
+    for (const seg of toc.segments) {
+      for (let v = seg.first; v <= seg.last; v++) {
+        const path23 = `${dir}/${pad2(v)}.json`;
+        const file = toc.files.get(v);
+        if (file === void 0) {
+          await storeWrite(app, path23, await versionText(app, toc, v));
+          result.written++;
+        } else storeSyncNext(app, file);
       }
-    });
-  }
-  let done = 0;
-  try {
-    for (const s of steps) {
-      await s.run();
-      done++;
     }
-  } catch (e) {
-    failed2.push({ path: "undo", error: messageOf(e) });
-  }
-  const journal = await writeJournal(
-    app,
-    settings,
-    {
-      op: op2,
-      ...entry.schema !== void 0 ? { schema: entry.schema } : {},
-      ...currentActor() ? { actor: currentActor() } : {},
-      summary: `undo ${migrationId}`,
-      executed_at: now.toISOString(),
-      rows: undoRows,
-      creates: undoCreates,
-      ...undoCreatedHashes.length > 0 ? { created_hashes: undoCreatedHashes } : {},
-      moves: undoMoves,
-      references: undoReferences,
-      deleted: undoDeleted,
-      failed: failed2,
-      undoes: migrationId
-    },
-    now
-  );
-  if (failed2.length === 0) {
-    await markUndone(app, settings, migrationId, journal.id, now);
+    const oldest = toc.versions[0];
+    if (oldest !== void 0 && oldest > 0) {
+      if (await wholeCheckpoint(app, dir, oldest)) storeSyncNext(app, checkpointPath(dir, oldest));
+      else {
+        await writeCheckpoint(app, dir, await replayState(app, settings, full, { version: oldest }), "files");
+        result.written++;
+      }
+    }
+    await storeFlush(app);
+    for (const seg of toc.segments) {
+      await storeRemove(app, seg.path);
+      result.removed++;
+    }
   }
-  return {
-    ok: failed2.length === 0,
-    undoes: migrationId,
-    migration_id: journal.id,
-    conflicts: [],
-    failed: failed2,
-    ...failed2.length > 0 ? { left: [...new Set(steps.slice(done).map((s) => s.path))] } : {},
-    touched: [
-      ...entry.rows.map((r) => r.path),
-      ...entry.creates,
-      ...[...entry.moves, ...since].flatMap((m) => [m.from, m.to]),
-      ...entry.references.map((r) => r.path),
-      ...entry.deleted.map((d) => d.path)
-    ]
-  };
-}
-function applyChangeSet(...args) {
-  const cs = args[2];
-  return phase("engine.apply", async (span) => {
-    const r = await applyChangeSetImpl(...args);
-    span.setAttributes({ "datanotes.notes_changed": r.notesChanged, "datanotes.files_created": r.filesCreated, "datanotes.files_moved": r.filesMoved, "datanotes.files_deleted": r.filesDeleted, "datanotes.failed": r.failed.length });
-    if (!r.ok) span.setAttribute("error.type", "write_failed").setStatus("error", "the write failed partway");
-    return r;
-  }, { "datanotes.edits": cs.edits.length, "datanotes.creates": cs.creates.length, "datanotes.moves": cs.moves.length, "datanotes.deletes": cs.deletes.length });
+  forgetLoggedStates(app);
+  return result;
 }
-var inStore, WRITE_CONCURRENCY, RECORD_ONLY_OPS;
-var init_changeset = __esm({
-  "src/core/changeset.ts"() {
+var TRANSACTION_LOG_FOLDER, CHECKPOINT_POLICY, LEGACY_CHECKPOINT, EXTERNAL_EDIT, AbsentTableError, ENTRY_HASHES, NO_KEYS, LIVE, DUE, CHECKPOINT_RUNNERS, LAST, LOCKS, ACTIVITY;
+var init_transaction_log = __esm({
+  "src/core/transaction-log.ts"() {
     "use strict";
+    init_file_cache();
     init_frontmatter();
+    init_metastore();
     init_actor();
-    init_journal();
     init_store();
-    init_metastore();
-    init_database_id();
-    init_message();
-    init_file_cache();
+    init_table_loader();
+    init_types_table();
+    init_database_move();
+    init_db_paths();
+    init_unreadable();
     init_tracing();
-    init_journal();
-    inStore = isStorePath;
-    WRITE_CONCURRENCY = { atOnce: 16, from: 32 };
-    RECORD_ONLY_OPS = {
-      move_database: "a move of the database folder cannot be undone: move it back with configure_database (root)",
-      set_database_id: "the database's id cannot be taken back: the engine finds its store by it",
-      rollback: "the rollback of a failed write cannot be undone: it put the database back as it was; run the write again instead"
+    init_vault_index();
+    init_telemetry();
+    init_message();
+    init_log_files();
+    TRANSACTION_LOG_FOLDER = "transaction_log";
+    CHECKPOINT_POLICY = { bytesFactor: 2, minBytes: 256 * 1024, maxVersions: 1e3, versionBytes: 16 * 1024 };
+    LEGACY_CHECKPOINT = { maxChars: 32 * 1024 * 1024 };
+    EXTERNAL_EDIT = "EXTERNAL_EDIT";
+    AbsentTableError = class extends HistoryError {
     };
+    ENTRY_HASHES = /* @__PURE__ */ new WeakMap();
+    NO_KEYS = /* @__PURE__ */ new Set();
+    LIVE = /* @__PURE__ */ new WeakMap();
+    DUE = /* @__PURE__ */ new WeakMap();
+    CHECKPOINT_RUNNERS = /* @__PURE__ */ new WeakMap();
+    LAST = /* @__PURE__ */ new WeakMap();
+    LOCKS = /* @__PURE__ */ new WeakMap();
+    ACTIVITY = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -32904,7 +32990,7 @@ var init_database = __esm({
 
 // src/core/write-check.ts
 function staleWrite(app) {
-  const ctx = storage3?.getStore();
+  const ctx = storage4?.getStore();
   if (ctx === void 0 || ctx.gen === generation(app)) return false;
   ctx.stale = true;
   return true;
@@ -32912,12 +32998,12 @@ function staleWrite(app) {
 function wrote(app) {
   const next = generation(app) + 1;
   GENERATION.set(app, next);
-  const ctx = storage3?.getStore();
+  const ctx = storage4?.getStore();
   if (ctx) ctx.gen = next;
 }
 async function runWrite(app, fn, isStale) {
-  if (!storage3) return fn();
-  const s = storage3;
+  if (!storage4) return fn();
+  const s = storage4;
   let ctx = { gen: 0, stale: false };
   const attempt = () => s.run(ctx = { gen: generation(app), stale: false }, fn);
   let result = await attempt();
@@ -32927,19 +33013,19 @@ async function runWrite(app, fn, isStale) {
 function holdsStaleWrite(value) {
   return JSON.stringify(value ?? null).includes(STALE_WRITE);
 }
-var STALE_WRITE, WRITE_ATTEMPTS, GENERATION, storage3, generation;
+var STALE_WRITE, WRITE_ATTEMPTS, GENERATION, storage4, generation;
 var init_write_check = __esm({
   "src/core/write-check.ts"() {
     "use strict";
     STALE_WRITE = "the database changed while this write was being checked";
     WRITE_ATTEMPTS = 5;
     GENERATION = /* @__PURE__ */ new WeakMap();
-    storage3 = null;
+    storage4 = null;
     try {
       const { AsyncLocalStorage: AsyncLocalStorage2 } = require("node:async_hooks");
-      storage3 = new AsyncLocalStorage2();
+      storage4 = new AsyncLocalStorage2();
     } catch {
-      storage3 = null;
+      storage4 = null;
     }
     generation = (app) => GENERATION.get(app) ?? 0;
   }
@@ -33251,14 +33337,23 @@ function readableKeys(t, settings) {
 function rowGetter(app, t, settings, tz = "") {
   const real = knownKeys(t, settings);
   let inlinks = null;
+  const scope = currentReadScope();
+  const seen = /* @__PURE__ */ new Map();
+  const counts = (src) => {
+    if (!scope) return true;
+    let ok2 = seen.get(src);
+    if (ok2 === void 0) seen.set(src, ok2 = pathReadable(app, settings, src, scope));
+    return ok2;
+  };
   const backlinks = (path23) => {
     if (!app) return null;
     const kept2 = app.metadataCache.backlinksOf;
-    if (kept2) return Object.keys(kept2.call(app.metadataCache, path23)).filter((src) => src !== path23).length;
+    if (kept2) return Object.keys(kept2.call(app.metadataCache, path23)).filter((src) => src !== path23 && counts(src)).length;
     if (!inlinks) {
       inlinks = /* @__PURE__ */ new Map();
       const resolved = app.metadataCache.resolvedLinks;
       for (const [src, dests] of Object.entries(resolved)) {
+        if (!counts(src)) continue;
         for (const d of Object.keys(dests)) if (d !== src) inlinks.set(d, (inlinks.get(d) ?? 0) + 1);
       }
     }
@@ -35090,6 +35185,7 @@ async function finish(app, settings, cs, conflicts, violations, opts) {
   base.conflicts = conflicts;
   base.violations = violations.filter((v) => v.violations.length > 0);
   if (base.conflicts.length > 0 || base.violations.length > 0) return base;
+  await assertChangeSetWritable(app, settings, cs);
   if (dryRun) return { ...base, ok: true };
   const done = await whileWriting(app, () => withLogLock(app, async () => {
     if (staleWrite(app)) return null;
@@ -36037,6 +36133,7 @@ var init_engine = __esm({
     init_actor();
     init_journal();
     init_inverse();
+    init_write_scope();
     init_file_cache();
     init_transaction_log();
     init_changeset();
@@ -38840,11 +38937,223 @@ var init_extension_host = __esm({
   }
 });
 
+// src/api/extension-columns.ts
+function roleOf(v) {
+  if (typeof v !== "string") return null;
+  const m = ROLE_REF.exec(v);
+  return m ? m[1] : null;
+}
+var isObject5, LOGICAL2, DATE_EXPR3, QUERY_KEYS, JOIN_KEYS, UNION_PART_KEYS, ColumnBinder;
+var init_extension_columns = __esm({
+  "src/api/extension-columns.ts"() {
+    "use strict";
+    init_extension_manifest();
+    isObject5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    LOGICAL2 = /* @__PURE__ */ new Set(["or", "and", "not"]);
+    DATE_EXPR3 = /^date\((.+)\)([+-]\d+)?$/;
+    QUERY_KEYS = /* @__PURE__ */ new Set(["table", "columns", "where", "order_by", "limit", "offset", "expand", "join", "group_by", "aggregates", "include_body", "union"]);
+    JOIN_KEYS = /* @__PURE__ */ new Set(["table", "on", "as", "type", "columns", "where"]);
+    UNION_PART_KEYS = /* @__PURE__ */ new Set(["table", "columns", "where"]);
+    ColumnBinder = class {
+      constructor(manifest, map) {
+        this.manifest = manifest;
+        this.issues = [];
+        this.map = {};
+        for (const [role, cols] of Object.entries(map)) {
+          const differing = Object.entries(cols).filter(([from, to]) => from !== to);
+          if (differing.length > 0) this.map[role] = Object.fromEntries(differing);
+        }
+      }
+      /** True when no role has a column bound to another name: every rewrite is the identity. */
+      get empty() {
+        return Object.keys(this.map).length === 0;
+      }
+      /** The bound name of a role's manifest column. */
+      name(role, column) {
+        return role === null ? column : this.map[role]?.[column] ?? column;
+      }
+      /** The manifest columns of a role bound to another name. */
+      mapped(role) {
+        return Object.keys(this.map[role] ?? {});
+      }
+      /** The role a link column of `role` points to (`ref: "@x"`, or `self`), or null. */
+      linkRole(role, column) {
+        const c = typeof column === "string" ? this.manifest.tables[role]?.columns.find((x) => x.name === column) : column;
+        if (!c || c.ref === void 0) return null;
+        if (!(c.type === "link" || c.type === "list" && c.items === "link")) return null;
+        return c.ref === "self" ? role : roleOf(c.ref);
+      }
+      /** A dotted column path read on `role`: each part on the role the previous link points to. */
+      path(role, dotted) {
+        if (role === null || this.empty) return dotted;
+        const parts = dotted.split(".");
+        const out2 = [];
+        let cur = role;
+        for (const part of parts) {
+          out2.push(this.name(cur, part));
+          cur = cur === null ? null : this.linkRole(cur, part);
+        }
+        return out2.join(".");
+      }
+      /** A group_by or join expression: `col`, `path`, `date(col)`, `date(col)+1`. */
+      expr(role, e) {
+        const d = DATE_EXPR3.exec(e);
+        return d ? `date(${this.path(role, d[1])})${d[2] ?? ""}` : this.path(role, e);
+      }
+      /** A `where` filter (or a CHECK) on `role`: keys are column paths; `or` / `and` / `not` nest. */
+      where(role, where) {
+        if (!isObject5(where) || role === null || this.empty) return where;
+        const out2 = {};
+        for (const [k, v] of Object.entries(where)) {
+          if (LOGICAL2.has(k)) out2[k] = Array.isArray(v) ? v.map((w) => this.where(role, w)) : this.where(role, v);
+          else out2[this.path(role, k)] = v;
+        }
+        return out2;
+      }
+      /** A column spec of `role`: its link filter (`ref_where`), `ref_by`, `inverse`. */
+      column(role, c) {
+        if (this.empty) return c;
+        let out2 = c;
+        const target = this.linkRole(role, c);
+        if (c.ref_where !== void 0) out2 = { ...out2, ref_where: this.where(target, c.ref_where) };
+        if (isObject5(c.ref_by)) {
+          const by = c.ref_by;
+          const col = this.name(role, String(by.column));
+          const tgt = this.name(target, String(by.target_column ?? by.column));
+          const { target_column: _t, ...rest } = by;
+          out2 = { ...out2, ref_by: { ...rest, column: col, ...tgt !== col ? { target_column: tgt } : {} } };
+        }
+        if (typeof c.inverse === "string") out2 = { ...out2, inverse: this.name(target, c.inverse) };
+        return out2;
+      }
+      /** A view query: the tables it reads are roles (`@meal`); every column it names follows them. */
+      query(view, q) {
+        if (this.empty) return q;
+        if (Array.isArray(q.union)) return this.union(view, q);
+        const role = roleOf(q.table);
+        const out2 = {};
+        const aliases = new Set(isObject5(q.aggregates) ? Object.keys(q.aggregates) : []);
+        const col = (v) => aliases.has(v) ? v : this.path(role, v);
+        for (const [k, v] of Object.entries(q)) {
+          switch (k) {
+            case "columns":
+            case "expand":
+              out2[k] = Array.isArray(v) ? v.map((x) => typeof x === "string" ? col(x) : x) : v;
+              break;
+            case "order_by":
+              out2[k] = Array.isArray(v) ? v.map((x) => this.order(x, col)) : this.order(v, col);
+              break;
+            case "where":
+              out2[k] = this.where(role, v);
+              break;
+            case "group_by":
+              out2[k] = Array.isArray(v) ? v.map((x) => typeof x === "string" ? this.expr(role, x) : x) : typeof v === "string" ? this.expr(role, v) : v;
+              break;
+            case "aggregates":
+              out2[k] = isObject5(v) ? Object.fromEntries(Object.entries(v).map(([a, spec2]) => [a, this.aggregate(role, spec2)])) : v;
+              break;
+            case "join":
+              out2[k] = isObject5(v) ? this.join(view, role, v) : v;
+              break;
+            default:
+              if (!QUERY_KEYS.has(k)) this.unknown(view, [role], k, v);
+              out2[k] = v;
+          }
+        }
+        return out2;
+      }
+      order(v, col) {
+        if (typeof v !== "string") return v;
+        return v.startsWith("-") ? `-${col(v.slice(1))}` : col(v);
+      }
+      /** `count`, `count:col`, `sum:meal.kcal`. */
+      aggregate(role, spec2) {
+        if (typeof spec2 !== "string") return spec2;
+        const i = spec2.indexOf(":");
+        return i < 0 ? spec2 : `${spec2.slice(0, i)}:${this.path(role, spec2.slice(i + 1))}`;
+      }
+      /** `{table, on: {left expr: right expr}, as, type, columns, where}`: `columns` and `where` read the joined table. */
+      join(view, left, j) {
+        const right = roleOf(j.table);
+        const out2 = {};
+        for (const [k, v] of Object.entries(j)) {
+          if (k === "on" && isObject5(v)) {
+            out2[k] = Object.fromEntries(Object.entries(v).map(([a, b]) => [this.expr(left, a), typeof b === "string" ? this.expr(right, b) : b]));
+          } else if (k === "columns" && Array.isArray(v)) out2[k] = v.map((x) => typeof x === "string" ? this.path(right, x) : x);
+          else if (k === "where") out2[k] = this.where(right, v);
+          else {
+            if (!JOIN_KEYS.has(k)) this.unknown(view, [left, right], `join.${k}`, v);
+            out2[k] = v;
+          }
+        }
+        return out2;
+      }
+      /** `{union: [{table, columns, where}], …}`: each part on its role; the outer clauses read every part, so a mapped column there is an issue. */
+      union(view, q) {
+        const roles = [];
+        const parts = q.union.map((p) => {
+          if (!isObject5(p)) return p;
+          const role = roleOf(p.table);
+          roles.push(role);
+          const out2 = {};
+          for (const [k, v] of Object.entries(p)) {
+            if (k === "columns" && Array.isArray(v)) out2[k] = v.map((x) => typeof x === "string" ? this.path(role, x) : x);
+            else if (k === "where") out2[k] = this.where(role, v);
+            else {
+              if (!UNION_PART_KEYS.has(k)) this.unknown(view, [role], `union.${k}`, v);
+              out2[k] = v;
+            }
+          }
+          return out2;
+        });
+        for (const [k, v] of Object.entries(q)) if (k !== "union") this.unknown(view, roles, `union ${k}`, v);
+        return { ...q, union: parts };
+      }
+      /** A clause the binder does not rewrite: an issue for each mapped column it names. */
+      unknown(view, roles, key2, v) {
+        for (const n of this.named(v, roles.filter((r) => r !== null), () => true)) this.issues.push({ ...n, where: `view ${view} (${key2})` });
+      }
+      /**
+       * The mapped columns a value names, where nothing rewrites it: a word that is a mapped column of
+       * one of `roles`, or a later part of a dotted path (`author.name`) that is a mapped column of any
+       * role. `keys(key, inKeys)` tells whether the keys under `key` are names too.
+       */
+      named(v, roles, keys) {
+        const words = /* @__PURE__ */ new Set();
+        const tails = /* @__PURE__ */ new Set();
+        const text5 = (x) => {
+          for (const w of x.split(/[^A-Za-z0-9_.]+/)) {
+            const parts = w.split(".");
+            if (parts.length === 1) words.add(w);
+            else for (const p of parts.slice(1)) tails.add(p);
+          }
+        };
+        const walk = (x, inKeys) => {
+          if (typeof x === "string") text5(x);
+          else if (Array.isArray(x)) x.forEach((y) => walk(y, inKeys));
+          else if (isObject5(x)) {
+            for (const [k, y] of Object.entries(x)) {
+              if (inKeys) text5(k);
+              walk(y, keys(k, inKeys));
+            }
+          }
+        };
+        walk(v, keys("", false));
+        const out2 = [];
+        for (const role of Object.keys(this.map)) {
+          for (const column of this.mapped(role)) if (tails.has(column) || roles.includes(role) && words.has(column)) out2.push({ role, column });
+        }
+        return out2;
+      }
+    };
+  }
+});
+
 // src/api/extension-plan.ts
 function stable(v) {
   const walk = (x) => {
     if (Array.isArray(x)) return x.map(walk);
-    if (isObject5(x)) {
+    if (isObject6(x)) {
       const out2 = {};
       for (const k of Object.keys(x).sort()) out2[k] = walk(x[k]);
       return out2;
@@ -39018,6 +39327,10 @@ function planChanges(input) {
   for (const role of m.roles) tables[role] = choiceOf.get(role)?.table ?? `@${role}`;
   const bind = (v) => bindRoles(v, tables);
   const existing = (c) => c.decision === "adopt" || c.decision === "match";
+  const columnMap = {};
+  for (const c of input.chosen) if (!c.owned && c.decision === "match") columnMap[c.role] = { ...recorded[c.role]?.columns ?? {}, ...choices.columns[c.role] ?? {} };
+  const binder = new ColumnBinder(m, columnMap);
+  const bindColumn = (role, c) => bind(spec(binder.column(role, c)));
   const model = /* @__PURE__ */ new Map();
   for (const c of input.chosen) if (existing(c)) model.set(c.table, modelTable(input.described[c.table] ?? { qualified: c.table, columns: [] }));
   const views = new Set(input.listing.views.map((v) => v.qualified));
@@ -39045,6 +39358,19 @@ function planChanges(input) {
           );
           continue;
         }
+        const touched = mappedNamed(raw);
+        if (touched !== null) {
+          migrationProblems.push(
+            problem(
+              "migration_conflict",
+              `migration ${g.version}: ${raw.op} names column ${touched.column} of ${touched.role}, which reads your column ${binder.name(touched.role, touched.column)}`,
+              `Rename your column to ${touched.column} with rename_column and run the command again without --map ${touched.role}.${touched.column}, or ask the extension's author.`,
+              EXT_DOCS.update,
+              { role: touched.role, column: touched.column }
+            )
+          );
+          continue;
+        }
         const op2 = bind(raw);
         const r = simulate(op2, g.version);
         if (typeof r === "string") {
@@ -39056,6 +39382,9 @@ function planChanges(input) {
       }
     }
   }
+  function mappedNamed(raw) {
+    return binder.named(raw, rolesNamed(raw), (k, inKeys) => inKeys || FILTER_KEYS.has(k))[0] ?? null;
+  }
   function qualify(op2) {
     return `${String(op2.catalog ?? catalog)}.${String(op2.schema ?? viewSchema)}.${String(op2.name)}`;
   }
@@ -39188,7 +39517,7 @@ function planChanges(input) {
         schema,
         name: tname,
         description: def.description,
-        columns: bind(def.columns.map(spec)),
+        columns: def.columns.map((c) => bindColumn(role, c)),
         ...def.filename !== void 0 ? { filename: def.filename } : {},
         ...def.aliases !== void 0 ? { aliases: def.aliases } : {}
       });
@@ -39197,8 +39526,8 @@ function planChanges(input) {
     }
     const actualCols = model.get(q).columns;
     for (const c of def.columns) {
-      const bound = bind(spec(c));
-      const actualName = choices.columns[role]?.[c.name] ?? recorded[role]?.columns?.[c.name] ?? c.name;
+      const bound = bindColumn(role, c);
+      const actualName = binder.name(role, c.name);
       const actual = actualCols.get(actualName);
       if (actual) {
         const diff = columnDifference(bound, actual, q, false);
@@ -39239,7 +39568,7 @@ function planChanges(input) {
     const q = t.table;
     const tags = { extension: name, extension_role: role };
     const instructions = def.instructions === void 0 ? void 0 : bind(def.instructions);
-    const constraint = (c) => ({ op: "add_constraint", table: q, name: c.name, check: bind(c.check), hint: c.hint });
+    const constraint = (c) => ({ op: "add_constraint", table: q, name: c.name, check: bind(binder.where(role, c.check)), hint: c.hint });
     if (t.decision === "create") {
       const [cat, schema, tname] = q.split(".");
       operations.push({
@@ -39248,7 +39577,7 @@ function planChanges(input) {
         schema,
         name: tname,
         description: def.description,
-        columns: bind(def.columns.map(spec)),
+        columns: def.columns.map((c) => bindColumn(role, c)),
         ...def.filename !== void 0 ? { filename: def.filename } : {},
         ...def.aliases !== void 0 ? { aliases: def.aliases } : {},
         ...instructions !== void 0 ? { instructions } : {},
@@ -39261,7 +39590,7 @@ function planChanges(input) {
     }
     const mt = model.get(q);
     for (const c of def.columns) {
-      const bound = bind(spec(c));
+      const bound = bindColumn(role, c);
       const actual = mt.columns.get(c.name);
       if (!actual) {
         operations.push({ op: "add_column", table: q, column: bound });
@@ -39285,7 +39614,7 @@ function planChanges(input) {
       if (!actual) {
         operations.push(constraint(c));
         t.changes.push(`add CHECK ${c.name}`);
-      } else if (stable(actual.check) !== stable(bind(c.check)) || actual.hint !== c.hint) {
+      } else if (stable(actual.check) !== stable(bind(binder.where(role, c.check))) || actual.hint !== c.hint) {
         operations.push({ op: "drop_constraint", table: q, name: c.name }, constraint(c));
         t.changes.push(`replace CHECK ${c.name}`);
       }
@@ -39313,13 +39642,14 @@ function planChanges(input) {
   for (const v of Object.keys(m.views)) {
     const def = m.views[v];
     const q = `${catalog}.${viewSchema}.${v}`;
+    const query = binder.query(v, def.query);
     const create = {
       op: "create_view",
       catalog,
       schema: viewSchema,
       name: v,
       description: def.description,
-      query: bind(def.query),
+      query: bind(query),
       ...def.aliases !== void 0 ? { aliases: def.aliases } : {},
       ...def.labels !== void 0 ? { labels: def.labels } : {}
     };
@@ -39328,7 +39658,7 @@ function planChanges(input) {
       viewPlan.changes.push(`create view ${v}`);
     } else if (action === "install") {
       reconcileProblems.push(problem("view_exists", `${q} exists already`, "Drop or rename that view (drop_view), or install with --schema <another schema>.", EXT_DOCS.install, { table: q }));
-    } else if (stable(oldManifest.views[v]) !== stable(def)) {
+    } else if (stable(oldManifest.views[v]) !== stable(def) || stable(query) !== stable(def.query)) {
       operations.push({ ...create, replace: true });
       viewPlan.changes.push(`replace view ${v}`);
     }
@@ -39344,6 +39674,17 @@ function planChanges(input) {
       if (m.tables[role] === void 0) notes.push(`${role} (${rt.table}) is no longer used by the extension: it stays in the database`);
     }
   }
+  for (const i of binder.issues) {
+    reconcileProblems.push(
+      problem(
+        "column_map_unsupported",
+        `${i.role}: ${i.where} names column ${i.column}, which reads your column ${binder.name(i.role, i.column)}: the installer cannot rewrite it there`,
+        `Rename your column to ${i.column} with rename_column and leave --map ${i.role}.${i.column} out, or ask the extension's author.`,
+        EXT_DOCS.tables,
+        { role: i.role, column: i.column }
+      )
+    );
+  }
   const toolProblems = [];
   const others = input.others.filter((o) => o.name !== name);
   const boundNames = (roles) => roles.map((r) => tables[r]);
@@ -39464,16 +39805,18 @@ function renderPlan(plan) {
   lines.push("", plan.agent_message, plan.summary);
   return lines.join("\n");
 }
-var AGENT_MESSAGE, MAX_OPERATIONS, isObject5, obj3, list2, tableName, isLink;
+var AGENT_MESSAGE, FILTER_KEYS, MAX_OPERATIONS, isObject6, obj3, list2, tableName, isLink;
 var init_extension_plan = __esm({
   "src/api/extension-plan.ts"() {
     "use strict";
+    init_extension_columns();
     init_extension_manifest();
     init_guidance();
     AGENT_MESSAGE = `For the agent installing this extension: show this plan to the user before anything is written. Where a table says "proposed", the installer chose it: ask the user to confirm it, to pick another table (--map <role>=<catalog.schema.table>, --map <role>.<column>=<column>), or to create it (--create <role>). Add a missing column only after the user agrees (--add <role>.<column>). Solve each problem the same way. Then run the same command again with the user's choices and --yes, only once the user approved the tables it creates or changes, the tools and the token's permissions.`;
+    FILTER_KEYS = /* @__PURE__ */ new Set(["check", "where", "ref_where", "query", "on"]);
     MAX_OPERATIONS = 200;
-    isObject5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-    obj3 = (v) => isObject5(v) ? v : {};
+    isObject6 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    obj3 = (v) => isObject6(v) ? v : {};
     list2 = (v) => Array.isArray(v) ? v : [];
     tableName = (t, role) => t.name ?? role;
     isLink = (c) => c.type === "link" || c.type === "list" && c.items === "link";
@@ -40600,7 +40943,7 @@ __export(util_exports, {
   hexToUint8Array: () => hexToUint8Array,
   hide: () => hide,
   installLazyProp: () => installLazyProp,
-  isObject: () => isObject6,
+  isObject: () => isObject7,
   isPlainObject: () => isPlainObject2,
   issue: () => issue,
   joinValues: () => joinValues,
@@ -40807,11 +41150,11 @@ function esc(str3) {
 function slugify(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function isObject6(data) {
+function isObject7(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 function isPlainObject2(o) {
-  if (isObject6(o) === false)
+  if (isObject7(o) === false)
     return false;
   const ctor = o.constructor;
   if (ctor === void 0)
@@ -40819,7 +41162,7 @@ function isPlainObject2(o) {
   if (typeof ctor !== "function")
     return true;
   const prot = ctor.prototype;
-  if (isObject6(prot) === false)
+  if (isObject7(prot) === false)
     return false;
   if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
     return false;
@@ -43218,7 +43561,7 @@ var init_schemas = __esm({
         }
         return propValues;
       });
-      const isObject7 = isObject6;
+      const isObject8 = isObject7;
       const catchall = def.catchall;
       let value;
       const memo2 = globalConfig.memoizer;
@@ -43226,7 +43569,7 @@ var init_schemas = __esm({
       inst._zod.parse = (payload, ctx) => {
         value ?? (value = _normalized.value);
         const input = payload.value;
-        if (!isObject7(input)) {
+        if (!isObject8(input)) {
           payload.issues.push({
             expected: "object",
             code: "invalid_type",
@@ -43362,7 +43705,7 @@ var init_schemas = __esm({
         return doc.compile();
       };
       let fastpass;
-      const isObject7 = isObject6;
+      const isObject8 = isObject7;
       const jit = !globalConfig.jitless;
       const allowsEval2 = allowsEval;
       const fastEnabled = jit && allowsEval2.value;
@@ -43371,7 +43714,7 @@ var init_schemas = __esm({
       inst._zod.parse = (payload, ctx) => {
         value ?? (value = _normalized.value);
         const input = payload.value;
-        if (!isObject7(input)) {
+        if (!isObject8(input)) {
           payload.issues.push({
             expected: "object",
             code: "invalid_type",
@@ -43471,7 +43814,7 @@ var init_schemas = __esm({
       const disc = cached(() => discriminatorMap(def));
       inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
-        if (!isObject6(input)) {
+        if (!isObject7(input)) {
           payload.issues.push({
             code: "invalid_type",
             expected: "object",
@@ -66871,17 +67214,28 @@ var SemanticIndex = class {
     if (this.queries.size > QUERY_VECTORS_MAX) this.queries.delete(this.queries.keys().next().value);
     return v;
   }
+  /** The index's counts; under a read scope (read-scope.ts), of the notes the token may read only. */
   status() {
     const s = this.getSettings();
+    const scope = currentReadScope();
+    const readable = (path23) => !scope || pathReadable(this.app, s, path23, scope);
+    let files = 0;
     let passages = 0;
-    for (const f of this.files.values()) passages += f.passages.length;
+    for (const [path23, f] of this.files) {
+      if (!readable(path23)) continue;
+      files++;
+      passages += f.passages.length;
+    }
+    let pending = 0;
+    if (scope) for (const path23 of this.pending) pending += readable(path23) ? 1 : 0;
+    else pending = this.pending.size;
     return {
       enabled: s.semanticEnabled,
       provider: s.semanticProvider,
       model: s.semanticModel,
-      files: this.files.size,
+      files,
       passages,
-      pending: this.pending.size,
+      pending,
       running: this.running !== null,
       ...this.lastSync ? { last_sync: this.lastSync } : {},
       ...this.lastError ? { last_error: this.lastError } : {}
@@ -69078,6 +69432,7 @@ init_guidance();
 init_requests();
 init_actor();
 init_read_scope();
+init_write_scope();
 init_changeset_checks();
 
 // src/server/token-routes.ts
@@ -69110,6 +69465,8 @@ var READ_ROUTES = /* @__PURE__ */ new Set(["/manual/search/", "/tokens/me/", "/t
 var OWNER_ADMIN_ROUTES = /* @__PURE__ */ new Set(["/tokens/", "/tokens/create/", "/tokens/update/", "/tokens/delete/", "/tokens/rotate/", "/extensions/record/", "/extensions/delete/", "/status/", "/stop/"]);
 var READ_SCOPE_UNSUPPORTED = "read permissions need Node's AsyncLocalStorage";
 var READ_SCOPE_UNSUPPORTED_HINT = guide(`This token has "read" patterns, which this runtime cannot enforce: run the engine on Node (datanotes serve), or have the owner pass "read": null to tokens/update/ for this token.`, "tokenRead");
+var WRITE_SCOPE_UNSUPPORTED = "write permissions need Node's AsyncLocalStorage";
+var WRITE_SCOPE_UNSUPPORTED_HINT = guide(`This token's "write" patterns limit the tables its writes may change, which this runtime cannot enforce: run the engine on Node (datanotes serve), or write with a token whose "write" is ["*"].`, "tokenWrite");
 
 // src/server/scheduler.ts
 init_telemetry();
@@ -69358,7 +69715,7 @@ function errorResponse(e, op2, route) {
   if (e instanceof MigrationNotFoundError) return { status: 404, json: body(guide("list_migrations lists the journal ids (migration_id) of the writes, newest first.", "undo")) };
   if (e instanceof VaultPathNotFoundError) return { status: 404, json: body(guide("list_folder lists a folder, search_notes finds notes by their words.", "readNote")) };
   if (e instanceof ReadDeniedError) return { status: 403, json: body(READ_DENIED_GUIDANCE) };
-  if (e instanceof Forbidden) return { status: 403, json: body(FORBIDDEN_HINT) };
+  if (e instanceof Forbidden || e instanceof WriteDeniedError) return { status: 403, json: body(FORBIDDEN_HINT) };
   if (e instanceof AmbiguousCatalogRefError) {
     return { status: 409, json: { ...body(guide(`Name the table in full (catalog.schema.table): ${e.candidates.join(" or ")}.`, "catalogs")), tables: e.candidates } };
   }
@@ -69766,6 +70123,7 @@ function createHandlers(app, getSettings, saveSettings = async () => {
     batch: async (b) => {
       const operations = list(b, "operations");
       if (operations.length === 0) throw new BadRequest(`"operations" must be a non-empty list`);
+      const denied = /* @__PURE__ */ new Set();
       const steps = operations.map((raw, i) => {
         const { op: op2, ...args } = raw;
         if (typeof op2 !== "string") throw new BadRequest(`operation ${i} needs "op"`);
@@ -69780,7 +70138,10 @@ function createHandlers(app, getSettings, saveSettings = async () => {
         return {
           op: op2,
           run: async (dryRun) => {
-            const res = await ops[op2]({ ...args, dry_run: dryRun }).catch((e) => errorResponse(e, op2));
+            const res = await ops[op2]({ ...args, dry_run: dryRun }).catch((e) => {
+              if (e instanceof WriteDeniedError) denied.add(i);
+              return errorResponse(e, op2);
+            });
             if ("op" in res.json) return res.json;
             throw stepFailure(res.json);
           }
@@ -69791,8 +70152,13 @@ function createHandlers(app, getSettings, saveSettings = async () => {
         ...str(b, "summary") !== void 0 ? { summary: str(b, "summary") } : {}
       });
       const failedStep = r.failed_at !== void 0 && (r.steps[r.failed_at]?.result?.failed.length ?? 0) > 0;
-      const status = r.ok ? 200 : r.rolled_back === false ? 500 : writeStatus(failedStep, true);
+      const forbidden = r.failed_at !== void 0 ? denied.has(r.failed_at) ? r.failed_at : void 0 : [...denied].sort((a, b2) => a - b2)[0];
+      const status = r.ok ? 200 : r.rolled_back === false ? 500 : forbidden !== void 0 ? 403 : writeStatus(failedStep, true);
       const answer = redactBatchRollback(r, app, s());
+      if (status === 403) {
+        const step = answer.steps[forbidden];
+        return { status, json: { ...answer, error: `operation ${forbidden}: ${step.error}`, hint: step.hint, docs: step.docs } };
+      }
       return { status, json: answer.ok ? answer : { ...answer, ...batchGuidance(answer) } };
     },
     // --- queries ---
@@ -70256,6 +70622,7 @@ var STATUS_TEXT = {
   409: "Ambiguous table name: it matches several tables (`paths` or `tables` lists them)."
 };
 var READ_DENIED_TEXT = "A named token whose `read` patterns do not cover the table, view or note the request names (such as `token cook may not read personal.health.weight`). Sets it did not name (listings, bases, search, the graph, the change feed) are filtered instead.";
+var SESSION_TAKEN_TEXT = "The `session` belongs to another named token: the first token to report a session owns it (compared on its first 16 characters), and only that token and the owner may report it again. Nothing is stored.";
 var ERRORS = {
   400: { description: STATUS_TEXT[400], content: json(ref("Error")) },
   401: { $ref: "#/components/responses/Unauthorized" },
@@ -70271,6 +70638,7 @@ function postRoute(d) {
   const read3 = op2 !== void 0 ? READ_OPERATIONS.has(op2) : READ_ROUTES.has(d.route) && d.route !== "/tokens/update/";
   if (!read3) responses["403"] = ERRORS[403];
   else if (op2 !== void 0) responses["403"] = ERRORS.readDenied;
+  if (d.forbidden) responses["403"] = { description: d.forbidden, content: json(ref("Error")) };
   if (d.namesTable) responses["404"] = ERRORS[404];
   const refused2 = op2 !== void 0 ? refusedStatus(op2) : void 0;
   if (refused2 === 409) {
@@ -70609,6 +70977,7 @@ function openApiDocument(version2) {
       route: "/sessions/identify/",
       operationId: "identify_session",
       summary: "Tell the engine the model and harness behind an agent session (what an MCP server reports): later requests carrying that session in `X-Datanotes-Actor` are journaled with it. Any token may call it.",
+      forbidden: SESSION_TAKEN_TEXT,
       body: { type: "object", required: ["session"], properties: { session: { type: "string" }, model: { type: "string" }, harness: { type: "string" } } },
       bodyRequired: true,
       result: ok
@@ -70617,6 +70986,7 @@ function openApiDocument(version2) {
       route: "/tool-calls/record/",
       operationId: "record_tool_call",
       summary: "Record an agent's tool call in the change feed (`tool_call` events): what an MCP server reports after each call, its own tools included (`served_by`). Any token may call it.",
+      forbidden: SESSION_TAKEN_TEXT,
       body: {
         type: "object",
         required: ["tool"],
@@ -71352,6 +71722,8 @@ var MAX_IDENTITIES = 2e3;
 var SessionIdentities = class {
   constructor() {
     this.map = /* @__PURE__ */ new Map();
+    /** Who reported each session first: "owner" or a token's name, by the session's first 16 characters. */
+    this.owners = /* @__PURE__ */ new Map();
   }
   set(key2, info) {
     const clean2 = Object.fromEntries(Object.entries(info).filter(([, v]) => typeof v === "string" && v.trim() !== "").map(([k, v]) => [k, String(v).trim().slice(0, 200)]));
@@ -71363,6 +71735,21 @@ var SessionIdentities = class {
   get(key2) {
     return this.map.get(key2) ?? this.map.get(key2.slice(0, 16));
   }
+  /**
+   * Claim a session for a credential ("owner" or a token's name): the first one to report it keeps
+   * it. Answers the token that holds it when that is another named token, else null (claimed, or
+   * the owner, who may report any session). Keyed by the first 16 characters, as lookups fall back
+   * to them: a token cannot take over another's session with a longer or shorter id.
+   */
+  claim(key2, who) {
+    const k = key2.slice(0, 16);
+    const held = this.owners.get(k);
+    if (held !== void 0 && held !== who && who !== "owner") return held;
+    this.owners.delete(k);
+    if (this.owners.size >= MAX_IDENTITIES) this.owners.delete(this.owners.keys().next().value);
+    this.owners.set(k, held ?? who);
+    return null;
+  }
 };
 
 // src/server/runtime.ts
@@ -71749,6 +72136,7 @@ async function engineStatus(i) {
 // src/server/tokens.ts
 init_actor();
 init_read_scope();
+init_write_scope();
 init_metastore();
 init_store();
 init_telemetry();
@@ -71768,6 +72156,13 @@ function tableAllowed(full, patterns) {
 function scopeOf(t) {
   return t.read === void 0 || t.read.includes("*") ? null : { token: t.name, patterns: t.read };
 }
+function writeScopeOf(t) {
+  return t.write.includes("*") ? null : { token: t.name, patterns: t.write };
+}
+function writesRows(route) {
+  const op2 = operationOf(route);
+  return op2 === "batch" || op2 !== void 0 && Object.prototype.hasOwnProperty.call(ROW_WRITES, op2);
+}
 function readCovers(r, w) {
   return r === "*" || r === w || r.endsWith(".*") && w.startsWith(r.slice(0, -1));
 }
@@ -72010,7 +72405,12 @@ var TokenRegistry = class {
         telemetry().log("WARN", "datanotes token refused", { token_name: name, "http.route": route, reason: READ_SCOPE_UNSUPPORTED });
         return { status: 503, json: { error: READ_SCOPE_UNSUPPORTED, ...READ_SCOPE_UNSUPPORTED_HINT } };
       }
-      return runWithReadScope(scope, () => dispatch2(route, handler, body));
+      const writeScope = writeScopeOf(token);
+      if (writeScope && writesRows(route) && !(this.deps.readScopeSupported ?? READ_SCOPE_SUPPORTED)) {
+        telemetry().log("WARN", "datanotes token refused", { token_name: name, "http.route": route, reason: WRITE_SCOPE_UNSUPPORTED });
+        return { status: 503, json: { error: WRITE_SCOPE_UNSUPPORTED, ...WRITE_SCOPE_UNSUPPORTED_HINT } };
+      }
+      return runWithReadScope(scope, () => runWithWriteScope(writeScope, () => dispatch2(route, handler, body)));
     };
   }
   // --- routes --------------------------------------------------------------------------------
@@ -72254,6 +72654,7 @@ var ExtensionRegistry = class {
 init_metastore();
 init_query_tables();
 init_file_cache();
+init_read_scope();
 init_vault_index();
 var CACHED_READS = /* @__PURE__ */ new Set([
   "select_rows",
@@ -72389,7 +72790,7 @@ var ReadCache = class {
     if (this.maxBytes === 0 || !CACHED_READS.has(op2)) return null;
     const settings = this.getSettings();
     const model = (await loadMetastore(this.app, settings).catch(() => null))?.model ?? null;
-    const deps = readDeps(op2, body, model);
+    const deps = readDeps(op2, body, model, currentReadScope() !== null);
     if (!deps) return null;
     if (!this.looseKnown) this.indexLoose(settings);
     if (deps.links && !this.linkPrints) this.printLinks();
@@ -72535,7 +72936,7 @@ var ReadCache = class {
 function settingsKey(s) {
   return JSON.stringify(s, (k, v) => SECRET_SETTINGS.has(k) ? void 0 : v);
 }
-function readDeps(op2, body, model) {
+function readDeps(op2, body, model, restricted = false) {
   if (!CACHED_READS.has(op2)) return null;
   const text5 = JSON.stringify(body);
   if (text5.includes("{now")) return null;
@@ -72546,7 +72947,10 @@ function readDeps(op2, body, model) {
     const found = /* @__PURE__ */ new Set();
     const r = queryTables(body, model, found, 0);
     if (r.now || r.store) return null;
-    if (!r.vault) return { tables: [...found].sort(), today: today || r.today, ...r.links ? { links: true } : {} };
+    if (!r.vault) {
+      const tables = r.links && restricted ? catalogTables(model).map(({ ref: ref2 }) => ref2.full) : [...found];
+      return { tables: tables.sort(), today: today || r.today, ...r.links ? { links: true } : {} };
+    }
     const views = viewTimes(model);
     if (views.now) return null;
     return { tables: "vault", today: today || r.today || views.today };
@@ -72575,6 +72979,7 @@ function viewTimes(model) {
 // src/server/runtime.ts
 init_message();
 init_hints();
+var SESSION_TAKEN_HINT = guide("Use your own session id, such as a new UUID for each agent session. This session belongs to another token: only that token and the owner may report it.", "sessionOwner");
 var REPORT_HINT = guide(`Send {"session", "model", "harness"} to sessions/identify/ and {"tool", "args", "ok", ...} to tool-calls/record/; DatanotesClient.recordToolCall does it.`, "reportAgents");
 var EXTERNAL_EDIT_DELAY_MS = 3e3;
 var LOG_CHECK_EVERY_MS = 10 * 6e4;
@@ -72709,6 +73114,8 @@ var EngineRuntime = class {
       "/sessions/identify/": async (body) => {
         const session = typeof body.session === "string" ? body.session.trim() : "";
         if (!session) return { status: 400, json: { error: `"session" is required`, ...REPORT_HINT } };
+        const taken = this.sessionTaken(session);
+        if (taken) return taken;
         this.identities.set(session, { model: body.model, harness: body.harness });
         return { status: 200, json: { ok: true } };
       },
@@ -72724,6 +73131,8 @@ var EngineRuntime = class {
       // an MCP server reports the tool calls of its agents (the change feed's tool_call events)
       "/tool-calls/record/": async (body) => {
         if (typeof body.tool !== "string" || !body.tool) return { status: 400, json: { error: `"tool" is required`, ...REPORT_HINT } };
+        const taken = typeof body.session === "string" && body.session.trim() ? this.sessionTaken(body.session.trim()) : null;
+        if (taken) return taken;
         const actor = currentActor();
         await this.recordToolCall({
           tool: body.tool,
@@ -72772,6 +73181,14 @@ var EngineRuntime = class {
       } : {}
     };
   }
+  /**
+   * The 403 when the session belongs to another named token; else null, and the session is
+   * claimed for the caller when nobody reported it before (the first reporter keeps it).
+   */
+  sessionTaken(session) {
+    if (this.identities.claim(session, tokenNameOf(currentActor()) ?? "owner") === null) return null;
+    return { status: 403, json: { error: `session "${session}" belongs to another token`, ...SESSION_TAKEN_HINT } };
+  }
   /**
    * An agent's tool call, as a change-feed event (secrets removed, long values cut); settled once
    * it is recorded. The feed is kept in the store, which the store backup commits: no secret.
@@ -77216,7 +77633,7 @@ function setUp(o, vault, home, explicit, self) {
 // src/node/service.ts
 init_local();
 init_hints();
-var VERSION = true ? "3.4.0" : "dev";
+var VERSION = true ? "3.4.2" : "dev";
 function parsePort(raw, from = "--port") {
   const n = /^\s*\d+\s*$/.test(raw) ? Number(raw) : NaN;
   if (n === 0 || Number.isInteger(n) && n >= 1024 && n <= 65535) return n;
@@ -78281,7 +78698,7 @@ Docs: https://datanotes.dev`;
 
 // src/node/cli.ts
 init_message();
-var VERSION2 = true ? "3.4.0" : "dev";
+var VERSION2 = true ? "3.4.2" : "dev";
 var consoleError = console.error;
 async function main5(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;