@wgtechlabs/mdd-engine 0.1.0-dev.3c34eeb

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Waren Gonzaga, WG Technology Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# mdd-engine
+
+The headless Markdown documentation compiler behind mdd. Give it a local project; get validated pages, navigation, assets, and article HTML that any frontend can consume.
+
+Built with TypeScript and Bun. Runs on Node.js 22, 24, and 26 without Bun. The default is the latest Node LTS, currently pinned to **24.21.0**.
+
+> Build Flow's default channels publish development, PR, and manual preview packages alongside regular releases to npm and GitHub Packages. See [build channels and releasing](docs/RELEASING.md).
+
+## A documentation project
+
+```text
+my-project/
+  mdd/
+    config.json           # optional
+    contents/
+      index.md            # required homepage
+      get-started/
+        installation.md
+      assets/
+        logo.png
+    themes/
+      custom/
+        theme.css
+        theme.js          # optional; engine never executes it
+```
+
+Ordinary Markdown works without configuration. Folder names become routes and navigation groups. For example, `get-started/installation.md` becomes `/get-started/installation/`; a folder's `index.md` becomes its landing page.
+
+```json
+{
+  "title": "My Project",
+  "paths": { "contents": "./contents", "themes": "./themes" },
+  "theme": "custom"
+}
+```
+
+All settings are optional. Custom paths are relative to `mdd/config.json` and must stay within the checkout. Selecting a custom theme requires its `theme.css`. The engine returns theme file locations for the website layer to apply. Plugin loading is deferred.
+
+## Compile without a website
+
+Install the regular package with `bun add @wgtechlabs/mdd-engine`. After a successful preview publication, use `bun add @wgtechlabs/mdd-engine@dev` for development builds or `bun add @wgtechlabs/mdd-engine@pr` for PRs targeting `dev`. Preview tags track the most recently published package in their channel; install an exact version to test a particular PR. You can also install a locally packed copy.
+
+In your Node project:
+
+```js
+import { compileProject } from '@wgtechlabs/mdd-engine';
+
+const result = await compileProject({
+  projectDir: '/absolute/path/to/my-project',
+  mddDir: 'mdd',
+  basePath: '/docs/'
+});
+
+if (!result.site) {
+  console.error(result.diagnostics);
+  process.exitCode = 1;
+} else {
+  console.log(result.site.pages[0].html);
+}
+```
+
+`site` is absent whenever authoring errors exist. Diagnostics contain a stable code, severity, message, and source location where available. Unexpected filesystem failures reject the promise with context. Identical inputs produce identical output.
+
+Excessive Markdown nesting that exceeds the runtime's call stack produces a `CONTENT_TOO_DEEP` diagnostic identifying the source file.
+
+The result includes:
+
+- `pages`: source, route, public URL, title, description, article HTML, readable Markdown, headings, and navigation metadata.
+- `navigation`: sorted folder/page tree, with optional landing URLs.
+- `assets`: referenced content files with checkout-relative sources, documentation-root-relative destinations, and public URLs.
+- `theme`: the built-in default or selected theme file locations.
+
+Paths in the model use forward slashes. Resolve sources against the same `projectDir` used to compile. Asset destinations are filesystem paths, while asset URLs and page routes are URL-encoded. Decode page-route segments when deriving output directories. Prefix asset destinations with the documentation output directory when exporting; do not prefix them with a GitHub repository name a second time. The engine emits no files and starts no server.
+
+## Markdown and components
+
+Supported Markdown includes headings, lists, code fences, links, images, GFM tables, task lists, and strikethrough. Optional YAML frontmatter supports `title`, `description`, `navTitle`, and finite numeric `order`:
+
+```markdown
+---
+title: Install mdd
+navTitle: Installation
+order: 1
+---
+# Installation
+
+> [!NOTE]
+> **Before you start**
+>
+> You need a local documentation project.
+
+:::details[More information]
+Ordinary **Markdown** works inside components.
+:::
+```
+
+Use GitHub-style alerts with `NOTE`, `TIP`, `IMPORTANT`, `WARNING`, or `CAUTION`. Put the exact uppercase marker on the opening line of a blockquote at the document root; nested blockquotes remain ordinary quotes. Alerts become semantic `aside` elements with `mdd-alert` and `mdd-<type>` classes. Their readable Markdown preserves the `> [!TYPE]` marker. The engine supplies meaning and labels; the reader composes the article, and themes supply icons and colors.
+
+`:::details[More information]` remains supported and becomes `details`/`summary`; its label is optional, attributes are errors, and its readable Markdown uses a blockquote with a bold label. The old `:::note`, `:::tip`, and `:::warning` directives now fail with a `REMOVED_COMPONENT` migration diagnostic. See [alerts and migration](docs/ALERTS.md) for all five types, theme hooks, and how to preserve custom titles and bodies.
+
+Title precedence is frontmatter title, first H1, then readable filename. Navigation uses `navTitle` when supplied. Explicit `order` sorts first; remaining siblings sort deterministically by label and path.
+
+Local `.md` links, extensionless routes, reference links, and images resolve from their source document. A leading slash addresses the documentation root. `basePath` prefixes public links, including `/docs/` and `/repository/docs/`. When a file-style URL matches both an existing supported asset and a page route, the asset wins: `chart.png` selects the image, while `/chart.png/` explicitly selects the page. If no regular asset exists, dotted page routes still resolve. External links are preserved without network requests. Headings have `mdd-`-prefixed GitHub-style slugs; author links such as `#installation` are rewritten to `#mdd-installation`. Duplicate headings receive `-1`, `-2`, and subsequent suffixes.
+
+Reference definitions follow Markdown's first-definition-wins rule. Unused definitions and unreferenced footnotes are omitted from normalized output and do not contribute assets, headings, or link-validation errors. Referenced footnotes, including notes reached through other notes, retain their content and validation.
+
+## Content boundaries
+
+Raw HTML, executable URL schemes, path escapes, unknown configuration, missing local targets, and route collisions fail compilation. MDX is not evaluated; expressions are inert Markdown text, and JSX-style HTML is rejected. Hidden/sensitive paths are excluded. Content discovery rejects symlinks to avoid aliases and traversal; configured roots are resolved and checked against the checkout. Source files must remain stable while compilation and export run.
+
+Referenced content assets are limited to PNG, JPEG, GIF, WebP, AVIF, ICO, PDF, and plain text. SVG, HTML, JavaScript, and CSS are not content assets in this first version. Custom theme CSS/JavaScript is declared separately and must be treated as trusted by the website layer. Asset bytes are not transformed or sanitized; hosts should serve correct media types with `nosniff` and downloads with suitable disposition.
+
+Generated paths `_assets/`, `_mdd/`, `markdown/`, `mdd-build.json`, `llms.txt`, `robots.txt`, `sitemap.xml`, and `404.html` are reserved. Keep generated output outside the content root.
+
+A complete [example project](examples/basic/mdd/contents/index.md) is included under `examples/basic`. Pass that directory as `projectDir` to compile it.
+
+## Develop
+
+```sh
+nvm use
+bun install --frozen-lockfile
+bun run check
+bun run coverage
+bun audit
+```
+
+`bun run build` emits Node ESM and TypeScript declarations to `dist/`. `bun run smoke` creates a package archive, installs it into an isolated consumer, and runs it with the current Node binary. It checks that Bun is unavailable inside the consumer and that all three base-path fixtures compile. On POSIX systems, `MDD_TEST_NODE_BINARIES` can contain colon-separated Node binary paths to exercise the same archive across versions.
+
+Follow [Clean Workflow](AGENTS.md), [contributing](CONTRIBUTING.md), and the [engine contract](docs/SPEC.md). See [verification](docs/VERIFICATION.md) for the checks performed during bootstrap.
+
+## License
+
+Licensed under the [MIT License](LICENSE).

