@omgbase/core 0.24.0 → 0.27.1

package/dist/src/core/edit-script.d.ts

@@ -0,0 +1,15 @@
+/** One step of the edit script: `keep` consumes a line from both sides,
+ * `delete` one from the old text, `insert` one from the new text. */
+export interface EditOp {
+    kind: "keep" | "delete" | "insert";
+    line: string;
+}
+/**
+ * Myers' O(ND) shortest edit script (forward, with a per-`d` trace for the
+ * backtrack). `V[k]` is the furthest x on diagonal `k = x - y` reachable with
+ * `d` edits. The canonical tie rule, identical in both engines: at each step
+ * take the diagonal from `k+1` (moving down — an insertion of `b[y]`) when
+ * `k == -d || (k != d && V[k-1] < V[k+1])`, else from `k-1` (moving right —
+ * a deletion of `a[x]`). On a tie (`V[k-1] == V[k+1]`) that is the deletion.
+ */
+export declare function myersScript(a: string[], b: string[]): EditOp[];

package/dist/src/core/edit-script.js

@@ -0,0 +1,72 @@
+// Myers' shortest edit script over two string arrays — the ONE diff algorithm
+// both engines share, so an edit script is deterministic across them. Two
+// consumers: the unified diff of `docs_diff_unified` (spec/surface §3;
+// `graph/history.ts` re-exports it, and `crates/omgbase-surface/src/history.rs`
+// is the twin) and the delta tree nodes of spec/store §4.1 (16.0;
+// `core/store/delta.ts`), whose ops are this script grouped. Kept in `core/`
+// because the store cannot import `graph/`.
+/**
+ * Myers' O(ND) shortest edit script (forward, with a per-`d` trace for the
+ * backtrack). `V[k]` is the furthest x on diagonal `k = x - y` reachable with
+ * `d` edits. The canonical tie rule, identical in both engines: at each step
+ * take the diagonal from `k+1` (moving down — an insertion of `b[y]`) when
+ * `k == -d || (k != d && V[k-1] < V[k+1])`, else from `k-1` (moving right —
+ * a deletion of `a[x]`). On a tie (`V[k-1] == V[k+1]`) that is the deletion.
+ */
+export function myersScript(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const max = n + m;
+    // V is indexed by k ∈ [-max-1, max+1]; `off` maps it onto a plain array.
+    const off = max + 1;
+    const v = new Array(2 * max + 3).fill(0);
+    const trace = [];
+    let found = false;
+    for (let d = 0; d <= max && !found; d++) {
+        trace.push(v.slice());
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && v[off + k - 1] < v[off + k + 1]))
+                x = v[off + k + 1];
+            else
+                x = v[off + k - 1] + 1;
+            let y = x - k;
+            while (x < n && y < m && a[x] === b[y]) {
+                x++;
+                y++;
+            }
+            v[off + k] = x;
+            if (x >= n && y >= m) {
+                found = true;
+                break;
+            }
+        }
+    }
+    // Backtrack from (n, m) through the trace, emitting ops newest-first.
+    const ops = [];
+    let x = n;
+    let y = m;
+    for (let d = trace.length - 1; d >= 0; d--) {
+        const vd = trace[d];
+        const k = x - y;
+        const prevK = k === -d || (k !== d && vd[off + k - 1] < vd[off + k + 1]) ? k + 1 : k - 1;
+        const prevX = vd[off + prevK];
+        const prevY = prevX - prevK;
+        while (x > prevX && y > prevY) {
+            x--;
+            y--;
+            ops.push({ kind: "keep", line: a[x] });
+        }
+        if (d > 0) {
+            if (x === prevX)
+                ops.push({ kind: "insert", line: b[prevY] });
+            else
+                ops.push({ kind: "delete", line: a[prevX] });
+        }
+        x = prevX;
+        y = prevY;
+    }
+    ops.reverse();
+    return ops;
+}
+//# sourceMappingURL=edit-script.js.map

package/dist/src/core/ingest.js

@@ -2,7 +2,8 @@ import { Store } from "./store/store.js";
 import { parseTree } from "./parse/tree.js";
 import { render } from "./parse/render.js";
 import { reconstructContent } from "./read/document.js";
