@omgbase/core 0.1.0

package/dist/src/mutate/docs.js

@@ -0,0 +1,232 @@
+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 { 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 dirOf(path) {
+    return path.replace(/[^/]*$/, "");
+}
+function underLock(ctx, fn) {
+    return ctx.omgbaseDir ? withWriterLock(ctx.omgbaseDir, fn) : fn();
+}
+function canonical(path) {
+    return path.replace(/^\/+/, "").split("\\").join("/");
+}
+// Compose a full document's bytes from optional frontmatter + body markdown.
+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);
+    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 = new Date().toISOString();
+        const res = ingestFile(store, ctx.repoId, rel, content, { ts, origin: "import", 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. The result
+ * lists the dangling inbound links; `retargetInbound` rewrites them.
+ */
+export function docsMove(store, ctx, docRef, toPath, opts = {}) {
+    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);
+    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 = new Date().toISOString();
+        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 !== info.docId || l.block === null)
+                    continue;
+                selfEdge.run(phantom, info.docId, info.docId, l.block, 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 (!opts.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 byBlock = new Map();
+    for (const l of inbound)
+        if (l.block !== null && !byBlock.has(l.block))
+            byBlock.set(l.block, l);
+    // A container's raw includes its children's raw, so a link inside a list item
+    // is reported for BOTH the list and the item. Rewrite the deepest block only:
+    // updating the container would re-parse (and re-identify) its children, and
+    // the child's update alone already changes the container's rendered raw.
+    const parentOf = store.db.prepare("SELECT parent_block FROM blocks WHERE block_id = ? AND deleted_commit IS NULL");
+    const containers = new Set();
+    for (const blockId of byBlock.keys()) {
+        let cur = blockId;
+        while (cur) {
+            const row = parentOf.get(cur);
+            cur = row?.parent_block ?? null;
+            if (cur && byBlock.has(cur))
+                containers.add(cur);
+        }
+    }
+    for (const c of containers)
+        byBlock.delete(c);
+    const ops = [];
+    const blocks = [];
+    const docs = new Set();
+    const readBlock = store.db.prepare("SELECT bl.raw_hash, b.bytes FROM blocks bl JOIN blobs b ON b.hash = bl.raw_hash WHERE bl.block_id = ? AND bl.deleted_commit IS NULL");
+    for (const [blockId, src] of byBlock) {
+        const row = readBlock.get(blockId);
+        if (!row)
+            continue;
+        // Match against the directory the link was RESOLVED in (the source's path at
+        // extraction time); write relative forms against the source's CURRENT
+        // directory — they differ only for links inside the moved doc itself.
+        const writeDir = src.doc === info.docId ? dirOf(toRel) : dirOf(src.path);
+        const newRaw = retargetLinksInRaw(row.bytes.toString("utf8"), dirOf(src.path), writeDir, info.path, toRel);
+        if (newRaw === null)
+            continue;
+        ops.push({ op: "update", block: blockId, markdown: newRaw, expect: { content_hash: row.raw_hash.toString("hex") } });
+        blocks.push(blockId);
+        docs.add(src.doc);
+    }
+    if (ops.length > 0) {
+        apply(store, {
+            repoId: ctx.repoId,
+            ...(ctx.rootPath ? { rootPath: ctx.rootPath } : {}),
+            ...(ctx.docStore ? { docStore: ctx.docStore } : {}),
+            ...(ctx.omgbaseDir ? { omgbaseDir: ctx.omgbaseDir } : {}),
+            ops,
+            origin: { actor: ctx.actor ?? "api", reason: `retarget inbound links ${info.path} -> ${toRel}` },
+        });
+    }
+    // Containers whose rewritten child covered them count as rewritten too.
+    const rewritten = new Set([...blocks, ...containers]);
+    const dangling = inbound.filter((l) => l.block === null || !rewritten.has(l.block));
+    return { ...moved, dangling, retargeted: { blocks, docs: [...docs] } };
+}
+/** 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);
+    return underLock(ctx, () => {
+        const ts = new Date().toISOString();
+        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);
+    return underLock(ctx, () => {
+        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];
+        const content = composeFile(body, merged);
+        docStore.write(info.path, content);
+        const ts = new Date().toISOString();
+        const res = ingestFile(store, ctx.repoId, info.path, content, { ts, origin: "import", 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) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
+    if (!m)
+        return { frontmatter: {}, body: content };
+    let fm = {};
+    try {
+        const parsed = parseYaml(m[1]);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            fm = parsed;
+    }
+    catch {
+        /* malformed → empty */
+    }
+    return { frontmatter: fm, body: content.slice(m[0].length) };
+}
+//# sourceMappingURL=docs.js.map

