mrplex 0.0.1

package/dist/links/repair.js

@@ -0,0 +1,96 @@
+/**
+ * mrplex links repair — rewrite stale link text so the written destination
+ * matches the target's current path (design §11.2 "Link rewriting is
+ * cosmetic, not structural — and opt-in").
+ *
+ * The graph is identity-bound, so a move breaks nothing structurally; this
+ * only repairs the visible text. Each source document is rewritten as an
+ * ordinary optimistic `docs.put` under the caller's token — `prev` checks
+ * apply, conflicts are reported and skipped, and every repair is a normal
+ * authored version in the chain (NOT a silent side effect of the move).
+ *
+ * Rewriting is surgical: only the destination spans of stale edges are
+ * spliced (right-to-left so earlier offsets stay valid); the rest of the
+ * body is byte-identical. Only inline/​wikilink edges with a captured
+ * destination span are rewritten; reference-definition links are left for a
+ * later phase.
+ */
+import { normalizeKey } from "../kernel/casefold.js";
+import { extractEdges } from "./extract.js";
+import { normalizeEdges } from "./resolve.js";
+/**
+ * Compute the body rewrites needed to repair stale links across a repo's
+ * live documents. Pure w.r.t. storage reads — no writes. The caller issues
+ * the puts (so auth, conflict handling, and dry-run all live at the op
+ * layer, where the actor and kernel are in scope).
+ */
+export async function planRepairs(storage, repoId, config) {
+    const live = await storage.versions_live_by_repo(repoId);
+    const currentPathByDoc = new Map();
+    for (const v of live)
+        currentPathByDoc.set(v.document_id, v.path);
+    const plans = [];
+    for (const version of live) {
+        const stored = await storage.links_by_source(version.document_id);
+        if (stored.length === 0)
+            continue;
+        const raw = extractEdges({ body: version.body, frontmatter: version.frontmatter, config });
+        const normalized = normalizeEdges(raw, version.path, config);
+        // The stored rows correspond to the storable (non-external) edges in
+        // order; re-derive that alignment, keeping the RawEdge (for dest_span).
+        const storableRaw = [];
+        for (let i = 0; i < normalized.length; i++) {
+            if (normalized[i].candidates.length > 0) {
+                storableRaw.push(raw[i]);
+            }
+        }
+        // Collect (span, replacement) rewrites for stale, span-bearing edges.
+        // Keyed by span start so multiple reference links sharing one `[id]: dest`
+        // definition produce a SINGLE rewrite (they resolve to the same target,
+        // so the replacement is identical) — splicing the shared span twice would
+        // corrupt the body.
+        const rewriteBySpan = new Map();
+        for (let i = 0; i < stored.length && i < storableRaw.length; i++) {
+            const row = stored[i];
+            const edge = storableRaw[i];
+            if (!row || !edge)
+                continue;
+            if (row.target_id === null)
+                continue; // dangling — nothing to repair
+            const currentPath = currentPathByDoc.get(row.target_id);
+            if (currentPath === undefined)
+                continue; // target not live
+            // row.target_norm is already folded (maintain.ts), so compare directly.
+            if (row.target_norm === normalizeKey(currentPath))
+                continue; // fresh
+            if (!edge.dest_span)
+                continue; // no rewritable span (shouldn't happen post-R4)
+            // Preserve any anchor the writer had on the destination.
+            const anchorIx = edge.target.indexOf("#");
+            const anchor = anchorIx >= 0 ? edge.target.slice(anchorIx) : "";
+            // Wikilinks are written without the .md extension by convention; keep
+            // that shape. Inline / reference links get the full repo-relative path.
+            const replacement = edge.wikilink ? stripMd(currentPath) + anchor : currentPath + anchor;
+            rewriteBySpan.set(edge.dest_span.start, {
+                start: edge.dest_span.start,
+                end: edge.dest_span.end,
+                text: replacement,
+            });
+        }
+        const rewrites = [...rewriteBySpan.values()];
+        if (rewrites.length === 0)
+            continue;
+        // Splice right-to-left so earlier offsets remain valid.
+        rewrites.sort((a, b) => b.start - a.start);
+        let body = version.body;
+        for (const r of rewrites) {
+            body = body.slice(0, r.start) + r.text + body.slice(r.end);
+        }
+        plans.push({ version, newBody: body, edges: rewrites.length });
+    }
+    return plans;
+}
+function stripMd(path) {
+    return path.endsWith(".md") ? path.slice(0, -3) : path;
+}
+//# sourceMappingURL=repair.js.map