package/dist/alerts.d.ts

@@ -0,0 +1,8 @@
+import type { Root } from "mdast";
+declare module "mdast" {
+    interface TextData {
+        mddAlertMarker?: true;
+    }
+}
+/** Recognize alerts only at the document root, using unescaped source syntax. */
+export declare function transformAlerts(tree: Root, source: string): void;

package/dist/alerts.js

@@ -0,0 +1,56 @@
+/** Recognize alerts only at the document root, using unescaped source syntax. */
+export function transformAlerts(tree, source) {
+    for (const node of tree.children) {
+        if (node.type !== "blockquote")
+            continue;
+        const paragraph = node.children[0];
+        const first = paragraph?.type === "paragraph" ? paragraph.children[0] : undefined;
+        const offset = paragraph?.position?.start.offset;
+        if (paragraph?.type !== "paragraph" ||
+            first?.type !== "text" ||
+            offset === undefined ||
+            paragraph.position?.start.line !== node.position?.start.line)
+            continue;
+        const marker = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][\t ]*(?:\r\n|\r|\n|$)/.exec(source.slice(offset));
+        const kind = marker?.[1];
+        if (!kind)
+            continue;
+        first.value = first.value.slice(kind.length + 3);
+        const bodyStart = paragraph.children[0];
+        if (bodyStart?.type === "text") {
+            bodyStart.value = bodyStart.value.replace(/^[\t ]*(?:\r\n|\r|\n)?/, "");
+            if (!bodyStart.value)
+                paragraph.children.shift();
+        }
+        if (paragraph.children[0]?.type === "break")
+            paragraph.children.shift();
+        if (!paragraph.children.length)
+            node.children.shift();
+        const type = kind.toLowerCase();
+        const label = type.charAt(0).toUpperCase() + type.slice(1);
+        const markerText = {
+            type: "text",
+            value: `[!${kind}]`,
+            data: { mddAlertMarker: true },
+        };
+        node.children.unshift({
+            type: "paragraph",
+            children: [markerText],
+            data: {
+                hProperties: { className: ["mdd-component-label"] },
+                hChildren: [
+                    {
+                        type: "element",
+                        tagName: "strong",
+                        properties: {},
+                        children: [{ type: "text", value: label }],
+                    },
+                ],
+            },
+        });
+        node.data = {
+            hName: "aside",
+            hProperties: { className: ["mdd-alert", `mdd-${type}`] },
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { CompileOptions, CompileResult } from "./types.js";
+export type { Asset, CompileOptions, CompileResult, Diagnostic, Heading, Metadata, NavigationItem, Page, Site, Theme, } from "./types.js";
+/** Compile a local checkout; never fetch repositories, execute author code, or emit files. */
+export declare function compileProject(options: CompileOptions): Promise<CompileResult>;

package/dist/index.js

@@ -0,0 +1,129 @@
+import { readFile } from "node:fs/promises";
+import { resolveLinks } from "./links.js";
+import { parseDocument, renderDocument, } from "./markdown.js";
+import { loadProject, relativeSource } from "./project.js";
+import { navigationFor, normalizeBasePath, publicUrl, routeFor, } from "./routes.js";
+const reserved = new Set([
+    "_assets",
+    "_mdd",
+    "markdown",
+    "mdd-build.json",
+    "llms.txt",
+    "sitemap.xml",
+    "robots.txt",
+    "404.html",
+]);
+function nestingDiagnostic(error, file) {
+    // V8 reports this error for excessive nesting in both parsing and rendering.
+    if (!(error instanceof RangeError) ||
+        error.message !== "Maximum call stack size exceeded")
+        throw error;
+    return {
+        severity: "error",
+        code: "CONTENT_TOO_DEEP",
+        message: "Markdown nesting is too deep; reduce nested blocks or formatting.",
+        file,
+    };
+}
+/** Compile a local checkout; never fetch repositories, execute author code, or emit files. */
+export async function compileProject(options) {
+    const diagnostics = [];
+    let basePath;
+    try {
+        basePath = normalizeBasePath(options.basePath ?? "/");
+    }
+    catch (error) {
+        return {
+            diagnostics: [
+                {
+                    severity: "error",
+                    code: "INVALID_BASE_PATH",
+                    message: error instanceof Error ? error.message : "Invalid basePath",
+                },
+            ],
+        };
+    }
+    const project = await loadProject(options, diagnostics);
+    if (!project)
+        return { diagnostics };
+    const sources = [];
+    const routes = new Map();
+    for (const file of project.files) {
+        const relative = relativeSource(project.contentsRoot, file);
+        const source = relativeSource(project.root, file);
+        const route = routeFor(relative);
+        const key = decodeURIComponent(route).normalize("NFC").toLowerCase();
+        if (reserved.has(key.split("/")[1] ?? "")) {
+            diagnostics.push({
+                severity: "error",
+                code: "RESERVED_ROUTE",
+                message: `Route '${route}' is reserved for generated output`,
+                file: source,
+            });
+        }
+        const conflict = routes.get(key);
+        if (conflict)
+            diagnostics.push({
+                severity: "error",
+                code: "ROUTE_COLLISION",
+                message: `Route '${route}' collides with ${conflict}`,
+                file: source,
+            });
+        routes.set(key, source);
+        const text = await readFile(file, "utf8");
+        let document;
+        try {
+            document = parseDocument(text, source, diagnostics);
+        }
+        catch (error) {
+            diagnostics.push(nestingDiagnostic(error, source));
+            return { diagnostics };
+        }
+        sources.push({ file, relative, route, document });
+    }
+    const assets = await resolveLinks(sources, project, basePath, diagnostics);
+    if (diagnostics.some((item) => item.severity === "error"))
+        return { diagnostics };
+    const pages = [];
+    for (const source of sources) {
+        const { document } = source;
+        let rendered;
+        try {
+            rendered = await renderDocument(document);
+        }
+        catch (error) {
+            diagnostics.push(nestingDiagnostic(error, relativeSource(project.root, source.file)));
+            return { diagnostics };
+        }
+        pages.push({
+            source: relativeSource(project.root, source.file),
+            route: source.route,
+            url: publicUrl(basePath, source.route),
+            title: document.title,
+            ...(document.metadata.description !== undefined
+                ? { description: document.metadata.description }
+                : {}),
+            ...rendered,
+            headings: document.headings,
+            navigation: {
+                title: document.metadata.navTitle ?? document.title,
+                ...(document.metadata.order !== undefined
+                    ? { order: document.metadata.order }
+                    : {}),
+            },
+        });
+    }
+    return {
+        site: {
+            title: project.title ??
+                pages.find((page) => page.route === "/")?.title ??
+                "Documentation",
+            basePath,
+            pages,
+            navigation: navigationFor(pages, sources.map((source) => source.relative)),
+            assets,
+            theme: project.theme,
+        },
+        diagnostics,
+    };
+}

package/dist/links.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedDocument } from "./markdown.js";
+import { type Project } from "./project.js";
+import type { Asset, Diagnostic } from "./types.js";
+export interface SourcePage {
+    file: string;
+    relative: string;
+    route: string;
+    document: ParsedDocument;
+}
+export declare function resolveLinks(pages: SourcePage[], project: Project, basePath: string, diagnostics: Diagnostic[]): Promise<Asset[]>;

package/dist/links.js

@@ -0,0 +1,154 @@
+import path from "node:path";
+import { visit } from "unist-util-visit";
+import { AuthoringError, isWithin, relativeSource, safeFile, } from "./project.js";
+import { encodePath, publicUrl } from "./routes.js";
+// Active file formats belong to an explicitly selected theme, never content assets.
+const assetExtensions = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".avif",
+    ".ico",
+    ".pdf",
+    ".txt",
+]);
+export async function resolveLinks(pages, project, basePath, diagnostics) {
+    const byFile = new Map(pages.map((page) => [page.file, page]));
+    const byRoute = new Map(pages.map((page) => [decodeURIComponent(page.route), page]));
+    const assets = new Map();
+    const destinations = new Map();
+    for (const page of pages) {
+        const links = [];
+        const imageReferences = new Set();
+        visit(page.document.tree, (node) => {
+            if (node.type === "imageReference")
+                imageReferences.add(node.identifier);
+            if (node.type === "link" ||
+                node.type === "image" ||
+                node.type === "definition")
+                links.push(node);
+        });
+        for (const node of links) {
+            const isImage = node.type === "image" ||
+                (node.type === "definition" && imageReferences.has(node.identifier));
+            const url = node.url;
+            // Protocol validation is owned by the parser. Do not fetch external targets.
+            if (/^[a-z][a-z\d+.-]*:/i.test(url) || url.startsWith("//"))
+                continue;
+            const location = {
+                file: relativeSource(project.root, page.file),
+                line: node.position?.start.line,
+                column: node.position?.start.column,
+            };
+            try {
+                const hashIndex = url.indexOf("#");
+                const beforeHash = hashIndex < 0 ? url : url.slice(0, hashIndex);
+                const hash = hashIndex < 0 ? "" : decodeURIComponent(url.slice(hashIndex + 1));
+                const queryIndex = beforeHash.indexOf("?");
+                const pathname = queryIndex < 0 ? beforeHash : beforeHash.slice(0, queryIndex);
+                const query = queryIndex < 0 ? "" : beforeHash.slice(queryIndex);
+                const decoded = decodeURIComponent(pathname);
+                // biome-ignore lint/suspicious/noControlCharactersInRegex: Local paths cannot include controls.
+                if (/[\\\u0000-\u001f\u007f]/u.test(decoded))
+                    throw new AuthoringError("INVALID_LINK", "Local links cannot contain backslashes or control characters");
+                const targetFile = decoded.startsWith("/")
+                    ? path.resolve(project.contentsRoot, `.${decoded}`)
+                    : path.resolve(path.dirname(page.file), decoded || path.basename(page.file));
+                if (!isWithin(project.contentsRoot, targetFile))
+                    throw new AuthoringError("PATH_ESCAPE", "Local links must stay inside the content root");
+                let target = !decoded ? page : byFile.get(targetFile);
+                const extension = path.extname(decoded).toLowerCase();
+                let asset = decoded.endsWith("/") ? undefined : assets.get(targetFile);
+                let assetExists = asset !== undefined;
+                if (!target &&
+                    !assetExists &&
+                    !decoded.endsWith("/") &&
+                    assetExtensions.has(extension)) {
+                    try {
+                        await safeFile(project.contentsRoot, targetFile);
+                        assetExists = true;
+                    }
+                    catch (error) {
+                        // An absent file or directory may still name a dotted page route.
+                        // Safety and operational errors must never become route fallbacks.
+                        if (!(error instanceof AuthoringError) ||
+                            !["PATH_NOT_FOUND", "INVALID_FILE_TYPE"].includes(error.code))
+                            throw error;
+                    }
+                }
+                if (!target && !assetExists) {
+                    const relative = relativeSource(project.contentsRoot, targetFile);
+                    const route = relative ? `/${relative.replace(/\/$/, "")}/` : "/";
+                    target = byRoute.get(route);
+                }
+                if (target) {
+                    if (isImage)
+                        throw new AuthoringError("INVALID_IMAGE", "Images must reference an asset, not a Markdown page");
+                    let anchor = "";
+                    if (hash) {
+                        const heading = target.document.headings.find((item) => item.id === hash || item.id === `mdd-${hash}`);
+                        if (!heading)
+                            throw new AuthoringError("MISSING_ANCHOR", `No heading '${hash}' in ${target.relative}`);
+                        anchor = `#${encodeURIComponent(heading.id)}`;
+                    }
+                    node.url = publicUrl(basePath, target.route) + query + anchor;
+                    continue;
+                }
+                if (decoded.toLowerCase().endsWith(".md") ||
+                    decoded.endsWith("/") ||
+                    !decoded ||
+                    !path.extname(decoded)) {
+                    throw new AuthoringError("MISSING_LINK", `No documentation page matches '${url}'`);
+                }
+                if (!assetExtensions.has(extension)) {
+                    throw new AuthoringError("UNSUPPORTED_ASSET", `Unsupported asset '${decoded}'. Use a raster image, PDF, or plain text file`);
+                }
+                if (isImage && [".pdf", ".txt"].includes(extension)) {
+                    throw new AuthoringError("INVALID_IMAGE", "Images must reference a supported raster image");
+                }
+                if (!asset) {
+                    if (!assetExists)
+                        await safeFile(project.contentsRoot, targetFile);
+                    const source = relativeSource(project.root, targetFile);
+                    const destination = `_assets/${relativeSource(project.contentsRoot, targetFile)}`;
+                    const key = destination.normalize("NFC").toLowerCase();
+                    const existing = destinations.get(key);
+                    if (existing && existing !== source)
+                        throw new AuthoringError("ASSET_COLLISION", `Asset output collides with ${existing}`);
+                    destinations.set(key, source);
+                    asset = {
+                        source,
+                        destination,
+                        url: publicUrl(basePath, encodePath(destination)),
+                    };
+                    assets.set(targetFile, asset);
+                }
+                node.url =
+                    asset.url + query + (hash ? `#${encodeURIComponent(hash)}` : "");
+            }
+            catch (error) {
+                if (error instanceof AuthoringError)
+                    diagnostics.push({
+                        severity: "error",
+                        code: error.code === "PATH_NOT_FOUND" ? "MISSING_ASSET" : error.code,
+                        message: error.message,
+                        ...location,
+                    });
+                else if (error instanceof URIError)
+                    diagnostics.push({
+                        severity: "error",
+                        code: "INVALID_LINK",
+                        message: `Malformed URL encoding in '${url}'`,
+                        ...location,
+                    });
+                else
+                    throw new Error(`Unable to resolve '${url}' in ${location.file}`, {
+                        cause: error,
+                    });
+            }
+        }
+    }
+    return [...assets.values()].sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0);
+}