package/dist/src/mutate/known-ids.d.ts

@@ -0,0 +1,12 @@
+import type { Store } from "../core/store/store.js";
+import type { IdResolver } from "../core/ingest.js";
+import type { MutDoc } from "./tree.js";
+/**
+ * An IdResolver that threads the ops' known ids (from the committed MutDoc)
+ * rather than reconciling. `priorIds` is the set of block ids that existed in
+ * the doc's previous revision — used only to label dispositions (same/edited vs
+ * inserted); it does not affect id assignment.
+ */
+export declare function makeKnownIdResolver(store: Store, repoId: string, doc: MutDoc, priorIds: Set<string>, opts?: {
+    path?: string;
+}): IdResolver;

package/dist/src/mutate/known-ids.js

@@ -0,0 +1,154 @@
+import { mintId } from "../core/ids.js";
+import { extractFromBlock, extractFromFrontmatter, resolveRelativePath } from "../graph/extract.js";
+import { resolveExternal, resolveDocPath } from "../core/store/edges.js";
+import { adapterForPath } from "../format/index.js";
+// Known-id resolver for the INTENT path (04 §2, node-editability fix). When
+// `apply` commits, it already holds the mutated tree with DETERMINISTIC block
+// ids — opUpdate keeps a block's id in place, untouched blocks keep theirs, and
+// new blocks carry the id the op minted. Re-ingesting the rendered bytes through
+// the probabilistic reconciler would DISCARD those ids and re-derive identity
+// from bytes, re-minting on ordinary edits (and cascading to node ids). This
+// resolver instead carries the MutDoc's ids onto the re-parsed blocks
+// positionally — round-trip law guarantees parse(render(tree)) is structurally
+// identical to the op tree — and records intent dispositions (confidence 1.0),
+// never a matcher guess. Edge extraction is still real derivation (reused).
+/** Flatten a MutDoc body to a positional id list mirroring flatten()'s keys. */
+function idByPositionalKey(children) {
+    const out = new Map();
+    const walk = (list, parentKey) => {
+        list.forEach((b, index) => {
+            const key = `${parentKey ?? ""}/${index}`;
+            out.set(key, b.id);
+            if (b.children.length > 0)
+                walk(b.children, key);
+        });
+    };
+    walk(children, null);
+    return out;
+}
+/** Assign the MutDoc's ids onto the re-parsed tree by positional key; mint only
+ *  if a position is unexpectedly absent (should not happen under round-trip). */
+function assignFromMut(blocks, byKey) {
+    const walk = (list, parentKey) => list.map((b, index) => {
+        const key = `${parentKey ?? ""}/${index}`;
+        const blockId = byKey.get(key) ?? mintId("b");
+        return { blockId, type: b.type, raw: b.raw, trivia: b.trivia, attrs: b.attrs, children: walk(b.children, key) };
+    });
+    return walk(blocks, null);
+}
+// Rebuild id-assigned blocks as RawBlock-shaped inputs for adapter edge
+// extraction, threading each block's blockId so extractEdges can set src_block.
+function collectRawBlocks(blocks) {
+    return blocks.map((b) => ({
+        type: b.type,
+        span: { start: 0, end: 0 },
+        raw: b.raw,
+        text: "",
+        attrs: b.attrs,
+        children: collectRawBlocks(b.children),
+        trivia: b.trivia,
+        anchors: [],
+        outLinks: [],
+        blockId: b.blockId,
+    }));
+}
+function collectIds(blocks) {
+    const out = [];
+    const walk = (list) => { for (const b of list) {
+        out.push(b.blockId);
+        walk(b.children);
+    } };
+    walk(blocks);
+    return out;
+}
+/**
+ * An IdResolver that threads the ops' known ids (from the committed MutDoc)
+ * rather than reconciling. `priorIds` is the set of block ids that existed in
+ * the doc's previous revision — used only to label dispositions (same/edited vs
+ * inserted); it does not affect id assignment.
+ */
+export function makeKnownIdResolver(store, repoId, doc, priorIds, opts = {}) {
+    const adapter = opts.path ? adapterForPath(opts.path) : undefined;
+    // Source directory for `./`/`../` link targets — the same rule the observed
+    // (reconciling) ingest applies, so an `apply` re-ingest resolves a relative
+    // link to the same node instead of minting a `phantom:../x.md` placeholder.
+    const docDir = opts.path ? opts.path.replace(/[^/]*$/, "") : "";
+    const byKey = idByPositionalKey(doc.children);
+    return (rest, docId) => {
+        const db = store.db;
+        const assigned = assignFromMut(rest, byKey);
+        const nowIds = collectIds(assigned);
+        const nowSet = new Set(nowIds);
+        // Dispositions are INTENT, not inference: a carried id that existed before is
+        // `same`/`edited` (confidence 1.0); an id new this commit is `inserted`; a
+        // prior id no longer present is `deleted`.
+        const dispositions = nowIds.map((id) => ({
+            blockId: id,
+            kind: priorIds.has(id) ? "edited" : "inserted",
+            confidence: 1,
+            reason: "api",
+            matcherV: null,
+            detail: {},
+        }));
+        const deleted = [...priorIds].filter((id) => !nowSet.has(id));
+        const extractEdges = (thisDocId, metadata) => {
+            const out = [];
+            if (adapter?.extractEdges) {
+                const raw = collectRawBlocks(assigned);
+                for (const e of adapter.extractEdges(raw, metadata))
+                    out.push(resolveAdapterEdge(db, repoId, thisDocId, e, docDir));
+            }
+            else {
+                const walk = (blocks) => {
+                    for (const b of blocks) {
+                        for (const e of extractFromBlock(b.blockId, b.type, b.raw))
+                            out.push(resolveEdge(db, repoId, thisDocId, e, docDir));
+                        if (b.children.length > 0)
+                            walk(b.children);
+                    }
+                };
+                walk(assigned);
+                for (const e of extractFromFrontmatter(metadata))
+                    out.push(resolveEdge(db, repoId, thisDocId, e, docDir));
+            }
+            return out;
+        };
+        void docId;
+        return { assigned, dispositions, deleted, extractEdges };
+    };
+}
+// Edge resolution — mirrors reconciling-ingest's resolvers (block-anchor targets
+// resolve to the document node in v1; the anchor is preserved on the edge).
+function resolveEdge(db, repoId, srcDoc, e, docDir) {
+    let dstNode;
+    let dstKind = e.dstKind;
+    if (e.dstKind === "external") {
+        dstNode = resolveExternal(db, repoId, e.target);
+    }
+    else if (e.target === "") {
+        dstNode = srcDoc;
+        dstKind = "document";
+    }
+    else {
+        dstNode = resolveDocPath(db, repoId, resolveRelativePath(e.target, docDir)).id;
+        dstKind = "document";
+    }
+    return { srcDoc, srcBlock: e.srcBlock, srcField: e.srcField, predicate: e.predicate, dstKind, dstNode, anchor: e.anchor, provenance: e.provenance };
+}
+function resolveAdapterEdge(db, repoId, srcDoc, e, docDir) {
+    let dstNode;
+    let dstKind = e.dstKind;
+    if (e.dstKind === "external") {
+        dstNode = resolveExternal(db, repoId, e.target);
+    }
+    else if (e.target === "") {
+        dstNode = srcDoc;
+        dstKind = "document";
+    }
+    else {
+        dstNode = resolveDocPath(db, repoId, resolveRelativePath(e.target, docDir)).id;
+        dstKind = "document";
+    }
+    return { srcDoc, srcBlock: e.srcBlock, srcField: e.srcField, predicate: e.predicate, dstKind, dstNode, anchor: e.anchor, provenance: e.provenance };
+}
+//# sourceMappingURL=known-ids.js.map

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