-import { assignIds, writeBlockTree, putBlob, newCommit, writeRevision } from "./store/writers.js";
+import { assignIds, writeBlockTree, writeFrontmatterBlob, isCheckpointRevision, previousRevision, newCommit, writeRevision } from "./store/writers.js";
+import { TreeResolver } from "./store/delta.js";
 import { sha256, childQuoteDepth, visibleText } from "./hash.js";
 import { mintId } from "./ids.js";
 import { keyBetween } from "./order-key.js";
@@ -114,20 +115,22 @@ export function ingestInto(db, repoId, path, content, opts) {
     const format = opts.format ?? adapter?.format ?? "markdown";
     const tree = opts.parsed ?? (adapter ? adapter.parse(content) : parseTree(content));
     const { fmBlock, rest } = extractFrontmatter(tree.children);
-    // Frontmatter blob (markdown-specific) preserved for revision history.
-    const fmBlobHex = fmBlock ? putBlob(db, fmBlock.raw) : null;
     // The exact separator bytes between the frontmatter block and the first body
     // block (the frontmatter block's trailing trivia). Persisted so the body
     // reconstructs byte-for-byte instead of assuming a canonical blank line.
     // NULL when there is no frontmatter.
     const fmTrivia = fmBlock ? fmBlock.trivia : null;
-    // Document property bag: whole-document metadata for the formats whose
-    // adapter extracts one (YAML, JSON); for Markdown — whose adapter has no
-    // `extractMetadata` — the YAML of the `frontmatter` block and nothing else
-    // (spec/properties §3.1: a document whose first block is not `frontmatter`
-    // has no frontmatter rows, whatever else its bytes resemble). Flattened into
-    // the properties table below (source=frontmatter); also drives frontmatter
-    // edge extraction.
+    // Document property bag — the document's AUTHORED MAPPING. For a `yaml` or
+    // `json` document it is the whole document's top-level mapping, from the
+    // adapter's `extractMetadata` (spec/properties §3.4, 1.2: null for a
+    // non-mapping root, a syntax error or an empty file; a YAML stream's first
+    // document only); for Markdown — whose adapter has no `extractMetadata` — the
+    // YAML of the `frontmatter` block and nothing else (§3.1: a document whose
+    // first block is not `frontmatter` has no frontmatter rows, whatever else its
+    // bytes resemble). Either way it is flattened into the properties table below
+    // under source=frontmatter — the same source, because it is the same thing
+    // (§3.4: "frontmatter" names the document's authored mapping) — and drives
+    // frontmatter edge extraction.
     const metadata = adapter?.extractMetadata
         ? (adapter.extractMetadata(content) ?? {})
         : parseFrontmatter(fmBlock);
@@ -161,7 +164,29 @@ export function ingestInto(db, repoId, path, content, opts) {
         ? opts.resolveIds(rest, isNew ? null : docId)
         : { assigned: assignIds(rest), dispositions: [], deleted: [] };
     const assigned = resolved.assigned;
-    const rootTreeHex = writeBlockTree(db, assigned);
+    // spec/store §4.4 (16.0): the revision's seq decides whether it is a
+    // checkpoint; a non-checkpoint revision writes its tree and frontmatter as
+    // deltas against the previous revision's RESOLVED tree and raw where that is
+    // smaller. The previous revision is the document's greatest seq — on every
+    // path the current revision, never archived (retention rule 1) — but the
+    // rule is stated for the general case: no live predecessor ⇒ a checkpoint.
+    const previous = previousRevision(db, docId);
+    const seq = previous ? previous.seq + 1 : 1;
+    const checkpoint = isCheckpointRevision(seq, previous);
+    const resolver = new TreeResolver(db);
+    const treeCtx = {
+        checkpoint,
+        base: !checkpoint && previous?.root_tree ? resolver.tree(docId, previous.seq, previous.root_tree.toString("hex")) : null,
+    };
+    const rootTreeHex = writeBlockTree(db, assigned, treeCtx);
+    // Frontmatter blob (markdown-specific) preserved for revision history: the
+    // raw at a checkpoint, else the smaller of a line delta over the previous
+    // revision's frontmatter and the raw (spec/store §5.4 step 1).
+    let fmBlobHex = null;
+    if (fmBlock) {
+        const baseRaw = !checkpoint && previous?.frontmatter_blob ? resolver.frontmatter(docId, previous.seq, previous.frontmatter_blob.toString("hex")) : null;
+        fmBlobHex = writeFrontmatterBlob(db, fmBlock.raw, baseRaw, checkpoint);
+    }
     const renderedHash = sha256(content);
     const rev = writeRevision(db, {
         docId,
@@ -170,6 +195,7 @@ export function ingestInto(db, repoId, path, content, opts) {
         renderedHash,
         path,
         commitId,
+        seq,
     });
     // Snapshot deleted blocks into the resurrection pool BEFORE dropping the
     // doc's rows (the ingest rebuilds current-state blocks wholesale).
@@ -264,7 +290,11 @@ export function ingestInto(db, repoId, path, content, opts) {
         propertyRows.push({ source: "frontmatter", blockId: null, ...r });
     }
     // Computed → property rows (source=computed). Engine-derived $-intrinsics
-    // ($title, $tags) from the adapter; never claim authored keys.
+    // ($title, $tags) from the adapter; never claim authored keys. Only the
+    // Markdown adapter computes (spec/properties §3.3): a `yaml`/`json` document
+    // has no body prose to derive a heading or a hashtag from, and its authored
+    // `title`/`tags` are reached as any other key of its mapping (§3.4), so it
+    // yields no computed rows.
     if (adapter?.computeProperties) {
         const computed = adapter.computeProperties(rest, metadata);
         for (const r of flattenComputed(computed)) {

package/dist/src/core/read/document.d.ts

@@ -32,6 +32,13 @@ export interface DocsReadResult {
 export interface DocsReadOptions {
     includeIds?: boolean;
 }
+/**
+ * A live revision's frontmatter raw (spec/store §6.1, 16.0): the blob the row
+ * names, resolved when it is a `{"f":…}` delta over the previous revision's
+ * (`TreeResolver.frontmatter`, at most 15 steps back). `null` when the
+ * revision has no frontmatter.
+ */
+export declare function currentFrontmatterRaw(db: Database, revId: string): string | null;
 /**
  * Reconstruct a document's full file bytes from its ordered top-level blocks.
  * Takes a raw Database handle so it can run inside an ingest transaction (the

package/dist/src/core/read/document.js

@@ -3,10 +3,30 @@ import { docPropertiesGrouped } from "../store/properties.js";
 import { sha256 } from "../hash.js";
 import { referencePath } from "../paths.js";
 import { revisionBody } from "../store/archive.js";
+import { TreeResolver } from "../store/delta.js";
+// A revision's root tree node is a JSON array of six-field canonical tuples
+// (see core/hash.ts serializeTreeEntries):
+//   [blockId, rawHashHex, childTreeHashHex, type, attrs, triviaHashHex]
+// — or, since 16.0, a delta over the previous revision's (core/store/delta.ts).
+// We read the top-level entries in array order and keep raw + trivia hashes;
+// child subtrees are NOT walked (a container block's `raw` already contains its
+// children verbatim — the same reason reconstructContent walks only roots).
 function blob(db, hash) {
     const row = db.prepare("SELECT bytes FROM blobs WHERE hash = ?").get(hash);
     return row ? row.bytes.toString("utf8") : "";
 }
+/**
+ * A live revision's frontmatter raw (spec/store §6.1, 16.0): the blob the row
+ * names, resolved when it is a `{"f":…}` delta over the previous revision's
+ * (`TreeResolver.frontmatter`, at most 15 steps back). `null` when the
+ * revision has no frontmatter.
+ */
+export function currentFrontmatterRaw(db, revId) {
+    const rev = db.prepare("SELECT doc_id, seq, frontmatter_blob FROM revisions WHERE rev_id = ?").get(revId);
+    if (!rev?.frontmatter_blob)
+        return null;
+    return new TreeResolver(db).frontmatter(rev.doc_id, rev.seq, rev.frontmatter_blob.toString("hex"));
+}
 /**
  * Reconstruct a document's full file bytes from its ordered top-level blocks.
  * Takes a raw Database handle so it can run inside an ingest transaction (the
@@ -20,13 +40,13 @@ export function reconstructContent(db, docId) {
         return null;
     const out = [doc.leading_trivia];
     if (doc.current_rev) {
-        const rev = db.prepare("SELECT frontmatter_blob FROM revisions WHERE rev_id = ?").get(doc.current_rev);
+        const fm = currentFrontmatterRaw(db, doc.current_rev);
         // Emit the frontmatter block followed by its exact stored separator. Ingest
         // always captures frontmatter_trivia whenever a frontmatter block exists, so
         // frontmatter_blob present ⇒ frontmatter_trivia is a real string (possibly
         // ""); the ?? "" is just a type guard.
-        if (rev?.frontmatter_blob)
-            out.push(blob(db, rev.frontmatter_blob) + (doc.frontmatter_trivia ?? ""));
+        if (fm !== null)
+            out.push(fm + (doc.frontmatter_trivia ?? ""));
     }
     // Top-level blocks only: a container's `raw` already contains its nested
     // children verbatim (03 §2.3), so walking roots reconstructs the whole body.
@@ -190,22 +210,23 @@ export function readDocumentAtRevision(store, docId, revId) {
         return row ? row.bytes.toString("utf8") : "";
     };
     const out = [doc.leading_trivia];
-    // Frontmatter blob for THIS revision (per-revision), then the doc-level
+    // The revision's nodes resolved in its context (spec/store §6.2, 16.0): a
+    // `{`-form root or frontmatter walks back through the previous revisions
+    // of the document to a checkpoint; a segment holds checkpoint forms only.
+    const resolver = new TreeResolver(db, rev.prefix);
+    // Frontmatter for THIS revision (per-revision), then the doc-level
     // separator (best-effort — see fidelity caveat).
     if (rev.frontmatter_blob)
-        out.push(blobAt(rev.frontmatter_blob) + (doc.frontmatter_trivia ?? ""));
-    // Top-level blocks in tree order, from THIS revision's Merkle root tree node.
-    // A container's raw already holds its children verbatim, so we deliberately do
-    // NOT recurse into childTreeHashHex (mirrors reconstructContent's
-    // parent_block IS NULL walk). An absent tree node yields empty body bytes.
-    const node = db.prepare(`SELECT entries FROM ${at("tree_nodes")} WHERE hash = ?`).get(rev.root_tree);
-    if (node) {
-        const entries = JSON.parse(node.entries);
-        for (const [, rawHashHex, , , , triviaHashHex] of entries) {
-            out.push(blobAt(Buffer.from(rawHashHex, "hex")));
-            if (triviaHashHex)
-                out.push(blobAt(Buffer.from(triviaHashHex, "hex")));
-        }
+        out.push(resolver.frontmatter(rev.doc_id, rev.seq, rev.frontmatter_blob.toString("hex")) + (doc.frontmatter_trivia ?? ""));
+    // Top-level blocks in tree order, from THIS revision's Merkle root. A
+    // container's raw already holds its children verbatim, so we deliberately do
+    // NOT recurse into the child trees (mirrors reconstructContent's
+    // parent_block IS NULL walk).
+    const root = resolver.list(rev.doc_id, rev.seq, rev.root_tree.toString("hex"), null);
+    for (const [, rawHashHex, , , , triviaHashHex] of root.entries) {
+        out.push(blobAt(Buffer.from(rawHashHex, "hex")));
+        if (triviaHashHex)
+            out.push(blobAt(Buffer.from(triviaHashHex, "hex")));
     }
     const content = out.join("");
     const renderedHashMatch = sha256(content).equals(rev.rendered_hash);

package/dist/src/core/store/archive.d.ts

@@ -1,4 +1,5 @@
 import type { Store } from "./store.js";
+import { TreeResolver } from "./delta.js";
 import { type EvaluateOptions, type RetentionPlan, type RetentionPolicy } from "./retention.js";
 /** spec/store/archive.sql, verbatim — the segment's DDL. */
 export declare const ARCHIVE_DDL = "-- ---- an archive segment (spec/store \u00A77 \"Retention\", 15.0) --------------------\n-- One file per `history export`, never appended: the bodies of the revisions\n-- the retention policy squashed, self-contained (every blob and tree node\n-- reachable from them), plus copies of their revision, commit, disposition and\n-- block-change rows, and one manifest row. The same DDL subset as schema.sql\n-- minus the foreign keys (a segment holds no repos or docs rows).\nCREATE TABLE IF NOT EXISTS manifest (\n  segment_id          TEXT PRIMARY KEY,\n  repo_id             TEXT NOT NULL,\n  created_at          TEXT NOT NULL,\n  policy              TEXT NOT NULL,\n  seq_lo              INTEGER NOT NULL,\n  seq_hi              INTEGER NOT NULL,\n  revision_count      INTEGER NOT NULL,\n  previous_segment    TEXT,\n  schema_user_version INTEGER NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS revisions (\n  rev_id           TEXT PRIMARY KEY,\n  doc_id           TEXT NOT NULL,\n  seq              INTEGER NOT NULL,\n  root_tree        BLOB NOT NULL,\n  frontmatter_blob BLOB,\n  rendered_hash    BLOB NOT NULL,\n  path             TEXT NOT NULL,\n  commit_id        TEXT NOT NULL,\n  UNIQUE (doc_id, seq)\n);\n\nCREATE TABLE IF NOT EXISTS commits (\n  commit_id     TEXT PRIMARY KEY,\n  repo_id       TEXT NOT NULL,\n  seq           INTEGER NOT NULL,\n  ts            TEXT NOT NULL,\n  origin        TEXT NOT NULL CHECK (origin IN ('api','observed','import','projection')),\n  actor         TEXT,\n  reason        TEXT,\n  checkpoint_id TEXT,\n  ops           TEXT\n);\n\nCREATE TABLE IF NOT EXISTS blobs (\n  hash  BLOB PRIMARY KEY,\n  bytes BLOB NOT NULL,\n  size  INTEGER NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS tree_nodes (\n  hash    BLOB PRIMARY KEY,\n  entries TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS dispositions (\n  commit_id  TEXT NOT NULL,\n  block_id   TEXT NOT NULL,\n  kind       TEXT NOT NULL CHECK (kind IN\n             ('same','edited','moved','edited_moved','inserted','deleted',\n              'split_from','merged_into','copied_from','resurrected','bulk_rewrite')),\n  confidence REAL,\n  reason     TEXT,\n  matcher_v  TEXT,\n  detail     TEXT NOT NULL DEFAULT '{}',\n  PRIMARY KEY (commit_id, block_id, kind)\n);\n\nCREATE TABLE IF NOT EXISTS block_changes (\n  block_id  TEXT NOT NULL,\n  commit_id TEXT NOT NULL,\n  kind      TEXT NOT NULL,\n  PRIMARY KEY (block_id, commit_id, kind)\n);\n";
@@ -120,6 +121,8 @@ export declare function archivePrefix(store: Store, rev: {
 export interface RevisionBody {
     rev_id: string;
     doc_id: string;
+    /** The per-document seq — the context a `{`-form node is resolved in (spec/store §6, 16.0). */
+    seq: number;
     path: string;
     rendered_hash: Buffer;
     root_tree: Buffer;
@@ -135,6 +138,29 @@ export interface RevisionBody {
  * its segment is unavailable.
  */
 export declare function revisionBody(store: Store, revId: string, docId?: string): RevisionBody | undefined;
+/**
+ * A live revision's bodies in CHECKPOINT form (spec/store §7.1, 16.0): every
+ * list a self-contained `[`-node, the frontmatter its raw — what a segment
+ * holds (a segment never walks back) and what the squash re-checkpoints a
+ * kept revision to when it archives the revision's base. `nodes` maps each
+ * full node's hex hash to its text; `blobs` are the raw/trivia hashes the
+ * tree names (every one present in the store while the bases are live);
+ * `frontmatter` is the raw and its hash, or null.
+ */
+export declare function checkpointBodies(store: Store, rev: {
+    doc_id: string;
+    seq: number;
+    root_tree: Buffer;
+    frontmatter_blob: Buffer | null;
+}, resolver?: TreeResolver): {
+    rootHex: string;
+    nodes: Map<string, string>;
+    blobs: Set<string>;
+    frontmatter: {
+        raw: string;
+        hex: string;
+    } | null;
+};
 export interface SegmentInfo {
     id: string;
     path: string;
@@ -152,6 +178,8 @@ export interface SquashResult {
     commits: number;
     dispositions: number;
     block_changes: number;
+    /** Kept revisions re-written in checkpoint form because the squash archived their base (spec/store §4.4, 16.0). */
+    checkpointed: number;
 }
 export interface ExportResult {
     plan: RetentionPlan;

package/dist/src/core/store/archive.js

@@ -3,8 +3,11 @@ import { chmodSync, existsSync, mkdirSync, readdirSync, renameSync, statSync, un
 import { basename, join, resolve } from "node:path";
 import { SCHEMA_VERSION } from "./schema.js";
 import { mintId } from "../ids.js";
+import { sha256 } from "../hash.js";
 import { sweepUnreachable } from "./gc.js";
-import { evaluateRetention, parseSettingsJson, ReachMarker, LAST_SEGMENT_SETTINGS_KEY, RETENTION_SETTINGS_KEY, } from "./retention.js";
+import { TreeResolver, entryBlobs } from "./delta.js";
+import { putBlob, putNodeText } from "./writers.js";
+import { evaluateRetention, parseSettingsJson, LAST_SEGMENT_SETTINGS_KEY, RETENTION_SETTINGS_KEY, } from "./retention.js";
 // Archive segments (spec/store §7 "Retention: plan, export, squash", 15.0).
 //
 // A segment is ONE SQLite file per `history export`, never appended: the bodies
@@ -366,18 +369,41 @@ export function archivePrefix(store, rev) {
  */
 export function revisionBody(store, revId, docId) {
     const row = store.db
-        .prepare(`SELECT rev_id, doc_id, path, rendered_hash, root_tree, frontmatter_blob, archive FROM revisions WHERE rev_id = ?${docId === undefined ? "" : " AND doc_id = ?"}`)
+        .prepare(`SELECT rev_id, doc_id, seq, path, rendered_hash, root_tree, frontmatter_blob, archive FROM revisions WHERE rev_id = ?${docId === undefined ? "" : " AND doc_id = ?"}`)
         .get(...(docId === undefined ? [revId] : [revId, docId]));
     if (!row)
         return undefined;
     if (row.archive === null) {
-        return { rev_id: row.rev_id, doc_id: row.doc_id, path: row.path, rendered_hash: row.rendered_hash, root_tree: row.root_tree, frontmatter_blob: row.frontmatter_blob, prefix: "", archived: false };
+        return { rev_id: row.rev_id, doc_id: row.doc_id, seq: row.seq, path: row.path, rendered_hash: row.rendered_hash, root_tree: row.root_tree, frontmatter_blob: row.frontmatter_blob, prefix: "", archived: false };
     }
     const prefix = archivePrefix(store, row);
     const body = store.db.prepare(`SELECT root_tree, frontmatter_blob FROM ${prefix}revisions WHERE rev_id = ?`).get(revId);
     if (!body)
         throw new RevisionArchived(revId, row.archive, archiveRow(store, row.archive)?.path ?? null);
-    return { rev_id: row.rev_id, doc_id: row.doc_id, path: row.path, rendered_hash: row.rendered_hash, root_tree: body.root_tree, frontmatter_blob: body.frontmatter_blob, prefix, archived: true };
+    return { rev_id: row.rev_id, doc_id: row.doc_id, seq: row.seq, path: row.path, rendered_hash: row.rendered_hash, root_tree: body.root_tree, frontmatter_blob: body.frontmatter_blob, prefix, archived: true };
+}
+/**
+ * A live revision's bodies in CHECKPOINT form (spec/store §7.1, 16.0): every
+ * list a self-contained `[`-node, the frontmatter its raw — what a segment
+ * holds (a segment never walks back) and what the squash re-checkpoints a
+ * kept revision to when it archives the revision's base. `nodes` maps each
+ * full node's hex hash to its text; `blobs` are the raw/trivia hashes the
+ * tree names (every one present in the store while the bases are live);
+ * `frontmatter` is the raw and its hash, or null.
+ */
+export function checkpointBodies(store, rev, resolver = new TreeResolver(store.db)) {
+    const tree = resolver.tree(rev.doc_id, rev.seq, rev.root_tree.toString("hex"));
+    const { rootHex, nodes } = resolver.checkpointForm(tree);
+    const blobs = new Set();
+    entryBlobs(tree.root.entries, blobs);
+    for (const list of tree.byBlock.values())
+        entryBlobs(list.entries, blobs);
+    let frontmatter = null;
+    if (rev.frontmatter_blob) {
+        const raw = resolver.frontmatter(rev.doc_id, rev.seq, rev.frontmatter_blob.toString("hex"));
+        frontmatter = { raw, hex: sha256(raw).toString("hex") };
+    }
+    return { rootHex, nodes, blobs, frontmatter };
 }
 /** An unrecorded segment under `dest` names both live and non-live revisions (it predates another squash, or belongs elsewhere). */
 export class StaleSegment extends Error {
@@ -446,14 +472,29 @@ function writeSegment(store, repoId, revIds, plan, dest) {
     const segmentId = mintId("s");
     const createdAt = plan.now;
     const previous = lastSegment(store, repoId);
-    const marker = new ReachMarker(store);
-    const trees = new Set();
+    // spec/store §7.1 (16.0): a segment holds CHECKPOINT forms — every list a
+    // self-contained node, the frontmatter its raw — so a reader of the segment
+    // never walks back into revisions that are not in it. The forms are computed
+    // from the resolved trees (a delta revision's full nodes and resolved raw
+    // were never rows of the store); the raw/trivia blobs they name are.
+    const resolver = new TreeResolver(db);
+    const nodes = new Map();
     const blobs = new Set();
-    marker.mark(revisions, trees, blobs);
+    const fmBlobs = new Map();
+    const bodies = new Map();
+    for (const r of revisions) {
+        const cp = checkpointBodies(store, r, resolver);
+        for (const [h, text] of cp.nodes)
+            nodes.set(h, text);
+        for (const b of cp.blobs)
+            blobs.add(b);
+        if (cp.frontmatter)
+            fmBlobs.set(cp.frontmatter.hex, cp.frontmatter.raw);
+        bodies.set(r.rev_id, { rootHex: cp.rootHex, fmHex: cp.frontmatter?.hex ?? null });
+    }
     const wholly = whollyArchivedCommits(store, new Set(revIds));
     const dispRows = db.prepare("SELECT commit_id, block_id, kind, confidence, reason, matcher_v, detail FROM dispositions WHERE commit_id = ? ORDER BY block_id, kind");
     const bcRows = db.prepare("SELECT block_id, commit_id, kind FROM block_changes WHERE commit_id = ? ORDER BY block_id, kind");
-    const treeRow = db.prepare("SELECT hash, entries FROM tree_nodes WHERE hash = ?");
     const blobRow = db.prepare("SELECT hash, bytes, size FROM blobs WHERE hash = ?");
     mkdirSync(dest, { recursive: true });
     for (const stale of readdirSync(dest))
@@ -471,23 +512,26 @@ function writeSegment(store, repoId, revIds, plan, dest) {
             seg.prepare("INSERT INTO manifest (segment_id, repo_id, created_at, policy, seq_lo, seq_hi, revision_count, previous_segment, schema_user_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)")
                 .run(segmentId, repoId, createdAt, JSON.stringify(plan.policy), seqLo, seqHi, revisions.length, previous, SCHEMA_VERSION);
             const insRev = seg.prepare("INSERT INTO revisions (rev_id, doc_id, seq, root_tree, frontmatter_blob, rendered_hash, path, commit_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-            for (const r of revisions)
-                insRev.run(r.rev_id, r.doc_id, r.seq, r.root_tree, r.frontmatter_blob, r.rendered_hash, r.path, r.commit_id);
+            for (const r of revisions) {
+                const body = bodies.get(r.rev_id);
+                insRev.run(r.rev_id, r.doc_id, r.seq, Buffer.from(body.rootHex, "hex"), body.fmHex ? Buffer.from(body.fmHex, "hex") : null, r.rendered_hash, r.path, r.commit_id);
+            }
             const insCommit = seg.prepare("INSERT INTO commits (commit_id, repo_id, seq, ts, origin, actor, reason, checkpoint_id, ops) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
             for (const c of commits)
                 insCommit.run(c.commit_id, c.repo_id, c.seq, c.ts, c.origin, c.actor, c.reason, c.checkpoint_id, c.ops);
             const insTree = seg.prepare("INSERT INTO tree_nodes (hash, entries) VALUES (?, ?)");
-            for (const t of [...trees].sort()) {
-                const row = treeRow.get(Buffer.from(t, "hex"));
-                if (row)
-                    insTree.run(row.hash, row.entries);
-            }
-            const insBlob = seg.prepare("INSERT INTO blobs (hash, bytes, size) VALUES (?, ?, ?)");
+            for (const h of [...nodes.keys()].sort())
+                insTree.run(Buffer.from(h, "hex"), nodes.get(h));
+            const insBlob = seg.prepare("INSERT OR IGNORE INTO blobs (hash, bytes, size) VALUES (?, ?, ?)");
             for (const b of [...blobs].sort()) {
                 const row = blobRow.get(Buffer.from(b, "hex"));
                 if (row)
                     insBlob.run(row.hash, row.bytes, row.size);
             }
+            for (const h of [...fmBlobs.keys()].sort()) {
+                const bytes = Buffer.from(fmBlobs.get(h), "utf8");
+                insBlob.run(Buffer.from(h, "hex"), bytes, bytes.length);
+            }
             const insDisp = seg.prepare("INSERT INTO dispositions (commit_id, block_id, kind, confidence, reason, matcher_v, detail) VALUES (?, ?, ?, ?, ?, ?, ?)");
             const insBc = seg.prepare("INSERT INTO block_changes (block_id, commit_id, kind) VALUES (?, ?, ?)");
             for (const c of wholly) {
@@ -520,6 +564,14 @@ function writeSegment(store, repoId, revIds, plan, dest) {
 function squash(store, repoId, segment, revIds) {
     return store.write((db) => {
         const wholly = whollyArchivedCommits(store, new Set(revIds));
+        // spec/store §4.4 "base liveness" (16.0): a kept revision whose previous
+        // revision this squash archives is re-written in checkpoint form FIRST,
+        // while its bases are still readable — its delta nodes and delta
+        // frontmatter resolve, the self-contained forms are put, the row repointed.
+        // Its own successors are untouched: a delta is over the resolved content,
+        // which re-encoding does not change, and only self-contained nodes are
+        // ever reused across revisions.
+        const checkpointed = checkpointDependents(store, new Set(revIds));
         const upd = db.prepare("UPDATE revisions SET root_tree = NULL, frontmatter_blob = NULL, archive = ? WHERE rev_id = ?");
         for (const id of revIds)
             upd.run(segment.id, id);
@@ -543,11 +595,48 @@ function squash(store, repoId, segment, revIds) {
         });
         setLastSegment(store, repoId, segment.id);
         return {
-            squashed: { revisions: revIds.length, commits: wholly.length, dispositions, block_changes: blockChanges },
+            squashed: { revisions: revIds.length, commits: wholly.length, dispositions, block_changes: blockChanges, checkpointed },
             gc: { blobs: swept.blobsSwept, tree_nodes: swept.treeNodesSwept },
         };
     });
 }
+/**
+ * Re-checkpoint every live revision that stays and whose predecessor
+ * (`seq − 1`, same document) is in `archiving`: resolve its tree and
+ * frontmatter, put the checkpoint forms, repoint the row. Returns how many
+ * rows changed (a revision already in checkpoint form changes nothing).
+ * Runs inside the squash transaction, before the bases lose their bodies.
+ */
+function checkpointDependents(store, archiving) {
+    const db = store.db;
+    const revRow = db.prepare("SELECT doc_id, seq FROM revisions WHERE rev_id = ?");
+    const nextRow = db.prepare("SELECT rev_id, doc_id, seq, root_tree, frontmatter_blob FROM revisions WHERE doc_id = ? AND seq = ? AND archive IS NULL");
+    const upd = db.prepare("UPDATE revisions SET root_tree = ?, frontmatter_blob = ? WHERE rev_id = ?");
+    const resolver = new TreeResolver(db);
+    const seen = new Set();
+    let changed = 0;
+    for (const id of [...archiving].sort()) {
+        const r = revRow.get(id);
+        if (!r)
+            continue;
+        const next = nextRow.get(r.doc_id, r.seq + 1);
+        if (!next || !next.root_tree || archiving.has(next.rev_id) || seen.has(next.rev_id))
+            continue;
+        seen.add(next.rev_id);
+        const cp = checkpointBodies(store, { doc_id: next.doc_id, seq: next.seq, root_tree: next.root_tree, frontmatter_blob: next.frontmatter_blob }, resolver);
+        const fmHex = cp.frontmatter ? cp.frontmatter.hex : null;
+        const oldFm = next.frontmatter_blob ? next.frontmatter_blob.toString("hex") : null;
+        if (cp.rootHex === next.root_tree.toString("hex") && fmHex === oldFm)
+            continue;
+        for (const text of cp.nodes.values())
+            putNodeText(db, text);
+        if (cp.frontmatter)
+            putBlob(db, cp.frontmatter.raw);
+        upd.run(Buffer.from(cp.rootHex, "hex"), fmHex ? Buffer.from(fmHex, "hex") : null, next.rev_id);
+        changed++;
+    }
+    return changed;
+}
 /**
  * `omg history export [--prune]`: evaluate the policy, write ONE new segment
  * for the revisions to archive (or finish an unrecorded one — the crash