@omgbase/core 0.1.0

package/dist/src/graph/inbound-links.js

@@ -0,0 +1,130 @@
+import { extractFromBlock, maskCode, resolveRelativePath } from "./extract.js";
+function canonical(path) {
+    return path.replace(/^\/+/, "");
+}
+function dirOf(path) {
+    return path.replace(/[^/]*$/, "");
+}
+/** Does a destination written in a doc under `srcDir` resolve to `docPath`? */
+function resolvesTo(dest, srcDir, docPath) {
+    if (dest === "" || /^[a-z][a-z0-9+.-]*:/i.test(dest))
+        return false;
+    return canonical(resolveRelativePath(dest, srcDir)) === docPath;
+}
+/**
+ * Every link occurrence in the repo whose destination resolves to `docPath`,
+ * found via the open edges that point at `docId`. Block-level edges are
+ * re-scanned from the block raw so `target`/`anchor` are as written (and so a
+ * self-doc pure-fragment link `#H`, which also has dst_node == docId, is NOT
+ * reported — it does not depend on the path). Frontmatter edges are reported
+ * with `block: null`, `target: docPath`, and their `field`.
+ */
+export function inboundLinksTo(store, repoId, docId, docPath) {
+    const rows = store.db
+        .prepare(`SELECT DISTINCT e.src_doc AS srcDoc, d.path AS srcPath, e.src_block AS srcBlock, e.src_field AS srcField
+       FROM edges e JOIN docs d ON d.doc_id = e.src_doc
+       WHERE e.repo_id = ? AND e.dst_node = ? AND e.to_commit IS NULL AND d.deleted_commit IS NULL
+       ORDER BY d.path, e.src_block`)
+        .all(repoId, docId);
+    const out = [];
+    const seenBlocks = new Set();
+    for (const r of rows) {
+        if (r.srcBlock === null) {
+            out.push({ doc: r.srcDoc, path: r.srcPath, block: null, target: docPath, anchor: null, ...(r.srcField ? { field: r.srcField } : {}) });
+            continue;
+        }
+        if (seenBlocks.has(r.srcBlock))
+            continue;
+        seenBlocks.add(r.srcBlock);
+        const blk = store.db
+            .prepare("SELECT bl.type, b.bytes FROM blocks bl JOIN blobs b ON b.hash = bl.raw_hash WHERE bl.block_id = ? AND bl.deleted_commit IS NULL")
+            .get(r.srcBlock);
+        if (!blk)
+            continue;
+        const srcDir = dirOf(r.srcPath);
+        for (const e of extractFromBlock(r.srcBlock, blk.type, blk.bytes.toString("utf8"))) {
+            if (e.dstKind === "external" || !resolvesTo(e.target, srcDir, docPath))
+                continue;
+            out.push({
+                doc: r.srcDoc,
+                path: r.srcPath,
+                block: r.srcBlock,
+                target: e.target,
+                anchor: e.anchor,
+                ...(e.srcField ? { field: e.srcField } : {}),
+            });
+        }
+    }
+    return out;
+}
+// Relative path from directory `fromDir` ("a/b/" or "") to file `to`.
+function relativePath(fromDir, to) {
+    const from = fromDir.split("/").filter(Boolean);
+    const target = to.split("/").filter(Boolean);
+    let i = 0;
+    while (i < from.length && i < target.length && from[i] === target[i])
+        i++;
+    const ups = from.length - i;
+    const rest = target.slice(i).join("/");
+    return ups === 0 ? `./${rest}` : `${"../".repeat(ups)}${rest}`;
+}
+// Rewrite one destination (path + optional fragment) if its path resolves to
+// `fromPath`, keeping the author's style: absolute stays absolute, `./`/`../`
+// stays relative (recomputed from `writeDir`), bare root-relative stays bare.
+function rewriteDest(dest, matchDir, writeDir, fromPath, toPath) {
+    const hashIdx = dest.indexOf("#");
+    const caretIdx = dest.indexOf("^");
+    let cut = dest.length;
+    if (caretIdx >= 0 && (hashIdx < 0 || caretIdx < hashIdx))
+        cut = caretIdx;
+    else if (hashIdx >= 0)
+        cut = hashIdx;
+    const pathPart = dest.slice(0, cut);
+    const fragment = dest.slice(cut);
+    if (!resolvesTo(pathPart, matchDir, fromPath))
+        return null;
+    let newPath;
+    if (pathPart.startsWith("/"))
+        newPath = "/" + toPath;
+    else if (pathPart.startsWith("./") || pathPart.startsWith("../"))
+        newPath = relativePath(writeDir, toPath);
+    else
+        newPath = toPath;
+    return newPath + fragment;
+}
+// Destination-bearing syntaxes, with the destination isolated in group 2 so we
+// can splice it in place. Scanned over the code-MASKED raw (positions carry
+// over 1:1 to the original), so links inside code are never touched.
+const MD_LINK_DEST = /(!?\[[^\]]*\]\()([^)\s]+)((?:\s+"[^"]*")?\))/g;
+const WIKILINK_DEST = /(!?\[\[)([^\]]+)(\]\])/g;
+const INLINE_FIELD_PATH = /((?:^|\s)[a-z][a-z0-9_]*::\s*)(\/[^\s]+)/gi;
+/**
+ * Rewrite every link destination in `raw` that resolves (relative to `matchDir`,
+ * the source doc's directory at extraction time) to `fromPath` so it points at
+ * `toPath`, writing relative forms against `writeDir` (the source doc's current
+ * directory — differs from `matchDir` only for links inside the moved doc
+ * itself). Anchors, link text, titles, and code spans are preserved. Returns
+ * null when nothing changed.
+ */
+export function retargetLinksInRaw(raw, matchDir, writeDir, fromPath, toPath) {
+    const masked = maskCode(raw);
+    const edits = [];
+    for (const re of [MD_LINK_DEST, WIKILINK_DEST, INLINE_FIELD_PATH]) {
+        for (const m of masked.matchAll(re)) {
+            const dest = m[2];
+            const replaced = rewriteDest(dest, matchDir, writeDir, fromPath, toPath);
+            if (replaced === null)
+                continue;
+            const start = (m.index ?? 0) + m[1].length;
+            edits.push({ start, end: start + dest.length, text: replaced });
+        }
+    }
+    if (edits.length === 0)
+        return null;
+    edits.sort((a, b) => b.start - a.start);
+    let out = raw;
+    for (const e of edits)
+        out = out.slice(0, e.start) + e.text + out.slice(e.end);
+    return out === raw ? null : out;
+}
+//# sourceMappingURL=inbound-links.js.map

