@openvulcan/dsh-vulcancode 0.0.0-stage → 0.4.0

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Long-term Markdown memory in dsh, ported from VulcanCode. Three tools let the model read and
+ * change memory; a snapshot of it enters each conversation once (and again after a compaction);
+ * the memory-curator skill guides tidying. Files live under `<dshHome>/vulcan-memory`, in the same
+ * formats as VulcanCode.
+ *
+ * The memory mode is read from `settings.json`: `markdown` (the default) enables everything here;
+ * `off` and the not-yet-implemented `vmm` leave the tools refusing and inject nothing.
+ *
+ * The memory page (`client/`) reads and changes the same files through the routes below
+ * {@link ROUTE_PREFIX}.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export type { MemoryMode, MemorySettings, InjectionBudget } from './settings.js';
+export declare const name = "vulcan-memory";
+export declare const inject: string[];
+/** Mirrored by `ROUTE_BASE` in `client/shared.ts`. */
+export declare const ROUTE_PREFIX = "/api/vulcan-memory/";
+export declare function apply(ctx: Context): Promise<void>;
+/** Fetch-shaped handler of one page route. */
+type Handler = (request: Request, url: URL) => Promise<unknown>;
+/** Group route rows by path; dsh dispatches only the methods registered for a path. */
+export declare function groupRoutes(routes: readonly (readonly ['GET' | 'POST', string, Handler])[]): Map<string, Map<'GET' | 'POST', Handler>>;
+/** Answer one page request; failures carry their kind and message, never a stack. */
+export declare function handle(handler: Handler, request: Request): Promise<Response>;
+/** Split a SKILL.md into its front-matter description and body. */
+export declare function parseSkill(text: string): {
+    description: string;
+    body: string;
+};

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/index.js

