@omgbase/core 0.2.0 → 0.4.0

package/dist/src/core/clock.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pin the wall clock to `ts` (RFC 3339): `new Date()` and `Date.now()` return
+ * that instant until the returned restore function runs. Explicit-argument
+ * constructions (`new Date(ms)`, `new Date(iso)`) and the static parsers are
+ * untouched. Throws `RangeError` when `ts` does not parse.
+ */
+export declare function pinClock(ts: string): () => void;
+/** Run `body` under `pinClock(ts)` (a no-op when `ts` is undefined), restoring the clock afterwards. */
+export declare function withClock<T>(ts: string | undefined, body: () => Promise<T>): Promise<T>;

package/dist/src/core/clock.js

@@ -0,0 +1,46 @@
+// The process clock seam (spec/surface §7.1). Every commit the engine stamps
+// reads "now" through `new Date()` / `Date.now()` (`ingest`, `apply`, the doc
+// ops, `observe*`, checkpoints — none caches a `Date`), so pinning the global
+// `Date` pins every timestamp a tool call produces. Two users: the surface
+// fixtures (`corpus/surface/fixture.ts`, per `read` step) and `omg mcp` under
+// `OMGBASE_SPEC_CLOCK` (for the whole process). Never used in production paths.
+/**
+ * Pin the wall clock to `ts` (RFC 3339): `new Date()` and `Date.now()` return
+ * that instant until the returned restore function runs. Explicit-argument
+ * constructions (`new Date(ms)`, `new Date(iso)`) and the static parsers are
+ * untouched. Throws `RangeError` when `ts` does not parse.
+ */
+export function pinClock(ts) {
+    const RealDate = Date;
+    const fixed = RealDate.parse(ts);
+    if (Number.isNaN(fixed))
+        throw new RangeError(`pinClock: not an RFC 3339 instant: ${JSON.stringify(ts)}`);
+    class PinnedDate extends RealDate {
+        constructor(...args) {
+            if (args.length === 0)
+                super(fixed);
+            else
+                super(...args);
+        }
+        static now() {
+            return fixed;
+        }
+    }
+    globalThis.Date = PinnedDate;
+    return () => {
+        globalThis.Date = RealDate;
+    };
+}
+/** Run `body` under `pinClock(ts)` (a no-op when `ts` is undefined), restoring the clock afterwards. */
+export async function withClock(ts, body) {
+    if (ts === undefined)
+        return body();
+    const restore = pinClock(ts);
+    try {
+        return await body();
+    }
+    finally {
+        restore();
+    }
+}
+//# sourceMappingURL=clock.js.map

package/dist/src/core/ingest.js

@@ -6,7 +6,7 @@ import { assignIds, writeBlockTree, putBlob, newCommit, writeRevision } from "./
 import { sha256, childQuoteDepth, visibleText } from "./hash.js";
 import { mintId } from "./ids.js";
 import { keyBetween } from "./order-key.js";
-import { ftsDeleteDoc, ftsIndexDoc } from "./store/fts.js";
+import { ftsBeforeEvictRows, ftsDeleteDoc, ftsIndexDoc } from "./store/fts.js";
 import { rebuildSections } from "./store/sections.js";
 import { writeDocNodes, projectSectionNodes, toByteSpans } from "./store/nodes.js";
 import { flattenFrontmatter, flattenComputed, writeDocProperties } from "./store/properties.js";
@@ -288,25 +288,28 @@ export function ingestFile(store, repoId, path, content, opts = {}) {
     });
 }
 // Remove another document's `blocks` row for each id in `ids` (a cross-doc move