package/dist/src/graph/link-destinations.d.ts

@@ -0,0 +1,22 @@
+/** Split an authored destination into its path part and its trailing fragment
+ * (`#Heading` / `^ref`, fragment includes the marker). Mirrors extract.ts
+ * splitAnchor: a `^` ref wins over a `#` heading when both appear. */
+export declare function splitDestination(dest: string): {
+    path: string;
+    fragment: string;
+};
+/** Canonical repo-relative path for a link path as authored in a doc living in
+ * `docDir` ("" for the root, else "dir/sub/"): `./`/`../` resolve against the
+ * doc's directory (mirroring sync/reconciling-ingest resolveRelativePath), and
+ * the leading `/` (repo-root anchor) is dropped — this is the path the edge
+ * index keys phantoms by. */
+export declare function canonicalLinkPath(path: string, docDir?: string): string;
+/** Directory prefix ("" or "a/b/") of a repo-relative doc path. */
+export declare function docDirOf(docPath: string): string;
+/**
+ * Rewrite link destinations in a block's raw markdown. `replace(dest)` is called
+ * once per link feature found outside inline code; it returns the new
+ * destination text, or null to leave that link untouched. Bytes outside link
+ * destinations are never changed.
+ */
+export declare function rewriteLinkDestinations(raw: string, replace: (dest: string) => string | null): string;

package/dist/src/graph/link-destinations.js

