@dooc-dev/dooc 0.0.0-stage → 0.0.2

package/dist/compiler/file-cache.d.ts

@@ -0,0 +1,14 @@
+export declare const fileSig: (path: string) => string;
+/**
+ * Memoizes a single file. If the signature matches, returns the previous value (same reference)
+ * without reading/computing.
+ */
+export declare const createFileCache: <T>() => {
+    get: (path: string, compute: (raw: string) => T) => T;
+};
+/** Memoizes by signature (wraps a per-directory loader). */
+export declare const createSigCache: <T>() => {
+    get: (sig: string, compute: () => T) => T;
+};
+/** Names directly under dir + each name's file signature; changes on any add/delete/modify. */
+export declare const dirSig: (dir: string, fileOf?: (name: string) => string) => string;

package/dist/compiler/file-cache.js

@@ -0,0 +1,61 @@
+// Makes the compiler incremental (even when the viewer calls compile() in full on every
+// keystroke / save, files unchanged on disk aren't re-read/re-parsed). signature = mtimeMs + size.
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+export const fileSig = (path) => {
+    let st;
+    try {
+        st = statSync(path);
+    }
+    catch {
+        return "-";
+    }
+    return `${st.mtimeMs}:${st.size}`;
+};
+/**
+ * Memoizes a single file. If the signature matches, returns the previous value (same reference)
+ * without reading/computing.
+ */
+export const createFileCache = () => {
+    const store = new Map();
+    return {
+        get: (path, compute) => {
+            const sig = fileSig(path);
+            const hit = store.get(path);
+            if (sig !== "-" && hit?.sig === sig) {
+                return hit.value;
+            }
+            const value = compute(readFileSync(path, "utf8"));
+            if (sig === "-") {
+                store.delete(path);
+            }
+            else {
+                store.set(path, { sig, value });
+            }
+            return value;
+        },
+    };
+};
+/** Memoizes by signature (wraps a per-directory loader). */
+export const createSigCache = () => {
+    let hit;
+    return {
+        get: (sig, compute) => {
+            if (hit?.sig !== sig) {
+                hit = { sig, value: compute() };
+            }
+            return hit.value;
+        },
+    };
+};
+/** Names directly under dir + each name's file signature; changes on any add/delete/modify. */
+export const dirSig = (dir, fileOf = (n) => n) => {
+    let names;
+    try {
+        names = readdirSync(dir).sort();
+    }
+    catch {
+        return "-";
+    }
+    return names.map((n) => `${n}:${fileSig(join(dir, fileOf(n)))}`).join("|");
+};

package/dist/compiler/files.d.ts

@@ -0,0 +1,29 @@
+import { type FileLayout } from "../core/files.js";
+export declare const managedFile: (file: string) => boolean;
+export interface ProjectFile {
+    path: string;
+    size: number;
+    extension: string;
+}
+export declare const projectFiles: (root: string) => ProjectFile[];
+export declare const filesSnapshot: (root: string) => {
+    files: ProjectFile[];
+    layout: FileLayout;
+    revision: string;
+    documents: {
+        [k: string]: string;
+    };
+};
+export declare const uploadFile: (root: string, input: Record<string, unknown>) => {
+    file: string;
+};
+/** Rewrite destinations only: examples, labels, titles and code stay byte-for-byte intact. */
+export declare const rewriteFileLinks: (raw: string, moves: ReadonlyMap<string, string>) => string;
+export declare const updateFiles: (root: string, input: Record<string, unknown>) => {
+    files: ProjectFile[];
+    layout: FileLayout;
+    revision: string;
+    documents: {
+        [k: string]: string;
+    };
+};

package/dist/compiler/files.js

