@dooc-dev/dooc 0.0.0-stage → 0.0.2

package/dist/compiler/bundle-urls.d.ts

@@ -0,0 +1,3 @@
+import type { ZipEntry } from "./zip.js";
+/** Snapshot embedded URLs and their declarative assets without changing the source bundle. */
+export declare const embedBundleUrls: (root: string, entries: readonly ZipEntry[]) => Promise<ZipEntry[]>;

package/dist/compiler/bundle-urls.js

@@ -0,0 +1,294 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { parseFragment, serialize } from "parse5";
+import postcss from "postcss";
+import valueParser from "postcss-value-parser";
+import { embeddedImages, parseMdast } from "../core/markdown.js";
+import { isRemoteTextfile } from "../core/textfile.js";
+import { collectRefs } from "./dialect.js";
+import { readManifest } from "./manifest.js";
+import { fetchPublicFile } from "./public-file.js";
+import { textfilePath } from "./textfile.js";
+import { remoteTextfileSource } from "./textfile-remote.js";
+const types = {
+    html: "text/html",
+    htm: "text/html",
+    css: "text/css",
+    svg: "image/svg+xml",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    json: "application/json",
+};
+const extension = (source) => posix.extname(new URL(source).pathname).slice(1).toLowerCase();
+const decode = (data) => new TextDecoder("utf-8", { fatal: true }).decode(data);
+/** Snapshot embedded URLs and their declarative assets without changing the source bundle. */
+export const embedBundleUrls = async (root, entries) => {
+    const result = new Map(entries.map((entry) => [entry.name, { ...entry }]));
+    const figures = new Set(entries
+        .filter((entry) => /\.(md|callouth)$/.test(entry.name))
+        .flatMap((entry) => collectRefs(parseMdast(decode(entry.data))).figures));
+    const siteIcon = readManifest(root).icon;
+    if (siteIcon)
+        figures.add(siteIcon);
+    const cache = new Map();
+    const sources = new Map();
+    const pending = new Set();
+    let total = 0;
+    let downloads = 0;
+    const keyOf = (source, base) => {
+        const url = new URL(source, base);
+        if (url.protocol !== "https:" &&
+            !(url.protocol === "bundle:" && new URL(base).protocol === "bundle:"))
+            throw new Error(`Cannot bundle resource: ${url.href} (public HTTPS required)`);
+        if (url.username || url.password || url.port)
+            throw new Error(`Cannot bundle resource with credentials or a custom port: ${url.origin}`);
+        return url;
+    };
+    const resource = async (url, stylesheet = true) => {
+        url = new URL(url);
+        url.hash = "";
+        const key = url.href;
+        const cacheKey = `${stylesheet}:${key}`;
+        const cached = cache.get(cacheKey);
+        if (cached)
+            return cached;
+        if (pending.has(key))
+            throw new Error(`Circular embedded resource: ${key}`);
+        pending.add(key);
+        try {
+            let source = sources.get(key);
+            if (!source) {
+                if (url.protocol === "https:" && ++downloads > 256)
+                    throw new Error("Bundle exceeds 256 remote assets");
+                let type = "";
+                const data = url.protocol === "bundle:"
+                    ? readFileSync(textfilePath(root, decodeURIComponent(url.pathname.slice(1))))
+                    : await fetchPublicFile(url.href, (value) => {
+                        type = value.split(";")[0]?.trim().toLowerCase() ?? "";
+                    });
+                if (url.protocol === "https:")
+                    total += data.length;
+                if (total > 64 * 1024 * 1024)
+                    throw new Error("Embedded assets exceed 64 MiB");
+                if (!type || type === "application/octet-stream")
+                    type = types[extension(key)] ?? "text/plain";
+                source = { data, type };
+                sources.set(key, source);
+            }
+            const { data, type } = source;
+            let output = data;
+            if (type === "text/html" || type === "image/svg+xml")
+                output = Buffer.from(await markup(decode(data), key));
+            else if (type === "text/css" && stylesheet)
+                output = Buffer.from(await css(decode(data), key));
+            const asset = { data: output, type };
+            cache.set(cacheKey, asset);
+            return asset;
+        }
+        catch (error) {
+            throw new Error(`${key}: ${error instanceof Error ? error.message : error}`);
+        }
+        finally {
+            pending.delete(key);
+        }
+    };
+    const inline = async (source, base) => {
+        if (!source || source.startsWith("#") || source.startsWith("data:"))
+            return source;
+        const url = keyOf(source, base);
+        const asset = await resource(url);
+        return `data:${asset.type};base64,${asset.data.toString("base64")}${url.hash}`;
+    };
+    const css = async (source, base) => {
+        const tree = postcss.parse(source);
+        const values = [];
+        tree.walkDecls((node) => {
+            values.push({
+                value: node.value,
+                set: (value) => {
+                    node.value = value;
+                },
+            });
+        });
+        tree.walkAtRules((node) => {
+            values.push({
+                value: node.params,
+                set: (value) => {
+                    node.params = value;
+                },
+                imports: node.name.toLowerCase() === "import",
+            });
+        });
+        for (const item of values) {
+            const parsed = valueParser(item.value);
+            const urls = [];
+            parsed.walk((node) => {
+                if (node.type === "function" && node.value.toLowerCase() === "url") {
+                    urls.push(node);
+                    return false;
+                }
+                if (node.type === "function" && /^(?:-webkit-)?image-set$/i.test(node.value))
+                    urls.push(...node.nodes.filter((child) => child.type === "string"));
+            });
+            const first = parsed.nodes.find((node) => node.type !== "space" && node.type !== "comment");
+            if (item.imports && first?.type === "string")
+                urls.push(first);
+            for (const node of urls) {
+                const source = node.type === "function"
+                    ? valueParser.stringify(node.nodes).replace(/^(['"])(.*)\1$/, "$2")
+                    : node.value;
+                if (source.includes("\\"))
+                    throw new Error("Escaped CSS resource URLs are not supported in static bundles");
+                const next = await inline(source, base);
+                if (node.type === "function")
+                    node.nodes = [
+                        {
+                            type: "string",
+                            quote: '"',
+                            value: next,
+                            sourceIndex: 0,
+                            sourceEndIndex: 0,
+                        },
+                    ];
+                else
+                    node.value = next;
+            }
+            item.set(parsed.toString());
+        }
+        return tree.toString();
+    };
+    const srcset = async (source, base) => {
+        const candidates = [];
+        let rest = source;
+        while (rest.trim()) {
+            rest = rest.replace(/^[\s,]+/, "");
+            const token = /^\S+/.exec(rest)?.[0];
+            if (!token)
+                break;
+            rest = rest.slice(token.length);
+            const url = token.replace(/,+$/, "");
+            const descriptor = token.endsWith(",") ? "" : (/^[^,]*/.exec(rest)?.[0] ?? "");
+            if (!token.endsWith(","))
+                rest = rest.slice(descriptor.length).replace(/^,/, "");
+            candidates.push(`${await inline(url, base)}${descriptor}`);
+        }
+        return candidates.join(", ");
+    };
+    const markup = async (source, base) => {
+        const tree = parseFragment(source);
+        const walk = async (parent) => {
+            for (const node of [...parent.childNodes]) {
+                if (!("tagName" in node))
+                    continue;
+                const attr = (name) => node.attrs.find((item) => item.name === name)?.value;
+                const href = attr("href");
+                if (node.tagName === "base" && href)
+                    base = keyOf(href, base).href;
+                if (["script", "base"].includes(node.tagName) ||
+                    (node.tagName === "meta" && attr("http-equiv"))) {
+                    parent.childNodes.splice(parent.childNodes.indexOf(node), 1);
+                    continue;
+                }
+                node.attrs = node.attrs.filter((item) => !/^on/i.test(item.name) &&
+                    ![
+                        "ping",
+                        "integrity",
+                        "crossorigin",
+                        "nonce",
+                        "formaction",
+                        "action",
+                    ].includes(item.name));
+                if (node.tagName === "link" && !/^(stylesheet|icon)$/i.test(attr("rel") ?? "")) {
+                    parent.childNodes.splice(parent.childNodes.indexOf(node), 1);
+                    continue;
+                }
+                for (const item of node.attrs) {
+                    if (item.name === "style")
+                        item.value = await css(item.value, base);
+                    else if (item.name === "srcdoc")
+                        item.value = await markup(item.value, base);
+                    else if (item.name === "srcset" || item.name === "imagesrcset")
+                        item.value = await srcset(item.value, base);
+                    else if (["src", "poster", "background"].includes(item.name) ||
+                        (item.name === "data" && node.tagName === "object") ||
+                        (item.name === "href" && !["a", "area"].includes(node.tagName)))
+                        item.value = await inline(item.value, base);
+                    else if (item.name === "href" && !item.value.startsWith("#")) {
+                        const url = new URL(item.value, base);
+                        item.value = /^(https?:|mailto:)$/.test(url.protocol) ? url.href : "#";
+                    }
+                }
+                if (node.tagName === "style") {
+                    for (const child of node.childNodes)
+                        if ("value" in child)
+                            child.value = await css(child.value, base);
+                }
+                if (node.tagName === "iframe")
+                    node.attrs.push({ name: "sandbox", value: "" });
+                await walk("content" in node ? node.content : node);
+            }
+        };
+        await walk(tree);
+        return serialize(tree);
+    };
+    for (const entry of entries) {
+        if (/\.(svg|html?)$/i.test(entry.name) &&
+            (figures.has(entry.name) ||
+                /^(?:figures|icons)\//.test(entry.name) ||
+                (entry.name.startsWith("themes/") &&
+                    [...figures].some((file) => entry.name.endsWith(`/${file}`))))) {
+            const base = `bundle:///${entry.name.split("/").map(encodeURIComponent).join("/")}`;
+            const data = await resource(new URL(base));
+            result.set(entry.name, { name: entry.name, data: data.data });
+        }
+        if (!/\.(md|callouth)$/.test(entry.name))
+            continue;
+        let source = decode(entry.data);
+        const changes = [];
+        const images = embeddedImages(parseMdast(source));
+        for (const image of images) {
+            if (!isRemoteTextfile(image.url))
+                continue;
+            const remote = remoteTextfileSource(image.url);
+            if (remote.ref)
+                throw new Error("Git URL embeds require a public HTTPS file URL");
+            const url = keyOf(remote.url, image.url);
+            const asset = await resource(url, false);
+            const ext = Object.entries(types).find(([, type]) => type === asset.type)?.[0] ??
+                (extension(url.href) || "txt");
+            const name = `files/bundle/${createHash("sha256").update(url.href).digest("hex")}.${ext}`;
+            const data = asset.type === "text/html"
+                ? Buffer.from(`<!--fig\ntitle: ${url.hostname}\n-->\n${decode(asset.data)}`)
+                : asset.data;
+            const existing = result.get(name);
+            if (existing && !existing.data.equals(data))
+                throw new Error(`Bundle resource path is already in use: ${name}`);
+            result.set(name, { name, data });
+            const hash = new URL(image.url).hash;
+            const range = /^#(?:L\d+(?:-L\d+)?|H)$/.test(hash) ? hash : "";
+            const start = image.position?.start.offset, end = image.position?.end.offset;
+            if (start === undefined || end === undefined)
+                throw new Error(`Cannot rewrite embed: ${image.url}`);
+            const alt = (image.alt ?? "").replace(/[\\[\]]/g, "\\$&");
+            changes.push({
+                start,
+                end,
+                value: `![${alt}](${name}${range}${image.title ? ` "${image.title.replace(/[\\"]/g, "\\$&")}"` : ""})`,
+            });
+        }
+        for (const change of changes.sort((a, b) => b.start - a.start))
+            source = source.slice(0, change.start) + change.value + source.slice(change.end);
+        result.set(entry.name, { name: entry.name, data: Buffer.from(source) });
+    }
+    return [...result.values()];
+};