@@ -0,0 +1,84 @@
+// Link-destination awareness shared by the stale detector (link-health.ts) and
+// the repair macro (mutate/macros.ts linksRepair). A "destination" is the exact
+// authored target text of a link feature in a block's raw markdown:
+//
+//   [text](dest)  ![alt](dest)     Markdown link / image  → `dest`
+//   [[dest]]  [[dest|alias]]        wikilink               → `dest` (alias kept aside)
+//   key:: /dest                     inline field, bare repo path → `/dest`
+//
+// Inline code spans (`…`) are opaque: a link-shaped string inside backticks is
+// prose about a link, not a link, so scanners skip them. Whole `code_fence`
+// blocks are the caller's job to exclude (they are their own block type).
+//
+// The same regexes the edge extractor (extract.ts) and node projector
+// (format/markdown.ts) use, so what this module rewrites is exactly what the
+// edge index reports as a link.
+/** Split an authored destination into its path part and its trailing fragment
+ * (`#Heading` / `^ref`, fragment includes the marker). Mirrors extract.ts
+ * splitAnchor: a `^` ref wins over a `#` heading when both appear. */
+export function splitDestination(dest) {
+    const caret = dest.indexOf("^");
+    if (caret >= 0)
+        return { path: dest.slice(0, caret), fragment: dest.slice(caret) };
+    const hash = dest.indexOf("#");
+    if (hash >= 0)
+        return { path: dest.slice(0, hash), fragment: dest.slice(hash) };
+    return { path: dest, fragment: "" };
+}
+/** Canonical repo-relative path for a link path as authored in a doc living in
+ * `docDir` ("" for the root, else "dir/sub/"): `./`/`../` resolve against the
+ * doc's directory (mirroring sync/reconciling-ingest resolveRelativePath), and
+ * the leading `/` (repo-root anchor) is dropped — this is the path the edge
+ * index keys phantoms by. */
+export function canonicalLinkPath(path, docDir = "") {
+    if (path.startsWith("./") || path.startsWith("../")) {
+        const out = [];
+        for (const p of (docDir + path).split("/")) {
+            if (p === "." || p === "")
+                continue;
+            if (p === "..") {
+                out.pop();
+                continue;
+            }
+            out.push(p);
+        }
+        return out.join("/");
+    }
+    return path.replace(/^\//, "");
+}
+/** Directory prefix ("" or "a/b/") of a repo-relative doc path. */
+export function docDirOf(docPath) {
+    const i = docPath.lastIndexOf("/");
+    return i < 0 ? "" : docPath.slice(0, i + 1);
+}
+// Link-feature scanners. Each captures (prefix, dest, suffix) so a rewrite can
+// splice a new destination in place and leave everything else byte-identical.
+const MD_LINK = /(!?\[[^\]]*\]\()([^)\s]+)((?:\s+"[^"]*")?\))/g;
+const WIKILINK = /(!?\[\[)([^\]|]+)((?:\|[^\]]*)?\]\])/g;
+const INLINE_FIELD_PATH = /((?:^|\s)[a-z][a-z0-9_]*::[ \t]*)(\/[^\s]+)()/gi;
+// Inline code: a backtick run closed by an identical run (CommonMark code span).
+const CODE_SPAN = /(`+)[^`][\s\S]*?\1/g;
+/**
+ * Rewrite link destinations in a block's raw markdown. `replace(dest)` is called
+ * once per link feature found outside inline code; it returns the new
+ * destination text, or null to leave that link untouched. Bytes outside link
+ * destinations are never changed.
+ */
+export function rewriteLinkDestinations(raw, replace) {
+    const rewriteSegment = (seg) => {
+        const sub = (re) => (s) => s.replace(re, (whole, pre, dest, post) => {
+            const next = replace(dest);
+            return next === null ? whole : pre + next + post;
+        });
+        return sub(INLINE_FIELD_PATH)(sub(WIKILINK)(sub(MD_LINK)(seg)));
+    };
+    let out = "";
+    let last = 0;
+    for (const m of raw.matchAll(CODE_SPAN)) {
+        const start = m.index ?? 0;
+        out += rewriteSegment(raw.slice(last, start)) + m[0];
+        last = start + m[0].length;
+    }
+    return out + rewriteSegment(raw.slice(last));
+}
+//# sourceMappingURL=link-destinations.js.map

package/dist/src/graph/link-health.d.ts

