@omgbase/core 0.1.0

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

@@ -0,0 +1,101 @@
+import { mintId } from "../ids.js";
+// Stable key for diffing an edge set against currently-open rows.
+function edgeKey(e) {
+    return `${e.srcBlock ?? ""}|${e.srcField ?? ""}|${e.predicate}|${e.dstNode}|${e.anchor ?? ""}`;
+}
+/**
+ * Reconcile the extracted edge set for a document against its currently-open
+ * rows: close rows no longer present (to_commit = this), open rows that are new
+ * (from_commit = this), leave unchanged rows untouched. Then recompute the
+ * doc_edges rollup for the doc. All within the caller's transaction.
+ */
+export function maintainEdges(db, repoId, srcDoc, commitId, edges) {
+    const openRows = db
+        .prepare(`SELECT edge_id, src_block, src_field, predicate, dst_node, anchor FROM edges
+       WHERE src_doc = ? AND to_commit IS NULL`)
+        .all(srcDoc);
+    // One open row per key. Two spellings of one target in one block
+    // (`../old.md` and `./x/../../old.md`) extract as two descriptors but resolve
+    // to the SAME key, so dedupe the wanted set here; and any duplicate open rows
+    // already in the table (from earlier versions of this function) are closed
+    // below so they cannot leak past the link they came from.
+    const openKeys = new Set();
+    for (const r of openRows)
+        openKeys.add(edgeKey({ srcBlock: r.src_block, srcField: r.src_field, predicate: r.predicate, dstNode: r.dst_node, anchor: r.anchor }));
+    const wantKeys = new Set();
+    const insert = db.prepare(`INSERT INTO edges (edge_id, repo_id, src_doc, src_block, src_field, predicate, dst_kind, dst_node, anchor, provenance, from_commit, to_commit)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)`);
+    for (const e of edges) {
+        const key = edgeKey(e);
+        if (wantKeys.has(key))
+            continue;
+        wantKeys.add(key);
+        if (!openKeys.has(key)) {
+            insert.run(mintId("e"), repoId, srcDoc, e.srcBlock, e.srcField, e.predicate, e.dstKind, e.dstNode, e.anchor, e.provenance, commitId);
+        }
+    }
+    // Close every open row whose key is no longer wanted, and all but the first
+    // open row of a wanted key.
+    const close = db.prepare("UPDATE edges SET to_commit = ? WHERE edge_id = ?");
+    const kept = new Set();
+    for (const r of openRows) {
+        const key = edgeKey({ srcBlock: r.src_block, srcField: r.src_field, predicate: r.predicate, dstNode: r.dst_node, anchor: r.anchor });
+        if (wantKeys.has(key) && !kept.has(key)) {
+            kept.add(key);
+            continue;
+        }
+        close.run(commitId, r.edge_id);
+    }
+    rebuildDocEdges(db, srcDoc);
+}
+// When a document is (re)created at a path, adopt any open phantom edges that
+// pointed at that path so backlinks re-point to the real node (05 §2). Rebuilds
+// the affected source docs' rollups.
+export function adoptPhantoms(db, path, realDocId) {
+    const canonical = path.replace(/^\//, "");
+    const phantom = `phantom:${canonical}`;
+    const affected = db.prepare("SELECT DISTINCT src_doc FROM edges WHERE dst_node = ? AND to_commit IS NULL").all(phantom);
+    if (affected.length === 0)
+        return;
+    db.prepare("UPDATE edges SET dst_node = ? WHERE dst_node = ? AND to_commit IS NULL").run(realDocId, phantom);
+    for (const a of affected)
+        rebuildDocEdges(db, a.src_doc);
+}
+/** Recompute the doc_edges rollup for one document from its open edges. */
+export function rebuildDocEdges(db, srcDoc) {
+    db.prepare("DELETE FROM doc_edges WHERE src_doc = ?").run(srcDoc);
+    const rows = db
+        .prepare(`SELECT predicate, dst_node, dst_kind, count(*) AS cnt,
+              json_group_array(src_block) AS blocks
+       FROM edges WHERE src_doc = ? AND to_commit IS NULL
+       GROUP BY predicate, dst_node, dst_kind`)
+        .all(srcDoc);
+    const insert = db.prepare("INSERT INTO doc_edges (src_doc, predicate, dst_node, dst_kind, count, samples) VALUES (?, ?, ?, ?, ?, ?)");
+    for (const r of rows) {
+        const blocks = JSON.parse(r.blocks).filter((b) => b !== null).slice(0, 3);
+        insert.run(srcDoc, r.predicate, r.dst_node, r.dst_kind, r.cnt, JSON.stringify(blocks));
+    }
+}
+// Resolve/mint an external node id for a normalized URI.
+export function resolveExternal(db, repoId, uri) {
+    const existing = db.prepare("SELECT node_id FROM external_nodes WHERE repo_id = ? AND uri = ?").get(repoId, uri);
+    if (existing)
+        return existing.node_id;
+    const id = mintId("x");
+    db.prepare("INSERT INTO external_nodes (node_id, repo_id, uri) VALUES (?, ?, ?)").run(id, repoId, uri);
+    return id;
+}
+// Resolve a repo-relative path to a document id, minting a phantom placeholder
+// if absent (05 §2) so backlinks appear the moment the target is created. The
+// phantom id is derived from the path so it is stable and re-resolves when the
+// real doc is ingested (the doc keeps its own minted id; edges point at the
+// path-keyed node, joined by path at query time).
+export function resolveDocPath(db, repoId, path) {
+    const canonical = path.replace(/^\//, "");
+    const doc = db.prepare("SELECT doc_id FROM docs WHERE repo_id = ? AND path = ? AND deleted_commit IS NULL").get(repoId, canonical);
+    if (doc)
+        return { id: doc.doc_id, phantom: false };
+    // Phantom: a deterministic placeholder keyed by path.
+    return { id: `phantom:${canonical}`, phantom: true };
+}
+//# sourceMappingURL=edges.js.map

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

@@ -0,0 +1,10 @@
+import type { Database } from "better-sqlite3";
+/** Remove a document's live block rows from the FTS index (call before deleting
+ * or tombstoning blocks). Only live blocks are indexed (see ftsIndexDoc), so the
+ * delete must target the SAME set: an already-tombstoned block has no FTS row, and
+ * re-issuing a 'delete' for it corrupts the external-content index. Keeping this
+ * symmetric with ftsIndexDoc (deleted_commit IS NULL) makes a tombstone followed by
+ * a later re-ingest of the same doc id (observed delete → recreate) idempotent. */
+export declare function ftsDeleteDoc(db: Database, docId: string): void;
+/** Index a document's current block rows (call after inserting blocks). */
+export declare function ftsIndexDoc(db: Database, docId: string): void;

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

@@ -0,0 +1,22 @@
+/** Remove a document's live block rows from the FTS index (call before deleting
+ * or tombstoning blocks). Only live blocks are indexed (see ftsIndexDoc), so the
+ * delete must target the SAME set: an already-tombstoned block has no FTS row, and
+ * re-issuing a 'delete' for it corrupts the external-content index. Keeping this
+ * symmetric with ftsIndexDoc (deleted_commit IS NULL) makes a tombstone followed by
+ * a later re-ingest of the same doc id (observed delete → recreate) idempotent. */
+export function ftsDeleteDoc(db, docId) {
+    const rows = db.prepare("SELECT rowid, text FROM blocks WHERE doc_id = ? AND deleted_commit IS NULL").all(docId);
+    const del = db.prepare("INSERT INTO blocks_fts(blocks_fts, rowid, text) VALUES('delete', ?, ?)");
+    for (const r of rows)
+        del.run(r.rowid, r.text);
+}
+/** Index a document's current block rows (call after inserting blocks). */
+export function ftsIndexDoc(db, docId) {
+    const rows = db
+        .prepare("SELECT rowid, text FROM blocks WHERE doc_id = ? AND deleted_commit IS NULL")
+        .all(docId);
+    const ins = db.prepare("INSERT INTO blocks_fts(rowid, text) VALUES(?, ?)");
+    for (const r of rows)
+        ins.run(r.rowid, r.text);
+}
+//# sourceMappingURL=fts.js.map

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

@@ -0,0 +1,18 @@
+import type { Store } from "./store.js";
+export interface GcResult {
+    blobsSwept: number;
+    treeNodesSwept: number;
+}
+/**
+ * Mark-and-sweep GC (flag-gated; enabled must be true to run — v1.0 ships it
+ * off). Removes blobs/tree_nodes unreachable from any revision root. Because
+ * revisions are append-only and never pruned in v1, nothing is actually
+ * unreachable unless revision pruning ran first — so this is a no-op in a
+ * default v1 repo, exactly as specified. Rebuild-equivalence is preserved.
+ */
+export declare function runGc(store: Store, opts?: {
+    enabled?: boolean;
+}): GcResult;
+/** Resurrection-pool expiry sweep (02 §7): drop rows past their expires_ts.
+ * Runs routinely (lazy, at checkpoint time). */
+export declare function sweepResurrectionPool(store: Store, nowIso: string): number;

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

@@ -0,0 +1,69 @@
+// Collect the set of tree-node hashes reachable from every revision root, and
+// the blob hashes referenced by those nodes (raw + trivia) plus frontmatter.
+function markReachable(store) {
+    const trees = new Set();
+    const blobs = new Set();
+    // Frontmatter blobs referenced by revisions.
+    const fmRows = store.db.prepare("SELECT DISTINCT frontmatter_blob FROM revisions WHERE frontmatter_blob IS NOT NULL").all();
+    for (const r of fmRows)
+        blobs.add(r.frontmatter_blob.toString("hex"));
+    const treeNode = store.db.prepare("SELECT entries FROM tree_nodes WHERE hash = ?");
+    const walk = (hashHex) => {
+        if (trees.has(hashHex))
+            return;
+        trees.add(hashHex);
+        const node = treeNode.get(Buffer.from(hashHex, "hex"));
+        if (!node)
+            return;
+        const entries = JSON.parse(node.entries);
+        for (const [, rawHashHex, childHashHex, , , triviaHashHex] of entries) {
+            blobs.add(rawHashHex);
+            if (triviaHashHex)
+                blobs.add(triviaHashHex);
+            if (childHashHex)
+                walk(childHashHex);
+        }
+    };
+    const roots = store.db.prepare("SELECT DISTINCT root_tree FROM revisions").all();
+    for (const r of roots)
+        walk(r.root_tree.toString("hex"));
+    return { trees, blobs };
+}
+/**
+ * Mark-and-sweep GC (flag-gated; enabled must be true to run — v1.0 ships it
+ * off). Removes blobs/tree_nodes unreachable from any revision root. Because
+ * revisions are append-only and never pruned in v1, nothing is actually
+ * unreachable unless revision pruning ran first — so this is a no-op in a
+ * default v1 repo, exactly as specified. Rebuild-equivalence is preserved.
+ */
+export function runGc(store, opts = {}) {
+    if (!opts.enabled)
+        return { blobsSwept: 0, treeNodesSwept: 0 };
+    return store.write((db) => {
+        const { trees, blobs } = markReachable(store);
+        let treeNodesSwept = 0;
+        const allTrees = db.prepare("SELECT hash FROM tree_nodes").all();
+        const delTree = db.prepare("DELETE FROM tree_nodes WHERE hash = ?");
+        for (const t of allTrees)
+            if (!trees.has(t.hash.toString("hex"))) {
+                delTree.run(t.hash);
+                treeNodesSwept++;
+            }
+        let blobsSwept = 0;
+        const allBlobs = db.prepare("SELECT hash FROM blobs").all();
+        const delBlob = db.prepare("DELETE FROM blobs WHERE hash = ?");
+        for (const b of allBlobs)
+            if (!blobs.has(b.hash.toString("hex"))) {
+                delBlob.run(b.hash);
+                blobsSwept++;
+            }
+        return { blobsSwept, treeNodesSwept };
+    });
+}
+/** Resurrection-pool expiry sweep (02 §7): drop rows past their expires_ts.
+ * Runs routinely (lazy, at checkpoint time). */
+export function sweepResurrectionPool(store, nowIso) {
+    const res = store.db.prepare("DELETE FROM resurrection_pool WHERE expires_ts <= ?").run(nowIso);
+    return res.changes;
+}
+//# sourceMappingURL=gc.js.map

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

@@ -0,0 +1,5 @@
+import type { Database } from "better-sqlite3";
+import type { ProjectedNode } from "../../format/adapter.js";
+export declare function projectSectionNodes(db: Database, docId: string): ProjectedNode[];
+export declare function deleteDocNodes(db: Database, docId: string): void;
+export declare function writeDocNodes(db: Database, repoId: string, docId: string, projected: ProjectedNode[]): number;

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

@@ -0,0 +1,57 @@
+import { hashHex } from "../hash.js";
+function mintNodeId(docId, blockId, kind, ordinal) {
+    return "n_" + hashHex(`${docId}|${blockId}|${kind}|${ordinal}`).slice(0, 12);
+}
+// Project `md:section` nodes from the derived `sections` table (02 §4). A
+// section node surfaces the outline latent in `sections`: it is anchored to the
+// heading block (a real `b_` id — so unlike adapter-projected nodes it carries a
+// valid block_id), names the heading text, and carries the section's TOP-LEVEL
+// ordinal range + level in attrs. Range containment over these attrs is what
+// OQX's `section.blocks` / `section.subsections` / `block.section` relations
+// correlate on. Derived/rebuildable; not a new source of truth. Non-markdown
+// formats have no heading blocks, so `sections` is empty and this returns [].
+export function projectSectionNodes(db, docId) {
+    const rows = db
+        .prepare(`SELECT s.heading_block AS heading_block, s.level AS level,
+              s.first_ordinal AS first_ordinal, s.last_ordinal AS last_ordinal,
+              hb.text AS text
+       FROM sections s
+       JOIN blocks hb ON hb.block_id = s.heading_block AND hb.doc_id = s.doc_id
+       WHERE s.doc_id = ? AND hb.deleted_commit IS NULL
+       ORDER BY s.first_ordinal`)
+        .all(docId);
+    return rows.map((r) => ({
+        kind: "md:section",
+        name: r.text,
+        blockId: r.heading_block,
+        attrs: { level: r.level, first_ordinal: r.first_ordinal, last_ordinal: r.last_ordinal },
+    }));
+}
+export function deleteDocNodes(db, docId) {
+    const rows = db.prepare("SELECT rowid, name, value FROM nodes WHERE doc_id = ?").all(docId);
+    for (const r of rows) {
+        db.prepare("INSERT INTO nodes_fts(nodes_fts, rowid, name, value) VALUES('delete', ?, ?, ?)").run(r.rowid, r.name ?? "", r.value ?? "");
+    }
+    db.prepare("DELETE FROM nodes WHERE doc_id = ?").run(docId);
+}
+export function writeDocNodes(db, repoId, docId, projected) {
+    deleteDocNodes(db, docId);
+    const insert = db.prepare(`INSERT INTO nodes (node_id, repo_id, doc_id, block_id, kind, name, value, span_start, span_end, attrs)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const ftsInsert = db.prepare("INSERT INTO nodes_fts(rowid, name, value) VALUES(?, ?, ?)");
+    const kindCounters = new Map();
+    for (const p of projected) {
+        const key = p.kind + "|" + (p.blockId ?? "");
+        const ordinal = kindCounters.get(key) ?? 0;
+        kindCounters.set(key, ordinal + 1);
+        const validBlockId = p.blockId?.startsWith("b_") ? p.blockId : null;
+        const nodeId = mintNodeId(docId, validBlockId ?? "", p.kind, ordinal);
+        const name = p.name ?? null;
+        const value = p.value ?? null;
+        insert.run(nodeId, repoId, docId, validBlockId, p.kind, name, value, p.spanStart ?? null, p.spanEnd ?? null, JSON.stringify(p.attrs ?? {}));
+        const lastRowid = db.prepare("SELECT last_insert_rowid() AS r").get();
+        ftsInsert.run(lastRowid.r, name ?? "", value ?? "");
+    }
+    return projected.length;
+}
+//# sourceMappingURL=nodes.js.map

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

@@ -0,0 +1,38 @@
+import type { Database } from "better-sqlite3";
+export type PropertySource = "frontmatter" | "inline" | "computed";
+export type PropertyCard = "scalar" | "list";
+export type PropertyType = "string" | "number" | "bool" | "null" | "json";
+export interface PropertyRow {
+    source: PropertySource;
+    blockId: string | null;
+    key: string;
+    card: PropertyCard;
+    ord: number;
+    valText: string | null;
+    valNum: number | null;
+    valBool: number | null;
+    valJson: string | null;
+    type: PropertyType;
+}
+export interface RangeValue {
+    lo: number | string | null;
+    hi: number | string | null;
+    exclusiveEnd: boolean;
+}
+/** Parse a string as a range value, or null if it is not a well-formed range.
+ * Strict on purpose (both bounds must share a scalar domain — numeric or ISO
+ * date) so ordinary strings that merely contain dots are never mis-promoted. */
+export declare function detectRange(s: string): RangeValue | null;
+export declare function flattenFrontmatter(obj: Record<string, unknown>): Omit<PropertyRow, "source" | "blockId">[];
+export declare function flattenComputed(obj: Record<string, unknown>): Omit<PropertyRow, "source" | "blockId">[];
+export declare function deleteDocProperties(db: Database, docId: string): void;
+/**
+ * Effective (merged) property bag for a document: each key mapped to its
+ * authored-shaped value (scalar or array), unioned across authored sources
+ * (frontmatter + inline). Computed `$`-keys are included under their `$` name.
+ * This is the projection/hydration view that replaces docs.metadata.
+ */
+export declare function docPropertiesMerged(db: Database, docId: string): Record<string, unknown>;
+/** Properties grouped by source (docs_read shape): {frontmatter, inline, computed}. */
+export declare function docPropertiesGrouped(db: Database, docId: string): Record<PropertySource, Record<string, unknown>>;
+export declare function writeDocProperties(db: Database, repoId: string, docId: string, createdCommit: string, rows: PropertyRow[]): number;

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

@@ -0,0 +1,177 @@
+import { hashHex } from "../hash.js";
+// Deterministic id: a property row is identified by its document, source, key,
+// and ordinal position within that (source,key). Same bytes ⇒ same id.
+function propId(docId, source, key, ord) {
+    return "p_" + hashHex(`${docId}|${source}|${key}|${ord}`).slice(0, 12);
+}
+const RANGE_NUM = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+const RANGE_ISO = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+/** Parse a string as a range value, or null if it is not a well-formed range.
+ * Strict on purpose (both bounds must share a scalar domain — numeric or ISO
+ * date) so ordinary strings that merely contain dots are never mis-promoted. */
+export function detectRange(s) {
+    // The operator is a maximal run of exactly 2 (`..`) or 3 (`...`) dots. A single
+    // dot is a decimal point and stays part of a bound; a run of 4+ is not a range.
+    const m = /^(.*?)(\.\.\.?)(.*)$/.exec(s);
+    if (!m)
+        return null;
+    const loRaw = m[1], dots = m[2], hiRaw = m[3];
+    if (loRaw.endsWith(".") || hiRaw.startsWith("."))
+        return null; // adjacent dot ⇒ non-maximal run
+    const lo = loRaw.length ? loRaw : null;
+    const hi = hiRaw.length ? hiRaw : null;
+    if (lo === null && hi === null)
+        return null; // `..` with no bounds is meaningless
+    const exclusiveEnd = dots.length === 3;
+    const present = [lo, hi].filter((b) => b !== null);
+    if (present.every((b) => RANGE_NUM.test(b))) {
+        return { lo: lo === null ? null : Number(lo), hi: hi === null ? null : Number(hi), exclusiveEnd };
+    }
+    if (present.every((b) => RANGE_ISO.test(b))) {
+        return { lo, hi, exclusiveEnd }; // keep ISO strings; lexical ordering is chronological
+    }
+    return null; // mixed domains or non-scalar bounds ⇒ an ordinary string
+}
+// Classify a single JSON scalar into a typed column. Objects/arrays are not
+// scalars — callers flatten those before reaching here.
+function typedValue(v) {
+    if (v === null || v === undefined)
+        return { valText: null, valNum: null, valBool: null, valJson: null, type: "null" };
+    if (typeof v === "boolean")
+        return { valText: null, valNum: null, valBool: v ? 1 : 0, valJson: null, type: "bool" };
+    if (typeof v === "number")
+        return { valText: null, valNum: v, valBool: null, valJson: null, type: "number" };
+    if (typeof v === "string") {
+        const range = detectRange(v);
+        // A range stays type='string' (verbatim in val_text so hydration, equality,
+        // and FTS are unchanged); the parsed bounds ride in val_json for querying.
+        if (range)
+            return { valText: v, valNum: null, valBool: null, valJson: JSON.stringify({ __range: true, ...range }), type: "string" };
+        return { valText: v, valNum: null, valBool: null, valJson: null, type: "string" };
+    }
+    // object / array that resisted flattening: escape hatch.
+    return { valText: null, valNum: null, valBool: null, valJson: JSON.stringify(v), type: "json" };
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+// Flatten a parsed frontmatter object into property rows.
+//  - nested maps → dotted keys (meta.owner)
+//  - arrays → one card='list' row per element, ord 0..n (scalars only; an array
+//    of objects goes to a single val_json row rather than exploding structure)
+//  - scalars → one card='scalar' row
+export function flattenFrontmatter(obj) {
+    const rows = [];
+    const walk = (value, key) => {
+        if (isPlainObject(value)) {
+            for (const [k, v] of Object.entries(value))
+                walk(v, key ? `${key}.${k}` : k);
+            return;
+        }
+        if (Array.isArray(value)) {
+            const allScalar = value.every((e) => !isPlainObject(e) && !Array.isArray(e));
+            if (allScalar) {
+                value.forEach((e, ord) => rows.push({ key, card: "list", ord, ...typedValue(e) }));
+            }
+            else {
+                // array of objects / nested arrays: keep as one json row (escape hatch).
+                rows.push({ key, card: "list", ord: 0, ...typedValue(value) });
+            }
+            return;
+        }
+        rows.push({ key, card: "scalar", ord: 0, ...typedValue(value) });
+    };
+    for (const [k, v] of Object.entries(obj))
+        walk(v, k);
+    return rows;
+}
+// Flatten computed properties (adapter computeProperties output) into rows.
+// Keys are already $-prefixed intrinsics ($title, $tags); a value is a scalar
+// (one scalar row) or an array of scalars (ord-indexed list rows).
+export function flattenComputed(obj) {
+    const rows = [];
+    for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value)) {
+            value.forEach((e, ord) => rows.push({ key, card: "list", ord, ...typedValue(e) }));
+        }
+        else {
+            rows.push({ key, card: "scalar", ord: 0, ...typedValue(value) });
+        }
+    }
+    return rows;
+}
+export function deleteDocProperties(db, docId) {
+    db.prepare("DELETE FROM properties WHERE doc_id = ?").run(docId);
+}
+function decode(r) {
+    switch (r.type) {
+        case "string": return r.val_text;
+        case "number": return r.val_num;
+        case "bool": return r.val_bool === 1;
+        case "null": return null;
+        case "json": return r.val_json ? JSON.parse(r.val_json) : null;
+    }
+}
+// Collapse a key's rows to the authored shape: a lone scalar row → the scalar;
+// anything else (list rows, or multiple values) → an array in (source-rank,
+// ord) order. Deterministic — see docs/properties-table.md §9.
+const SOURCE_RANK = { frontmatter: 0, inline: 1, computed: 2 };
+function shapeValues(rows) {
+    if (rows.length === 1 && rows[0].card === "scalar")
+        return decode(rows[0]);
+    const ordered = [...rows].sort((a, b) => SOURCE_RANK[a.source] - SOURCE_RANK[b.source] || a.ord - b.ord);
+    return ordered.map(decode);
+}
+/**
+ * Effective (merged) property bag for a document: each key mapped to its
+ * authored-shaped value (scalar or array), unioned across authored sources
+ * (frontmatter + inline). Computed `$`-keys are included under their `$` name.
+ * This is the projection/hydration view that replaces docs.metadata.
+ */
+export function docPropertiesMerged(db, docId) {
+    const rows = db.prepare("SELECT source, key, card, ord, val_text, val_num, val_bool, val_json, type FROM properties WHERE doc_id = ? AND deleted_commit IS NULL").all(docId);
+    const byKey = new Map();
+    for (const r of rows) {
+        const g = byKey.get(r.key) ?? [];
+        g.push(r);
+        byKey.set(r.key, g);
+    }
+    const out = {};
+    for (const [key, group] of byKey)
+        out[key] = shapeValues(group);
+    return out;
+}
+/** Properties grouped by source (docs_read shape): {frontmatter, inline, computed}. */
+export function docPropertiesGrouped(db, docId) {
+    const rows = db.prepare("SELECT source, key, card, ord, val_text, val_num, val_bool, val_json, type FROM properties WHERE doc_id = ? AND deleted_commit IS NULL").all(docId);
+    const grouped = {
+        frontmatter: new Map(), inline: new Map(), computed: new Map(),
+    };
+    for (const r of rows) {
+        const m = grouped[r.source];
+        const g = m.get(r.key) ?? [];
+        g.push(r);
+        m.set(r.key, g);
+    }
+    const out = { frontmatter: {}, inline: {}, computed: {} };
+    for (const src of ["frontmatter", "inline", "computed"]) {
+        for (const [key, group] of grouped[src])
+            out[src][key] = shapeValues(group);
+    }
+    return out;
+}
+// Replace a document's property rows. Deterministic prop_id per (source,key,ord)
+// gives dedup/stable identity; a genuine duplicate (same source+key+ord) is
+// collapsed by the primary key (INSERT OR REPLACE).
+export function writeDocProperties(db, repoId, docId, createdCommit, rows) {
+    deleteDocProperties(db, docId);
+    const insert = db.prepare(`INSERT OR REPLACE INTO properties
+       (prop_id, repo_id, doc_id, block_id, source, key, card, ord,
+        val_text, val_num, val_bool, val_json, type, created_commit)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    for (const r of rows) {
+        insert.run(propId(docId, r.source, r.key, r.ord), repoId, docId, r.blockId, r.source, r.key, r.card, r.ord, r.valText, r.valNum, r.valBool, r.valJson, r.type, createdCommit);
+    }
+    return rows.length;
+}
+//# sourceMappingURL=properties.js.map

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

@@ -0,0 +1,3 @@
+import type { Store } from "./store.js";
+export type RebuildTarget = "sections" | "edges" | "fts" | "block_changes" | "all";
+export declare function rebuildIndex(store: Store, target?: RebuildTarget): void;

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

@@ -0,0 +1,29 @@
+import { rebuildSections } from "./sections.js";
+import { rebuildDocEdges } from "./edges.js";
+import { ftsIndexDoc } from "./fts.js";
+export function rebuildIndex(store, target = "all") {
+    store.write((db) => {
+        const docIds = db.prepare("SELECT doc_id FROM docs WHERE deleted_commit IS NULL").all().map((r) => r.doc_id);
+        if (target === "sections" || target === "all") {
+            for (const docId of docIds)
+                rebuildSections(db, docId);
+        }
+        if (target === "edges" || target === "all") {
+            // doc_edges is a pure rollup of the open `edges` rows; rebuild per doc.
+            for (const docId of docIds)
+                rebuildDocEdges(db, docId);
+        }
+        if (target === "fts" || target === "all") {
+            // Rebuild the external-content FTS index from current block text.
+            db.exec("INSERT INTO blocks_fts(blocks_fts) VALUES('rebuild')");
+        }
+        if (target === "block_changes" || target === "all") {
+            // block_changes is a projection of dispositions across commits: rebuild
+            // it verbatim from the dispositions table (which is durable).
+            db.prepare("DELETE FROM block_changes").run();
+            db.exec("INSERT OR IGNORE INTO block_changes (block_id, commit_id, kind) SELECT block_id, commit_id, kind FROM dispositions");
+        }
+    });
+    void ftsIndexDoc; // fts rebuild uses the FTS5 'rebuild' command directly
+}
+//# sourceMappingURL=rebuild.js.map

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

@@ -0,0 +1,9 @@
+export declare const SCHEMA_VERSION = 13;
+export declare const FILE_STATS_DDL = "\nCREATE TABLE IF NOT EXISTS file_stats (\n  repo_id  TEXT NOT NULL,\n  path     TEXT NOT NULL,\n  mtime_ns INTEGER NOT NULL,\n  size     INTEGER NOT NULL,\n  hash     BLOB NOT NULL,\n  PRIMARY KEY (repo_id, path)\n);\n";
+export declare const PROPERTIES_DDL = "\nCREATE TABLE IF NOT EXISTS properties (\n  prop_id        TEXT PRIMARY KEY,\n  repo_id        TEXT NOT NULL,\n  doc_id         TEXT NOT NULL,\n  block_id       TEXT,                    -- NULL = document-scoped (frontmatter, computed)\n  source         TEXT NOT NULL CHECK (source IN ('frontmatter','inline','computed')),\n  key            TEXT NOT NULL,           -- dotted, flattened: \"layer\",\"meta.owner\"; computed carry $: \"$title\"\n  card           TEXT NOT NULL CHECK (card IN ('scalar','list')),\n  ord            INTEGER NOT NULL DEFAULT 0,\n  val_text       TEXT,\n  val_num        REAL,\n  val_bool       INTEGER,\n  val_json       TEXT,\n  type           TEXT NOT NULL CHECK (type IN ('string','number','bool','null','json')),\n  created_commit TEXT NOT NULL,\n  deleted_commit TEXT\n);\nCREATE INDEX IF NOT EXISTS idx_props_doc      ON properties(doc_id)                 WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_props_key_text ON properties(repo_id, key, val_text) WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_props_key_num  ON properties(repo_id, key, val_num)  WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_props_src_key  ON properties(repo_id, source, key)   WHERE deleted_commit IS NULL;\n";
+export declare const SYNC_DDL = "\nCREATE TABLE IF NOT EXISTS adapters (\n  name     TEXT PRIMARY KEY,        -- workspace-unique adapter name (e.g. \"fs\")\n  command  TEXT NOT NULL,           -- argv[0] to spawn (e.g. \"omgbase-fs-adapter\")\n  args     TEXT NOT NULL DEFAULT '[]'  -- fixed leading args (JSON string[])\n);\n\nCREATE TABLE IF NOT EXISTS sources (\n  source_id TEXT PRIMARY KEY,\n  name      TEXT NOT NULL UNIQUE,   -- workspace-unique source name\n  adapter   TEXT NOT NULL REFERENCES adapters(name),\n  config    TEXT NOT NULL DEFAULT '{}',  -- JSON object \u2192 rendered to flags (13 \u00A73.1)\n  env       TEXT NOT NULL DEFAULT '{}'   -- JSON object \u2192 spawn env (secrets; 13 \u00A73.2)\n);\n\nCREATE TABLE IF NOT EXISTS attachments (\n  repo_id   TEXT NOT NULL REFERENCES repos(repo_id),\n  source_id TEXT NOT NULL REFERENCES sources(source_id),\n  PRIMARY KEY (repo_id, source_id)\n);\n\nCREATE TABLE IF NOT EXISTS sync_state (\n  repo_id   TEXT NOT NULL,\n  source_id TEXT NOT NULL,\n  path      TEXT NOT NULL,          -- '' reserved for the attachment-level cursor row\n  revision  TEXT,                   -- last-observed source revision for this path\n  cursor    TEXT,                   -- last poll/webhook cursor (attachment-level row)\n  PRIMARY KEY (repo_id, source_id, path)\n);\n";
+export declare const WORKSPACE_SETTINGS_DDL = "\nCREATE TABLE IF NOT EXISTS workspace_settings (\n  id       INTEGER PRIMARY KEY CHECK (id = 0),\n  settings TEXT NOT NULL DEFAULT '{}'\n);\nINSERT OR IGNORE INTO workspace_settings (id, settings) VALUES (0, '{}');\n";
+export declare const NODES_DDL = "\nCREATE TABLE IF NOT EXISTS nodes (\n  node_id    TEXT PRIMARY KEY,\n  repo_id    TEXT NOT NULL,\n  doc_id     TEXT NOT NULL,\n  block_id   TEXT,\n  kind       TEXT NOT NULL,\n  name       TEXT,\n  value      TEXT,\n  span_start INTEGER,\n  span_end   INTEGER,\n  attrs      TEXT NOT NULL DEFAULT '{}'\n);\nCREATE INDEX IF NOT EXISTS idx_nodes_doc  ON nodes(doc_id);\nCREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);\nCREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name) WHERE name IS NOT NULL;\nCREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(\n  name, value, content='nodes', content_rowid='rowid', tokenize='porter unicode61'\n);\n";
+export declare const DOC_EMBEDDINGS_DDL = "\nCREATE TABLE IF NOT EXISTS doc_embeddings (\n  doc_id     TEXT NOT NULL,\n  model      TEXT NOT NULL,\n  input_hash BLOB NOT NULL,\n  method     TEXT NOT NULL CHECK (method IN ('whole','pooled')),\n  dim        INTEGER NOT NULL,\n  vec        BLOB NOT NULL,\n  PRIMARY KEY (doc_id, model)\n);\n";
+export declare const MIGRATIONS: Record<number, string>;
+export declare const DDL = "\n-- ---- durable tables (02 \u00A73) --------------------------------------------------\nCREATE TABLE IF NOT EXISTS repos (\n  repo_id   TEXT PRIMARY KEY,\n  slug      TEXT NOT NULL UNIQUE,\n  settings  TEXT NOT NULL DEFAULT '{}'\n);\n-- A repo owns identity + history, NOT a filesystem (ADR-014). Where its bytes\n-- come from is a sources row (adapter=fs, config.root) joined via attachments;\n-- the former repos.root_path column was removed in schema v13.\n\nCREATE TABLE IF NOT EXISTS docs (\n  doc_id         TEXT PRIMARY KEY,\n  repo_id        TEXT NOT NULL REFERENCES repos(repo_id),\n  path           TEXT NOT NULL,\n  format         TEXT NOT NULL DEFAULT 'markdown',\n  current_rev    TEXT,\n  file_hash      BLOB,\n  conflicted     INTEGER NOT NULL DEFAULT 0,\n  leading_trivia TEXT NOT NULL DEFAULT '',\n  frontmatter_trivia TEXT,                  -- separator between frontmatter and first body block (NULL = no frontmatter)\n  deleted_commit TEXT,\n  UNIQUE (repo_id, path)\n);\n\nCREATE TABLE IF NOT EXISTS blocks (\n  block_id       TEXT PRIMARY KEY,\n  repo_id        TEXT NOT NULL REFERENCES repos(repo_id),\n  doc_id         TEXT NOT NULL REFERENCES docs(doc_id),\n  parent_block   TEXT,\n  order_key      TEXT NOT NULL,\n  ordinal        INTEGER NOT NULL,\n  depth          INTEGER NOT NULL,\n  ancestor_path  TEXT NOT NULL,\n  type           TEXT NOT NULL,\n  attrs          TEXT NOT NULL DEFAULT '{}',\n  text           TEXT NOT NULL,\n  raw_hash       BLOB NOT NULL,\n  norm_hash      BLOB NOT NULL,\n  trivia_hash    BLOB,                     -- trailing trivia blob hash (NULL = no trivia)\n  created_commit TEXT NOT NULL,\n  deleted_commit TEXT\n);\nCREATE INDEX IF NOT EXISTS idx_blocks_doc      ON blocks(doc_id, parent_block, order_key) WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_blocks_type     ON blocks(repo_id, type)                   WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_blocks_rawhash  ON blocks(raw_hash);\nCREATE INDEX IF NOT EXISTS idx_blocks_ancestor ON blocks(doc_id, ancestor_path);\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 revisions (\n  rev_id           TEXT PRIMARY KEY,\n  doc_id           TEXT NOT NULL REFERENCES docs(doc_id),\n  seq              INTEGER NOT NULL,\n  root_tree        BLOB NOT NULL REFERENCES tree_nodes(hash),\n  frontmatter_blob BLOB REFERENCES blobs(hash),\n  rendered_hash    BLOB NOT NULL,\n  path             TEXT NOT NULL,\n  commit_id        TEXT NOT NULL REFERENCES commits(commit_id),\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 REFERENCES repos(repo_id),\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  UNIQUE (repo_id, seq)\n);\n\nCREATE TABLE IF NOT EXISTS dispositions (\n  commit_id  TEXT NOT NULL REFERENCES commits(commit_id),\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 edges (\n  edge_id     TEXT PRIMARY KEY,\n  repo_id     TEXT NOT NULL,\n  src_doc     TEXT NOT NULL,\n  src_block   TEXT,\n  src_field   TEXT,\n  predicate   TEXT NOT NULL,\n  dst_kind    TEXT NOT NULL CHECK (dst_kind IN ('document','block','external','collection')),\n  dst_node    TEXT NOT NULL,\n  anchor      TEXT,\n  provenance  TEXT NOT NULL CHECK (provenance IN ('link','frontmatter','inline_field','projected',\n               'yaml_ref','yaml_schema','yaml_extends','json_ref','json_schema')),\n  via_node    TEXT,\n  from_commit TEXT NOT NULL,\n  to_commit   TEXT\n);\nCREATE INDEX IF NOT EXISTS idx_edges_src      ON edges(src_doc, predicate) WHERE to_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_edges_dst      ON edges(dst_node, predicate) WHERE to_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_edges_temporal ON edges(from_commit, to_commit);\n\nCREATE TABLE IF NOT EXISTS external_nodes (\n  node_id TEXT PRIMARY KEY,\n  repo_id TEXT NOT NULL,\n  uri     TEXT NOT NULL,\n  title   TEXT,\n  UNIQUE (repo_id, uri)\n);\n\nCREATE TABLE IF NOT EXISTS collections (\n  node_id TEXT PRIMARY KEY,\n  repo_id TEXT NOT NULL,\n  name    TEXT NOT NULL,\n  spec    TEXT NOT NULL DEFAULT '{}'\n);\n\nCREATE TABLE IF NOT EXISTS checkpoints (\n  id       TEXT PRIMARY KEY,\n  repo_id  TEXT NOT NULL,\n  ts       TEXT NOT NULL,\n  files    TEXT NOT NULL,\n  git_head TEXT\n);\n\nCREATE TABLE IF NOT EXISTS resurrection_pool (\n  block_id       TEXT PRIMARY KEY,\n  repo_id        TEXT NOT NULL,\n  doc_id         TEXT NOT NULL,\n  raw_hash       BLOB NOT NULL,\n  norm_hash      BLOB NOT NULL,\n  type           TEXT NOT NULL,\n  deleted_commit TEXT NOT NULL,\n  expires_ts     TEXT NOT NULL\n);\n\n-- ---- derived tables (02 \u00A74; rebuildable) ------------------------------------\nCREATE TABLE IF NOT EXISTS sections (\n  heading_block TEXT NOT NULL,\n  doc_id        TEXT NOT NULL,\n  level         INTEGER NOT NULL,\n  first_ordinal INTEGER NOT NULL,\n  last_ordinal  INTEGER NOT NULL,\n  PRIMARY KEY (doc_id, heading_block)\n);\n\nCREATE TABLE IF NOT EXISTS doc_edges (\n  src_doc   TEXT NOT NULL,\n  predicate TEXT NOT NULL,\n  dst_node  TEXT NOT NULL,\n  dst_kind  TEXT NOT NULL,\n  count     INTEGER NOT NULL,\n  samples   TEXT NOT NULL,\n  PRIMARY KEY (src_doc, predicate, dst_node)\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\nCREATE TABLE IF NOT EXISTS inferred_edges (\n  src_node    TEXT NOT NULL,\n  dst_node    TEXT NOT NULL,\n  predicate   TEXT NOT NULL,\n  method      TEXT NOT NULL,\n  score       REAL NOT NULL,\n  model_v     TEXT NOT NULL,\n  computed_at TEXT NOT NULL,\n  PRIMARY KEY (src_node, dst_node, predicate, method)\n);\n\nCREATE TABLE IF NOT EXISTS embeddings (\n  content_hash BLOB NOT NULL,\n  ctx_hash     BLOB NOT NULL,\n  model        TEXT NOT NULL,\n  dim          INTEGER NOT NULL,\n  vec          BLOB NOT NULL,\n  PRIMARY KEY (content_hash, ctx_hash, model)\n);\n\n\nCREATE TABLE IF NOT EXISTS doc_embeddings (\n  doc_id     TEXT NOT NULL,\n  model      TEXT NOT NULL,\n  input_hash BLOB NOT NULL,\n  method     TEXT NOT NULL CHECK (method IN ('whole','pooled')),\n  dim        INTEGER NOT NULL,\n  vec        BLOB NOT NULL,\n  PRIMARY KEY (doc_id, model)\n);\n\n\nCREATE VIRTUAL TABLE IF NOT EXISTS blocks_fts USING fts5(\n  text, content='blocks', content_rowid='rowid', tokenize='porter unicode61'\n);\n\nCREATE TABLE IF NOT EXISTS nodes (\n  node_id    TEXT PRIMARY KEY,\n  repo_id    TEXT NOT NULL,\n  doc_id     TEXT NOT NULL,\n  block_id   TEXT,\n  kind       TEXT NOT NULL,\n  name       TEXT,\n  value      TEXT,\n  span_start INTEGER,\n  span_end   INTEGER,\n  attrs      TEXT NOT NULL DEFAULT '{}'\n);\nCREATE INDEX IF NOT EXISTS idx_nodes_doc  ON nodes(doc_id);\nCREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);\nCREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name) WHERE name IS NOT NULL;\n\nCREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(\n  name, value, content='nodes', content_rowid='rowid', tokenize='porter unicode61'\n);\n\n\nCREATE TABLE IF NOT EXISTS file_stats (\n  repo_id  TEXT NOT NULL,\n  path     TEXT NOT NULL,\n  mtime_ns INTEGER NOT NULL,\n  size     INTEGER NOT NULL,\n  hash     BLOB NOT NULL,\n  PRIMARY KEY (repo_id, path)\n);\n\n\nCREATE TABLE IF NOT EXISTS properties (\n  prop_id        TEXT PRIMARY KEY,\n  repo_id        TEXT NOT NULL,\n  doc_id         TEXT NOT NULL,\n  block_id       TEXT,                    -- NULL = document-scoped (frontmatter, computed)\n  source         TEXT NOT NULL CHECK (source IN ('frontmatter','inline','computed')),\n  key            TEXT NOT NULL,           -- dotted, flattened: \"layer\",\"meta.owner\"; computed carry $: \"$title\"\n  card           TEXT NOT NULL CHECK (card IN ('scalar','list')),\n  ord            INTEGER NOT NULL DEFAULT 0,\n  val_text       TEXT,\n  val_num        REAL,\n  val_bool       INTEGER,\n  val_json       TEXT,\n  type           TEXT NOT NULL CHECK (type IN ('string','number','bool','null','json')),\n  created_commit TEXT NOT NULL,\n  deleted_commit TEXT\n);\nCREATE INDEX IF NOT EXISTS idx_props_doc      ON properties(doc_id)                 WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_props_key_text ON properties(repo_id, key, val_text) WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_props_key_num  ON properties(repo_id, key, val_num)  WHERE deleted_commit IS NULL;\nCREATE INDEX IF NOT EXISTS idx_props_src_key  ON properties(repo_id, source, key)   WHERE deleted_commit IS NULL;\n\n\nCREATE TABLE IF NOT EXISTS adapters (\n  name     TEXT PRIMARY KEY,        -- workspace-unique adapter name (e.g. \"fs\")\n  command  TEXT NOT NULL,           -- argv[0] to spawn (e.g. \"omgbase-fs-adapter\")\n  args     TEXT NOT NULL DEFAULT '[]'  -- fixed leading args (JSON string[])\n);\n\nCREATE TABLE IF NOT EXISTS sources (\n  source_id TEXT PRIMARY KEY,\n  name      TEXT NOT NULL UNIQUE,   -- workspace-unique source name\n  adapter   TEXT NOT NULL REFERENCES adapters(name),\n  config    TEXT NOT NULL DEFAULT '{}',  -- JSON object \u2192 rendered to flags (13 \u00A73.1)\n  env       TEXT NOT NULL DEFAULT '{}'   -- JSON object \u2192 spawn env (secrets; 13 \u00A73.2)\n);\n\nCREATE TABLE IF NOT EXISTS attachments (\n  repo_id   TEXT NOT NULL REFERENCES repos(repo_id),\n  source_id TEXT NOT NULL REFERENCES sources(source_id),\n  PRIMARY KEY (repo_id, source_id)\n);\n\nCREATE TABLE IF NOT EXISTS sync_state (\n  repo_id   TEXT NOT NULL,\n  source_id TEXT NOT NULL,\n  path      TEXT NOT NULL,          -- '' reserved for the attachment-level cursor row\n  revision  TEXT,                   -- last-observed source revision for this path\n  cursor    TEXT,                   -- last poll/webhook cursor (attachment-level row)\n  PRIMARY KEY (repo_id, source_id, path)\n);\n\n\nCREATE TABLE IF NOT EXISTS workspace_settings (\n  id       INTEGER PRIMARY KEY CHECK (id = 0),\n  settings TEXT NOT NULL DEFAULT '{}'\n);\nINSERT OR IGNORE INTO workspace_settings (id, settings) VALUES (0, '{}');\n\n";