@omgbase/core 0.11.1 → 0.19.0

package/dist/src/mutate/doc-store.js

@@ -1,7 +1,7 @@
-import { writeFileSync, readFileSync, existsSync, renameSync, unlinkSync, mkdirSync } from "node:fs";
+import { openSync, writeSync, fsyncSync, closeSync, readFileSync, existsSync, renameSync, unlinkSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { sha256 } from "../core/hash.js";
-import { recordFileStat } from "../sync/freshness.js";
+import { recordFileStat } from "../sync/stat-cache.js";
 import { EngineError } from "../mcp/errors.js";
 /** Filesystem-backed DocStore rooted at a working-tree directory (v1 default). */
 export class FsDocStore {
@@ -22,8 +22,20 @@ export class FsDocStore {
     write(path, bytes) {
         const abs = this.abs(path);
         mkdirSync(dirname(abs), { recursive: true });
+        // Temp file + rename for atomicity; the temp file is fsynced before the
+        // rename (store 14.0) so a power loss after the commit cannot leave a
+        // truncated file under the final name — the same loss class as SQLite's
+        // `synchronous = NORMAL`. No directory fsync: the rename itself may be lost,
+        // which the pending row then replays.
         const tmp = `${abs}.omgtmp`;
-        writeFileSync(tmp, bytes);
+        const fd = openSync(tmp, "w");
+        try {
+            writeSync(fd, bytes);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
         renameSync(tmp, abs);
     }
     rename(from, to) {
@@ -52,9 +64,12 @@ export class NullDocStore {
     read() {
         return null;
     }
-    write() { }
-    rename() { }
-    remove() { }
+    // Parameters spelled out so a subclass may override with the interface's
+    // signature (a zero-parameter base method makes `write(path, bytes)` an
+    // incompatible override under TS2416).
+    write(_path, _bytes) { }
+    rename(_from, _to) { }
+    remove(_path) { }
     recordStat() { }
     clearStat() { }
 }

package/dist/src/mutate/docs.d.ts

@@ -1,91 +1,46 @@
 import type { Store } from "../core/store/store.js";
 import { type InboundLink } from "../graph/inbound-links.js";
-import { type DocStore } from "./doc-store.js";
-export interface DocOpContext {
-    repoId: string;
-    /** Working-tree root for the default filesystem write target. Omit only when
-     *  supplying an explicit `docStore` (e.g. a headless NullDocStore). */
-    rootPath?: string;
-    /** Write target (ADR-014 §5); defaults to a filesystem store at `rootPath`. */
-    docStore?: DocStore;
-    /** workspace .omgbase/ dir; when set, the write runs under the writer flock. */
-    omgbaseDir?: string;
-    actor?: string;
-    /** Commit timestamp (RFC 3339 UTC) for every commit the operation records; defaults to now (see `ApplyRequest.ts`). */
-    ts?: string;
-    /**
-     * Validate and plan only: every check the real operation makes (`doc_missing`,
-     * `path_taken`, …) runs, nothing is written or committed, and the result
-     * carries `committed: false` plus the per-file `diffs` the operation would
-     * produce — the same shape `apply`'s `dryRun` returns. A create's `docId` is
-     * the id the real run would mint next (a dry run consumes it, as `apply`'s does).
-     */
-    dryRun?: boolean;
-}
-export interface DocOpResult {
-    docId: string;
-    path: string;
-    committed: boolean;
-    /**
-     * With `dryRun`: the file changes the operation would make, keyed by
-     * repo-relative path — `before` the current bytes (`""` for a file that
-     * would be created), `after` the bytes the operation would leave (`""` for a
-     * file that would be removed). A rename is two entries: the old path
-     * emptied, the new path filled. Absent on a committed result.
-     */
-    diffs?: Record<string, {
-        before: string;
-        after: string;
-    }>;
-}
-export interface DocMoveOptions {
-    /**
-     * Rewrite the inbound links that named the OLD path so they point at the new
-     * one — a destination-aware rewrite (anchors, link text, titles, and code
-     * spans preserved; absolute/relative style kept) applied as a CAS-checked
-     * `update` per source block in one follow-up api changeset. **Default `true`**
-     * (spec/mutate 1.3): a move means "same document, new place", so the authored
-     * links follow it; pass `false` for the rarer intent that the old path become
-     * unbound. Frontmatter-level relations are never rewritten (reported in
-     * `dangling`).
-     */
-    retargetInbound?: boolean;
-}
-export interface DocMoveResult extends DocOpResult {
-    /**
-     * Inbound links still pointing at the OLD path after this call — the source
-     * blocks `links_stale` will now report (with the default retarget: only the
-     * frontmatter relations, which are never rewritten). Computed from the open
-     * edge index before the move.
-     */
-    dangling: InboundLink[];
-    /**
-     * The source blocks rewritten and the docs re-ingested (empty lists when the
-     * rewrite ran but only frontmatter relations linked in); `null` when the
-     * retarget was opted out (`retargetInbound: false`) or nothing linked in.
-     */
-    retargeted: {
-        blocks: string[];
-        docs: string[];
-    } | null;
-}
-/** docs_create: create a new document from complete file bytes (frontmatter incl.). */
-export declare function docsCreate(store: Store, ctx: DocOpContext, path: string, markdown: string, frontmatter?: Record<string, unknown>): DocOpResult;
+import type { Op } from "./apply.js";
+import type { MutDoc } from "./tree.js";
+/** spec/mutate §6: the storage form of a document path — leading `/` stripped, `\` → `/`. */
+export declare function canonicalDocPath(path: string): string;
+/** Compose a full document's bytes from optional frontmatter + body markdown
+ *  (spec/mutate §6 `docs_create`): the body with a trailing `\n` ensured; a
+ *  non-empty frontmatter mapping becomes `---\n<yaml>\n---\n` followed by a
+ *  blank line unless the body already starts with one. The effect planner's
+ *  `set frontmatter.<k>` composes through this same function (§11.3), so its
+ *  bytes equal `docs_set_meta`'s for the same patch. */
+export declare function composeFile(markdown: string, frontmatter?: Record<string, unknown>): string;
+/**
+ * A document this request CREATES as the planner's working tree (spec/mutate
+ * §11.3, 3.0): `source` (the composed file) parsed per the path's format —
+ * the frontmatter block becomes `frontmatterRaw` (its raw + its trailing
+ * trivia, as `loadMutDoc` builds it), the bytes before it the leading trivia,
+ * every body block a `MutBlock` with its exact trivia and an id minted NOW in
+ * pre-order under the current minter (the symbolic one at plan time, so the
+ * ids are `$new.k`; the production one at execute, so the replay mints the
+ * same positions). `docId` is the plan's document symbol. The round-trip law
+ * makes `renderDoc` of the result equal `source` byte for byte.
+ */
+export declare function parseNewDoc(symbol: string, path: string, source: string): MutDoc;
 /**
- * docs_move: rename a document to a new path (identity preserved). The edge
- * index follows the path, not the identity: links written against the OLD path
- * now dangle (their open edges are re-pointed at `phantom:<old>`, exactly what
- * re-extracting the source would produce, so `links_stale` sees them), and
- * phantom edges already written against the NEW path are adopted. By default
- * the dangling inbound links are then rewritten to the new path in one
- * follow-up changeset (spec/mutate 1.3); `retargetInbound: false` leaves them
- * as written and the result lists them.
+ * The `retarget_inbound` plan of a move `fromPath → toRel`: one coalesced,
+ * CAS-pinned `update` per deepest hit block, the blocks and docs it touches,
+ * and the inbound links it leaves dangling. Pure over the store's current
+ * blocks — the move itself changes no block — so the effect planner's `move
+ * document` (§11.3) and the tool's `dangling`/`retargeted` report (computed
+ * before the commit) plan identically.
  */
-export declare function docsMove(store: Store, ctx: DocOpContext, docRef: string, toPath: string, opts?: DocMoveOptions): DocMoveResult;
-/** docs_delete: mark a document deleted and remove its file (resurrection-poolable). */
-export declare function docsDelete(store: Store, ctx: DocOpContext, docRef: string): DocOpResult;
-/** docs_set_meta: surgical frontmatter patch (set/unset keys), re-ingested. */
-export declare function docsSetMeta(store: Store, ctx: DocOpContext, docRef: string, patch: {
-    set?: Record<string, unknown>;
-    unset?: string[];
-}): DocOpResult;
+export declare function planInboundRetarget(store: Store, docId: string, fromPath: string, toRel: string, inbound: InboundLink[]): {
+    ops: Op[];
+    blocks: string[];
+    docs: string[];
+    dangling: InboundLink[];
+};
+/** Split a file's bytes into (frontmatter object, body markdown) with
+ *  `^---\r?\n([\s\S]*?)\r?\n---\r?\n?` (spec/mutate §6). Missing or malformed
+ *  frontmatter yields an empty object and the whole content as body. */
+export declare function splitFrontmatter(content: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+};

package/dist/src/mutate/docs.js

@@ -1,175 +1,72 @@
 import { stringify as stringifyYaml, parse as parseYaml } from "yaml";
-import { ingestFile } from "../core/ingest.js";
-import { findDoc, findDocByRef } from "../core/read/reader.js";
-import { makeReconcilingResolver } from "../sync/reconciling-ingest.js";
-import { newCommit } from "../core/store/writers.js";
+import { parseTree } from "../core/parse/tree.js";
+import { adapterForPath } from "../format/index.js";
 import { mintId } from "../core/ids.js";
-import { ftsDeleteDoc } from "../core/store/fts.js";
-import { adoptPhantoms, rebuildDocEdges } from "../core/store/edges.js";
-import { withWriterLock } from "../sync/writer-lock.js";
-import { inboundLinksTo, retargetLinksInRaw } from "../graph/inbound-links.js";
-import { apply } from "./apply.js";
-import { resolveDocStore } from "./doc-store.js";
-import { MutationError } from "./tree.js";
-function nowOr(ctx) {
-    return ctx.ts ?? new Date().toISOString();
-}
+import { retargetLinksInRaw } from "../graph/inbound-links.js";
+// The document operations' shared pieces (spec/mutate §6, 3.0). Through 2.x this
+// module held `docsCreate` / `docsMove` / `docsDelete` / `docsSetMeta`, library
+// functions that composed the internal commit effects themselves; since 3.0 the
+// operations are the effect builders of `sugar.ts` (`create`, `move document`,
+// `remove document`, `set`/`unset frontmatter.<k>`) planned and executed by the
+// Effect layer (`plan.ts`), and what remains here is what the planner's
+// lowerings share with them: the path canonicalization, the file composition,
+// the parse of a created document, the inbound-link retarget plan and the
+// frontmatter split.
 function dirOf(path) {
     return path.replace(/[^/]*$/, "");
 }
-function underLock(ctx, fn) {
-    return ctx.omgbaseDir ? withWriterLock(ctx.omgbaseDir, fn) : fn();
-}
-function canonical(path) {
+/** spec/mutate §6: the storage form of a document path — leading `/` stripped, `\` → `/`. */
+export function canonicalDocPath(path) {
     return path.replace(/^\/+/, "").split("\\").join("/");
 }
-// Compose a full document's bytes from optional frontmatter + body markdown.
-function composeFile(markdown, frontmatter) {
+/** Compose a full document's bytes from optional frontmatter + body markdown
+ *  (spec/mutate §6 `docs_create`): the body with a trailing `\n` ensured; a
+ *  non-empty frontmatter mapping becomes `---\n<yaml>\n---\n` followed by a
+ *  blank line unless the body already starts with one. The effect planner's
+ *  `set frontmatter.<k>` composes through this same function (§11.3), so its
+ *  bytes equal `docs_set_meta`'s for the same patch. */
+export function composeFile(markdown, frontmatter) {
     const body = markdown.endsWith("\n") || markdown.length === 0 ? markdown : markdown + "\n";
     if (!frontmatter || Object.keys(frontmatter).length === 0)
         return body;
     const yaml = stringifyYaml(frontmatter).replace(/\n$/, "");
     return `---\n${yaml}\n---\n${body.startsWith("\n") ? body : "\n" + body}`;
 }
-/** docs_create: create a new document from complete file bytes (frontmatter incl.). */
-export function docsCreate(store, ctx, path, markdown, frontmatter) {
-    const rel = canonical(path);
-    const existing = findDoc(store, { repoId: ctx.repoId, path: rel });
-    if (existing)
-        throw new MutationError("path_taken", `document already exists at ${rel}`);
-    const content = composeFile(markdown, frontmatter);
-    const docStore = resolveDocStore(ctx);
-    if (ctx.dryRun) {
-        if (docStore.exists(rel))
-            throw new MutationError("path_taken", `file already exists on disk at ${rel}`);
-        return { docId: mintId("d"), path: rel, committed: false, diffs: { [rel]: { before: "", after: content } } };
-    }
-    return underLock(ctx, () => {
-        if (docStore.exists(rel))
-            throw new MutationError("path_taken", `file already exists on disk at ${rel}`);
-        docStore.write(rel, content);
-        const ts = nowOr(ctx);
-        const res = ingestFile(store, ctx.repoId, rel, content, { ts, origin: "api", actor: ctx.actor ?? null, reason: `create ${rel}`, resolveIds: makeReconcilingResolver(store, ctx.repoId, { ts, path: rel }) });
-        if (ctx.omgbaseDir)
-            docStore.recordStat(store, ctx.repoId, rel, content);
-        return { docId: res.docId, path: rel, committed: true };
-    });
-}
 /**
- * docs_move: rename a document to a new path (identity preserved). The edge
- * index follows the path, not the identity: links written against the OLD path
- * now dangle (their open edges are re-pointed at `phantom:<old>`, exactly what
- * re-extracting the source would produce, so `links_stale` sees them), and
- * phantom edges already written against the NEW path are adopted. By default
- * the dangling inbound links are then rewritten to the new path in one
- * follow-up changeset (spec/mutate 1.3); `retargetInbound: false` leaves them
- * as written and the result lists them.
+ * A document this request CREATES as the planner's working tree (spec/mutate
+ * §11.3, 3.0): `source` (the composed file) parsed per the path's format —
+ * the frontmatter block becomes `frontmatterRaw` (its raw + its trailing
+ * trivia, as `loadMutDoc` builds it), the bytes before it the leading trivia,
+ * every body block a `MutBlock` with its exact trivia and an id minted NOW in
+ * pre-order under the current minter (the symbolic one at plan time, so the
+ * ids are `$new.k`; the production one at execute, so the replay mints the
+ * same positions). `docId` is the plan's document symbol. The round-trip law
+ * makes `renderDoc` of the result equal `source` byte for byte.
  */
-export function docsMove(store, ctx, docRef, toPath, opts = {}) {
-    const retargetInbound = opts.retargetInbound !== false;
-    const info = findDocByRef(store, ctx.repoId, docRef);
-    if (!info)
-        throw new MutationError("doc_missing", `no document ${docRef}`);
-    const toRel = canonical(toPath);
-    if (findDoc(store, { repoId: ctx.repoId, path: toRel }))
-        throw new MutationError("path_taken", `a document already exists at ${toRel}`);
-    // Who links here BY PATH, as written — before the path changes.
-    const inbound = inboundLinksTo(store, ctx.repoId, info.docId, info.path);
-    const docStore = resolveDocStore(ctx);
-    if (ctx.dryRun) {
-        if (docStore.exists(toRel))
-            throw new MutationError("path_taken", `file already exists on disk at ${toRel}`);
-        const content = docStore.read(info.path) ?? "";
-        const diffs = { [info.path]: { before: content, after: "" }, [toRel]: { before: "", after: content } };
-        const planned = { docId: info.docId, path: toRel, committed: false, diffs };
-        if (!retargetInbound || inbound.length === 0)
-            return { ...planned, dangling: inbound, retargeted: null };
-        const plan = planInboundRetarget(store, info.docId, info.path, toRel, inbound);
-        if (plan.ops.length > 0) {
-            const preview = apply(store, { ...applyCtx(ctx), ops: plan.ops, dryRun: true, origin: { actor: ctx.actor ?? "api", reason: `retarget inbound links ${info.path} -> ${toRel}` } });
-            Object.assign(diffs, preview.diffs ?? {});
-        }
-        return { ...planned, dangling: plan.dangling, retargeted: { blocks: plan.blocks, docs: plan.docs } };
-    }
-    const moved = underLock(ctx, () => {
-        if (docStore.exists(toRel))
-            throw new MutationError("path_taken", `file already exists on disk at ${toRel}`);
-        const content = docStore.read(info.path) ?? "";
-        if (docStore.exists(info.path))
-            docStore.rename(info.path, toRel);
-        else
-            docStore.write(toRel, content);
-        const ts = nowOr(ctx);
-        store.write((db) => {
-            // Update the document row's path + its open revisions' path pointer, and
-            // record an api commit noting the move.
-            const commit = newCommit(db, { repoId: ctx.repoId, ts, origin: "api", actor: ctx.actor ?? null, reason: `move ${info.path} -> ${toRel}` });
-            db.prepare("UPDATE docs SET path = ? WHERE doc_id = ?").run(toRel, info.docId);
-            db.prepare("UPDATE revisions SET path = ? WHERE doc_id = ? AND rev_id = ?").run(toRel, info.docId, info.currentRev);
-            void commit;
-            // Edge index. Every open edge from ANOTHER doc into this one resolved
-            // via the old path, so it dangles now → re-point it at the old path's
-            // phantom (in place, mirroring adoptPhantoms). A self-doc edge dangles
-            // only when the link names the path (`[x](/old.md#H)`); a pure fragment
-            // (`#H`) resolves to the doc regardless of path and is left alone — the
-            // inbound scan distinguishes them from the raw.
-            const phantom = `phantom:${info.path}`;
-            const affected = new Set();
-            const others = db.prepare("SELECT DISTINCT src_doc FROM edges WHERE dst_node = ? AND to_commit IS NULL AND src_doc != ?").all(info.docId, info.docId);
-            for (const r of others)
-                affected.add(r.src_doc);
-            db.prepare("UPDATE edges SET dst_node = ? WHERE dst_node = ? AND to_commit IS NULL AND src_doc != ?").run(phantom, info.docId, info.docId);
-            const selfEdge = db.prepare("UPDATE edges SET dst_node = ? WHERE dst_node = ? AND to_commit IS NULL AND src_doc = ? AND src_block = ? AND anchor IS ?");
-            for (const l of inbound) {
-                if (l.doc_id !== info.docId || l.block_id === null)
-                    continue;
-                selfEdge.run(phantom, info.docId, info.docId, l.block_id, l.anchor);
-                affected.add(info.docId);
-            }
-            for (const d of affected)
-                rebuildDocEdges(db, d);
-            // Links already written against the NEW path resolve to this doc now.
-            adoptPhantoms(db, toRel, info.docId);
-        });
-        if (ctx.omgbaseDir) {
-            docStore.clearStat(store, ctx.repoId, info.path); // drop the old path's row
-            docStore.recordStat(store, ctx.repoId, toRel, content);
-        }
-        return { docId: info.docId, path: toRel, committed: true };
-    });
-    if (!retargetInbound || inbound.length === 0)
-        return { ...moved, dangling: inbound, retargeted: null };
-    // Rewrite the dangling links block by block (one coalesced update per block,
-    // CAS on the block's current hash) and apply as one changeset; the re-ingest
-    // re-extracts each source doc, whose links now resolve to the moved doc.
-    const plan = planInboundRetarget(store, info.docId, info.path, toRel, inbound);
-    if (plan.ops.length > 0) {
-        apply(store, {
-            ...applyCtx(ctx),
-            ops: plan.ops,
-            origin: { actor: ctx.actor ?? "api", reason: `retarget inbound links ${info.path} -> ${toRel}` },
-        });
-    }
-    return { ...moved, dangling: plan.dangling, retargeted: { blocks: plan.blocks, docs: plan.docs } };
-}
-/** The `ApplyRequest` fields a document operation's context supplies to a follow-up changeset. */
-function applyCtx(ctx) {
+export function parseNewDoc(symbol, path, source) {
+    const adapter = adapterForPath(path);
+    const tree = adapter ? adapter.parse(source) : parseTree(source);
+    const fm = tree.children[0]?.type === "frontmatter" ? tree.children[0] : null;
+    const rest = fm ? tree.children.slice(1) : tree.children;
+    const toMut = (b) => ({ id: mintId("b"), type: b.type, raw: b.raw, trivia: b.trivia, attrs: b.attrs, children: b.children.map(toMut) });
     return {
-        repoId: ctx.repoId,
-        ...(ctx.rootPath ? { rootPath: ctx.rootPath } : {}),
-        ...(ctx.docStore ? { docStore: ctx.docStore } : {}),
-        ...(ctx.omgbaseDir ? { omgbaseDir: ctx.omgbaseDir } : {}),
-        ...(ctx.ts ? { ts: ctx.ts } : {}),
+        docId: symbol,
+        path,
+        format: adapter?.format ?? "markdown",
+        leadingTrivia: tree.leadingTrivia,
+        frontmatterRaw: fm ? fm.raw + fm.trivia : null,
+        children: rest.map(toMut),
     };
 }
 /**
  * The `retarget_inbound` plan of a move `fromPath → toRel`: one coalesced,
  * CAS-pinned `update` per deepest hit block, the blocks and docs it touches,
  * and the inbound links it leaves dangling. Pure over the store's current
- * blocks — the move itself changes no block — so the real move and its dry run
- * plan identically.
+ * blocks — the move itself changes no block — so the effect planner's `move
+ * document` (§11.3) and the tool's `dangling`/`retargeted` report (computed
+ * before the commit) plan identically.
  */
-function planInboundRetarget(store, docId, fromPath, toRel, inbound) {
+export function planInboundRetarget(store, docId, fromPath, toRel, inbound) {
     const byBlock = new Map();
     for (const l of inbound)
         if (l.block_id !== null && !byBlock.has(l.block_id))
@@ -215,61 +112,10 @@ function planInboundRetarget(store, docId, fromPath, toRel, inbound) {
     const dangling = inbound.filter((l) => l.block_id === null || !rewritten.has(l.block_id));
     return { ops, blocks, docs: [...docs], dangling };
 }
-/** docs_delete: mark a document deleted and remove its file (resurrection-poolable). */
-export function docsDelete(store, ctx, docRef) {
-    const info = findDocByRef(store, ctx.repoId, docRef);
-    if (!info)
-        throw new MutationError("doc_missing", `no document ${docRef}`);
-    const docStore = resolveDocStore(ctx);
-    if (ctx.dryRun) {
-        return { docId: info.docId, path: info.path, committed: false, diffs: { [info.path]: { before: docStore.read(info.path) ?? "", after: "" } } };
-    }
-    return underLock(ctx, () => {
-        const ts = nowOr(ctx);
-        store.write((db) => {
-            const commit = newCommit(db, { repoId: ctx.repoId, ts, origin: "api", actor: ctx.actor ?? null, reason: `delete ${info.path}` });
-            // Tombstone the document and its live blocks; FTS rows drop with the blocks.
-            ftsDeleteDoc(db, info.docId);
-            db.prepare("UPDATE blocks SET deleted_commit = ? WHERE doc_id = ? AND deleted_commit IS NULL").run(commit.commitId, info.docId);
-            db.prepare("UPDATE docs SET deleted_commit = ? WHERE doc_id = ?").run(commit.commitId, info.docId);
-        });
-        docStore.remove(info.path);
-        if (ctx.omgbaseDir)
-            docStore.clearStat(store, ctx.repoId, info.path);
-        return { docId: info.docId, path: info.path, committed: true };
-    });
-}
-/** docs_set_meta: surgical frontmatter patch (set/unset keys), re-ingested. */
-export function docsSetMeta(store, ctx, docRef, patch) {
-    const info = findDocByRef(store, ctx.repoId, docRef);
-    if (!info)
-        throw new MutationError("doc_missing", `no document ${docRef}`);
-    const docStore = resolveDocStore(ctx);
-    const patched = () => {
-        const original = docStore.read(info.path) ?? "";
-        const { frontmatter, body } = splitFrontmatter(original);
-        const merged = { ...frontmatter, ...(patch.set ?? {}) };
-        for (const k of patch.unset ?? [])
-            delete merged[k];
-        return { original, content: composeFile(body, merged) };
-    };
-    if (ctx.dryRun) {
-        const { original, content } = patched();
-        return { docId: info.docId, path: info.path, committed: false, diffs: { [info.path]: { before: original, after: content } } };
-    }
-    return underLock(ctx, () => {
-        const { content } = patched();
-        docStore.write(info.path, content);
-        const ts = nowOr(ctx);
-        const res = ingestFile(store, ctx.repoId, info.path, content, { ts, origin: "api", actor: ctx.actor ?? null, reason: `set_meta ${info.path}`, resolveIds: makeReconcilingResolver(store, ctx.repoId, { ts, path: info.path }) });
-        if (ctx.omgbaseDir)
-            docStore.recordStat(store, ctx.repoId, info.path, content);
-        return { docId: res.docId, path: info.path, committed: true };
-    });
-}
-// Split a file's bytes into (frontmatter object, body markdown). Missing or
-// malformed frontmatter yields an empty object and the whole content as body.
-function splitFrontmatter(content) {
+/** Split a file's bytes into (frontmatter object, body markdown) with
+ *  `^---\r?\n([\s\S]*?)\r?\n---\r?\n?` (spec/mutate §6). Missing or malformed
+ *  frontmatter yields an empty object and the whole content as body. */
+export function splitFrontmatter(content) {
     const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
     if (!m)
         return { frontmatter: {}, body: content };