@@ -0,0 +1,79 @@
+import type { Store } from "../core/store/store.js";
+export type StaleReason = "dangling_doc" | "dangling_block" | "broken_anchor";
+export interface StaleLink {
+    /** source document id */
+    srcDoc: string;
+    /** source document repo-relative path */
+    srcPath: string;
+    /** source block id (null for frontmatter-level edges) */
+    srcBlock: string | null;
+    predicate: string;
+    provenance: string;
+    dstKind: string;
+    /** canonical target PATH (phantom prefix stripped, no leading `/`), e.g. "guides/old.md" */
+    target: string;
+    /** the destination exactly as authored in the source block, e.g. "/guides/old.md#Setup"
+     * — paste-ready as `links_repair.from`. null when it can't be recovered (frontmatter
+     * edges have no block; a projected node no longer matches). */
+    authored: string | null;
+    anchor: string | null;
+    reason: StaleReason;
+}
+/** links_stale summary mode: counts only, no per-row output. */
+export interface LinkHealthSummary {
+    /** number of dangling internal links (rows `linksStale` would return, uncapped) */
+    staleCount: number;
+    /** distinct missing targets, most-referenced first (ties by target) */
+    byTarget: {
+        target: string;
+        count: number;
+    }[];
+    /** source documents carrying dangling links, most first (ties by path) */
+    bySource: {
+        srcPath: string;
+        count: number;
+    }[];
+    externalCount: number;
+    totalOpenEdges: number;
+}
+export interface LinkHealth {
+    /** dangling internal links, ordered by srcPath then target */
+    stale: StaleLink[];
+    /** open external (http(s)) edges — unverifiable, not counted as stale */
+    externalCount: number;
+    /** total open edges scanned (after src-doc glob scoping) */
+    totalOpenEdges: number;
+    /** true when `stale` was capped by `limit` */
+    truncated: boolean;
+}
+export interface LinkHealthOptions {
+    /** scope the SOURCE docs by a path glob (`journal/*`); `*` maps to SQL `%`. */
+    pathGlob?: string;
+    /** cap the number of stale links returned (default 500). */
+    limit?: number;
+}
+export declare function globClause(column: string, glob: string): {
+    clause: string;
+    param: string;
+};
+/**
+ * linksStale: scan open edges repo-wide and return the dangling internal ones,
+ * plus a count of unverifiable external links. Read-only; pure DB read over the
+ * edge index (no FS/network).
+ *
+ * Dangling detection: an open edge whose `dst_node LIKE 'phantom:%'` points at a
+ * path with no live doc. `target` is the path with the `phantom:` prefix
+ * stripped so callers see `guides/old.md`, not the internal id.
+ *
+ * Scoping: `pathGlob` filters the SOURCE docs (joined edges.src_doc → docs).
+ * Edges whose src_doc is tombstoned (docs.deleted_commit IS NOT NULL) are
+ * skipped — a deleted doc's dangling links are not actionable.
+ */
+export declare function linksStale(store: Store, repoId: string, opts?: LinkHealthOptions): LinkHealth;
+/**
+ * linksStaleSummary: the same scan as linksStale, reduced to counts grouped by
+ * missing target and by source document — a repo-wide audit in one small call
+ * (no per-row output, no limit). Scoping (`pathGlob` over SOURCE docs) and the
+ * tombstone rule match linksStale exactly, so the totals agree.
+ */
+export declare function linksStaleSummary(store: Store, repoId: string, opts?: Pick<LinkHealthOptions, "pathGlob">): LinkHealthSummary;

package/dist/src/graph/link-health.js