@@ -0,0 +1,240 @@
+/**
+ * Long-term Markdown memory in dsh, ported from VulcanCode. Three tools let the model read and
+ * change memory; a snapshot of it enters each conversation once (and again after a compaction);
+ * the memory-curator skill guides tidying. Files live under `<dshHome>/vulcan-memory`, in the same
+ * formats as VulcanCode.
+ *
+ * The memory mode is read from `settings.json`: `markdown` (the default) enables everything here;
+ * `off` and the not-yet-implemented `vmm` leave the tools refusing and inject nothing.
+ *
+ * The memory page (`client/`) reads and changes the same files through the routes below
+ * {@link ROUTE_PREFIX}.
+ */
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { INITIAL_STATE, PROJECTION_KEY, SOURCE_KIND, applyEvent, injectionStateSchema, isSubagent, renderMemoryBlock } from './inject.js';
+import { MemoryError } from './markdown/errors.js';
+import * as markdown from './markdown/index.js';
+import * as page from './page.js';
+import { projectContext } from './project.js';
+import { loadSettings } from './settings.js';
+export const name = 'vulcan-memory';
+export const inject = ['tools', 'skills', 'agents', 'sessionProjections'];
+/** Mirrored by `ROUTE_BASE` in `client/shared.ts`. */
+export const ROUTE_PREFIX = '/api/vulcan-memory/';
+const ASSETS = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'assets');
+const SKILL_NAME = 'memory-curator';
+/** The standard rank of packaged skills; the type ties the literal to dsh's constant. */
+const SKILL_RANK = 600;
+const PROVIDER = 'vulcan-memory';
+const OUTPUT = {
+    schema: { type: 'object', properties: { content: { type: 'string' } }, required: ['content'], additionalProperties: false },
+    render: (_args, value) => [{ type: 'text', text: value.content }],
+};
+export async function apply(ctx) {
+    const memoryDirectory = path.join(resolveDshHome(), 'vulcan-memory');
+    const store = new markdown.MarkdownMemoryStore(memoryDirectory);
+    const guide = readFileSync(path.join(ASSETS, 'markdown-memory-guide.md'), 'utf8');
+    const skill = parseSkill(readFileSync(path.join(ASSETS, SKILL_NAME, 'SKILL.md'), 'utf8'));
+    /** Memory of an agent's project, or `undefined` when memory is not active for it. */
+    const access = (agent) => markdown.resolveAccess(store, loadSettings(memoryDirectory), projectContext(agent.session.header.cwd));
+    const tool = (spec, run) => ({
+        name: spec.name,
+        description: spec.description,
+        parameters: spec.parameters,
+        output: OUTPUT,
+        async execute(args, { agent }) {
+            if (agent === undefined)
+                throw new Error('memory tools need a session');
+            const resolved = access(agent);
+            if (resolved === undefined)
+                throw new Error(markdown.NOT_ACTIVE_MESSAGE);
+            return { content: run(resolved, args, agent) };
+        },
+    });
+    ctx.effect(() => ctx.tools.register(tool(markdown.TOOL_SPECS.outline, (resolved, args) => markdown.outline(resolved, args))));
+    ctx.effect(() => ctx.tools.register(tool(markdown.TOOL_SPECS.search, (resolved, args) => markdown.search(resolved, args))));
+    ctx.effect(() => ctx.tools.register(tool(markdown.TOOL_SPECS.write, (resolved, args, agent) => markdown.write(resolved, { session: agent.id, source: 'ai' }, args))));
+    // VulcanCode hides memory_write in Plan mode and forbids it for subagents; dsh keeps the tool
+    // catalog stable, so the same rule is a refusal before the call runs.
+    ctx.on('tools/pre-execute', async (exec, next) => {
+        if (exec.name !== markdown.TOOL_SPECS.write.name || exec.agent === undefined)
+            return next();
+        if (isSubagent(exec.agent.session.header)) {
+            return { kind: 'deny', reason: 'Subagents cannot change long-term memory; report the fact to the parent conversation instead.' };
+        }
+        if (ctx.get('planMode')?.get(exec.agent).active === true) {
+            return { kind: 'deny', reason: 'Plan mode is read-only: long-term memory cannot be changed until plan mode ends.' };
+        }
+        return next();
+    });
+    const projections = ctx.sessionProjections;
+    const registered = await projections.register({
+        key: PROJECTION_KEY,
+        stateVersion: 1,
+        stateSchema: injectionStateSchema,
+        init: () => INITIAL_STATE,
+        apply: applyEvent,
+    });
+    /** Whether this session's model currently sees a memory snapshot. */
+    const injectionState = isHandle(registered)
+        ? session => registered.stateOf(session)
+        // dsh 0.2.1 serves states by key only.
+        : session => projections.stateOf(session, PROJECTION_KEY) ?? INITIAL_STATE;
+    ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || signal.aborted)
+            return decision;
+        if (isSubagent(agent.session.header))
+            return decision;
+        const state = injectionState(agent.session);
+        if (state.injectedSeq !== null)
+            return decision;
+        let text;
+        try {
+            const resolved = access(agent);
+            if (resolved === undefined)
+                return decision;
+            text = renderMemoryBlock(guide, markdown.snapshot(resolved), state.compacted);
+        }
+        catch (error) {
+            ctx.logger.warn(`cannot read long-term memory: ${error instanceof Error ? error.message : String(error)}`);
+            return decision;
+        }
+        return {
+            ...decision,
+            messages: [createUserMessage({
+                    content: [{ type: 'text', text }],
+                    source: { kind: SOURCE_KIND, form: 'snapshot', sections: [{ name: SOURCE_KIND, text }] },
+                }), ...decision.messages],
+        };
+    }, { prepend: true });
+    ctx.skills.registerProvider(() => {
+        const provider = {
+            name: PROVIDER,
+            list: () => Promise.resolve(loadSettings(memoryDirectory).mode !== 'markdown' ? [] : [{
+                    name: SKILL_NAME,
+                    description: skill.description,
+                    invocation: { modelInvocable: true, userInvocable: true },
+                    provider: PROVIDER,
+                    source: 'vulcan-memory',
+                    rank: SKILL_RANK,
+                    locator: SKILL_NAME,
+                }]),
+            async get(candidate) {
+                const { rank: _rank, locator: _locator, ...summary } = candidate;
+                return { ...summary, content: skill.body };
+            },
+        };
+        return provider;
+    });
+    ctx.inject(['connection', 'workspaceRegistry'], (child) => {
+        const hosts = () => child.workspaceRegistry.list().map(page.hostProjectOf);
+        const routes = [
+            ['GET', 'overview', async (_request, url) => {
+                    const all = hosts();
+                    return page.loadOverview(store, all, page.resolveHost(all, param(url, 'projectId')), param(url, 'memoryProjectId'));
+                }],
+            ['POST', 'write', async (request) => {
+                    const input = page.fields(await readJson(request), ['projectId', 'memoryProjectId', 'operations']);
+                    const all = hosts();
+                    return page.writeAsUser(store, all, page.resolveHost(all, page.optionalText(input, 'projectId')), page.optionalText(input, 'memoryProjectId'), input['operations']);
+                }],
+            ['GET', 'file', async (_request, url) => page.readFile(store, page.scopeParam(url.searchParams.get('scope')), param(url, 'memoryProjectId'))],
+            ['POST', 'file', async (request) => {
+                    const input = page.fields(await readJson(request), ['scope', 'memoryProjectId', 'expected', 'text']);
+                    return page.replaceFile(store, page.scopeParam(input['scope']), page.optionalText(input, 'memoryProjectId'), page.text(input, 'expected'), page.text(input, 'text'));
+                }],
+            ['POST', 'project', async (request) => {
+                    const action = page.parseProjectAction(await readJson(request));
+                    return page.applyProjectAction(store, page.resolveHost(hosts(), page.actionHostId(action)), action);
+                }],
+            ['GET', 'settings', async () => page.settingsView(loadSettings(memoryDirectory))],
+            ['POST', 'settings', async (request) => {
+                    const settings = page.parseSettingsSave(await readJson(request));
+                    page.saveSettings(memoryDirectory, settings);
+                    return page.settingsView(settings);
+                }],
+            ['POST', 'export', async (request) => page.exportRequest(store, await readJson(request))],
+            ['POST', 'import/preview', async (request) => page.previewRequest(store, await readJson(request))],
+            ['POST', 'import', async (request) => page.importRequest(store, await readJson(request))],
+        ];
+        // dsh accepts one registration per exact path, so a path's methods share one route.
+        for (const [route, byMethod] of groupRoutes(routes)) {
+            child.effect(() => child.connection.fetch.register({
+                path: `${ROUTE_PREFIX}${route}`,
+                methods: [...byMethod.keys()],
+                requestBody: 'buffered',
+                fetch: request => handle(byMethod.get(request.method), request),
+            }));
+        }
+    });
+}
+/**
+ * Whether an awaited registration is a dsh 0.2.2 handle. dsh 0.2.1 registers synchronously and
+ * awaiting its disposer yields a function; both are inside `engines.dsh`.
+ */
+function isHandle(value) {
+    return typeof value === 'object' && value !== null && typeof value.stateOf === 'function';
+}
+/** Group route rows by path; dsh dispatches only the methods registered for a path. */
+export function groupRoutes(routes) {
+    const grouped = new Map();
+    for (const [method, route, handler] of routes) {
+        const byMethod = grouped.get(route) ?? new Map();
+        if (byMethod.has(method))
+            throw new Error(`vulcan-memory: ${method} ${route} is declared twice`);
+        byMethod.set(method, handler);
+        grouped.set(route, byMethod);
+    }
+    return grouped;
+}
+function param(url, name) {
+    const value = url.searchParams.get(name);
+    return value === null || value === '' ? undefined : value;
+}
+async function readJson(request) {
+    try {
+        return await request.json();
+    }
+    catch {
+        throw MemoryError.invalid('The request body must be JSON.');
+    }
+}
+const STATUS = {
+    invalid: 400,
+    unsupported_format: 400,
+    project_unavailable: 400,
+    not_found: 404,
+    revision_mismatch: 409,
+    concurrent_modification: 409,
+    rollback_incomplete: 500,
+    io: 500,
+    json: 500,
+};
+/** Answer one page request; failures carry their kind and message, never a stack. */
+export async function handle(handler, request) {
+    try {
+        const value = await handler(request, new URL(request.url));
+        return Response.json({ ok: true, value: value ?? null }, { headers: { 'cache-control': 'no-store' } });
+    }
+    catch (error) {
+        const code = error instanceof MemoryError ? error.kind : 'failed';
+        const status = error instanceof MemoryError ? STATUS[error.kind] : 500;
+        const message = error instanceof Error ? error.message : String(error);
+        return Response.json({ ok: false, error: { code, message } }, { status, headers: { 'cache-control': 'no-store' } });
+    }
+}
+/** Split a SKILL.md into its front-matter description and body. */
+export function parseSkill(text) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (match === null)
+        throw new Error('memory-curator SKILL.md has no front matter');
+    const description = /^description:\s*(.+)$/m.exec(match[1] ?? '')?.[1]?.trim();
+    if (description === undefined || description === '')
+        throw new Error('memory-curator SKILL.md has no description');
+    return { description, body: text.slice(match[0].length).trim() };
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/inject.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The memory snapshot a conversation sees. VulcanCode locks it into the system-prompt baseline;
+ * dsh's equivalent is one durable, source-attributed user message: appended before the first step
+ * of a session, and again only after a compaction shadowed it. Writes made in between are not
+ * shown (the model reads current text with `memory_search`), so the prompt cache stays intact.
+ */
+import { z } from 'zod';
+import type { ContextFormed } from '@deepseek-ai/dsh-llm';
+import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session';
+export declare const SOURCE_KIND = "vulcan-memory";
+export declare const PROJECTION_KEY = "vulcanMemory";
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'vulcan-memory': {
+            kind: 'vulcan-memory';
+        } & ContextFormed;
+    }
+}
+export declare const injectionStateSchema: z.ZodObject<{
+    injectedSeq: z.ZodNullable<z.ZodNumber>;
+    compacted: z.ZodBoolean;
+}, z.core.$strip>;
+export type InjectionState = z.infer<typeof injectionStateSchema>;
+export declare const INITIAL_STATE: InjectionState;
+/** Fold one session event into the injection state. */
+export declare function applyEvent(state: InjectionState, event: SessionEvent): InjectionState;
+/** Subagents never see or write long-term memory, as in VulcanCode. */
+export declare function isSubagent(header: SessionHeader): boolean;
+/** The snapshot message text: VulcanCode's `long_term_memory` block, guide first. */
+export declare function renderMemoryBlock(guide: string, snapshot: string, compacted: boolean): string;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/inject.js