-// or a resurrection re-homes the id into `docId`). A live foreign row still has
-// an FTS entry (external-content index: delete with the original text); a
-// tombstoned one does not. The source document, if it commits later in the same
+// or a resurrection re-homes the id into `docId`). A live foreign LEAF row still
+// has an FTS entry (external-content index: delete with the original text); a
+// tombstoned row or a container does not (spec/search §1.1) — ftsBeforeEvictRows
+// decides leaf-ness over the table before any row goes and re-indexes a parent
+// left childless. The source document, if it commits later in the same
 // checkpoint, rewrites its rows wholesale and never lists a carried id as
 // deleted, so nothing there depends on the evicted row.
 function evictForeignBlockRows(db, docId, ids) {
-    const sel = db.prepare("SELECT rowid, text, deleted_commit FROM blocks WHERE block_id = ? AND doc_id != ?");
-    const ftsDel = db.prepare("INSERT INTO blocks_fts(blocks_fts, rowid, text) VALUES('delete', ?, ?)");
+    const sel = db.prepare("SELECT rowid, block_id, doc_id, parent_block, text, deleted_commit FROM blocks WHERE block_id = ? AND doc_id != ?");
     const del = db.prepare("DELETE FROM blocks WHERE block_id = ? AND doc_id != ?");
     const unpool = db.prepare("DELETE FROM resurrection_pool WHERE block_id = ?");
+    const rows = [];
     for (const id of ids) {
         const row = sel.get(id, docId);
-        if (row) {
-            if (row.deleted_commit === null)
-                ftsDel.run(row.rowid, row.text);
-            del.run(id, docId);
-        }
-        unpool.run(id);
+        if (row)
+            rows.push(row);
     }
+    ftsBeforeEvictRows(db, rows);
+    for (const r of rows)
+        del.run(r.block_id, docId);
+    for (const id of ids)
+        unpool.run(id);
 }
 // Zip assigned block ids onto the parsed RawBlocks for node projection. The
 // parsed `rest` and `assigned` trees are the same blocks in the same order and

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

@@ -116,8 +116,13 @@ export function docsReadMany(store, repoId, refs, opts = {}) {
             errors.push({ ref, error: "doc_not_found" });
             continue;
         }
+        // The budget is checked before the SECOND item onward (spec/surface §2, 1.2):
+        // the first item is always emitted even when it alone exceeds the budget —
+        // the same "at least one row" contract docs_list/docs_tree keep, so a
+        // budgeted client always makes progress. `truncated` stays honest: it is
+        // set only when the budget stopped an item that would otherwise have shipped.
         const cost = Math.ceil(JSON.stringify(read).length / 4);