@@ -0,0 +1,146 @@
+import { canonicalLinkPath, docDirOf, splitDestination } from "./link-destinations.js";
+// Convert a path glob to a SQL LIKE clause + param, mirroring compileWithin
+// (search/cel/compile.ts) and docHistory (graph/history.ts): escape %/_ then
+// map `*`→`%`. A glob without `*` is an exact-path match.
+export function globClause(column, glob) {
+    if (glob.includes("*")) {
+        const like = glob.replace(/[%_]/g, "\\$&").replace(/\*/g, "%");
+        return { clause: `${column} LIKE ? ESCAPE '\\'`, param: like };
+    }
+    return { clause: `${column} = ?`, param: glob };
+}
+/**
+ * linksStale: scan open edges repo-wide and return the dangling internal ones,
+ * plus a count of unverifiable external links. Read-only; pure DB read over the
+ * edge index (no FS/network).
+ *
+ * Dangling detection: an open edge whose `dst_node LIKE 'phantom:%'` points at a
+ * path with no live doc. `target` is the path with the `phantom:` prefix
+ * stripped so callers see `guides/old.md`, not the internal id.
+ *
+ * Scoping: `pathGlob` filters the SOURCE docs (joined edges.src_doc → docs).
+ * Edges whose src_doc is tombstoned (docs.deleted_commit IS NOT NULL) are
+ * skipped — a deleted doc's dangling links are not actionable.
+ */
+export function linksStale(store, repoId, opts = {}) {
+    const limit = opts.limit ?? 500;
+    const params = [repoId];
+    let globSql = "";
+    if (opts.pathGlob) {
+        const { clause, param } = globClause("d.path", opts.pathGlob);
+        globSql = `AND ${clause}`;
+        params.push(param);
+    }
+    // Total open edges (scoped) and external count in one pass over the join.
+    const totals = store.db
+        .prepare(`SELECT count(*) AS total,
+              sum(CASE WHEN e.dst_kind = 'external' THEN 1 ELSE 0 END) AS external
+       FROM edges e
+       JOIN docs d ON d.doc_id = e.src_doc
+       WHERE e.repo_id = ? AND e.to_commit IS NULL AND d.deleted_commit IS NULL ${globSql}`)
+        .get(...params);
+    // Dangling internal links: open, source not tombstoned, dst is a phantom.
+    const rows = store.db
+        .prepare(`SELECT e.src_doc AS srcDoc, d.path AS srcPath, e.src_block AS srcBlock,
+              e.predicate AS predicate, e.provenance AS provenance, e.dst_kind AS dstKind,
+              e.dst_node AS dstNode, e.anchor AS anchor
+       FROM edges e
+       JOIN docs d ON d.doc_id = e.src_doc
+       WHERE e.repo_id = ? AND e.to_commit IS NULL AND d.deleted_commit IS NULL
+         AND e.dst_node LIKE 'phantom:%' ${globSql}
+       ORDER BY d.path, e.dst_node, e.src_block
+       LIMIT ?`)
+        .all(...params, limit + 1);
+    const truncated = rows.length > limit;
+    const page = rows.slice(0, limit);
+    // Recover the destination AS AUTHORED from the block's projected link nodes:
+    // the edge index keeps only the canonical target, but md:link / md:wikilink /
+    // md:inline_field nodes carry the exact destination text. Pick the node whose
+    // canonical (path, fragment) equals this edge's (target, anchor).
+    const nodeStmt = store.db.prepare("SELECT kind, value FROM nodes WHERE block_id = ? AND kind IN ('md:link','md:wikilink','md:inline_field') AND value IS NOT NULL");
+    const authoredFor = (srcBlock, srcPath, target, anchor) => {
+        if (srcBlock === null)
+            return null;
+        const docDir = docDirOf(srcPath);
+        for (const n of nodeStmt.all(srcBlock)) {
+            let dest = n.value;
+            if (n.kind === "md:inline_field") {
+                const wl = /^\[\[([^\]]+)\]\]$/.exec(dest);
+                if (wl)
+                    dest = wl[1];
+                else if (!dest.startsWith("/"))
+                    continue;
+            }
+            if (n.kind === "md:wikilink")
+                dest = dest.split("|")[0];
+            const { path, fragment } = splitDestination(dest);
+            if (canonicalLinkPath(path, docDir) !== target)
+                continue;
+            if ((fragment === "" ? null : fragment.slice(1)) !== anchor)
+                continue;
+            return dest;
+        }
+        return null;
+    };
+    const stale = page.map((r) => {
+        // Strip the "phantom:" prefix to expose the canonical path.
+        const target = r.dstNode.slice("phantom:".length);
+        return {
+            srcDoc: r.srcDoc,
+            srcPath: r.srcPath,
+            srcBlock: r.srcBlock,
+            predicate: r.predicate,
+            provenance: r.provenance,
+            dstKind: r.dstKind,
+            target,
+            authored: authoredFor(r.srcBlock, r.srcPath, target, r.anchor),
+            anchor: r.anchor,
+            // All phantom targets are dangling DOCUMENTS in this data model (cross-doc
+            // block refs collapse to document phantoms carrying an anchor). We tag rows
+            // that also carry an anchor as such, but the miss is still a missing doc.
+            reason: "dangling_doc",
+        };
+    });
+    return {
+        stale,
+        externalCount: totals.external ?? 0,
+        totalOpenEdges: totals.total,
+        truncated,
+    };
+}
+/**
+ * linksStaleSummary: the same scan as linksStale, reduced to counts grouped by
+ * missing target and by source document — a repo-wide audit in one small call
+ * (no per-row output, no limit). Scoping (`pathGlob` over SOURCE docs) and the
+ * tombstone rule match linksStale exactly, so the totals agree.
+ */
+export function linksStaleSummary(store, repoId, opts = {}) {
+    const params = [repoId];
+    let globSql = "";
+    if (opts.pathGlob) {
+        const { clause, param } = globClause("d.path", opts.pathGlob);
+        globSql = `AND ${clause}`;
+        params.push(param);
+    }
+    const base = `FROM edges e JOIN docs d ON d.doc_id = e.src_doc
+     WHERE e.repo_id = ? AND e.to_commit IS NULL AND d.deleted_commit IS NULL ${globSql}`;
+    const totals = store.db
+        .prepare(`SELECT count(*) AS total, sum(CASE WHEN e.dst_kind = 'external' THEN 1 ELSE 0 END) AS external ${base}`)
+        .get(...params);
+    const phantom = `${base} AND e.dst_node LIKE 'phantom:%'`;
+    const byTarget = store.db
+        .prepare(`SELECT e.dst_node AS dstNode, count(*) AS count ${phantom} GROUP BY e.dst_node ORDER BY count DESC, e.dst_node`)
+        .all(...params)
+        .map((r) => ({ target: r.dstNode.slice("phantom:".length), count: r.count }));
+    const bySource = store.db
+        .prepare(`SELECT d.path AS srcPath, count(*) AS count ${phantom} GROUP BY d.path ORDER BY count DESC, d.path`)
+        .all(...params);
+    return {
+        staleCount: byTarget.reduce((n, t) => n + t.count, 0),
+        byTarget,
+        bySource,
+        externalCount: totals.external ?? 0,
+        totalOpenEdges: totals.total,
+    };
+}
+//# sourceMappingURL=link-health.js.map

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

