datanotes 3.4.0 → 3.4.1

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,418 +29757,1131 @@ 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;
+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) });
+  };
+  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;
+      }
+    }
+  }
+  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 {
+    }
+  }
+  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
+  };
+}
+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);
+  }
+}
+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 });
+      }
+    }
+    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) });
+  }
+  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 });
+  }
+  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) });
+  }
+  for (const [path23, t] of texts) if (t.before !== t.after) cs.texts.push({ path: path23, ...t });
+  return cs;
+}
+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: []
+    };
+  }
+  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" });
+    }
+  }
+  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" });
+    }
+  }
+  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" });
+    }
+  }
+  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 {
+    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);
+  }
+  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"
+    };
+  }
+});
+
+// src/core/write-scope.ts
+function runWithWriteScope(scope, fn) {
+  if (!storage3) {
+    if (scope) throw new Error("write permissions need Node's AsyncLocalStorage");
+    return fn();
+  }
+  if (!scope && !storage3.getStore()) return fn();
+  return storage3.run({ scope }, fn);
+}
+function currentWriteScope() {
+  return storage3?.getStore()?.scope ?? null;
+}
+function tableOfFrontmatter(model, settings, fm) {
+  return rowTableFull(model, fmGet(fm, settings.tableKey));
+}
+function changeSetTables(app, settings, model, cs) {
+  const out2 = /* @__PURE__ */ new Set();
+  const add = (full) => {
+    if (full !== null) out2.add(full);
+  };
+  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));
+  }
+  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 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;
+    }
+    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;
+      }
+    };
+  }
+});
+
+// src/core/unreadable.ts
+function frontmatterError(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);
+  }
+  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 tocsOf(app) {
+  let m = TOCS.get(app);
+  if (!m) TOCS.set(app, m = /* @__PURE__ */ new Map());
+  return m;
+}
+function latestOf(toc) {
+  return toc.versions.length > 0 ? toc.versions[toc.versions.length - 1] : -1;
+}
+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 };
+}
+function framed(version2, text5) {
+  const lines = text5.split("\n").length - 1;
+  return `${JSON.stringify({ commit: { version: version2, lines, hash: contentHash(text5) } })}
+${text5}`;
+}
+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;
+}
+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();
+    }
+  }
+  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;
+}
+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 wholeVersions(app, seg) {
+  return new Set((await segmentText(app, seg)).index.keys());
+}
+function segmentsWith(toc, v) {
+  return toc.segments.filter((s) => v >= s.first && v <= s.last).reverse();
+}
+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;
+}
+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}`);
+  }
+  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 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 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 = [];
+  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;
+}
+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 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;
+    }
+    cur.push(l);
+    chars += l.length + 1;
+  }
+  if (cur.length > 0 || out2.length === 0) out2.push(cur);
+  return out2;
+}
+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);
@@ -30631,1128 +31346,499 @@ async function stateFromLogged(app, settings, state) {
     movesApplied: state.movesApplied
   };
 }
-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 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;
-    }
-    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);
-    }
-    live.cursor = cursor;
-  }
-  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}`);
-  }
-  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++;
-  }
-  return n;
-}
-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 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;
-    }
-  }
-  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++;
-    });
-  }
-  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 [path23, f] of prev.files) {
-    const now = files.get(path23);
-    if (!now || now.hash !== f.hash) remove3.push({ path: path23, hash: f.hash });
-  }
-  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;
-    }
-    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);
-      }
-    }
-  }
-  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]);
-  }
-  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);
-  }
-  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;
-      }
-      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++;
-      }
-    }
-    await storeFlush(app);
-    for (const seg of toc.segments) {
-      await storeRemove(app, seg.path);
-      result.removed++;
-    }
-  }
-  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"() {
-    "use strict";
-    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 {
-    };
-    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();
-  }
-});
-
-// src/core/changeset.ts
-function createdHash(text5) {
-  try {
-    const { ordered, body } = readOrderedFromMarkdown(text5);
-    return contentHash(JSON.stringify([ordered, body]));
-  } catch {
-    return contentHash(text5);
-  }
-}
-function bodyChanges(e) {
-  return e.bodyAfter !== void 0 && e.bodyAfter !== e.bodyBefore;
+function infoOf(text5) {
+  return JSON.parse(text5.slice(0, text5.indexOf("\n"))).commitInfo;
 }
-function bodyOf(text5) {
-  const split2 = splitFrontmatter(text5);
-  return split2 ? split2.body : text5;
+async function commitInfos(app, settings, full) {
+  const toc = await tocOf(app, settings, full);
+  return (await versionTexts(app, toc, toc.versions)).map(infoOf);
 }
-function replaceBody(text5, body) {
-  const split2 = splitFrontmatter(text5);
-  if (!split2) return body;
-  return text5.slice(0, text5.length - split2.body.length) + body;
+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 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 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 emptyChangeSet(op2, summary, schema) {
-  return {
-    op: op2,
-    summary,
-    ...schema !== void 0 ? { schema } : {},
-    edits: [],
-    creates: [],
-    moves: [],
-    deletes: [],
-    texts: []
-  };
+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 same(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
+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 diffOrdered(before, after) {
-  const b = new Map(before);
-  const a = new Map(after);
-  const d = {
-    set: [],
-    remove: [],
-    beforeValues: {},
-    beforeAbsent: [],
-    afterValues: {},
-    afterAbsent: []
+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) };
   };
-  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 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);
     }
+    live.cursor = cursor;
   }
-  return d;
+  return live.tables;
 }