@@ -0,0 +1,46 @@
+/**
+ * The memory snapshot a conversation sees. VulcanCode locks it into the system-prompt baseline;
+ * dsh's equivalent is one durable, source-attributed user message: appended before the first step
+ * of a session, and again only after a compaction shadowed it. Writes made in between are not
+ * shown (the model reads current text with `memory_search`), so the prompt cache stays intact.
+ */
+import { z } from 'zod';
+export const SOURCE_KIND = 'vulcan-memory';
+export const PROJECTION_KEY = 'vulcanMemory';
+export const injectionStateSchema = z.object({
+    /** Seq of the snapshot message the model currently sees, or null when none is visible. */
+    injectedSeq: z.number().nullable(),
+    /** Whether a compaction shadowed an earlier snapshot. */
+    compacted: z.boolean(),
+});
+export const INITIAL_STATE = { injectedSeq: null, compacted: false };
+/** Fold one session event into the injection state. */
+export function applyEvent(state, event) {
+    if (event.type === 'user/message') {
+        return event.data.source.kind === SOURCE_KIND ? { ...state, injectedSeq: event.seq } : state;
+    }
+    if (event.type === 'compaction/summary' || event.type === 'compaction/prune') {
+        const injected = state.injectedSeq;
+        if (injected !== null && event.data.shadowedSeqs.some(seq => seq === injected))
+            return { injectedSeq: null, compacted: true };
+    }
+    return state;
+}
+/** Subagents never see or write long-term memory, as in VulcanCode. */
+export function isSubagent(header) {
+    return header.origin === 'subagent' || (header.delegationDepth ?? 0) > 0;
+}
+const DESCRIPTION = 'Long-term memory captured when this conversation started or was last compacted. Changes written since then are not shown here; use memory_search for the current text.';
+/** The snapshot message text: VulcanCode's `long_term_memory` block, guide first. */
+export function renderMemoryBlock(guide, snapshot, compacted) {
+    const memory = snapshot.trim() === '' ? 'Memory is empty so far.' : snapshot;
+    return [
+        '<long_term_memory>',
+        DESCRIPTION,
+        `Phase: ${compacted ? 'after_context_compaction' : 'first_session'}`,
+        'Source: Markdown memory',
+        '',
+        `${guide.trim()}\n\n${memory}`,
+        '</long_term_memory>',
+    ].join('\n');
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/constants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Limits of Markdown memory, the same as VulcanCode's `vulcan-markdown-memory` crate
+ * (`crates/vulcan-markdown-memory/src/lib.rs`, `settings.rs`). Byte limits count UTF-8 bytes.
+ */
+export declare const MAX_NODE_LEVEL = 4;
+export declare const MAX_TITLE_CHARS = 120;
+export declare const MAX_NODE_BODY_BYTES: number;
+export declare const MAX_FILE_BYTES: number;
+export declare const MAX_OPERATIONS_PER_WRITE = 16;
+export declare const MAX_SEARCH_PATTERNS = 12;
+export declare const DEFAULT_SEARCH_LIMIT = 6;
+export declare const MAX_SEARCH_LIMIT = 20;
+export declare const NODE_PAGE_BYTES: number;
+export declare const BUDGET_WARNING_PERCENT = 80;
+export declare const MAX_PART_TOKENS = 16000;
+export declare const REGISTRY_FORMAT_VERSION = 1;
+export declare const SETTINGS_FORMAT_VERSION = 1;
+export declare const MAX_PACKAGE_PROJECTS = 256;
+/** The manifest, user and space entries plus every project, each at most a whole file. */
+export declare const MAX_PACKAGE_BYTES: number;
+export declare const EXPORT_FORMAT_VERSION = 1;
+/** UTF-8 byte length, which every Rust `str::len` limit counts. */
+export declare function byteLength(text: string): number;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/constants.js

@@ -0,0 +1,25 @@
+/**
+ * Limits of Markdown memory, the same as VulcanCode's `vulcan-markdown-memory` crate
+ * (`crates/vulcan-markdown-memory/src/lib.rs`, `settings.rs`). Byte limits count UTF-8 bytes.
+ */
+export const MAX_NODE_LEVEL = 4;
+export const MAX_TITLE_CHARS = 120;
+export const MAX_NODE_BODY_BYTES = 16 * 1024;
+export const MAX_FILE_BYTES = 512 * 1024;
+export const MAX_OPERATIONS_PER_WRITE = 16;
+export const MAX_SEARCH_PATTERNS = 12;
+export const DEFAULT_SEARCH_LIMIT = 6;
+export const MAX_SEARCH_LIMIT = 20;
+export const NODE_PAGE_BYTES = 6 * 1024;
+export const BUDGET_WARNING_PERCENT = 80;
+export const MAX_PART_TOKENS = 16_000;
+export const REGISTRY_FORMAT_VERSION = 1;
+export const SETTINGS_FORMAT_VERSION = 1;
+export const MAX_PACKAGE_PROJECTS = 256;
+/** The manifest, user and space entries plus every project, each at most a whole file. */
+export const MAX_PACKAGE_BYTES = (MAX_PACKAGE_PROJECTS + 3) * MAX_FILE_BYTES;
+export const EXPORT_FORMAT_VERSION = 1;
+/** UTF-8 byte length, which every Rust `str::len` limit counts. */
+export function byteLength(text) {
+    return Buffer.byteLength(text, 'utf8');
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/markdown/document.d.ts

@@ -0,0 +1,108 @@
+/**
+ * One memory file parsed into heading nodes (`document.rs`). Parsing never fails and rendering
+ * reproduces the source bytes exactly; only nodes that were written regenerate their heading or
+ * metadata line. Headings are found with a CommonMark parser, so `#` lines inside fences, quotes
+ * and lists stay body text.
+ */
+import type { MemoryScope } from './scope.js';
+export type NodeSource = 'ai' | 'user';
+/** Parsed `<!-- mem ... -->` metadata line. */
+export interface NodeMeta {
+    readonly id: string;
+    readonly section?: string;
+    readonly created: string;
+    readonly updated: string;
+    readonly session?: string;
+    readonly source: NodeSource;
+}
+/** Whether a value can be stored in a metadata line and read back. */
+export declare function isMetaValue(value: string): boolean;
+/** Parse one metadata line; malformed lines are ordinary body text. */
+export declare function parseMetaLine(line: string): NodeMeta | undefined;
+/** Render a metadata comment without a line terminator. */
+export declare function renderMeta(meta: NodeMeta): string;
+/** One heading node with its own body and child nodes. */
+export declare class MemoryNode {
+    level: number;
+    title: string;
+    meta: NodeMeta | undefined;
+    /** Own body bytes up to the next node heading. */
+    private body;
+    /** Original heading bytes including the terminator; `undefined` regenerates it. */
+    private headingRaw;
+    /** Original metadata line including the terminator; `undefined` regenerates it. */
+    private metaRaw;
+    children: MemoryNode[];
+    constructor(level: number, title: string, meta: NodeMeta | undefined, 
+    /** Own body bytes up to the next node heading. */
+    body: string, raw?: {
+        heading: string;
+        meta: string | undefined;
+    });
+    /** Copy without children for another document: lines regenerate at `level`, the body uses `eol`. */
+    detached(level: number, eol: string): MemoryNode;
+    rawBody(): string;
+    /** The own body with normalized line endings and no surrounding blank lines. */
+    bodyText(): string;
+    setBody(body: string): void;
+    setTitle(title: string): void;
+    setMeta(meta: NodeMeta): void;
+    /** Shift the subtree to a new root level; returns the deepest level reached when it does not fit. */
+    relevel(level: number): number | undefined;
+    private subtreeDepth;
+    private shiftLevels;
+    /** Revision token of the node's own title and body. */
+    revision(): string;
+    descendantCount(): number;
+    /** Append this subtree's text, reusing original bytes wherever they are still valid. */
+    render(eol: string, output: string[]): void;
+}
+/** A flattened, read-only view of one node used by search, outline and writes. */
+export interface NodeView {
+    /** Metadata id, or an `h-` id derived from scope, title path and occurrence. */
+    readonly id: string;
+    readonly scope: MemoryScope;
+    readonly level: number;
+    /** Titles from the top-level node down to this one. */
+    readonly path: readonly string[];
+    /** Child indexes from the document root. */
+    readonly locator: readonly number[];
+    /** Section key of the top-level H1 this node belongs to. */
+    readonly section: string | undefined;
+    readonly revision: string;
+    readonly meta: NodeMeta | undefined;
+    /** Normalized own body. */
+    readonly body: string;
+    /** Titles of the direct children. */
+    readonly children: readonly string[];
+    readonly descendants: number;
+}
+/** The last title of a view's path. */
+export declare function viewTitle(view: NodeView): string;
+/** One parsed memory file. */
+export declare class MemoryDocument {
+    /** Line terminator for generated lines, taken from the source. */
+    readonly eol: '\n' | '\r\n';
+    /** Bytes before the first node heading. */
+    private readonly preamble;
+    readonly roots: MemoryNode[];
+    private constructor();
+    static empty(): MemoryDocument;
+    static parse(text: string): MemoryDocument;
+    render(): string;
+    /** Views of every node in document order. */
+    views(scope: MemoryScope): NodeView[];
+    node(locator: readonly number[]): MemoryNode | undefined;
+    /** Remove and return the subtree at a locator. */
+    remove(locator: readonly number[]): MemoryNode | undefined;
+    /** Append a subtree as the last child of a parent, or as the last top-level node. */
+    append(parent: readonly number[] | undefined, node: MemoryNode): boolean;
+}
+/** Convert written text into stored body bytes: the file's terminators and one trailing blank line. */
+export declare function storedBody(text: string, eol: string): string;
+/** Levels of node-forming headings in text written as a body. */
+export declare function nodeHeadingLevels(text: string): number[];
+/** Whether text renders as exactly one ATX heading with the given title. */
+export declare function titleRoundTrips(level: number, title: string): boolean;
+/** Rust `str::lines`: split on `\n`, drop one trailing empty line, strip a `\r` ending each line. */
+export declare function lines(text: string): string[];