@@ -0,0 +1,3 @@
+import type { Database } from "better-sqlite3";
+import type { MutDoc } from "./tree.js";
+export declare function loadMutDoc(db: Database, docId: string): MutDoc | null;

package/dist/src/mutate/load.js

@@ -0,0 +1,66 @@
+export function loadMutDoc(db, docId) {
+    const doc = db.prepare("SELECT doc_id, path, format, leading_trivia, frontmatter_trivia, current_rev FROM docs WHERE doc_id = ? AND deleted_commit IS NULL").get(docId);
+    if (!doc)
+        return null;
+    const rows = db
+        .prepare(`SELECT block_id, parent_block, ordinal, type, attrs, raw_hash, trivia_hash
+       FROM blocks WHERE doc_id = ? AND deleted_commit IS NULL
+       ORDER BY parent_block, ordinal`)
+        .all(docId);
+    const blob = db.prepare("SELECT bytes FROM blobs WHERE hash = ?");
+    const nodes = new Map();
+    for (const r of rows) {
+        const raw = blob.get(r.raw_hash)?.bytes.toString("utf8") ?? "";
+        // A NULL trivia_hash means the block's trailing trivia was genuinely empty
+        // (e.g. the last block of a file with no trailing newline). Emit "" — never
+        // a fabricated separator, which would corrupt the file on the next write.
+        // Freshly-inserted blocks carry their own explicit trivia from the op layer,
+        // so they are unaffected by this.
+        let trivia = "";
+        if (r.trivia_hash) {
+            const tb = blob.get(r.trivia_hash);
+            if (tb)
+                trivia = tb.bytes.toString("utf8");
+        }
+        nodes.set(r.block_id, {
+            id: r.block_id,
+            type: r.type,
+            raw,
+            trivia,
+            attrs: JSON.parse(r.attrs),
+            children: [],
+        });
+    }
+    const roots = [];
+    const ordered = [...rows].sort((a, b) => a.ordinal - b.ordinal);
+    for (const r of ordered) {
+        const node = nodes.get(r.block_id);
+        if (r.parent_block && nodes.has(r.parent_block))
+            nodes.get(r.parent_block).children.push(node);
+    }
+    for (const r of ordered) {
+        if (!r.parent_block || !nodes.has(r.parent_block))
+            roots.push(nodes.get(r.block_id));
+    }
+    let frontmatterRaw = null;
+    if (doc.current_rev) {
+        const rev = db.prepare("SELECT frontmatter_blob FROM revisions WHERE rev_id = ?").get(doc.current_rev);
+        if (rev?.frontmatter_blob) {
+            const fm = blob.get(rev.frontmatter_blob);
+            // Append the exact stored separator (docs.frontmatter_trivia) so the
+            // write path round-trips byte-for-byte. Ingest always captures it when a
+            // frontmatter block exists, so the ?? "" is just a type guard.
+            if (fm)
+                frontmatterRaw = fm.bytes.toString("utf8") + (doc.frontmatter_trivia ?? "");
+        }
+    }
+    return {
+        docId: doc.doc_id,
+        path: doc.path,
+        format: doc.format,
+        leadingTrivia: doc.leading_trivia,
+        frontmatterRaw,
+        children: roots,
+    };
+}
+//# sourceMappingURL=load.js.map

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