@@ -0,0 +1,23 @@
+import type { Store } from "../core/store/store.js";
+export interface LinkEdge {
+    predicate: string;
+    /** the other endpoint (dst for out-edges, src for in-edges) */
+    node: string;
+    kind: string;
+    /** how many underlying block-grain edges this doc-grain row rolls up */
+    count: number;
+    /** sample source block ids (out-edges only) */
+    samples?: string[];
+}
+export interface LinksResult {
+    out: LinkEdge[];
+    in: LinkEdge[];
+}
+export interface LinksOptions {
+    direction?: "out" | "in" | "both";
+    predicates?: string[];
+    /** block-grain instead of the doc_edges rollup */
+    blocks?: boolean;
+}
+/** Open edges touching a document, grouped by direction (11 §5.4). */
+export declare function docLinks(store: Store, docId: string, opts?: LinksOptions): LinksResult;

package/dist/src/graph/links.js

@@ -0,0 +1,42 @@
+/** Open edges touching a document, grouped by direction (11 §5.4). */
+export function docLinks(store, docId, opts = {}) {
+    const dir = opts.direction ?? "both";
+    const predFilter = opts.predicates && opts.predicates.length > 0 ? opts.predicates : null;
+    const inPred = (p) => !predFilter || predFilter.includes(p);
+    const out = [];
+    const inbound = [];
+    if (dir === "out" || dir === "both") {
+        if (opts.blocks) {
+            const rows = store.db
+                .prepare(`SELECT predicate, dst_node, dst_kind FROM edges
+           WHERE src_doc = ? AND to_commit IS NULL ORDER BY predicate, dst_node`)
+                .all(docId);
+            for (const r of rows)
+                if (inPred(r.predicate))
+                    out.push({ predicate: r.predicate, node: r.dst_node, kind: r.dst_kind, count: 1 });
+        }
+        else {
+            const rows = store.db
+                .prepare(`SELECT predicate, dst_node, dst_kind, count, samples FROM doc_edges
+           WHERE src_doc = ? ORDER BY predicate, dst_node`)
+                .all(docId);
+            for (const r of rows) {
+                if (!inPred(r.predicate))
+                    continue;
+                out.push({ predicate: r.predicate, node: r.dst_node, kind: r.dst_kind, count: r.count, samples: JSON.parse(r.samples) });
+            }
+        }
+    }
+    if (dir === "in" || dir === "both") {
+        const rows = store.db
+            .prepare(`SELECT predicate, src_doc, count(*) AS cnt FROM edges
+         WHERE dst_node = ? AND to_commit IS NULL
+         GROUP BY predicate, src_doc ORDER BY predicate, src_doc`)
+            .all(docId);
+        for (const r of rows)
+            if (inPred(r.predicate))
+                inbound.push({ predicate: r.predicate, node: r.src_doc, kind: "document", count: r.cnt });
+    }
+    return { out, in: inbound };
+}
+//# sourceMappingURL=links.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,60 @@
+export { VERSION } from "./core/index.js";
+export type { FormatAdapter, AdapterEdge, ProjectedNode, EmbeddingChunk, ReconcileHints } from "./format/adapter.js";
+export { AdapterCapability } from "./format/adapter.js";
+export { registerAdapter, adapterForFormat, adapterForPath, registeredFormats, detectFormat } from "./format/registry.js";
+export { markdownAdapter, MARKDOWN_FORMAT } from "./format/markdown.js";
+export { yamlAdapter, YAML_FORMAT } from "./format/yaml.js";
+export { jsonAdapter, JSON_FORMAT } from "./format/json.js";
+export { writeDocNodes, deleteDocNodes } from "./core/store/nodes.js";
+export { docPropertiesMerged, docPropertiesGrouped, writeDocProperties, flattenFrontmatter } from "./core/store/properties.js";
+import "./format/index.js";
+export { Store, type StoreOptions } from "./core/store/store.js";
+export { Workspace, RepoSelectionError, type RepoRow } from "./sync/workspace.js";
+export { resolveSettings, workspaceSettings, repoOwnSettings, writeWorkspaceSettings, writeRepoSettings, deepMerge, type Settings, } from "./sync/settings.js";
+export { freshnessSweep, rebuildFileStats, recordFileStat, detectDiskDrift, type SweepResult, type DiskDrift } from "./sync/freshness.js";
+export { withWriterLock, writerLockFree, WriterLockTimeout } from "./sync/writer-lock.js";
+export { WatchLease, watchLeaseLive } from "./sync/watch-lease.js";
+export { ingestDirectory, type IngestDirResult } from "./sync/attach.js";
+export { ensureRepo } from "./core/attach.js";
+export { walkMarkdown, walkMarkdownAsync } from "./sync/fs-util.js";
+export { Watcher, type WatcherOptions } from "./sync/watcher.js";
+export type { SyncSource, SourceCapabilities, SourceIdentity, SourceEntry, SourceItem, SourceWatch, WatchListener, } from "./sync/plugin.js";
+export { createExternalSource, type ExternalSourceSpec } from "./sync/external-source.js";
+export { ensureAdapter, listAdapters, createSource, deleteSource, listSources, getSourceByName, attachSourceToRepo, detachSourceFromRepo, sourcesForRepo, renderConfigFlags, type AdapterRow, type SourceRow, } from "./sync/sources.js";
+export { reconcileChanges, attachSource } from "./sync/driver.js";
+export { observeFile, observeMany, observeOne, observeDelete, type ObserveResult, type ObserveOneResult, type ObserveDeleteResult } from "./sync/observe.js";
+export { buildServer, type ServerContext } from "./mcp/server.js";
+export { serveStdio, type ServeStdioHandle } from "./mcp/stdio.js";
+export { processCheckpoint, type CheckpointResult } from "./sync/checkpoint.js";
+export { reposStatus, syncStatus, type RepoStatus, type SyncStatus, type DiskStatus } from "./sync/admin.js";
+export { docsOutline, type OutlineResult, type OutlineOptions } from "./core/read/outline.js";
+export { docsRead, reconstructContent, type DocsReadResult, type DocsReadOptions } from "./core/read/document.js";
+export { nodesGet, nodesGetMany, type GetNode, type Resolution } from "./core/read/nodes.js";
+export { findDoc, loadDocBlocks, blockRaw, docsList, docsTree, normalizeTreePrefix, DOCS_LIST_DEFAULT_LIMIT, DOCS_TREE_DEFAULT_LIMIT, type DocInfo, type BlockNode, type DocListRow, type DocListPage, type DocListOptions, type DocTreeEntry, type DocTreePage, type DocTreeOptions, } from "./core/read/reader.js";
+export { CursorInvalid, encodeCursor, decodeCursor } from "./core/cursor.js";
+export { resolveRef, type ResolvedRef } from "./core/read/refs.js";
+export { resolve, type ResolveHit, type ResolveInput } from "./search/resolve.js";
+export { oqxRun, oqxRunAsync, collectSemanticPhrases, parseOqx, type OqxResult, type OqxHit, type OqxOptions, type EmbedQuery } from "./oqx/run.js";
+export { EmbeddingWorker, SemanticUnavailable, contextPrefix, shouldEmbed, estimateTokens, type EmbeddingProvider, type EmbedTask, type DocEmbedTask, type DocEmbedBlockRef, type DocEmbedMethod, type DocVectorRow, } from "./search/embeddings.js";
+export { buildEmbedTasks, buildDocEmbedTasks } from "./search/tasks.js";
+export { EmbedDrainer, type DrainerOptions } from "./search/drain.js";
+export { embeddingSettings, type EmbeddingSettings } from "./search/provider.js";
+export { createExternalProvider, type ExternalProvider } from "./search/external.js";
+export { hybridSearch, type HybridHit, type HybridInput } from "./search/rrf.js";
+export { vectorSearch, docVectorSearch, type VectorHit, type DocVectorHit } from "./search/vector.js";
+export { historyNode, diffUnified, changesSince, type NodeChange, type CommitDigest } from "./graph/history.js";
+export { docLinks, type LinksResult, type LinkEdge, type LinksOptions } from "./graph/links.js";
+export { FilterInvalid } from "./search/cel/parser.js";
+export { EngineError, type ErrorCode } from "./mcp/errors.js";
+export { MutationError } from "./mutate/tree.js";
+export { isValidId, prefixOf } from "./core/ids.js";
+export { apply, type ApplyRequest, type ApplyResult, type Op } from "./mutate/apply.js";
+export { type DocStore, FsDocStore, NullDocStore, resolveDocStore } from "./mutate/doc-store.js";
+export { type To, type At, type Expect } from "./mutate/ops.js";
+export { tasksComplete, sectionsAppend, sectionsRename, sectionsMove, listsInsertItem, linksRetarget, nodeSet, editablePropsFor, type RetargetHit, } from "./mutate/macros.js";
+export { docsCreate, docsMove, docsDelete, docsSetMeta, type DocOpContext, type DocOpResult, type DocMoveOptions, type DocMoveResult, } from "./mutate/docs.js";
+export { inboundLinksTo, retargetLinksInRaw, type InboundLink } from "./graph/inbound-links.js";
+export { planUpdate, applyOpset, docsUpdate, type PlanUpdateOptions, type ApplyOpsetRequest, type DocsUpdateContext, type DocsUpdateResult, } from "./mutate/plan-update.js";
+export { opsetKernelOps, renderOpsetPlan, serializeOpset, parseOpset, type Opset, type PlanOp, type OpsetSummary, type OpsetPrecondition, type PlanDisposition, } from "./mutate/opset.js";
+export { rebuildIndex, type RebuildTarget } from "./core/store/rebuild.js";
+export { runGc, type GcResult } from "./core/store/gc.js";