-        if (tokens + cost > budget) {
+        if (items.length > 0 && tokens + cost > budget) {
             truncated = true;
             break;
         }

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

@@ -89,8 +89,12 @@ export function nodesGetMany(store, docId, blockIds, opts = {}) {
             continue;
         }
         const projected = project(store, node, resolution, false);
+        // At least one resolved node is always returned (spec/surface §2, 1.2): the
+        // budget is checked before the second node onward, as docsReadMany does, so
+        // a first node that alone exceeds it still ships and `truncated` only says
+        // that more remained.
         const cost = Math.ceil(JSON.stringify(projected).length / 4);
-        if (tokens + cost > budget) {
+        if (nodes.length > 0 && tokens + cost > budget) {
             truncated = true;
             break;
         }

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

@@ -1,10 +1,41 @@
 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. */
+/**
+ * SQL predicate: the `blocks` row aliased `b` is a live leaf. `c.doc_id =
+ * b.doc_id` lets the NOT EXISTS use `idx_blocks_doc` (block ids are unique, so
+ * it never changes the answer).
+ */
+export declare const LIVE_LEAF_SQL = "b.deleted_commit IS NULL AND NOT EXISTS (SELECT 1 FROM blocks c WHERE c.doc_id = b.doc_id AND c.parent_block = b.block_id AND c.deleted_commit IS NULL)";
+/** Remove a document's live leaf rows from the FTS index (call before deleting
+ * or tombstoning blocks). Only live leaves are indexed (see ftsIndexDoc), so the
+ * delete must target the SAME set: an already-tombstoned block or a container has
+ * no FTS row, and re-issuing a 'delete' for it corrupts the external-content
+ * index's statistics. Keeping this symmetric with ftsIndexDoc 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). */
+/** Index a document's current live leaf rows (call after inserting blocks). */
 export declare function ftsIndexDoc(db: Database, docId: string): void;
+/**
+ * Rebuild the whole index: `'delete-all'`, then every live leaf of every live
+ * document. (FTS5's own `'rebuild'` command reads the content table wholesale,
+ * containers included, so it is not used.)
+ */
+export declare function ftsRebuild(db: Database): void;
+/**
+ * Remove single `blocks` rows (by id) that are about to be deleted out of
+ * another document's row set — the cross-document eviction of spec/store §5.4
+ * step 8 — keeping the index equal to the table's live leaves. Every row's
+ * leaf-ness is decided over the table BEFORE any of them goes (so a list moving
+ * with its items is order-independent: the items are leaves and lose their
+ * entries, the list never had one), and a live parent that keeps its row but
+ * loses its last live child becomes a leaf and gains an entry. The caller owns
+ * the DELETE of the rows, which must follow this call.
+ */
+export declare function ftsBeforeEvictRows(db: Database, rows: {
+    rowid: number;
+    block_id: string;
+    doc_id: string;
+    parent_block: string | null;
+    text: string;
+    deleted_commit: string | null;
+}[]): void;

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

@@ -1,22 +1,73 @@
-/** 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. */
+/**
+ * SQL predicate: the `blocks` row aliased `b` is a live leaf. `c.doc_id =
+ * b.doc_id` lets the NOT EXISTS use `idx_blocks_doc` (block ids are unique, so
+ * it never changes the answer).
+ */
+export const LIVE_LEAF_SQL = "b.deleted_commit IS NULL AND NOT EXISTS (SELECT 1 FROM blocks c WHERE c.doc_id = b.doc_id AND c.parent_block = b.block_id AND c.deleted_commit IS NULL)";
+/** Remove a document's live leaf rows from the FTS index (call before deleting
+ * or tombstoning blocks). Only live leaves are indexed (see ftsIndexDoc), so the
+ * delete must target the SAME set: an already-tombstoned block or a container has
+ * no FTS row, and re-issuing a 'delete' for it corrupts the external-content
+ * index's statistics. Keeping this symmetric with ftsIndexDoc 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 rows = db.prepare(`SELECT b.rowid AS rowid, b.text AS text FROM blocks b WHERE b.doc_id = ? AND ${LIVE_LEAF_SQL}`).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). */
+/** Index a document's current live leaf 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")
+        .prepare(`SELECT b.rowid AS rowid, b.text AS text FROM blocks b WHERE b.doc_id = ? AND ${LIVE_LEAF_SQL}`)
         .all(docId);
     const ins = db.prepare("INSERT INTO blocks_fts(rowid, text) VALUES(?, ?)");
     for (const r of rows)
         ins.run(r.rowid, r.text);
 }
+/**
+ * Rebuild the whole index: `'delete-all'`, then every live leaf of every live
+ * document. (FTS5's own `'rebuild'` command reads the content table wholesale,
+ * containers included, so it is not used.)
+ */
+export function ftsRebuild(db) {
+    db.exec("INSERT INTO blocks_fts(blocks_fts) VALUES('delete-all')");
+    const docIds = db.prepare("SELECT doc_id FROM docs WHERE deleted_commit IS NULL").all().map((r) => r.doc_id);
+    for (const docId of docIds)
+        ftsIndexDoc(db, docId);
+}
+/**
+ * Remove single `blocks` rows (by id) that are about to be deleted out of
+ * another document's row set — the cross-document eviction of spec/store §5.4
+ * step 8 — keeping the index equal to the table's live leaves. Every row's
+ * leaf-ness is decided over the table BEFORE any of them goes (so a list moving
+ * with its items is order-independent: the items are leaves and lose their
+ * entries, the list never had one), and a live parent that keeps its row but
+ * loses its last live child becomes a leaf and gains an entry. The caller owns
+ * the DELETE of the rows, which must follow this call.
+ */
+export function ftsBeforeEvictRows(db, rows) {
+    if (rows.length === 0)
+        return;
+    const evicted = new Set(rows.map((r) => r.block_id));
+    const hasLiveChild = db.prepare("SELECT 1 FROM blocks c WHERE c.doc_id = ? AND c.parent_block = ? AND c.deleted_commit IS NULL LIMIT 1");
+    const del = db.prepare("INSERT INTO blocks_fts(blocks_fts, rowid, text) VALUES('delete', ?, ?)");
+    const leaves = rows.filter((r) => r.deleted_commit === null && !hasLiveChild.get(r.doc_id, r.block_id));
+    for (const r of leaves)
+        del.run(r.rowid, r.text);
+    // Parents that stay live but are left childless are leaves from now on.
+    const parentRow = db.prepare(`SELECT b.rowid AS rowid, b.text AS text FROM blocks b WHERE b.block_id = ? AND b.doc_id = ? AND b.deleted_commit IS NULL
+       AND NOT EXISTS (SELECT 1 FROM blocks c WHERE c.doc_id = b.doc_id AND c.parent_block = b.block_id AND c.deleted_commit IS NULL AND c.block_id NOT IN (${rows.map(() => "?").join(",")}))`);
+    const ins = db.prepare("INSERT INTO blocks_fts(rowid, text) VALUES(?, ?)");
+    const seen = new Set();
+    for (const r of rows) {
+        if (r.deleted_commit !== null || !r.parent_block || evicted.has(r.parent_block) || seen.has(r.parent_block))
+            continue;
+        seen.add(r.parent_block);
+        const p = parentRow.get(r.parent_block, r.doc_id, ...rows.map((x) => x.block_id));
+        if (p)
+            ins.run(p.rowid, p.text);
+    }
+}
 //# sourceMappingURL=fts.js.map

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

@@ -1,6 +1,6 @@
 import { rebuildSections } from "./sections.js";
 import { rebuildDocEdges } from "./edges.js";
-import { ftsIndexDoc } from "./fts.js";
+import { ftsRebuild } 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);
@@ -14,8 +14,10 @@ export function rebuildIndex(store, target = "all") {
                 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')");
+            // spec/search §1.1: 'delete-all', then every live leaf of every live doc
+            // (FTS5's 'rebuild' would index the content table wholesale, containers
+            // included).
+            ftsRebuild(db);
         }
         if (target === "block_changes" || target === "all") {
             // block_changes is a projection of dispositions across commits: rebuild
@@ -24,6 +26,5 @@ export function rebuildIndex(store, target = "all") {
             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/writers.d.ts

@@ -9,6 +9,12 @@ export interface TreeInputBlock {
     trivia: string;
     attrs: Record<string, unknown>;
     children: TreeInputBlock[];
+    /** The parsed block's source span, when the tree came from a parse — what
+     *  `ownText` (spec/properties §3.2) uses to blank a container's children. */
+    span?: {
+        start: number;
+        end: number;
+    };
 }
 /** Assign fresh minted ids to a parsed block tree (Stage-1 re-mint path). */
 export declare function assignIds(blocks: RawBlock[]): TreeInputBlock[];

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

@@ -9,6 +9,7 @@ export function assignIds(blocks) {
         trivia: b.trivia,
         attrs: b.attrs,
         children: assignIds(b.children),
+        span: b.span,
     }));
 }
 /** Content-address raw text into blobs; returns hex hash. Dedups. */