@@ -0,0 +1,32 @@
+import type { RawBlock } from "../core/parse/types.js";
+import { type MutDoc } from "./tree.js";
+import type { PlanOp } from "./opset.js";
+/** A disposition row as this module consumes it (decoupled from reconcile/). */
+export interface LowerDisposition {
+    blockId: string;
+    kind: string;
+    confidence: number | null;
+    reason: string | null;
+    detail?: Record<string, unknown>;
+}
+export interface LowerResult {
+    ops: PlanOp[];
+    preserved: number;
+    ambiguous: number;
+}
+/**
+ * Lower a reconciled whole-document update to a kernel opset (top-level
+ * granularity). Preserves identity for every top-level block carried unchanged
+ * and correctly realizes add / remove / reorder / content-edit at the top
+ * level. A carried container whose content changed is updated as a whole (its
+ * children re-minted); recursion to preserve nested identity is a later
+ * refinement (verification keeps this honest either way).
+ */
+export declare function lowerTopLevel(oldDoc: MutDoc, rest: RawBlock[], assignment: Map<string, string>, dispositions: LowerDisposition[]): LowerResult;
+/**
+ * Guaranteed fallback: replace the whole body. Remove every current top-level
+ * block, then insert the entire proposed body as one op. Loses all block
+ * identity but always reproduces the exact bytes (verification still checks).
+ * Used only when no identity-preserving lowering converges.
+ */
+export declare function lowerReplace(oldDoc: MutDoc, content: string): LowerResult;