package/dist/links/repair.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair.js","sourceRoot":"","sources":["../../src/links/repair.ts"],"names":[],"mappings":"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"}

package/dist/links/resolve.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Target normalization — design §11.2 "Path resolution rules" (WS2 half).
+ *
+ * Turns a RawEdge's as-written target into:
+ *   • target_raw   — the repo-root-relative path stored in the links table,
+ *                    anchor preserved (this is what `links repair` compares
+ *                    against and what dangling re-resolution keys on)
+ *   • candidates   — ordered repo-root-relative *paths* (anchor stripped) to
+ *                    try against the live path set; the first that resolves
+ *                    to a document binds the edge (WS3)
+ *
+ * Paths are stored without a leading slash (e.g. "people/alice.md"), so
+ * "repo-absolute" here means repo-root-relative in that same form. Binding
+ * a candidate to a document id is WS3's job (resolve-against-live-paths);
+ * this module is pure and has no storage dependency.
+ *
+ * External targets (a URI scheme like https:, or a bare fragment "#x")
+ * produce no candidates — they never enter the graph (links are repo-local,
+ * §11.2).
+ */
+import type { RawEdge } from "./extract.js";
+import type { LinkConfig } from "./link-config.js";
+export type NormalizedEdge = {
+    ord: number;
+    field: string;
+    /** Repo-root-relative, anchor preserved. Stored as links.target_raw. */
+    target_raw: string;
+    /**
+     * Ordered candidate paths (no anchor) to resolve against live paths.
+     * Empty = external / unresolvable target (never binds, never dangles).
+     */
+    candidates: string[];
+};
+/**
+ * Normalize one raw edge against its source document's path and the repo's
+ * link config. `srcPath` is the repo-root-relative path of the document the
+ * edge originates from (e.g. "moc/employees.md").
+ */
+export declare function normalizeTarget(edge: RawEdge, srcPath: string, config: LinkConfig): NormalizedEdge;
+/** Convenience: normalize a whole edge list for one source document. */
+export declare function normalizeEdges(edges: readonly RawEdge[], srcPath: string, config: LinkConfig): NormalizedEdge[];

package/dist/links/resolve.js