package/dist/markdown.d.ts

@@ -0,0 +1,13 @@
+import type { Root } from "mdast";
+import type { Diagnostic, Heading, Metadata } from "./types.js";
+export interface ParsedDocument {
+    tree: Root;
+    metadata: Metadata;
+    title: string;
+    headings: Heading[];
+}
+export declare function parseDocument(source: string, file: string, diagnostics: Diagnostic[]): ParsedDocument;
+export declare function renderDocument(document: ParsedDocument): Promise<{
+    html: string;
+    markdown: string;
+}>;

package/dist/markdown.js

@@ -0,0 +1,266 @@
+import { basename, extname } from "node:path";
+import GithubSlugger from "github-slugger";
+import { toString as nodeText } from "mdast-util-to-string";
+import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
+import rehypeStringify from "rehype-stringify";
+import remarkDirective from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+import { SKIP, visit } from "unist-util-visit";
+import { parseDocument as parseYaml } from "yaml";
+import { transformAlerts } from "./alerts.js";
+const parser = unified()
+    .use(remarkParse)
+    .use(remarkGfm)
+    .use(remarkFrontmatter, ["yaml"])
+    .use(remarkDirective);
+const htmlRenderer = unified()
+    .use(remarkRehype)
+    .use(rehypeSanitize, {
+    ...defaultSchema,
+    // Only generated, mdd-prefixed heading IDs enter the document.
+    clobberPrefix: "",
+    tagNames: [...(defaultSchema.tagNames ?? []), "aside"],
+    attributes: {
+        ...defaultSchema.attributes,
+        aside: [["className", /^mdd-/]],
+        details: [["className", "mdd-details"]],
+        p: [
+            ...(defaultSchema.attributes?.p ?? []),
+            ["className", "mdd-component-label"],
+        ],
+        summary: [
+            ...(defaultSchema.attributes?.summary ?? []),
+            ["className", "mdd-component-label"],
+        ],
+    },
+    protocols: {
+        ...defaultSchema.protocols,
+        href: ["http", "https", "mailto", "tel"],
+        src: ["http", "https"],
+    },
+})
+    .use(rehypeStringify);
+const markdownRenderer = unified()
+    .use(remarkGfm)
+    .use(remarkStringify, {
+    handlers: {
+        text(node, _parent, state, info) {
+            // Only generated alert markers bypass normal Markdown escaping.
+            return node.data?.mddAlertMarker === true
+                ? node.value
+                : state.safe(node.value, info);
+        },
+    },
+});
+const removedNotices = new Set(["note", "tip", "warning"]);
+/** Keep the same first-wins, reachable definitions that the HTML renderer uses. */
+function retainReferencedDefinitions(tree) {
+    const definitions = new Map();
+    const footnotes = new Map();
+    visit(tree, (node) => {
+        if (node.type === "definition") {
+            const id = node.identifier.toUpperCase();
+            if (!definitions.has(id))
+                definitions.set(id, node);
+        }
+        else if (node.type === "footnoteDefinition") {
+            const id = node.identifier.toUpperCase();
+            if (!footnotes.has(id))
+                footnotes.set(id, node);
+        }
+    });
+    const usedDefinitions = new Set();
+    const usedFootnotes = new Set();
+    const pending = [tree];
+    for (const content of pending) {
+        visit(content, (node, index, parent) => {
+            // Definitions are global, even when nested inside an unused footnote.
+            // Detach them now and append only reachable definitions after the body.
+            if ((node.type === "definition" || node.type === "footnoteDefinition") &&
+                parent &&
+                index !== undefined) {
+                parent.children.splice(index, 1);
+                return [SKIP, index];
+            }
+            if (node.type === "linkReference" || node.type === "imageReference") {
+                const definition = definitions.get(node.identifier.toUpperCase());
+                if (definition)
+                    usedDefinitions.add(definition);
+            }
+            else if (node.type === "footnoteReference") {
+                const footnote = footnotes.get(node.identifier.toUpperCase());
+                if (footnote && !usedFootnotes.has(footnote)) {
+                    usedFootnotes.add(footnote);
+                    pending.push(footnote);
+                }
+            }
+        });
+    }
+    tree.children.push(...usedDefinitions, ...usedFootnotes);
+}
+function unsafeUrl(url, image) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: Reject schemes hidden by URL control characters.
+    const normalized = url.replace(/[\u0000-\u0020\u007f-\u009f]/g, "");
+    const scheme = /^([a-z][a-z\d+.-]*):/i.exec(normalized)?.[1]?.toLowerCase();
+    return Boolean(scheme &&
+        !(image ? ["http", "https"] : ["http", "https", "mailto", "tel"]).includes(scheme));
+}
+export function parseDocument(source, file, diagnostics) {
+    const tree = parser.parse(source);
+    transformAlerts(tree, source);
+    retainReferencedDefinitions(tree);
+    const metadata = {};
+    const headings = [];
+    const slugger = new GithubSlugger();
+    const imageReferences = new Set();
+    visit(tree, "imageReference", (node) => {
+        imageReferences.add(node.identifier.toLowerCase());
+    });
+    const report = (code, message, node) => {
+        diagnostics.push({
+            severity: "error",
+            code,
+            message,
+            file,
+            line: node.position?.start.line,
+            column: node.position?.start.column,
+        });
+    };
+    const frontmatter = tree.children[0];
+    if (frontmatter?.type === "yaml") {
+        try {
+            const yaml = parseYaml(frontmatter.value);
+            if (yaml.errors.length || yaml.warnings.length) {
+                throw new Error([...yaml.errors, ...yaml.warnings]
+                    .map((error) => error.message)
+                    .join("; "));
+            }
+            const value = yaml.toJS({ maxAliasCount: 0 });
+            if ((value === null && yaml.contents !== null) ||
+                (value !== null && (typeof value !== "object" || Array.isArray(value)))) {
+                throw new Error("Frontmatter must be a mapping of metadata fields.");
+            }
+            for (const [key, entry] of Object.entries(value ?? {})) {
+                if (key === "order") {
+                    if (typeof entry !== "number" || !Number.isFinite(entry)) {
+                        throw new Error("Frontmatter order must be a finite number.");
+                    }
+                    metadata.order = entry;
+                }
+                else if (key === "title" ||
+                    key === "description" ||
+                    key === "navTitle") {
+                    if (typeof entry !== "string" || !entry.trim()) {
+                        throw new Error(`Frontmatter ${key} must be a nonempty string.`);
+                    }
+                    metadata[key] = entry.trim();
+                }
+                else {
+                    throw new Error(`Unknown frontmatter field: ${key}.`);
+                }
+            }
+        }
+        catch (error) {
+            report("INVALID_FRONTMATTER", error instanceof Error ? error.message : "Invalid YAML frontmatter.", frontmatter);
+        }
+        tree.children.shift();
+    }
+    visit(tree, (node, index, parent) => {
+        if (node.type === "html") {
+            report("RAW_HTML", "Raw HTML is not supported; use Markdown or an mdd component.", node);
+            if (parent && index !== undefined) {
+                parent.children.splice(index, 1);
+                return [SKIP, index];
+            }
+        }
+        if ((node.type === "link" ||
+            node.type === "image" ||
+            node.type === "definition") &&
+            unsafeUrl(node.url, node.type === "image" ||
+                (node.type === "definition" &&
+                    imageReferences.has(node.identifier.toLowerCase())))) {
+            report("UNSAFE_URL", "Use a relative URL or an allowed HTTP, HTTPS, mailto, or tel URL.", node);
+            node.url = "";
+        }
+        if (node.type === "heading") {
+            const text = nodeText(node);
+            const id = `mdd-${slugger.slug(text)}`;
+            node.data = { ...node.data, hProperties: { id } };
+            headings.push({ depth: node.depth, text, id });
+        }
+        if (node.type !== "containerDirective" &&
+            node.type !== "leafDirective" &&
+            node.type !== "textDirective") {
+            return;
+        }
+        if (removedNotices.has(node.name)) {
+            report("REMOVED_COMPONENT", `The ${node.name} directive was removed; use > [!${node.name.toUpperCase()}] followed by quoted body lines. Keep any optional custom title as bold text in the alert body.`, node);
+            return;
+        }
+        if (node.type !== "containerDirective" || node.name !== "details") {
+            report("UNKNOWN_COMPONENT", `Unsupported component ${node.name}; use a GitHub alert or a details container.`, node);
+            return;
+        }
+        if (Object.keys(node.attributes ?? {}).length) {
+            report("INVALID_COMPONENT", `The ${node.name} component does not support attributes.`, node);
+        }
+        if (index === undefined || !parent)
+            return;
+        const first = node.children[0];
+        const defaultLabel = "Details";
+        const label = first?.type === "paragraph" && first.data?.directiveLabel
+            ? first
+            : {
+                type: "paragraph",
+                children: [
+                    {
+                        type: "text",
+                        value: defaultLabel,
+                    },
+                ],
+            };
+        if (label !== first)
+            node.children.unshift(label);
+        if (!nodeText(label).trim()) {
+            label.children = [{ type: "text", value: defaultLabel }];
+        }
+        label.children = [{ type: "strong", children: label.children }];
+        label.data = {
+            hName: "summary",
+            hProperties: { className: ["mdd-component-label"] },
+        };
+        parent.children[index] = {
+            type: "blockquote",
+            children: node.children,
+            position: node.position,
+            data: {
+                hName: "details",
+                hProperties: { className: ["mdd-details"] },
+            },
+        };
+        // Revisit the replacement so nested content is validated exactly once.
+        return [SKIP, index];
+    });
+    const filename = basename(file, extname(file)).replace(/[-_]+/g, " ");
+    const fallbackTitle = filename.charAt(0).toUpperCase() + filename.slice(1);
+    return {
+        tree,
+        metadata,
+        title: metadata.title ??
+            headings.find((heading) => heading.depth === 1)?.text ??
+            fallbackTitle,
+        headings,
+    };
+}
+export async function renderDocument(document) {
+    const htmlTree = await htmlRenderer.run(document.tree);
+    return {
+        html: String(htmlRenderer.stringify(htmlTree)),
+        markdown: String(markdownRenderer.stringify(document.tree)),
+    };
+}