@@ -0,0 +1,431 @@
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, rmdirSync, rmSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, posix } from "node:path";
+import { visit } from "unist-util-visit";
+import { Document, isSeq, parseDocument } from "yaml";
+import { flattenTree, MANIFEST_FILE } from "../core/content-metadata.js";
+import { defaultFilePath, docFile, docIconFile, fileExtension, isDocumentFileName, localFile, MAX_FILE_UPLOAD_BYTES, parseFileLayout, } from "../core/files.js";
+import { codeBlockAt, parseMdast } from "../core/markdown.js";
+import { docPath } from "../core/routing.js";
+import { termFileUrl } from "../core/term-reference.js";
+import { isRemoteTextfile, parseFileReference } from "../core/textfile.js";
+import { fileSig } from "./file-cache.js";
+import { translationFile, translationFiles, translationLanguages } from "./locales.js";
+import { readManifest } from "./manifest.js";
+import { textfilePath, writeTextfile } from "./textfile.js";
+import { themeNames, themeVariants } from "./theme-variants.js";
+// Project settings and translations have their own layout, outside file restructuring.
+const reserved = new Set([MANIFEST_FILE, "docs.config.mjs", "node_modules", "dist", "locales"]);
+export const managedFile = (file) => localFile(file) && !reserved.has(file.split("/")[0] ?? "");
+export const projectFiles = (root) => {
+    const result = [];
+    const walk = (directory) => {
+        for (const entry of readdirSync(join(root, directory), { withFileTypes: true })) {
+            const path = directory ? `${directory}/${entry.name}` : entry.name;
+            if (!managedFile(path) || entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                walk(path);
+            else if (entry.isFile())
+                result.push({
+                    path,
+                    size: statSync(textfilePath(root, path)).size,
+                    extension: fileExtension(path),
+                });
+        }
+    };
+    walk("");
+    return result.sort((a, b) => a.path.localeCompare(b.path));
+};
+export const filesSnapshot = (root) => {
+    const manifest = readManifest(root);
+    if (manifest.errors.length)
+        throw new Error(manifest.errors.join("\n"));
+    let files = projectFiles(root);
+    if (files.length) {
+        const ignored = spawnSync("git", ["-C", root, "check-ignore", "--stdin", "-z"], {
+            input: `${files.map((file) => file.path).join("\0")}\0`,
+            encoding: "utf8",
+            timeout: 2_000,
+            maxBuffer: 5_000_000,
+            windowsHide: true,
+        });
+        if (ignored.status === 0) {
+            const paths = new Set(ignored.stdout.split("\0"));
+            files = files.filter((file) => !paths.has(file.path));
+        }
+    }
+    const layout = manifest.files ?? parseFileLayout({});
+    const rank = new Map(layout.order.map((path, index) => [path, index]));
+    files.sort((a, b) => (rank.get(a.path) ?? Infinity) - (rank.get(b.path) ?? Infinity) ||
+        a.path.localeCompare(b.path));
+    const hash = createHash("sha256");
+    hash.update(existsSync(join(root, MANIFEST_FILE)) ? readFileSync(join(root, MANIFEST_FILE)) : "");
+    for (const file of files)
+        hash.update(file.path)
+            .update(String(statSync(textfilePath(root, file.path)).mtimeMs))
+            .update(String(file.size));
+    for (const file of translationFiles(root))
+        hash.update(file).update(fileSig(textfilePath(root, file)));
+    const docs = flattenTree(manifest.tree);
+    return {
+        files,
+        layout,
+        revision: hash.digest("hex"),
+        documents: Object.fromEntries(docs.map(({ id }) => [docFile(id, layout), docPath(docs, id)])),
+    };
+};
+export const uploadFile = (root, input) => {
+    if (typeof input.name !== "string" || !managedFile(input.name) || input.name.includes("/"))
+        throw new Error("Invalid file name");
+    if (typeof input.data !== "string")
+        throw new Error("Invalid file content");
+    const data = Buffer.from(input.data, "base64");
+    if (data.length > MAX_FILE_UPLOAD_BYTES)
+        throw new Error("File exceeds 64 MiB");
+    if (data.toString("base64") !== input.data)
+        throw new Error("Invalid file content");
+    const manifest = readManifest(root);
+    if (manifest.errors.length)
+        throw new Error(manifest.errors.join("\n"));
+    const initial = manifest.files?.defaultLayout !== false ? defaultFilePath(input.name) : input.name;
+    const extension = posix.extname(initial);
+    const stem = initial.slice(0, initial.length - extension.length);
+    let file = initial;
+    for (let index = 2; existsSync(textfilePath(root, file)); index++)
+        file = `${stem}-${index}${extension}`;
+    const path = textfilePath(root, file);
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = join(dirname(path), `.upload-${randomUUID()}.tmp`);
+    try {
+        writeFileSync(temp, data, { flag: "wx" });
+        linkSync(temp, path);
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+    return { file };
+};
+const imageDestination = (source) => {
+    let depth = 0;
+    for (let i = source.indexOf("["); i < source.length; i++) {
+        const char = source[i];
+        if (char === "\\") {
+            i++;
+            continue;
+        }
+        if (char === "`") {
+            const marker = /^`+/.exec(source.slice(i))?.[0] ?? "`";
+            const end = source.indexOf(marker, i + marker.length);
+            if (end >= 0) {
+                i = end + marker.length - 1;
+                continue;
+            }
+        }
+        if (char === "[")
+            depth++;
+        if (char === "]" && --depth === 0)
+            return source[i + 1] === "(" ? i + 2 : -1;
+    }
+    return -1;
+};
+/** Rewrite destinations only: examples, labels, titles and code stay byte-for-byte intact. */
+export const rewriteFileLinks = (raw, moves) => {
+    if (!moves.size)
+        return raw;
+    const changes = [];
+    visit(parseMdast(raw), (node) => {
+        if (node.type === "code" && node.lang === "callouth" && node.position) {
+            const block = codeBlockAt(raw, node.position.start.offset ?? 0);
+            const before = block.code.split("\n");
+            const after = rewriteFileLinks(block.code, moves).split("\n");
+            for (const [index, text] of after.entries()) {
+                const from = block.offsets[index];
+                if (text !== before[index] && from !== undefined)
+                    changes.push({ from, to: from + (before[index]?.length ?? 0), text });
+            }
+        }
+        if (node.type !== "image" && node.type !== "link" && node.type !== "definition")
+            return;
+        let file;
+        try {
+            file = parseFileReference(node.url).file.replace(/^(\.\/)+/, "");
+        }
+        catch {
+            return;
+        }
+        if (isRemoteTextfile(file))
+            return;
+        const next = moves.get(file);
+        if (!next)
+            return;
+        const from = node.position?.start.offset;
+        const to = node.position?.end.offset;
+        if (from === undefined || to === undefined)
+            throw new Error(`Cannot update reference: ${node.url}`);
+        const source = raw.slice(from, to);
+        const head = node.type === "definition"
+            ? /^\[[\s\S]*?\]:\s*/.exec(source)?.[0].length
+            : node.type === "image"
+                ? imageDestination(source)
+                : source.indexOf("](", Math.max(0, (node.children.at(-1)?.position?.end.offset ?? from) - from)) + 2;
+        if (!head || head < 2)
+            throw new Error(`Cannot update reference: ${node.url}`);
+        const start = head + (source.slice(head).match(/^\s*/)?.[0].length ?? 0);
+        let end = start;
+        if (source[start] === "<")
+            end = source.indexOf(">", start) + 1;
+        else {
+            let depth = 0;
+            for (; end < source.length; end++) {
+                const ch = source[end];
+                if (ch === "\\") {
+                    end++;
+                    continue;
+                }
+                if (ch === "(")
+                    depth++;
+                if (ch === ")") {
+                    if (!depth)
+                        break;
+                    depth--;
+                }
+                if (/\s/.test(ch ?? ""))
+                    break;
+            }
+        }
+        if (end <= start)
+            throw new Error(`Cannot update reference: ${node.url}`);
+        const check = parseMdast(`[x](${source.slice(start, end)})`).children[0];
+        if (check?.type !== "paragraph" ||
+            check.children[0]?.type !== "link" ||
+            check.children[0].url !== node.url)
+            throw new Error(`Cannot update reference: ${node.url}`);
+        const fragment = node.url.includes("#") ? node.url.slice(node.url.indexOf("#")) : "";
+        changes.push({ from: from + start, to: from + end, text: termFileUrl(next) + fragment });
+    });
+    for (const change of changes.sort((a, b) => b.from - a.from))
+        raw = raw.slice(0, change.from) + change.text + raw.slice(change.to);
+    return raw;
+};
+export const updateFiles = (root, input) => {
+    const snapshot = filesSnapshot(root);
+    if (input.revision !== snapshot.revision)
+        throw new Error("Files changed. Reload before retrying.");
+    const manifest = readManifest(root);
+    const layout = snapshot.layout;
+    const paths = snapshot.files.map((file) => file.path);
+    const moves = new Map();
+    let order = [...paths];
+    if (input.action === "layout") {
+        if (typeof input.enabled !== "boolean")
+            throw new Error("Invalid layout setting");
+        layout.defaultLayout = input.enabled;
+    }
+    else if (input.action === "restructure") {
+        const taken = new Set(paths);
+        for (const file of paths) {
+            if (file.startsWith("themes/"))
+                continue;
+            let target = defaultFilePath(file);
+            if (target === file)
+                continue;
+            const ext = posix.extname(target);
+            const stem = target.slice(0, target.length - ext.length);
+            for (let index = 2; taken.has(target); index++)
+                target = `${stem}-${index}${ext}`;
+            taken.add(target);
+            moves.set(file, target);
+        }
+    }
+    else if (input.action === "rename") {
+        if (typeof input.file !== "string" || !paths.includes(input.file))
+            throw new Error("File not found");
+        if (!localFile(input.name) || input.name.includes("/"))
+            throw new Error("Invalid file name");
+        if (flattenTree(manifest.tree).some(({ id }) => docFile(id, layout) === input.file) &&
+            !isDocumentFileName(input.name))
+            throw new Error("Enter a file name ending in .md");
+        const target = posix.join(posix.dirname(input.file), input.name);
+        if (!managedFile(target))
+            throw new Error("Invalid file name");
+        if (target !== input.file)
+            moves.set(input.file, target);
+    }
+    else if (input.action === "move") {
+        if (!Array.isArray(input.paths) ||
+            !input.paths.length ||
+            input.paths.some((path) => !managedFile(path)) ||
+            typeof input.directory !== "string" ||
+            (input.directory && !managedFile(input.directory)))
+            throw new Error("Invalid move");
+        const selected = input.paths.filter((path, i, all) => !all.some((parent, j) => i !== j && path.startsWith(`${parent}/`)));
+        const directory = input.directory;
+        const picked = paths.filter((path) => selected.some((item) => path === item || path.startsWith(`${item}/`)));
+        if (!picked.length ||
+            selected.some((path) => !picked.some((file) => file === path || file.startsWith(`${path}/`))))
+            throw new Error("File not found");
+        for (const item of selected) {
+            if (directory === item || directory.startsWith(`${item}/`))
+                throw new Error("Cannot move a folder into itself");
+            const target = directory
+                ? `${directory}/${posix.basename(item)}`
+                : posix.basename(item);
+            for (const file of picked.filter((path) => path === item || path.startsWith(`${item}/`))) {
+                const next = target + file.slice(item.length);
+                if (next !== file)
+                    moves.set(file, next);
+            }
+        }
+        order = paths.filter((path) => !picked.includes(path));
+        const before = input.before;
+        const index = before === undefined
+            ? order.length
+            : order.findIndex((path) => path === before || path.startsWith(`${before}/`));
+        if (index < 0)
+            throw new Error("Invalid drop position");
+        order.splice(index, 0, ...picked);
+    }
+    else
+        throw new Error("Unknown file action");
+    for (const [source, target] of [...moves]) {
+        for (const [theme, file] of Object.entries(themeVariants(root, source, themeNames(root))))
+            moves.set(file, `themes/${theme}/${target}`);
+    }
+    const translated = translationFiles(root);
+    for (const language of translationLanguages(root)) {
+        for (const [source, target] of [...moves]) {
+            if (!source.endsWith(".md") || source.startsWith("locales/"))
+                continue;
+            const file = translationFile(source, language);
+            if (translated.includes(file))
+                moves.set(file, translationFile(target, language));
+        }
+    }
+    if (new Set(moves.values()).size !== moves.size)
+        throw new Error("Duplicate destination");
+    for (const target of moves.values()) {
+        const path = textfilePath(root, target);
+        if (existsSync(path))
+            throw new Error(`File already exists: ${target}`);
+    }
+    for (const { id } of flattenTree(manifest.tree)) {
+        const file = docFile(id, layout);
+        if (moves.has(file))
+            layout.documents[id] = moves.get(file);
+        const icon = docIconFile(id, layout);
+        if (moves.has(icon)) {
+            layout.icons ??= {};
+            layout.icons[id] = moves.get(icon);
+        }
+    }
+    layout.order = order.map((file) => moves.get(file) ?? file);
+    const rawManifest = existsSync(join(root, MANIFEST_FILE))
+        ? readFileSync(join(root, MANIFEST_FILE), "utf8")
+        : null;
+    const parsed = parseDocument(rawManifest ?? "docs: []\n");
+    const yaml = isSeq(parsed.contents) ? new Document({ docs: parsed.toJS() }) : parsed;
+    yaml.set("files", layout);
+    if (manifest.icon && moves.has(manifest.icon))
+        yaml.set("icon", moves.get(manifest.icon));
+    const writes = [];
+    const links = new Map(moves);
+    for (const file of [...paths, ...translated].filter((file) => /\.(md|callouth)$/.test(file))) {
+        const base = readFileSync(textfilePath(root, file));
+        const next = rewriteFileLinks(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(base), moves);
+        const data = Buffer.from(next);
+        if (base.equals(data))
+            continue;
+        links.delete(file);
+        const target = moves.get(file) ?? file;
+        writes.push({
+            file: target,
+            data,
+            base: target === file ? base : null,
+            mode: statSync(textfilePath(root, file)).mode,
+        });
+    }
+    writes.push({
+        file: MANIFEST_FILE,
+        base: rawManifest === null ? null : Buffer.from(rawManifest),
+        data: Buffer.from(yaml.toString()),
+    });
+    const originalModes = new Map([...moves.keys()].map((file) => [file, statSync(textfilePath(root, file)).mode]));
+    const originals = new Map([...moves.keys()].map((file) => [
+        file,
+        {
+            signature: fileSig(textfilePath(root, file)),
+            data: links.has(file) ? undefined : readFileSync(textfilePath(root, file)),
+        },
+    ]));
+    const linked = [];
+    const completed = [];
+    const removed = [];
+    try {
+        for (const [source, target] of links) {
+            const destination = textfilePath(root, target);
+            mkdirSync(dirname(destination), { recursive: true });
+            linkSync(textfilePath(root, source), destination);
+            linked.push([source, target]);
+        }
+        for (const write of writes) {
+            const path = textfilePath(root, write.file);
+            mkdirSync(dirname(path), { recursive: true });
+            if (write.base === null)
+                writeFileSync(path, write.data, { flag: "wx", mode: write.mode });
+            else if (!writeTextfile(root, write.file, write.data.toString("utf8"), write.base.toString("utf8")))
+                throw new Error(`File changed: ${write.file}`);
+            completed.push(write);
+        }
+        for (const [file, base] of originals) {
+            if (fileSig(textfilePath(root, file)) !== base.signature)
+                throw new Error(`File changed: ${file}`);
+        }
+        for (const file of originals.keys()) {
+            unlinkSync(textfilePath(root, file));
+            removed.push(file);
+        }
+    }
+    catch (error) {
+        for (const file of removed) {
+            const original = originals.get(file);
+            if (original?.data)
+                writeFileSync(textfilePath(root, file), original.data, {
+                    flag: "wx",
+                    mode: originalModes.get(file),
+                });
+            else
+                linkSync(textfilePath(root, moves.get(file)), textfilePath(root, file));
+        }
+        for (const write of completed.reverse()) {
+            const path = textfilePath(root, write.file);
+            if (!readFileSync(path).equals(write.data))
+                continue;
+            if (write.base === null)
+                unlinkSync(path);
+            else
+                writeFileSync(path, write.base);
+        }
+        for (const [source, target] of linked) {
+            const src = textfilePath(root, source);
+            const dest = textfilePath(root, target);
+            if (existsSync(dest) && statSync(src).ino === statSync(dest).ino)
+                unlinkSync(dest);
+        }
+        throw error;
+    }
+    for (const file of moves.keys()) {
+        let dir = posix.dirname(file);
+        while (dir !== ".") {
+            try {
+                rmdirSync(join(root, dir));
+            }
+            catch {
+                break;
+            }
+            dir = posix.dirname(dir);
+        }
+    }
+    return filesSnapshot(root);
+};

package/dist/compiler/fonts.d.ts

@@ -0,0 +1,10 @@
+export declare const PROJECT_FONTS_DIR = ".dooc/fonts";
+export interface ProjectFont {
+    name: string;
+    family: string;
+    source: string;
+}
+export declare const listProjectFonts: (root: string) => string[];
+export declare const addProjectFont: (root: string, file: string) => string;
+export declare const removeProjectFont: (root: string, name: string) => void;
+export declare const loadProjectFonts: (root: string) => ProjectFont[];

package/dist/compiler/fonts.js

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { basename, extname } from "node:path";
+import { localFile } from "../core/files.js";
+import { textfilePath } from "./textfile.js";
+export const PROJECT_FONTS_DIR = ".dooc/fonts";
+const fontName = (name) => {
+    if (!localFile(name) || name.includes("/") || !/\.(ttf|otf|woff2?)$/i.test(name))
+        throw new Error("Expected a TTF, OTF, WOFF or WOFF2 file name");
+    return name;
+};
+export const listProjectFonts = (root) => {
+    const directory = textfilePath(root, PROJECT_FONTS_DIR);
+    if (!lstatSync(directory, { throwIfNoEntry: false }))
+        return [];
+    return readdirSync(directory, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && /\.(ttf|otf|woff2?)$/i.test(entry.name))
+        .map((entry) => fontName(entry.name))
+        .sort();
+};
+export const addProjectFont = (root, file) => {
+    const name = fontName(basename(file));
+    const data = readFileSync(file);
+    const extension = extname(name).slice(1).toLowerCase();
+    const signature = data.subarray(0, 4).toString("latin1");
+    const signatures = {
+        ttf: ["\x00\x01\x00\x00", "true"],
+        otf: ["OTTO"],
+        woff: ["wOFF"],
+        woff2: ["wOF2"],
+    };
+    if (data.length < (extension === "woff2" ? 48 : extension === "woff" ? 44 : 12) ||
+        !signatures[extension]?.includes(signature) ||
+        (extension.startsWith("woff") && data.readUInt32BE(8) !== data.length))
+        throw new Error(`${name}: invalid font header`);
+    mkdirSync(textfilePath(root, PROJECT_FONTS_DIR), { recursive: true });
+    // Exclusive creation preserves a registered font until it is explicitly removed.
+    writeFileSync(textfilePath(root, `${PROJECT_FONTS_DIR}/${name}`), data, { flag: "wx" });
+    return `${PROJECT_FONTS_DIR}/${name}`;
+};
+export const removeProjectFont = (root, name) => {
+    if (!listProjectFonts(root).includes(fontName(name)))
+        throw new Error(`Font not found: ${name}`);
+    unlinkSync(textfilePath(root, `${PROJECT_FONTS_DIR}/${name}`));
+};
+export const loadProjectFonts = (root) => listProjectFonts(root).map((name) => {
+    const data = readFileSync(textfilePath(root, `${PROJECT_FONTS_DIR}/${name}`));
+    const hash = createHash("sha256").update(data).digest("hex").slice(0, 16);
+    return {
+        name,
+        family: `dooc-font-${hash}`,
+        source: `url(data:font/${extname(name).slice(1).toLowerCase()};base64,${data.toString("base64")})`,
+    };
+});

package/dist/compiler/format.d.ts

@@ -0,0 +1 @@
+export declare function formatMarkdown(body: string): string;

package/dist/compiler/format.js

@@ -0,0 +1,42 @@
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkStringify from "remark-stringify";
+import stringWidth from "string-width";
+import { unified } from "unified";
+import { parseMdast } from "./dialect.js";
+export function formatMarkdown(body) {
+    if (!body.trim())
+        return "";
+    const lines = body.replaceAll("\r\n", "\n").split("\n");
+    // Semantic code fences carry their own syntax; preserve their source verbatim.
+    const preserve = (node) => {
+        const position = node.position;
+        if (!position)
+            throw new Error("Missing source position for Markdown formatting");
+        const raw = lines.slice(position.start.line - 1, position.end.line);
+        const indent = position.start.column - 1;
+        return raw
+            .map((line, index) => index === 0 ? line.slice(indent) : line.replace(new RegExp(`^ {0,${indent}}`), ""))
+            .join("\n");
+    };
+    const printer = unified()
+        .use(remarkFrontmatter)
+        .use(remarkGfm, { stringLength: stringWidth })
+        .use(remarkStringify, {
+        bullet: "-",
+        listItemIndent: "one",
+        fences: true,
+        handlers: {
+            code: (node, parent) => {
+                // Nested blocks need the printer to reconstruct list/quote prefixes.
+                if (parent?.type !== "root") {
+                    const marker = "`".repeat(Math.max(3, ...[...node.value.matchAll(/`+/g)].map((match) => match[0].length + 1)));
+                    return `${marker}${node.lang ?? ""}${node.meta ? ` ${node.meta}` : ""}\n${node.value}\n${marker}`;
+                }
+                return preserve(node);
+            },
+        },
+    });
+    const formatted = printer.stringify(parseMdast(body));
+    return body.includes("\r\n") ? formatted.replaceAll("\n", "\r\n") : formatted;
+}

package/dist/compiler/from-mdast.d.ts

@@ -0,0 +1,16 @@
+import type { Root } from "mdast";
+import { type Block, type TocEntry } from "../core/blocks.js";
+import type { PreviewSettings } from "../core/previewers.js";
+/**
+ * Dialect mdast → normalized Block[] + TOC. Heading slugs are made unique within the document.
+ * `raw` is the whole source document, used to validate semantic code fences.
+ * `lines` holds the source start line at the same index as blocks (1-indexed relative to the
+ * whole raw, as root is).
+ * Only the edit tool's "body element ↔ source line" mapping uses it (the rendering model
+ * is unaffected).
+ */
+export declare const toBlocks: (root: Root, raw: string, settings?: PreviewSettings, file?: string) => {
+    blocks: Block[];
+    toc: TocEntry[];
+    lines: number[];
+};