package/dist/compiler/bundle.d.ts

@@ -0,0 +1,2 @@
+import type { ZipEntry } from "./zip.js";
+export declare const bundleEntries: (root: string) => ZipEntry[];

package/dist/compiler/bundle.js

@@ -0,0 +1,100 @@
+// A bundle contains dooc.yaml and its managed source files, assets and local configuration.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, posix } from "node:path";
+import { MANIFEST_FILE } from "../core/content-metadata.js";
+import { isRemoteTextfile } from "../core/textfile.js";
+import { CODE_LANGUAGES_DIR } from "./code-languages.js";
+import { CONFIG_FILE } from "./config.js";
+import { collectRefs, parseDoc } from "./dialect.js";
+import { projectFiles } from "./files.js";
+import { PROJECT_FONTS_DIR } from "./fonts.js";
+import { readManifest } from "./manifest.js";
+import { readTextfile, textfilePath } from "./textfile.js";
+const LAYOUT_DIRS = [
+    "content",
+    "figures",
+    "icons",
+    "locales",
+    "themes",
+    ".dooc/editor-tools",
+    PROJECT_FONTS_DIR,
+];
+export const bundleEntries = (root) => {
+    const entries = [
+        ...[CONFIG_FILE, MANIFEST_FILE]
+            .filter((name) => existsSync(join(root, name)))
+            .map((name) => ({ name, data: readFileSync(join(root, name)) })),
+        ...(existsSync(join(root, CODE_LANGUAGES_DIR))
+            ? readdirSync(join(root, CODE_LANGUAGES_DIR))
+                .filter((file) => !file.startsWith(".") &&
+                file.endsWith(".json") &&
+                statSync(join(root, CODE_LANGUAGES_DIR, file)).isFile())
+                .sort()
+                .map((file) => ({
+                name: `${CODE_LANGUAGES_DIR}/${file}`,
+                data: readFileSync(join(root, CODE_LANGUAGES_DIR, file)),
+            }))
+            : []),
+        ...LAYOUT_DIRS.filter((dir) => existsSync(join(root, dir))).flatMap((dir) => readdirSync(join(root, dir), { recursive: true, encoding: "utf8" })
+            .filter((rel) => !rel
+            .replaceAll("\\", "/")
+            .split("/")
+            .some((seg) => seg.startsWith(".")))
+            .map((rel) => `${dir}/${rel.replaceAll("\\", "/")}`)
+            .filter((name) => statSync(join(root, name)).isFile())
+            .sort()
+            .map((name) => ({ name, data: readFileSync(textfilePath(root, name)) }))),
+    ];
+    const known = new Set(entries.map((entry) => entry.name));
+    const layout = readManifest(root).files;
+    const mapped = new Set([...(layout?.order ?? []), ...Object.values(layout?.documents ?? {})]);
+    for (const file of projectFiles(root))
+        if ((file.path.startsWith("files/") || mapped.has(file.path)) && !known.has(file.path))
+            entries.push({ name: file.path, data: readFileSync(join(root, file.path)) });
+    const bodies = entries
+        .filter((entry) => /\.(md|callouth)$/.test(entry.name))
+        .map((entry) => entry.data.toString("utf8"));
+    const included = new Set(entries.map((entry) => entry.name));
+    const { icon } = readManifest(root);
+    if (icon && !included.has(posix.normalize(icon))) {
+        const name = posix.normalize(icon);
+        entries.push({ name, data: Buffer.from(readTextfile(root, icon), "utf8") });
+        included.add(name);
+    }
+    for (const body of bodies) {
+        const refs = collectRefs(parseDoc(body).root);
+        for (const file of refs.figures) {
+            if (included.has(file))
+                continue;
+            try {
+                entries.push({ name: file, data: readFileSync(textfilePath(root, file)) });
+                included.add(file);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        for (const file of [...refs.textfiles, ...refs.terms]) {
+            if (isRemoteTextfile(file))
+                continue;
+            let text;
+            try {
+                text = readTextfile(root, file);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            const name = posix.normalize(file);
+            if (included.has(name))
+                continue;
+            entries.push({ name, data: Buffer.from(text, "utf8") });
+            included.add(name);
+            if (name.endsWith(".callouth"))
+                bodies.push(text);
+        }
+    }
+    return entries;
+};

package/dist/compiler/check-prose.d.ts

@@ -0,0 +1,11 @@
+import type { Root } from "mdast";
+import type { CheckDiagnostic } from "./check-types.js";
+export interface ProseSegment {
+    text: string;
+    line: number;
+    column: number;
+}
+/** Extract rendered prose, leaving code examples, URLs and front-matter syntax out. */
+export declare const markdownProse: (root: Root, lineOffset?: number) => ProseSegment[];
+export declare const assetProse: (file: string, raw: string) => ProseSegment[] | undefined;
+export declare const checkProse: (segments: ProseSegment[], language: string) => Omit<CheckDiagnostic, "file" | "check">[];

package/dist/compiler/check-prose.js

@@ -0,0 +1,138 @@
+import { francAll } from "franc";
+import { visit } from "unist-util-visit";
+import { parseMdast } from "../core/markdown.js";
+import { parseContentSource } from "./code-blocks.js";
+/** Extract rendered prose, leaving code examples, URLs and front-matter syntax out. */
+export const markdownProse = (root, lineOffset = 0) => {
+    const segments = [];
+    visit(root, (node) => {
+        const line = (node.position?.start.line ?? 1) + lineOffset;
+        const column = node.position?.start.column ?? 1;
+        if (["paragraph", "heading", "tableCell"].includes(node.type)) {
+            const parts = [];
+            visit(node, (child, _index, parent) => {
+                if (child.type === "text") {
+                    if (parent?.type === "link" && child.value === parent.url)
+                        return;
+                    parts.push(child.value);
+                }
+                if (child.type === "image" && child.alt)
+                    parts.push(child.alt);
+            });
+            if (parts.length)
+                segments.push({ text: parts.join(" "), line, column });
+        }
+        if (node.type !== "code")
+            return;
+        if (node.lang === "callouth") {
+            if (node.meta)
+                segments.push({ text: node.meta, line, column });
+            segments.push(...markdownProse(parseMdast(node.value), line));
+            return;
+        }
+        const parsed = parseContentSource(node.lang ?? "", node.value, "check");
+        if (parsed && node.meta)
+            segments.push({ text: node.meta, line, column });
+        for (const block of parsed?.blocks ?? []) {
+            const parts = [];
+            if (block.type === "term")
+                parts.push(block.entry.name, block.entry.definition, block.entry.description ?? "");
+            if (block.type === "graph")
+                parts.push(...block.graph.nodes.map((n) => (n.label === n.id ? "" : n.label)), ...block.graph.edges.map((edge) => edge.label ?? ""), ...block.graph.regions.map((region) => region.label ?? ""));
+            if (block.type === "schemaGraph")
+                parts.push(...block.graph.groups.map((group) => group.label ?? ""), ...block.graph.tables.flatMap((table) => table.notes));
+            if (parts.length)
+                segments.push({ text: parts.join(" "), line: line + 1, column: 1 });
+        }
+    });
+    return segments;
+};
+export const assetProse = (file, raw) => {
+    if (/\.(md|callouth)$/.test(file))
+        return markdownProse(parseMdast(raw));
+    const language = /\.(termth|graphth|schemath)$/.exec(file)?.[1];
+    if (language)
+        return markdownProse(parseMdast(`\`\`\`${language}\n${raw}\n\`\`\``), -1);
+    if (/\.(txt|html|svg)$/.test(file)) {
+        // shortcut: markup text is heuristic, use an XML/HTML parser if exact element ranges are needed.
+        const text = file.endsWith(".txt")
+            ? raw
+            : raw
+                .replace(/<!--[\s\S]*?-->/g, " ")
+                .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, " ")
+                .replace(/<[^>]*>/g, " ")
+                .replace(/&(?:#\d+|#x[\da-f]+|[a-z]+);/gi, " ");
+        return [{ text, line: 1, column: 1 }];
+    }
+    return undefined;
+};
+// Franc reports individual languages for several commonly configured macrolanguages.
+const macroLanguages = {
+    cmn: "zho",
+    arb: "ara",
+    pes: "fas",
+    ekk: "est",
+    swh: "swa",
+    azj: "aze",
+    uzn: "uzb",
+    pbu: "pus",
+    npi: "nep",
+    khk: "mon",
+    lvs: "lav",
+};
+export const checkProse = (segments, language) => {
+    const findings = [];
+    let checked = 0;
+    const inspect = ({ text, line, column }) => {
+        const clean = text
+            .replace(/https?:\/\/\S+/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        const letters = clean.match(/\p{L}/gu)?.length ?? 0;
+        const minimum = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u.test(clean)
+            ? 10
+            : 40;
+        if (letters < minimum)
+            return;
+        const ranked = francAll(clean, { minLength: minimum });
+        const detected = ranked[0]?.[0];
+        if (!detected || detected === "und")
+            return;
+        checked++;
+        const matches = (code) => code === language || macroLanguages[code] === language;
+        if (matches(detected))
+            return;
+        // Distance scores are relative rankings, not probabilities; near ties are inconclusive.
+        if (ranked.some(([code, score]) => matches(code) && score >= 0.9))
+            return;
+        findings.push({
+            code: "LANGUAGE_SUSPECT",
+            severity: "warning",
+            message: `Prose appears to be ${macroLanguages[detected] ?? detected}; expected ${language}. Language detection is heuristic.`,
+            line,
+            column,
+            language,
+            detectedLanguage: macroLanguages[detected] ?? detected,
+        });
+    };
+    const sentences = new Intl.Segmenter(undefined, { granularity: "sentence" });
+    // Franc samples at most 2048 characters; bounded chunks also check the end of long prose.
+    for (const segment of segments)
+        for (const sentence of sentences.segment(segment.text))
+            for (const text of sentence.segment.match(/[\s\S]{1,1024}/g) ?? [])
+                inspect({ ...segment, text });
+    if (!checked && segments.length)
+        inspect({
+            text: segments.map((s) => s.text).join(" "),
+            line: segments[0]?.line ?? 1,
+            column: 1,
+        });
+    if (!checked)
+        findings.push({
+            code: "LANGUAGE_UNDETERMINED",
+            severity: "info",
+            message: "Not enough identifiable prose to check the language.",
+            language,
+        });
+    return findings;
+};

package/dist/compiler/check-types.d.ts

@@ -0,0 +1,44 @@
+export declare const CHECK_KINDS: readonly ["render", "languages", "themes"];
+export type CheckKind = (typeof CHECK_KINDS)[number];
+export interface CheckOptions {
+    /** Run only these checks; omitted means all checks. Manifest validity is always checked. */
+    only?: readonly CheckKind[];
+    /** Permit identical SVG files across themes, including symlinks and byte copies. */
+    allowSharedSvg?: boolean;
+    warningsAsErrors?: boolean;
+}
+export type CheckCode = "INVOCATION_INVALID" | "CHECK_FAILED" | "MANIFEST_INVALID" | "RENDER_INVALID" | "FILE_MISSING" | "FILE_UNREADABLE" | "DOCUMENT_INVALID" | "ASSET_INVALID" | "LANGUAGE_INVALID" | "LANGUAGE_UNDECLARED" | "TRANSLATION_MISSING" | "TRANSLATION_ORPHAN" | "TRANSLATION_IDENTICAL" | "LANGUAGE_MISMATCH" | "LANGUAGE_SUSPECT" | "LANGUAGE_UNDETERMINED" | "LANGUAGE_UNCHECKED" | "THEME_INVALID" | "THEME_UNDECLARED" | "THEME_VARIANT_MISSING" | "THEME_VARIANT_ORPHAN" | "THEME_CONTENT_IDENTICAL" | "REMOTE_UNCHECKED";
+export interface CheckDiagnostic {
+    check: CheckKind | "config";
+    code: CheckCode;
+    severity: "error" | "warning" | "info";
+    message: string;
+    /** Path relative to report.root; lines and columns are one-based. */
+    file: string;
+    line?: number;
+    column?: number;
+    documentId?: string;
+    sourceFile?: string;
+    relatedFile?: string;
+    /** Expected language, normalized to ISO 639-3. */
+    language?: string;
+    detectedLanguage?: string;
+    theme?: string;
+}
+export interface CheckReport {
+    schemaVersion: 1;
+    root: string;
+    /** Checks actually requested, so a partial report cannot be mistaken for a full audit. */
+    checks: CheckKind[];
+    languages: string[];
+    themes: string[];
+    /** Sorted deterministically by file, line, code, language and theme. */
+    diagnostics: CheckDiagnostic[];
+    summary: {
+        errors: number;
+        warnings: number;
+        info: number;
+    };
+    /** 0 = passed, 1 = findings failed policy, 2 = invocation or execution failed. */
+    exitCode: 0 | 1 | 2;
+}

package/dist/compiler/check-types.js

@@ -0,0 +1 @@
+export const CHECK_KINDS = ["render", "languages", "themes"];

package/dist/compiler/check.d.ts

@@ -0,0 +1,5 @@
+import { type CheckOptions, type CheckReport } from "./check-types.js";
+export type { CheckCode, CheckDiagnostic, CheckKind, CheckOptions, CheckReport, } from "./check-types.js";
+export { CHECK_KINDS } from "./check-types.js";
+/** Read-only, offline consistency audit. Content errors are returned, never written or repaired. */
+export declare const checkSite: (root: string, options?: CheckOptions) => CheckReport;