package/dist/project.d.ts

@@ -0,0 +1,16 @@
+import type { CompileOptions, Diagnostic, Theme } from "./types.js";
+export interface Project {
+    root: string;
+    contentsRoot: string;
+    title?: string;
+    theme: Theme;
+    files: string[];
+}
+export declare class AuthoringError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function relativeSource(root: string, file: string): string;
+export declare function isWithin(root: string, file: string): boolean;
+export declare function safeFile(root: string, file: string): Promise<string>;
+export declare function loadProject(options: CompileOptions, diagnostics: Diagnostic[]): Promise<Project | undefined>;

package/dist/project.js

@@ -0,0 +1,252 @@
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+export class AuthoringError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AuthoringError";
+    }
+}
+export function relativeSource(root, file) {
+    return path.relative(root, file).split(path.sep).join("/");
+}
+export function isWithin(root, file) {
+    const relative = path.relative(root, file);
+    return (relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+function protectedName(name) {
+    return (name.startsWith(".") ||
+        /^(?:node_modules|credentials?(?:\..*)?|secrets?(?:\..*)?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\..*)?)$/i.test(name) ||
+        /\.(?:pem|key|p12|pfx)$/i.test(name));
+}
+function assertPath(root, file) {
+    if (!isWithin(root, file)) {
+        throw new AuthoringError("PATH_OUTSIDE_PROJECT", `Path escapes its allowed root: ${file}`);
+    }
+    if (relativeSource(root, file).split("/").some(protectedName)) {
+        throw new AuthoringError("PROTECTED_PATH", `Hidden or sensitive paths cannot be used: ${file}`);
+    }
+}
+function missing(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function checkedPath(root, file, allowMissing = false) {
+    const absolute = path.resolve(root, file);
+    assertPath(root, absolute);
+    let resolved;
+    try {
+        resolved = await realpath(absolute);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error) {
+            if (error.code === "ELOOP")
+                throw new AuthoringError("SYMLINK_CYCLE", `Path contains a symlink cycle: ${absolute}`);
+            if (error.code === "ENOTDIR")
+                throw new AuthoringError("INVALID_DIRECTORY", `A path component is not a directory: ${absolute}`);
+        }
+        if (missing(error)) {
+            if (!allowMissing || absolute === root) {
+                throw new AuthoringError("PATH_NOT_FOUND", `Path does not exist: ${absolute}`);
+            }
+            const entry = await lstat(absolute).catch((inspectionError) => {
+                if (missing(inspectionError))
+                    return undefined;
+                throw new Error(`Cannot inspect path ${absolute}`, {
+                    cause: inspectionError,
+                });
+            });
+            if (entry?.isSymbolicLink())
+                throw new AuthoringError("BROKEN_SYMLINK", `Path is a broken symlink: ${absolute}`);
+            // Resolve existing ancestors too: an absent leaf must not conceal a symlink escape.
+            resolved = path.join(await checkedPath(root, path.dirname(absolute), true), path.basename(absolute));
+        }
+        else {
+            throw new Error(`Cannot resolve path ${absolute}`, { cause: error });
+        }
+    }
+    assertPath(root, resolved);
+    return resolved;
+}
+export async function safeFile(root, file) {
+    const resolved = await checkedPath(root, file);
+    try {
+        if (!(await stat(resolved)).isFile()) {
+            throw new AuthoringError("INVALID_FILE_TYPE", `Expected a regular file: ${file}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof AuthoringError)
+            throw error;
+        if (missing(error))
+            throw new AuthoringError("PATH_NOT_FOUND", `File does not exist: ${file}`);
+        throw new Error(`Cannot inspect file ${file}`, { cause: error });
+    }
+    return resolved;
+}
+async function directory(root, file, optional = false) {
+    const resolved = await checkedPath(root, file, optional);
+    try {
+        if (!(await stat(resolved)).isDirectory()) {
+            throw new AuthoringError("INVALID_DIRECTORY", `Expected a directory: ${file}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof AuthoringError)
+            throw error;
+        if (optional && missing(error))
+            return resolved;
+        throw new Error(`Cannot inspect directory ${file}`, { cause: error });
+    }
+    return resolved;
+}
+function object(value, label, fields) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new AuthoringError("INVALID_CONFIG", `${label} must be an object.`);
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (!fields.includes(key))
+            throw new AuthoringError("UNKNOWN_CONFIG_FIELD", `Unsupported ${label} field: ${key}`);
+    }
+    return record;
+}
+function text(value, label) {
+    if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
+        throw new AuthoringError("INVALID_CONFIG", `${label} must be a non-empty string.`);
+    }
+    return value;
+}
+function relativePath(value, label) {
+    const result = text(value, label);
+    if (path.isAbsolute(result) ||
+        path.win32.isAbsolute(result) ||
+        result.includes("\\")) {
+        throw new AuthoringError("INVALID_CONFIG_PATH", `${label} must be a relative path using forward slashes.`);
+    }
+    return result;
+}
+async function optionalFile(root, file) {
+    try {
+        await lstat(file);
+    }
+    catch (error) {
+        if (missing(error))
+            return undefined;
+        throw new Error(`Cannot inspect optional file ${file}`, { cause: error });
+    }
+    return safeFile(root, file);
+}
+async function scan(root) {
+    const files = [];
+    async function walk(directory) {
+        const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+            throw new Error(`Cannot read content directory ${directory}`, {
+                cause: error,
+            });
+        });
+        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const entry of entries) {
+            if (protectedName(entry.name))
+                continue;
+            const file = path.join(directory, entry.name);
+            // Reject aliases during discovery so routes are unambiguous and directory cycles impossible.
+            if (entry.isSymbolicLink()) {
+                throw new AuthoringError("CONTENT_SYMLINK", `Content discovery does not follow symlinks: ${file}`);
+            }
+            if (entry.isDirectory())
+                await walk(file);
+            else if (path.extname(entry.name).toLowerCase() === ".md")
+                files.push(await safeFile(root, file));
+        }
+    }
+    await walk(root);
+    return files.sort();
+}
+export async function loadProject(options, diagnostics) {
+    let source;
+    try {
+        const root = await realpath(options.projectDir).catch((error) => {
+            if (missing(error))
+                throw new AuthoringError("PROJECT_NOT_FOUND", `Project directory does not exist: ${options.projectDir}`);
+            throw new Error(`Cannot resolve project directory ${options.projectDir}`, { cause: error });
+        });
+        const mddRoot = await directory(root, relativePath(options.mddDir ?? "mdd", "mddDir"));
+        const configPath = path.join(mddRoot, "config.json");
+        source = relativeSource(root, configPath);
+        const configFile = await optionalFile(root, configPath);
+        let config = {};
+        if (configFile) {
+            const json = await readFile(configFile, "utf8").catch((error) => {
+                throw new Error(`Cannot read configuration ${configFile}`, {
+                    cause: error,
+                });
+            });
+            let parsed;
+            try {
+                parsed = JSON.parse(json);
+            }
+            catch {
+                throw new AuthoringError("INVALID_CONFIG_JSON", "config.json must contain valid JSON.");
+            }
+            config = object(parsed, "config", ["title", "paths", "theme"]);
+        }
+        const title = config.title === undefined ? undefined : text(config.title, "title");
+        const paths = config.paths === undefined
+            ? {}
+            : object(config.paths, "paths", ["contents", "themes"]);
+        const contentsRoot = await directory(root, path.resolve(mddRoot, relativePath(paths.contents === undefined ? "contents" : paths.contents, "paths.contents")));
+        const themesRoot = await directory(root, path.resolve(mddRoot, relativePath(paths.themes === undefined ? "themes" : paths.themes, "paths.themes")), true);
+        if (contentsRoot === root || themesRoot === root) {
+            throw new AuthoringError("INVALID_CONTENT_ROOT", "Content and theme paths must select a directory inside the project, not the whole checkout.");
+        }
+        if (isWithin(contentsRoot, themesRoot) ||
+            isWithin(themesRoot, contentsRoot)) {
+            throw new AuthoringError("OVERLAPPING_ROOTS", "Content and theme directories must not overlap.");
+        }
+        const name = text(config.theme === undefined ? "default" : config.theme, "theme");
+        if (name === "." ||
+            name === ".." ||
+            name.includes("/") ||
+            name.includes("\\") ||
+            protectedName(name)) {
+            throw new AuthoringError("INVALID_THEME", "theme must name a single, non-hidden folder inside the themes directory.");
+        }
+        let theme = { name: "default" };
+        if (name !== "default") {
+            const themeRoot = await directory(root, path.join(themesRoot, name));
+            if (!isWithin(themesRoot, themeRoot))
+                throw new AuthoringError("PATH_OUTSIDE_PROJECT", "Selected theme escapes the themes directory.");
+            const css = await safeFile(themeRoot, path.join(themeRoot, "theme.css"));
+            const js = await optionalFile(themeRoot, path.join(themeRoot, "theme.js"));
+            theme = {
+                name,
+                directory: relativeSource(root, themeRoot),
+                css: relativeSource(root, css),
+                ...(js ? { js: relativeSource(root, js) } : {}),
+            };
+        }
+        source = relativeSource(root, contentsRoot);
+        const files = await scan(contentsRoot);
+        if (!files.includes(path.join(contentsRoot, "index.md"))) {
+            source = relativeSource(root, path.join(contentsRoot, "index.md"));
+            throw new AuthoringError("MISSING_HOME", "The content root must contain an index.md homepage.");
+        }
+        if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+            return undefined;
+        return { root, contentsRoot, title, theme, files };
+    }
+    catch (error) {
+        if (!(error instanceof AuthoringError))
+            throw error;
+        diagnostics.push({
+            severity: "error",
+            code: error.code,
+            message: error.message,
+            ...(source ? { file: source } : {}),
+        });
+        return undefined;
+    }
+}