package/dist/src/format/markdown.js

@@ -2,7 +2,7 @@
 import { AdapterCapability } from "./adapter.js";
 import { parseTree, assertFullCoverage } from "../core/parse/tree.js";
 import { render } from "../core/parse/render.js";
-import { extractFromBlock, extractFromFrontmatter, maskCode } from "../graph/extract.js";
+import { extractFromBlock, extractFromFrontmatter, ownText, scanText, INLINE_FIELD_BRACKETED, INLINE_FIELD_LINE } from "../graph/extract.js";
 export const MARKDOWN_FORMAT = "markdown";
 function toAdapterEdge(e) {
     return {
@@ -35,14 +35,15 @@ export const markdownAdapter = {
     extractEdges(blocks, metadata) {
         const edges = [];
         // Walk every block (recursing into list/blockquote/table nesting) and scan
-        // its raw for links. srcBlock is the block's OWN assigned id — the caller
-        // passes id-assigned blocks (blockId zipped on), mirroring projectNodes; a
-        // block-grain edge without it is useless, so fall back to "" only for the
-        // pre-identity callers. extractFromBlock returns [] for link-free blocks, so
-        // no per-block gate is needed (matches the non-adapter fallback path).
+        // its OWN text for links (spec/graph §1: the raw with the children blanked,
+        // so a link in an item is the item's edge only). srcBlock is the block's
+        // OWN assigned id — the caller passes id-assigned blocks (blockId zipped
+        // on), mirroring projectNodes; a block-grain edge without it is useless, so
+        // fall back to "" only for the pre-identity callers. extractFromBlock
+        // returns [] for link-free blocks, so no per-block gate is needed.
         const walk = (list) => {
             for (const block of list) {
-                for (const e of extractFromBlock(block.blockId ?? "", block.type, block.raw)) {
+                for (const e of extractFromBlock(block.blockId ?? "", block.type, ownText(block))) {
                     edges.push(toAdapterEdge(e));
                 }
                 if (block.children.length > 0)
@@ -76,12 +77,13 @@ export const markdownAdapter = {
                 // Anchor to the block's OWN assigned id (zipped on by ingest); fall back
                 // to the parent's id, then "root", for pre-identity/parse-time callers.
                 const id = b.blockId || parentId || "root";
-                // Code is not prose (extraction_version x2): a code_fence block projects
-                // no link/anchor/field nodes, and inline code spans are masked before the
-                // regex scans below. Same rule as graph/extract.ts so the md:link /
-                // md:wikilink nodes and the `references` edges agree. maskCode is
-                // length-preserving, so spans still index the ORIGINAL raw.
-                const scan = b.type === "code_fence" ? "" : maskCode(b.raw);
+                // The block's own text (spec/graph §1): children blanked, so a feature
+                // belongs to the innermost block only; then code masked — a code_fence
+                // block projects no link/anchor/field nodes, and inline code spans are
+                // blanked (extraction_version x2). Same rule as graph/extract.ts so the
+                // md:link / md:wikilink nodes and the `references` edges agree. Both
+                // masks are length-preserving, so spans still index the ORIGINAL raw.
+                const scan = scanText(b);
                 // Links: [text](target)
                 for (const m of scan.matchAll(/\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g)) {
                     nodes.push({ kind: "md:link", name: m[1], value: m[2], blockId: id, ...span(m) });
@@ -100,20 +102,22 @@ export const markdownAdapter = {
                 for (const m of scan.matchAll(anchorRe)) {
                     nodes.push({ kind: "md:anchor", name: m[1], blockId: id, ...span(m) });
                 }
-                // Inline fields (dataview forms). Two shapes, so a multi-word value is
-                // captured whole instead of truncated at the first space:
-                //   line form  `key:: value`  — key at line start, value to end of line
+                // Inline fields (dataview forms; the patterns are spec/properties §3.2's,
+                // shared with the properties scanner). Two shapes, so a multi-word value
+                // is captured whole instead of truncated at the first space:
+                //   line form  `key:: value`  — key at line start (after blanks and, since
+                //              1.1, an optional list marker + task checkbox), value to
+                //              end of line; span from the key to the trimmed value's end
                 //   bracketed  `[key:: value]` / `(key:: value)` — value ends at closer
-                // Bracketed matches first; the line form is anchored to a line start
-                // (leading whitespace only), so a `[key:: …]`/`(key:: …)` sitting on its
-                // own line is not double-counted (a bracket is not `[a-z]`).
-                for (const m of scan.matchAll(/[[(]([a-z][a-z0-9_]*)::[ \t]*([^\]\n)]*?)[ \t]*[\])]/gi)) {
+                // Bracketed matches first; a `[key:: …]`/`(key:: …)` sitting on its own
+                // line is not double-counted (a bracket is not `[a-z]`).
+                for (const m of scan.matchAll(INLINE_FIELD_BRACKETED)) {
                     nodes.push({ kind: "md:inline_field", name: m[1], value: m[2], blockId: id, ...span(m) });
                 }
-                for (const m of scan.matchAll(/^[ \t]*([a-z][a-z0-9_]*)::[ \t]*([^\n]*?)[ \t]*$/gim)) {
-                    const start = (m.index ?? 0) + (m[0].match(/^[ \t]*/)?.[0].length ?? 0);
+                for (const m of scan.matchAll(INLINE_FIELD_LINE)) {
+                    const start = (m.index ?? 0) + m[1].length;
                     const end = (m.index ?? 0) + m[0].replace(/[ \t]+$/, "").length;
-                    nodes.push({ kind: "md:inline_field", name: m[1], value: m[2], blockId: id, spanStart: start, spanEnd: end });
+                    nodes.push({ kind: "md:inline_field", name: m[2], value: m[3], blockId: id, spanStart: start, spanEnd: end });
                 }
                 if (b.children.length > 0)
                     walk(b.children, id);

package/dist/src/graph/extract.d.ts

@@ -11,6 +11,42 @@ export interface ExtractedEdge {
     anchor: string | null;
     provenance: Provenance;
 }
+/** Bracketed form: `[key:: value]` / `(key:: value)` anywhere in prose; the value
+ *  runs to the first closer (either bracket), trimmed of spaces and tabs. */
+export declare const INLINE_FIELD_BRACKETED: RegExp;
+/** Line form (1.1): a key at the start of a line — after blanks and optionally
+ *  a list marker (`-`/`*`/`+`/`1.`/`1)`) and a task checkbox — with the value
+ *  to the end of the line, trimmed. Group 1 is the prefix (so a span can start
+ *  at the key), 2 the key as written, 3 the trimmed value. A bracketed field on
+ *  its own line is not also a line-form match: `[`/`(` is not `[a-z]`. */
+export declare const INLINE_FIELD_LINE: RegExp;
+interface SpannedBlock {
+    raw: string;
+    span: {
+        start: number;
+        end: number;
+    };
+    children: SpannedBlock[];
+}
+/**
+ * A block's own text: its `raw` with the span of every DIRECT child blanked to
+ * spaces (newlines kept, like `maskCode`, so line structure survives). A child
+ * sits at `child.span.start - block.span.start` in the parent's raw (spans are
+ * source offsets; spec/format §1 inv. 3 puts a child inside its parent). That
+ * offset is trusted only when the parent's raw actually reads `child.raw`
+ * there; otherwise — callers that hand in blocks without real spans (a tree
+ * rebuilt from store rows carries `{0,0}`), which the invariant makes impossible
+ * for a parsed tree — the child is located as the first occurrence of its raw
+ * at or after the previous child's end, and skipped when not found. Length-
+ * preserving: offsets into the result are offsets into `raw`.
+ */
+export declare function ownText(block: SpannedBlock): string;
+/** What the scanners see for a block: nothing for a `code_fence`, else
+ *  `maskCode(ownText(block))` — own text first (a child's fence is blanked
+ *  either way), code second. Same length as `raw`. */
+export declare function scanText(block: SpannedBlock & {
+    type: string;
+}): string;
 /**
  * Resolve a `./foo` / `../bar` destination against the source document's
  * directory (`docDir` = path with the filename stripped, e.g. "a/b/" or "").
@@ -33,6 +69,10 @@ export declare function normalizeUri(uri: string): string;
  */
 export declare function maskCode(raw: string): string;
 /** Extract edges from a single block's raw markdown. Code is skipped: a
- *  `code_fence` block yields nothing, and inline code spans are masked. */
+ *  `code_fence` block yields nothing, and inline code spans are masked. Pass the
+ *  block's own text (`ownText`) for a container so its children's features are
+ *  not counted again here — the adapter does; a caller with only a stored raw
+ *  (no children) passes it as is. */
 export declare function extractFromBlock(blockId: string, blockType: string, rawInput: string): ExtractedEdge[];
 export declare function extractFromFrontmatter(fm: Record<string, unknown>): ExtractedEdge[];
+export {};

package/dist/src/graph/extract.js

@@ -10,6 +10,12 @@
 // (and links_stale no longer reports them as dangling). There is no persisted
 // extraction version — an existing repo re-extracts a document the next time
 // that document is ingested (checkpoint/observe/apply), not via rebuild-index.
+//
+// spec/properties 1.1 + spec/graph 1.1: every scanner runs over the block's
+// OWN text — `maskCode(ownText(block))`, the raw with each direct child's span
+// blanked — so a feature inside a list item belongs to the item (the innermost
+// block that contains it), never also to the list; and the inline-field line
+// form admits a list marker and a task checkbox (`- key:: v`, `- [ ] due:: x`).
 export const EXTRACTION_VERSION = "x2";
 // --- link/inline scanners (operate on a block's raw markdown) ----------------
 const MD_LINK = /(!?)\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g; // [t](dest) / ![alt](dest)
@@ -17,6 +23,55 @@ const WIKILINK = /(!?)\[\[([^\]]+)\]\]/g; // [[note]] / [[note#H]] / [[note^ref]
 const BARE_URL = /(?<![("[])\bhttps?:\/\/[^\s)>\]]+/g;
 const AUTOLINK = /<(https?:\/\/[^>]+)>/g;
 const INLINE_FIELD = /(?:^|\s)([a-z][a-z0-9_]*)::\s*(\[\[[^\]]+\]\]|\/[^\s]+|https?:\/\/[^\s]+)/gi;
+// --- inline-field forms (spec/properties §3.2; shared with md:inline_field) ---
+/** Bracketed form: `[key:: value]` / `(key:: value)` anywhere in prose; the value
+ *  runs to the first closer (either bracket), trimmed of spaces and tabs. */
+export const INLINE_FIELD_BRACKETED = /[[(]([a-z][a-z0-9_]*)::[ \t]*([^\]\n)]*?)[ \t]*[\])]/gi;
+/** Line form (1.1): a key at the start of a line — after blanks and optionally
+ *  a list marker (`-`/`*`/`+`/`1.`/`1)`) and a task checkbox — with the value
+ *  to the end of the line, trimmed. Group 1 is the prefix (so a span can start
+ *  at the key), 2 the key as written, 3 the trimmed value. A bracketed field on
+ *  its own line is not also a line-form match: `[`/`(` is not `[a-z]`. */
+export const INLINE_FIELD_LINE = /^([ \t]*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+(?:\[[ xX]\][ \t]+)?)?)([a-z][a-z0-9_]*)::[ \t]*([^\n]*?)[ \t]*$/gim;
+/**
+ * A block's own text: its `raw` with the span of every DIRECT child blanked to
+ * spaces (newlines kept, like `maskCode`, so line structure survives). A child
+ * sits at `child.span.start - block.span.start` in the parent's raw (spans are
+ * source offsets; spec/format §1 inv. 3 puts a child inside its parent). That
+ * offset is trusted only when the parent's raw actually reads `child.raw`
+ * there; otherwise — callers that hand in blocks without real spans (a tree
+ * rebuilt from store rows carries `{0,0}`), which the invariant makes impossible
+ * for a parsed tree — the child is located as the first occurrence of its raw
+ * at or after the previous child's end, and skipped when not found. Length-
+ * preserving: offsets into the result are offsets into `raw`.
+ */
+export function ownText(block) {
+    if (block.children.length === 0)
+        return block.raw;
+    const raw = block.raw;
+    let out = raw;
+    let cursor = 0;
+    for (const child of block.children) {
+        const len = child.raw.length;
+        if (len === 0)
+            continue;
+        let at = child.span.start - block.span.start;
+        if (!(at >= cursor && at + len <= raw.length && raw.startsWith(child.raw, at))) {
+            at = raw.indexOf(child.raw, cursor);
+            if (at < 0)
+                continue;
+        }
+        out = out.slice(0, at) + blank(child.raw) + out.slice(at + len);
+        cursor = at + len;
+    }
+    return out;
+}
+/** What the scanners see for a block: nothing for a `code_fence`, else
+ *  `maskCode(ownText(block))` — own text first (a child's fence is blanked
+ *  either way), code second. Same length as `raw`. */
+export function scanText(block) {
+    return block.type === "code_fence" ? "" : maskCode(ownText(block));
+}
 function splitAnchor(target) {
     const hashIdx = target.indexOf("#");
     const caretIdx = target.indexOf("^");
@@ -161,7 +216,10 @@ export function maskCode(raw) {
     return out;
 }
 /** Extract edges from a single block's raw markdown. Code is skipped: a
- *  `code_fence` block yields nothing, and inline code spans are masked. */
+ *  `code_fence` block yields nothing, and inline code spans are masked. Pass the
+ *  block's own text (`ownText`) for a container so its children's features are
+ *  not counted again here — the adapter does; a caller with only a stored raw
+ *  (no children) passes it as is. */
 export function extractFromBlock(blockId, blockType, rawInput) {
     const edges = [];
     if (blockType === "code_fence")

package/dist/src/graph/history.d.ts

@@ -25,8 +25,40 @@ export interface DiffEntry {
     after?: string;
 }
 export declare function diffBlocks(store: Store, docId: string, fromRev: string, toRev: string): DiffEntry[];
-/** Unified textual diff (line-based) between two revisions' rendered files. */
+/** `diff_unified` (spec/surface §3): a unified diff of two revisions' rendered
+ * texts — each revision's live raws joined by `\n` — via {@link unifiedDiff}. */
 export declare function diffUnified(store: Store, docId: string, fromRev: string, toRev: string): string;
+/** How each text becomes lines: `split("\n")` exactly — no trimming, no
+ * dropping of a trailing empty element (a raw ending in `\n` yields one) — with
+ * a single special case: the empty text has *no* lines (an empty file is zero
+ * lines, not one empty line), so a diff from/to nothing is `@@ -0,0 +1,n @@`. */
+export declare function diffLines(text: string): string[];
+/** 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[];
+/**
+ * The unified diff of two texts (spec/surface §3): hunks of `DIFF_CONTEXT` (3)
+ * lines of context; a change group extends to include the next change when
+ * fewer than `2 * DIFF_CONTEXT + 1` unchanged lines separate them (the two
+ * contexts touch or overlap). Each hunk is `@@ -a,b +c,d @@` (1-based start
+ * and length; a length of 1 is written as the start alone; a length of 0 as
+ * `a,0` with `a` the line before the insertion point, `0` at the very top)
+ * followed by its lines prefixed `-`, `+` or a space with nothing after the
+ * sign; hunks joined by `\n`; no file header; identical texts → `""`.
+ */
+export declare function unifiedDiff(oldText: string, newText: string): string;
 export interface CommitDigest {
     commit: string;
     seq: number;