@@ -0,0 +1,121 @@
+/**
+ * Target normalization — design §11.2 "Path resolution rules" (WS2 half).
+ *
+ * Turns a RawEdge's as-written target into:
+ *   • target_raw   — the repo-root-relative path stored in the links table,
+ *                    anchor preserved (this is what `links repair` compares
+ *                    against and what dangling re-resolution keys on)
+ *   • candidates   — ordered repo-root-relative *paths* (anchor stripped) to
+ *                    try against the live path set; the first that resolves
+ *                    to a document binds the edge (WS3)
+ *
+ * Paths are stored without a leading slash (e.g. "people/alice.md"), so
+ * "repo-absolute" here means repo-root-relative in that same form. Binding
+ * a candidate to a document id is WS3's job (resolve-against-live-paths);
+ * this module is pure and has no storage dependency.
+ *
+ * External targets (a URI scheme like https:, or a bare fragment "#x")
+ * produce no candidates — they never enter the graph (links are repo-local,
+ * §11.2).
+ */
+const SCHEME = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+/**
+ * Normalize one raw edge against its source document's path and the repo's
+ * link config. `srcPath` is the repo-root-relative path of the document the
+ * edge originates from (e.g. "moc/employees.md").
+ */
+export function normalizeTarget(edge, srcPath, config) {
+    const base = { ord: edge.ord, field: edge.field };
+    // Split off the anchor. `preserve_anchors` keeps it on target_raw; the
+    // path used for resolution never includes it.
+    const hashIx = edge.target.indexOf("#");
+    const hasAnchor = hashIx >= 0;
+    const rawPath = hasAnchor ? edge.target.slice(0, hashIx) : edge.target;
+    const anchor = hasAnchor ? edge.target.slice(hashIx) : "";
+    const keepAnchor = config.resolution.preserve_anchors ? anchor : "";
+    // A bare fragment ("#section") is a same-document link — no edge target.
+    if (rawPath.length === 0) {
+        return { ...base, target_raw: edge.target, candidates: [] };
+    }
+    // External URIs (https:, mailto:, etc.) are repo-external — dropped.
+    if (SCHEME.test(rawPath)) {
+        return { ...base, target_raw: edge.target, candidates: [] };
+    }
+    if (edge.wikilink) {
+        return normalizeWikilink(base, rawPath, keepAnchor, config);
+    }
+    return normalizeCommonMark(base, rawPath, keepAnchor, srcPath);
+}
+/** Convenience: normalize a whole edge list for one source document. */
+export function normalizeEdges(edges, srcPath, config) {
+    return edges.map((e) => normalizeTarget(e, srcPath, config));
+}
+// -----------------------------------------------------------------------------
+// CommonMark: relative-to-source unless repo-absolute (leading '/').
+// -----------------------------------------------------------------------------
+function normalizeCommonMark(base, rawPath, anchor, srcPath) {
+    const resolved = rawPath.startsWith("/")
+        ? normalizeSegments(rawPath.slice(1).split("/"))
+        : normalizeSegments([...dirSegments(srcPath), ...rawPath.split("/")]);
+    // Unresolvable (escaped above repo root via too many "..") → no candidate.
+    const candidates = resolved === null ? [] : [resolved];
+    const target_raw = resolved === null ? rawPath + anchor : resolved + anchor;
+    return { ...base, target_raw, candidates };
+}
+// -----------------------------------------------------------------------------
+// Wikilinks: root-relative, with extension elision candidates.
+// -----------------------------------------------------------------------------
+function normalizeWikilink(base, rawPath, anchor, config) {
+    // Wikilinks are root-relative (Obsidian-style short links resolve from the
+    // vault root), leading slash tolerated.
+    const stripped = rawPath.startsWith("/") ? rawPath.slice(1) : rawPath;
+    const resolved = normalizeSegments(stripped.split("/"));
+    if (resolved === null) {
+        return { ...base, target_raw: rawPath + anchor, candidates: [] };
+    }
+    if (!config.resolution.wikilink_elision) {
+        return { ...base, target_raw: resolved + anchor, candidates: [resolved] };
+    }
+    // Elision: [[foo]] → foo.md → foo/<index>.md. Only an explicit `.md`
+    // suffix skips elision — every other bare name gets `.md` appended,
+    // including dotted daily-note names like `2024.01.01` (→ 2024.01.01.md).
+    // Deliberately NOT keyed on "contains a dot": that would strand daily
+    // notes. A non-`.md` extension (e.g. `[[diagram.png]]`) therefore also
+    // gets `.md` appended and simply dangles — mrplex documents are markdown
+    // (§2), and non-document attachments are inert to the graph regardless.
+    // target_raw records the primary (.md) candidate so `links repair` has a
+    // canonical written form (§11.2 table).
+    if (resolved.endsWith(".md")) {
+        return { ...base, target_raw: resolved + anchor, candidates: [resolved] };
+    }
+    const dotMd = `${resolved}.md`;
+    const indexMd = `${resolved}/${config.resolution.index_basename}.md`;
+    return { ...base, target_raw: dotMd + anchor, candidates: [dotMd, indexMd] };
+}
+// -----------------------------------------------------------------------------
+// Segment normalization — collapse '.', apply '..', reject repo-root escape.
+// -----------------------------------------------------------------------------
+function normalizeSegments(segments) {
+    const out = [];
+    for (const seg of segments) {
+        if (seg === "" || seg === ".")
+            continue;
+        if (seg === "..") {
+            if (out.length === 0)
+                return null; // escaped above repo root
+            out.pop();
+            continue;
+        }
+        out.push(seg);
+    }
+    if (out.length === 0)
+        return null;
+    return out.join("/");
+}
+/** Directory segments of a repo-root-relative file path. */
+function dirSegments(path) {
+    const segs = path.split("/");
+    segs.pop(); // drop the filename
+    return segs;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/links/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/links/resolve.ts"],"names":[],"mappings":"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"}

package/dist/links/stale.d.ts

@@ -0,0 +1,32 @@
+/**
+ * links.stale — find live documents whose written link text no longer
+ * matches the resolved target's current path (design §11.2 "Link rewriting
+ * is cosmetic"). A move is identity-bound, so the edge stays resolved but
+ * the *text* goes stale; this surfaces that gap so `mrplex links repair`
+ * can rewrite it.
+ *
+ * Staleness is defined only for RESOLVED edges (target_id not null) — a
+ * dangling edge has no current target path to disagree with. And only for
+ * body edges with a rewritable destination span; a reference-style link's
+ * destination lives in a separate definition (out of scope for Phase 1
+ * repair), and frontmatter edges aren't a "link text" in the body.
+ */
+import type { Storage } from "../storage/types.js";
+import type { LinkConfig } from "./link-config.js";
+export type StaleLink = {
+    source_id: number;
+    source_path: string;
+    ord: number;
+    written: string;
+    current: string;
+};
+/**
+ * Scan a repo's live documents for stale link text. Scope filtering is the
+ * caller's concern (the kernel op applies it); this walks the raw index.
+ *
+ * Algorithm: for each live source, re-extract its edges (to recover the
+ * per-edge destination span + written form), resolve them, and for each
+ * resolved edge compare the target's current path against what was written.
+ * Re-extraction keeps this consistent with exactly what repair will rewrite.
+ */
+export declare function findStaleLinks(storage: Storage, repoId: number, config: LinkConfig): Promise<StaleLink[]>;

package/dist/links/stale.js

@@ -0,0 +1,73 @@
+/**
+ * links.stale — find live documents whose written link text no longer
+ * matches the resolved target's current path (design §11.2 "Link rewriting
+ * is cosmetic"). A move is identity-bound, so the edge stays resolved but
+ * the *text* goes stale; this surfaces that gap so `mrplex links repair`
+ * can rewrite it.
+ *
+ * Staleness is defined only for RESOLVED edges (target_id not null) — a
+ * dangling edge has no current target path to disagree with. And only for
+ * body edges with a rewritable destination span; a reference-style link's
+ * destination lives in a separate definition (out of scope for Phase 1
+ * repair), and frontmatter edges aren't a "link text" in the body.
+ */
+import { normalizeKey } from "../kernel/casefold.js";
+import { extractEdges } from "./extract.js";
+import { normalizeEdges } from "./resolve.js";
+/**
+ * Scan a repo's live documents for stale link text. Scope filtering is the
+ * caller's concern (the kernel op applies it); this walks the raw index.
+ *
+ * Algorithm: for each live source, re-extract its edges (to recover the
+ * per-edge destination span + written form), resolve them, and for each
+ * resolved edge compare the target's current path against what was written.
+ * Re-extraction keeps this consistent with exactly what repair will rewrite.
+ */
+export async function findStaleLinks(storage, repoId, config) {
+    const out = [];
+    const live = await storage.versions_live_by_repo(repoId);
+    // Map document_id → current path for O(1) target lookups.
+    const currentPathByDoc = new Map();
+    for (const v of live)
+        currentPathByDoc.set(v.document_id, v.path);
+    for (const version of live) {
+        const stored = await storage.links_by_source(version.document_id);
+        if (stored.length === 0)
+            continue;
+        // Re-extract to recover destination spans + the written target string.
+        const raw = extractEdges({ body: version.body, frontmatter: version.frontmatter, config });
+        const normalized = normalizeEdges(raw, version.path, config);
+        // Align stored rows (dense ord) with the re-extracted edges that
+        // produced them (external edges were dropped during storage, so filter
+        // the normalized list the same way maintain.ts does).
+        const storable = normalized.filter((e) => e.candidates.length > 0);
+        for (let i = 0; i < stored.length && i < storable.length; i++) {
+            const row = stored[i];
+            const edge = storable[i];
+            if (!row || !edge)
+                continue;
+            if (row.target_id === null)
+                continue; // dangling: no current path to compare
+            const currentTargetPath = currentPathByDoc.get(row.target_id);
+            if (currentTargetPath === undefined)
+                continue; // target not live (deleted)
+            // The written target resolves to the target's OLD path; compare its
+            // folded form against the target's CURRENT folded path. A mismatch is
+            // stale text. Comparison is case-insensitive (identity is folded), so
+            // a pure recasing of the target isn't flagged unless the path changed.
+            // row.target_norm is already folded (maintain.ts stores it), so
+            // compare it directly against the folded current path.
+            if (row.target_norm !== normalizeKey(currentTargetPath)) {
+                out.push({
+                    source_id: version.document_id,
+                    source_path: version.path,
+                    ord: row.ord,
+                    written: row.target_raw,
+                    current: currentTargetPath,
+                });
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=stale.js.map

package/dist/links/stale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stale.js","sourceRoot":"","sources":["../../src/links/stale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAU9C;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,OAAgB,EAChB,MAAc,EACd,MAAkB;IAElB,MAAM,GAAG,GAAgB,EAAE,CAAC;IAC5B,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACzD,0DAA0D;IAC1D,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAkB,CAAC;IACnD,KAAK,MAAM,CAAC,IAAI,IAAI;QAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IAElE,KAAK,MAAM,OAAO,IAAI,IAAI,EAAE,CAAC;QAC3B,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QAElC,uEAAuE;QACvE,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;QAC3F,MAAM,UAAU,GAAG,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAE7D,iEAAiE;QACjE,uEAAuE;QACvE,sDAAsD;QACtD,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAEnE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9D,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACtB,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI;gBAAE,SAAS;YAC5B,IAAI,GAAG,CAAC,SAAS,KAAK,IAAI;gBAAE,SAAS,CAAC,uCAAuC;YAE7E,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC9D,IAAI,iBAAiB,KAAK,SAAS;gBAAE,SAAS,CAAC,4BAA4B;YAE3E,oEAAoE;YACpE,sEAAsE;YACtE,sEAAsE;YACtE,uEAAuE;YACvE,gEAAgE;YAChE,uDAAuD;YACvD,IAAI,GAAG,CAAC,WAAW,KAAK,YAAY,CAAC,iBAAiB,CAAC,EAAE,CAAC;gBACxD,GAAG,CAAC,IAAI,CAAC;oBACP,SAAS,EAAE,OAAO,CAAC,WAAW;oBAC9B,WAAW,EAAE,OAAO,CAAC,IAAI;oBACzB,GAAG,EAAE,GAAG,CAAC,GAAG;oBACZ,OAAO,EAAE,GAAG,CAAC,UAAU;oBACvB,OAAO,EAAE,iBAAiB;iBAC3B,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/markdown/content-hash.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `$content_hash` — the canonical content fingerprint (sync/history plan §2).
+ *
+ * A derived, server-owned property: the SHA-256 (bare lowercase hex, no
+ * algorithm prefix) of a version's canonical content —
+ * `join({ frontmatter_raw, body })` where `frontmatter_raw` has already been
+ * stripped of `$*` system lines. The hash excludes all intrinsics and the
+ * document path (a pure move does not change it).
+ *
+ * The server and every client must produce byte-identical input, which is why
+ * the hash lives in this one shared module rather than parallel
+ * implementations. Three byte-exactness traps it honors (§2.1):
+ *
+ *   1. Empty-frontmatter collapse — route through `join`, which collapses the
+ *      empty block, so `frontmatter_raw === ""` hashes bare `<body>`.
+ *   2. Trailing-newline normalization — `join` forces the frontmatter block to
+ *      end in `\n`; a local file lacking it normalizes identically.
+ *   3. Line endings — the delimiter grammar is LF-based; CRLF is normalized to
+ *      LF before hashing.
+ */
+/** Canonical bytes hashed for `$content_hash`. */
+export declare function canonicalContent(frontmatterRaw: string, body: string): string;
+/**
+ * Hash a version's canonical content. `frontmatterRaw` must already be the
+ * stored raw (stripped of `$*` system lines by `canonicalizeFrontmatter`).
+ */
+export declare function contentHash(frontmatterRaw: string, body: string): string;
+/**
+ * Hash a whole file as the server would after storing it. Normalizes CRLF→LF,
+ * strips embedded `$*` lines via the same split/strip/join path so a file
+ * carrying intrinsics from a prior materialization hashes to the same value as
+ * its stored version.
+ */
+export declare function contentHashOfFile(text: string): string;

package/dist/markdown/content-hash.js

@@ -0,0 +1,46 @@
+/**
+ * `$content_hash` — the canonical content fingerprint (sync/history plan §2).
+ *
+ * A derived, server-owned property: the SHA-256 (bare lowercase hex, no
+ * algorithm prefix) of a version's canonical content —
+ * `join({ frontmatter_raw, body })` where `frontmatter_raw` has already been
+ * stripped of `$*` system lines. The hash excludes all intrinsics and the
+ * document path (a pure move does not change it).
+ *
+ * The server and every client must produce byte-identical input, which is why
+ * the hash lives in this one shared module rather than parallel
+ * implementations. Three byte-exactness traps it honors (§2.1):
+ *
+ *   1. Empty-frontmatter collapse — route through `join`, which collapses the
+ *      empty block, so `frontmatter_raw === ""` hashes bare `<body>`.
+ *   2. Trailing-newline normalization — `join` forces the frontmatter block to
+ *      end in `\n`; a local file lacking it normalizes identically.
+ *   3. Line endings — the delimiter grammar is LF-based; CRLF is normalized to
+ *      LF before hashing.
+ */
+import { createHash } from "node:crypto";
+import { extractSystemProperties, join, split } from "./frontmatter.js";
+/** Canonical bytes hashed for `$content_hash`. */
+export function canonicalContent(frontmatterRaw, body) {
+    return join({ frontmatter_raw: frontmatterRaw, body });
+}
+/**
+ * Hash a version's canonical content. `frontmatterRaw` must already be the
+ * stored raw (stripped of `$*` system lines by `canonicalizeFrontmatter`).
+ */
+export function contentHash(frontmatterRaw, body) {
+    return createHash("sha256").update(canonicalContent(frontmatterRaw, body), "utf8").digest("hex"); // bare hex
+}
+/**
+ * Hash a whole file as the server would after storing it. Normalizes CRLF→LF,
+ * strips embedded `$*` lines via the same split/strip/join path so a file
+ * carrying intrinsics from a prior materialization hashes to the same value as
+ * its stored version.
+ */
+export function contentHashOfFile(text) {
+    const lf = text.replace(/\r\n/g, "\n");
+    const { frontmatter_raw, body } = split(lf);
+    const stripped = extractSystemProperties(frontmatter_raw).raw;
+    return contentHash(stripped, body);
+}
+//# sourceMappingURL=content-hash.js.map

package/dist/markdown/content-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-hash.js","sourceRoot":"","sources":["../../src/markdown/content-hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,uBAAuB,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAExE,kDAAkD;AAClD,MAAM,UAAU,gBAAgB,CAAC,cAAsB,EAAE,IAAY;IACnE,OAAO,IAAI,CAAC,EAAE,eAAe,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,CAAC;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,cAAsB,EAAE,IAAY;IAC9D,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW;AAC/G,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACvC,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5C,MAAM,QAAQ,GAAG,uBAAuB,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC;IAC9D,OAAO,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC"}

package/dist/markdown/frontmatter.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Split, parse, and join Markdown files with YAML frontmatter.
+ *
+ * The design (§3.2) stores frontmatter twice: `frontmatter_raw` (byte-verbatim
+ * YAML source) and `frontmatter` (parsed JSON, a derived query index). The
+ * utilities here are the source of truth for that split/join contract.
+ *
+ * The delimiter grammar we recognize is deliberately narrow and LF-based:
+ *
+ *   ---LF
+ *   <raw YAML>
+ *   ---LF
+ *   <body>
+ *
+ * That is, a file has frontmatter iff it starts with the literal `---\n` AND a
+ * subsequent line consisting of exactly `---\n` (or `---` at EOF). Files that
+ * don't match are treated as pure body, with `frontmatter_raw = ""`. Round-trip
+ * (`join(split(x)) === x`) holds exactly for the canonical form; a
+ * present-but-empty frontmatter (`---\n---\n<body>`) collapses to no-frontmatter
+ * (semantically equivalent — `parse("") === {}`).
+ */
+export type Split = {
+    frontmatter_raw: string;
+    body: string;
+};
+/**
+ * Split a raw Markdown file into `{ frontmatter_raw, body }`. No parsing yet —
+ * `frontmatter_raw` is the exact YAML source between the delimiters.
+ */
+export declare function split(text: string): Split;
+/**
+ * Join back to the canonical file form. Inverse of `split` for canonical inputs.
+ */
+export declare function join(parts: Split): string;
+/** Value stored in `versions.frontmatter` — parsed frontmatter as JSON. */
+export type FrontmatterJson = Record<string, unknown>;
+export declare class FrontmatterInvalidError extends Error {
+    constructor(message: string);
+}
+/**
+ * Parse the raw YAML source into a JSON object. Empty raw → `{}`. Anything that
+ * doesn't parse to a plain map throws `FrontmatterInvalidError` (surfaced as
+ * kernel error `frontmatter_invalid` in M1 writes, per design §4.3).
+ */
+export declare function parse(frontmatterRaw: string): FrontmatterJson;
+/**
+ * Append a system property (`$key: value`) as a plain text line to raw YAML
+ * source. Non-destructive — never round-trips through the YAML parser, so
+ * existing comments, key order, and whitespace are preserved byte-exact.
+ *
+ * `value` must be a simple scalar (string / number / boolean). Strings are
+ * emitted unquoted; callers are responsible for supplying values that are
+ * safe as bare YAML scalars (all current system props — version ids, ISO
+ * timestamps, user slugs — satisfy this).
+ */
+export declare function appendSystemProperty(frontmatterRaw: string, key: string, value: string | number | boolean): string;
+/**
+ * Strip every `$key: value` line from raw YAML source and return the parsed
+ * key→value map alongside the cleaned source. Non-destructive on the
+ * remainder — only the matched lines are removed, everything else stays
+ * byte-exact.
+ *
+ * Values are returned as trimmed strings (leading/trailing whitespace after
+ * the colon removed). Callers coerce as needed.
+ */
+export declare function extractSystemProperties(frontmatterRaw: string): {
+    raw: string;
+    props: Record<string, string>;
+};