package/dist/routes.d.ts

@@ -0,0 +1,7 @@
+import type { NavigationItem, Page } from "./types.js";
+export declare function encodePath(value: string): string;
+export declare function normalizeBasePath(value: string): string;
+export declare function routeFor(source: string): string;
+export declare function publicUrl(basePath: string, route: string): string;
+export declare function readableName(name: string): string;
+export declare function navigationFor(pages: Page[], relativeFiles: string[]): NavigationItem[];

package/dist/routes.js

@@ -0,0 +1,89 @@
+import path from "node:path";
+export function encodePath(value) {
+    return value.split("/").map(encodeURIComponent).join("/");
+}
+export function normalizeBasePath(value) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: Reject control characters at the URL boundary.
+    const invalidPath = /[?#\\\u0000-\u0020]/u.test(value);
+    if (invalidPath || value.includes(":") || value.startsWith("//")) {
+        throw new Error("basePath must be a URL path without a host, query, fragment, or whitespace");
+    }
+    const parts = value.split("/").filter(Boolean);
+    const decoded = parts.map((part) => decodeURIComponent(part));
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: Reject decoded controls and path separators.
+    const invalidSegment = /[/\\\u0000-\u0020]/u;
+    if (decoded.some((part) => part === "." || part === ".." || invalidSegment.test(part))) {
+        throw new Error("basePath must not contain traversal or encoded separators");
+    }
+    return parts.length ? `/${decoded.map(encodeURIComponent).join("/")}/` : "/";
+}
+export function routeFor(source) {
+    const stem = source.slice(0, -3);
+    const route = stem === "index" ? "" : stem.replace(/\/index$/, "");
+    return route ? `/${encodePath(route)}/` : "/";
+}
+export function publicUrl(basePath, route) {
+    return basePath + route.replace(/^\//, "");
+}
+export function readableName(name) {
+    return name
+        .replace(/[-_]/g, " ")
+        .replace(/^./u, (char) => char.toUpperCase());
+}
+export function navigationFor(pages, relativeFiles) {
+    const root = { key: "", title: "", children: new Map() };
+    pages.forEach((page, index) => {
+        const source = relativeFiles[index];
+        if (!source)
+            return;
+        const segments = source.split("/");
+        const file = segments.pop();
+        let parent = root;
+        for (const folder of segments) {
+            let group = parent.children.get(folder);
+            if (!group) {
+                group = {
+                    key: folder,
+                    title: readableName(folder),
+                    children: new Map(),
+                };
+                parent.children.set(folder, group);
+            }
+            parent = group;
+        }
+        if (file?.slice(0, -3) === "index" && parent !== root) {
+            parent.page = page;
+            parent.title = page.navigation.title;
+        }
+        else {
+            const key = source === "index.md"
+                ? ""
+                : path.posix.basename(source, path.posix.extname(source));
+            parent.children.set(key, {
+                key,
+                title: page.navigation.title,
+                page,
+                children: new Map(),
+            });
+        }
+    });
+    function sorted(entry) {
+        return [...entry.children.values()]
+            .sort((a, b) => {
+            const order = (a.page?.navigation.order ?? Infinity) -
+                (b.page?.navigation.order ?? Infinity);
+            if (order && !Number.isNaN(order))
+                return order;
+            return compare(a.title, b.title) || compare(a.key, b.key);
+        })
+            .map((child) => ({
+            title: child.title,
+            ...(child.page ? { route: child.page.route, url: child.page.url } : {}),
+            ...(child.children.size ? { children: sorted(child) } : {}),
+        }));
+    }
+    return sorted(root);
+}
+function compare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}