-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 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}`);
+  }
+  if (out2.length > 0 && repair) forgetCurrentStates(app);
+  return out2.sort();
 }
-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 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));
 }
-function fileOrNull(app, path23) {
-  const f = app.vault.getAbstractFileByPath(path23);
-  return f != null && "extension" in f ? f : null;
+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) }));
 }
-function parentFolder(path23) {
-  const i = path23.lastIndexOf("/");
-  return i < 0 ? "" : path23.slice(0, i);
+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;
 }
-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 formatOf(settings) {
+  return settings.transactionLogFormat === "files" ? "files" : "segments";
 }
-async function readOrderedFor(app, file) {
-  return readOrderedFromMarkdown(await app.vault.read(file)).ordered;
+function setCheckpointRunner(app, run2) {
+  if (run2) CHECKPOINT_RUNNERS.set(app, run2);
+  else CHECKPOINT_RUNNERS.delete(app);
 }
-async function fileExists(app, path23) {
-  return inStore(path23) ? storeExists(app, path23) : fileOrNull(app, path23) != null;
+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++;
+  }
+  return n;
 }
-async function occupied(app, path23) {
-  return inStore(path23) ? storeExists(app, path23) : app.vault.getAbstractFileByPath(path23) != null;
+async function wholeCheckpoint(app, dir, v) {
+  return parseCheckpoint(await storeRead(app, checkpointPath(dir, v)) ?? "")?.version === v;
 }
-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 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;
     }
   }
-  return out2;
+  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 atOnceFor(count2) {
-  return count2 >= WRITE_CONCURRENCY.from ? WRITE_CONCURRENCY.atOnce : 1;
+function forgetLoggedStates(app) {
+  LAST.delete(app);
 }
-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);
-      }
-    }
-  }
-  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 knownState(app, settings, full) {
+  return LAST.get(app)?.get(full) ?? readLastState(app, settings, full);
 }
-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 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 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;
-      }
-    }
-  }
-  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 {
-    }
-  }
-  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
-  };
+async function stillLatest(app, settings, state) {
+  return latestOf(await tocOf(app, settings, state.full)) === state.version;
 }
-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);
-  }
+async function latestVersion(app, settings, full) {
+  const latest = latestOf(await tocOf(app, settings, full));
+  return latest >= 0 ? latest : null;
 }
-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 });
-      }
-    }
-    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);
+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++;
+    });
+  }
+  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 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) });
   }
-  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 });
+  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 });
   }
-  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) });
+  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 [path23, t] of texts) if (t.before !== t.after) cs.texts.push({ path: path23, ...t });
-  return cs;
+  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 };
 }
-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: []
-    };
-  }
-  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" });
+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;
     }
+    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 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" });
+  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);
   }
-  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" });
+  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 });
   }
-  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" });
+  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);
       }
-      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 });
+  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 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;
+}
+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 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 { 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 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 });
+      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);
       }
-    });
-  }
-  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 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++;
       }
-    });
-  }
-  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);
+    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();
@@ -66871,17 +66968,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 +69186,7 @@ init_guidance();
 init_requests();
 init_actor();
 init_read_scope();
+init_write_scope();
 init_changeset_checks();
 
 // src/server/token-routes.ts
@@ -69110,6 +69219,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 +69469,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 +69877,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 +69892,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 +69906,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 +70376,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 +70392,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 +70731,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 +70740,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 +71476,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 +71489,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 +71890,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 +71910,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 +72159,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 +72408,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 +72544,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 +72690,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 +72701,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 +72733,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 +72868,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 +72885,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 +72935,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 +77387,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.1" : "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 +78452,7 @@ Docs: https://datanotes.dev`;
 
 // src/node/cli.ts
 init_message();
-var VERSION2 = true ? "3.4.0" : "dev";
+var VERSION2 = true ? "3.4.1" : "dev";
 var consoleError = console.error;
 async function main5(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;