package/dist/types.d.ts

@@ -0,0 +1,76 @@
+export interface Diagnostic {
+    severity: "error" | "warning";
+    code: string;
+    message: string;
+    file?: string;
+    line?: number;
+    column?: number;
+}
+export interface Metadata {
+    title?: string;
+    description?: string;
+    navTitle?: string;
+    order?: number;
+}
+export interface Heading {
+    depth: number;
+    text: string;
+    id: string;
+}
+export interface Page {
+    /** POSIX path relative to projectDir. */
+    source: string;
+    /** Encoded, trailing-slash path relative to the documentation root. */
+    route: string;
+    url: string;
+    title: string;
+    description?: string;
+    html: string;
+    markdown: string;
+    headings: Heading[];
+    navigation: {
+        title: string;
+        order?: number;
+    };
+}
+export interface NavigationItem {
+    title: string;
+    route?: string;
+    url?: string;
+    children?: NavigationItem[];
+}
+export interface Asset {
+    /** POSIX path relative to projectDir; consumers resolve against the same checkout. */
+    source: string;
+    /** Filesystem output path relative to the documentation root; not URL-encoded. */
+    destination: string;
+    url: string;
+}
+export type Theme = {
+    name: "default";
+} | {
+    name: string;
+    directory: string;
+    css: string;
+    js?: string;
+};
+export interface Site {
+    title: string;
+    basePath: string;
+    pages: Page[];
+    navigation: NavigationItem[];
+    assets: Asset[];
+    theme: Theme;
+}
+export interface CompileOptions {
+    projectDir: string;
+    mddDir?: string;
+    basePath?: string;
+}
+export type CompileResult = {
+    site: Site;
+    diagnostics: Diagnostic[];
+} | {
+    site?: undefined;
+    diagnostics: Diagnostic[];
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@wgtechlabs/mdd-engine",
+  "version": "0.1.0-dev.3c34eeb",
+  "description": "Headless Markdown documentation compiler for mdd",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wgtechlabs/mdd-engine.git"
+  },
+  "homepage": "https://github.com/wgtechlabs/mdd-engine#readme",
+  "bugs": "https://github.com/wgtechlabs/mdd-engine/issues",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "packageManager": "bun@1.3.10",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "biome check src tests scripts package.json tsconfig.json tsconfig.build.json biome.json",
+    "format": "biome check --write src tests scripts package.json tsconfig.json tsconfig.build.json biome.json",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "coverage": "bun test --coverage",
+    "build": "tsc -p tsconfig.build.json",
+    "smoke": "node scripts/smoke.mjs",
+    "check": "bun run lint && bun run typecheck && bun test && bun run build && bun run smoke"
+  },
+  "dependencies": {
+    "github-slugger": "2.0.0",
+    "mdast-util-to-string": "4.0.0",
+    "rehype-sanitize": "6.0.0",
+    "rehype-stringify": "10.0.1",
+    "remark-directive": "4.0.0",
+    "remark-frontmatter": "5.0.0",
+    "remark-gfm": "4.0.1",
+    "remark-parse": "11.0.0",
+    "remark-rehype": "11.1.2",
+    "remark-stringify": "11.0.0",
+    "unified": "11.0.5",
+    "unist-util-visit": "5.1.0",
+    "yaml": "2.9.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.15",
+    "@types/bun": "1.4.2",
+    "@types/hast": "3.0.5",
+    "@types/mdast": "4.0.4",
+    "@types/node": "22",
+    "typescript": "7.0.2"
+  }
+}