@dogsbay/format-asciidoc 0.2.0-beta.101

package/dist/loaders/plain.js

@@ -0,0 +1,58 @@
+/**
+ * Plain corpus loader — walks every `.adoc` under the source dir
+ * and treats directory structure as nav. The MVP / default loader;
+ * also the fallback when no topology marker is present.
+ *
+ * Lineage: this logic used to live inline in `cli.ts` (Phase 8a).
+ * Phase 9a extracted it behind the CorpusLoader contract so other
+ * loaders (master-adoc, asciibinder, antora) can sit alongside it.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+import { isAsciidocDominant } from "./dominance.js";
+import { buildNavFromDirectoryMirror, prettifyName } from "./util.js";
+function walkAdocFiles(dir, root, out = []) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkAdocFiles(full, root, out);
+        }
+        else if (entry.name.endsWith(".adoc")) {
+            const rel = relative(root, full).replace(/\\/g, "/");
+            const slug = rel.replace(/\.adoc$/, "");
+            out.push({ filePath: full, slug });
+        }
+    }
+    return out;
+}
+export const plainLoader = {
+    name: "plain",
+    /**
+     * Claims a directory only when it is asciidoc-DOMINANT (more `.adoc` than
+     * `.md`, ignoring dot/dependency dirs) — not merely when some `.adoc` file
+     * exists somewhere. Mere presence meant one vendored
+     * `node_modules/**\/README.adoc` made an entire markdown corpus import as
+     * AsciiDoc, dropping every page. See ./dominance.ts.
+     */
+    detect(sourceDir) {
+        return isAsciidocDominant(sourceDir);
+    },
+    async load(sourceDir, opts) {
+        if (!existsSync(sourceDir)) {
+            throw new Error(`Source directory not found: ${sourceDir}`);
+        }
+        const st = statSync(sourceDir);
+        if (!st.isDirectory()) {
+            throw new Error(`Source must be a directory: ${sourceDir}`);
+        }
+        const hrefPrefix = opts.hrefPrefix ?? "";
+        const files = walkAdocFiles(sourceDir, sourceDir);
+        const pages = files.map((f) => ({
+            filePath: f.filePath,
+            slug: f.slug,
+        }));
+        const nav = buildNavFromDirectoryMirror(pages.map((p) => ({ slug: p.slug, title: prettifyName(basename(p.slug)) })), hrefPrefix);
+        return { pages, nav };
+    },
+};
+//# sourceMappingURL=plain.js.map

package/dist/loaders/plain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain.js","sourceRoot":"","sources":["../../src/loaders/plain.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,2BAA2B,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEtE,SAAS,aAAa,CACpB,GAAW,EACX,IAAY,EACZ,MAA4C,EAAE;IAE9C,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;YACxB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QACjC,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACxC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACrD,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;YACxC,GAAG,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAiB;IACvC,IAAI,EAAE,OAAO;IAEb;;;;;;OAMG;IACH,MAAM,CAAC,SAAiB;QACtB,OAAO,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,SAAiB,EAAE,IAAgB;QAC5C,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,+BAA+B,SAAS,EAAE,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC/B,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,+BAA+B,SAAS,EAAE,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC;QACzC,MAAM,KAAK,GAAG,aAAa,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAClD,MAAM,KAAK,GAAiB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC5C,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,IAAI,EAAE,CAAC,CAAC,IAAI;SACb,CAAC,CAAC,CAAC;QACJ,MAAM,GAAG,GAAG,2BAA2B,CACrC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAC3E,UAAU,CACX,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;IACxB,CAAC;CACF,CAAC"}

package/dist/loaders/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * CorpusLoader contract — Phase 9a.
+ *
+ * AsciiDoc corpora come in distinct topology shapes:
+ *
+ *   - **plain** (Phase 9a)        — flat .adoc walk; directory mirrors nav.
+ *   - **master-adoc** (Phase 9a)  — AAP convention: each `master.adoc`
+ *                                   is a title; its include:: chain
+ *                                   defines the module ordering.
+ *   - **asciibinder** (Phase 9b)  — `_topic_maps/_topic_map.yml` +
+ *                                   distros (OpenShift).
+ *   - **antora** (Phase 9c)       — `antora-playbook.yml` + per-component
+ *                                   `antora.yml` (version axis maps to
+ *                                   Dogsbay's version axis).
+ *
+ * Each loader is a thin enumerator: discover the corpus, decide which
+ * .adoc files become pages, propose a nav. Loaders do NOT parse —
+ * `cli.ts` runs `parseAsciidocToTree` on each `PageSource.filePath`.
+ * Keeping the split clean means loaders can be tested in isolation
+ * against their topology fixtures without depending on the full
+ * markdown-it pipeline.
+ *
+ * See plans/asciidoc-corpus-loaders.md for the four-loader rollout
+ * + axis-translation bridge spec.
+ */
+import type { NavItem } from "@dogsbay/types";
+export interface PageSource {
+    /** Absolute filesystem path to the .adoc file. */
+    filePath: string;
+    /**
+     * URL slug for this page (e.g. `"guides/install"`). The cli's
+     * caller is free to prepend its own hrefPrefix when emitting.
+     */
+    slug: string;
+    /**
+     * AsciiDoc `:leveloffset:` adjustment if the loader's topology
+     * implies one (master.adoc includes carry `leveloffset=+1`, etc.).
+     * Engine handles the actual offset; loader just declares it.
+     */
+    leveloffset?: number;
+    /**
+     * Per-page attribute context contributed by the loader's topology
+     * (AAP `_attributes/attributes.adoc`, Antora component attributes,
+     * AsciiBinder distro filters). Merged onto the global attributes
+     * passed to the engine + Minja.
+     */
+    attributes?: Record<string, unknown>;
+}
+export interface LoaderOpts {
+    /**
+     * URL prefix to apply when building nav hrefs. The CLI fills this
+     * in from the consumer site's section mount; loaders just append
+     * `/<slug>` after.
+     */
+    hrefPrefix?: string;
+    /**
+     * Target distro for AsciiBinder corpora. When set, topic-map
+     * entries whose `Distros:` list doesn't include this distro are
+     * skipped (both from the page list and the nav). Entries with no
+     * `Distros:` field are treated as universal and always kept —
+     * matching AsciiBinder's own build-time filter.
+     *
+     * Without this option, every entry flows through and pages with
+     * the same `File:` but different `Distros:` collide in the nav
+     * (`Fedora CoreOS` and `Red Hat Enterprise Linux CoreOS` both
+     * pointing at `architecture-rhcos.md`). Other loaders ignore this
+     * option — they don't have a distro concept.
+     */
+    distro?: string;
+    /**
+     * Topic-map path for the AsciiBinder loader, relative to the source
+     * root. Defaults to the AsciiBinder convention
+     * `_topic_maps/_topic_map.yml`. Override for corpora that name their
+     * topic map differently (e.g. a distro-specific `_topic_map_ms.yml`),
+     * used by both `detect()` and `load()` so a custom-named corpus can
+     * be auto-detected and loaded without editing the source. Other
+     * loaders ignore this option.
+     */
+    topicMap?: string;
+}
+export interface LoaderResult {
+    pages: PageSource[];
+    nav: NavItem[];
+    /**
+     * Optional list of distro names declared by the corpus (AsciiBinder
+     * `_distro_map.yml` or topic-level `Distros:` aggregation). Surfaced
+     * for forward-compatibility with distro-axis emission per the
+     * "axis translation" bridge spec in plans/asciidoc-corpus-loaders.md.
+     * Today's callers don't consume it; the data is informational only.
+     */
+    distros?: string[];
+}
+export interface CorpusLoader {
+    /** Identifier surfaced via the CLI's `--loader <name>` override. */
+    name: "plain" | "asciibinder" | "master-adoc" | "antora";
+    /**
+     * Heuristic detection: does this directory look like this corpus
+     * shape? Detection is best-effort; the CLI's `--loader` override
+     * always wins. detect() must NOT throw — return false on any
+     * unexpected state.
+     *
+     * `opts` carries the same loader options passed to `load()` so
+     * detection can honour overrides (e.g. a non-default `topicMap`
+     * name for AsciiBinder). Loaders that don't need options may accept
+     * just `sourceDir`.
+     */
+    detect(sourceDir: string, opts?: LoaderOpts): boolean;
+    /**
+     * Enumerate pages + build nav. Loaders may walk the filesystem,
+     * read topology files (`master.adoc`, `_topic_map.yml`,
+     * `antora.yml`), and resolve includes. They MUST NOT parse the
+     * `.adoc` body — that's `cli.ts`'s job, per the separation in
+     * the plan.
+     */
+    load(sourceDir: string, opts: LoaderOpts): Promise<LoaderResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/loaders/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/loaders/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,GAAG,EAAE,OAAO,EAAE,CAAC;IACf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,IAAI,EAAE,OAAO,GAAG,aAAa,GAAG,aAAa,GAAG,QAAQ,CAAC;IACzD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IACtD;;;;;;OAMG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAClE"}

package/dist/loaders/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/loaders/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/loaders/types.ts"],"names":[],"mappings":""}

package/dist/loaders/util.d.ts

@@ -0,0 +1,15 @@
+import type { NavItem } from "@dogsbay/types";
+export declare function prettifyName(slug: string): string;
+/**
+ * Compose a nav tree that mirrors an on-disk directory layout from
+ * a flat list of `{ slug, title }` pages. Subdirectories become
+ * NavItem groups; leaves are `{ label, href: <hrefPrefix>/<slug> }`.
+ *
+ * Shared between the plain loader and (with topology overlay) the
+ * master-adoc loader's per-title grouping.
+ */
+export declare function buildNavFromDirectoryMirror(pages: {
+    slug: string;
+    title: string;
+}[], hrefPrefix: string): NavItem[];
+//# sourceMappingURL=util.d.ts.map

package/dist/loaders/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/loaders/util.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,EACxC,UAAU,EAAE,MAAM,GACjB,OAAO,EAAE,CA6BX"}

package/dist/loaders/util.js

@@ -0,0 +1,49 @@
+/**
+ * Shared utilities for the corpus loaders.
+ */
+import { basename, dirname } from "node:path";
+export function prettifyName(slug) {
+    return slug
+        .split(/[-_]/)
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+/**
+ * Compose a nav tree that mirrors an on-disk directory layout from
+ * a flat list of `{ slug, title }` pages. Subdirectories become
+ * NavItem groups; leaves are `{ label, href: <hrefPrefix>/<slug> }`.
+ *
+ * Shared between the plain loader and (with topology overlay) the
+ * master-adoc loader's per-title grouping.
+ */
+export function buildNavFromDirectoryMirror(pages, hrefPrefix) {
+    const groups = new Map();
+    groups.set("", []);
+    for (const page of pages) {
+        const dir = dirname(page.slug);
+        const key = dir === "." ? "" : dir;
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push({
+            label: page.title,
+            href: `${hrefPrefix}/${page.slug}`,
+        });
+    }
+    // Wrap each non-root directory as a group under its parent —
+    // deepest-first so child groups exist when parents wrap them.
+    const sortedKeys = [...groups.keys()].sort((a, b) => b.split("/").length - a.split("/").length);
+    for (const key of sortedKeys) {
+        if (key === "")
+            continue;
+        const parent = dirname(key) === "." ? "" : dirname(key);
+        if (!groups.has(parent))
+            groups.set(parent, []);
+        groups.get(parent).push({
+            label: prettifyName(basename(key)),
+            children: groups.get(key),
+        });
+    }
+    return groups.get("");
+}
+//# sourceMappingURL=util.js.map

package/dist/loaders/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/loaders/util.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAG9C,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI;SACR,KAAK,CAAC,MAAM,CAAC;SACb,MAAM,CAAC,OAAO,CAAC;SACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAClD,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAAwC,EACxC,UAAkB;IAElB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAqB,CAAC;IAC5C,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAEnB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC1C,MAAM,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC,IAAI,CAAC;YACpB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,IAAI,EAAE,GAAG,UAAU,IAAI,IAAI,CAAC,IAAI,EAAE;SACnC,CAAC,CAAC;IACL,CAAC;IAED,6DAA6D;IAC7D,8DAA8D;IAC9D,MAAM,UAAU,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CACxC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CACpD,CAAC;IACF,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAC7B,IAAI,GAAG,KAAK,EAAE;YAAE,SAAS;QACzB,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAChD,MAAM,CAAC,GAAG,CAAC,MAAM,CAAE,CAAC,IAAI,CAAC;YACvB,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAClC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAE;SAC3B,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC,GAAG,CAAC,EAAE,CAAE,CAAC;AACzB,CAAC"}

package/dist/parse.d.ts

@@ -0,0 +1,178 @@
+/**
+ * AsciiDoc → TreeNode pipeline.
+ *
+ * Three composable stages, each independently testable:
+ *
+ *   1. @dogsbay/adoc2md-modular  — AsciiDoc → Markdown-with-Minja-directives.
+ *      Pure syntactic translation. The engine emits `{{ name }}` for
+ *      attribute refs, `{% if name %}` for conditionals, `{% include %}`
+ *      for include::, `{% set name = "value" %}` for in-doc :name: entries.
+ *   2. @dogsbay/minja             — resolve directives against the
+ *      attribute context. undefinedBehavior: "preserve" lets unresolved
+ *      attrs / conditionals survive into the markdown so a downstream
+ *      pass can finish the job.
+ *   3. markdown-it + walker       — Markdown → Token[] → TreeNode[].
+ *      Each format-X package owns its own walker per the convention
+ *      (see plans/format-asciidoc-import.md Phase 6).
+ *
+ * Notably we do NOT register markdown-it-attrs here. The engine emits
+ * `{id="…"}` after headings (from AsciiDoc `[id="…"]` block anchors)
+ * and md-attrs would consume those — but it would also consume any
+ * trailing `{% endif %}` / `{{ var }}` at the end of a paragraph as a
+ * malformed attribute block, dropping the directive and breaking the
+ * build-time preprocessor pass. md2md sidestepped this by fully
+ * resolving Nunjucks at convert time (single-pass), so no directives
+ * survived to collide. We support a two-pass model (migrate-asciidoc
+ * preserves directives so the build-time preprocessor can substitute
+ * later from config), which means the directives ARE present when
+ * markdown-it tokenises. So we leave md-attrs out of this stage and
+ * let `extractHeadings` (cli.ts) parse `{id="…"}` / `{#anchor}`
+ * trailers out of heading text manually — a localised concern that
+ * doesn't risk eating directives in paragraph content. md-attrs runs
+ * at Astro render time, after the preprocessor has resolved
+ * directives, where the collision can't happen.
+ *
+ * See plans/format-asciidoc-import.md for the full architecture rationale.
+ */
+import type MarkdownIt from "markdown-it";
+import type { TreeNode } from "@dogsbay/types";
+export interface ParseAsciidocOptions {
+    /**
+     * Filesystem path of the source `.adoc` file. Used as the base for
+     * `include::` directive resolution (both at AsciiDoc convert time
+     * via adoc2md-modular's `basePath` AND at Minja resolution time
+     * for the same directive after conversion). Optional; without it
+     * includes won't resolve, but unresolved `{% include %}` directives
+     * are preserved as text per Minja's `undefinedBehavior: "preserve"`.
+     */
+    filePath?: string;
+    /**
+     * Containment root for `{% include %}` resolution at the Minja stage
+     * (issue #027). When set, an include target that resolves (after
+     * symlinks) OUTSIDE this directory is refused and the parse fails —
+     * without it, a crafted include in an untrusted corpus splices any
+     * file the process can read into the page. Callers that walk a corpus
+     * pass the corpus root; unset = uncontained (backward compatible for
+     * direct single-file API use).
+     */
+    includeRoot?: string;
+    /**
+     * AsciiDoc attribute values. Surfaces in two places:
+     *  - `adoc2md-modular`'s `attributes` option (mostly a no-op today —
+     *    the engine emits `{{ name }}` for everything anyway).
+     *  - Minja's render context — this is where the actual substitution
+     *    happens. Any `{{ name }}` whose `name` is in this map gets
+     *    resolved; the rest are preserved.
+     */
+    attributes?: Record<string, unknown>;
+    /**
+     * Caller-supplied env values merged into the markdown-it env object.
+     * Available to plugins; format-asciidoc itself doesn't read from env.
+     */
+    envOverrides?: Record<string, unknown>;
+    /**
+     * Definition-list output format passed to the engine. Dogsbay defaults
+     * to `'pandoc'` (a real `term` / `:   desc` list that markdown-it-deflist
+     * renders as `<dl>`) rather than the engine's generic `'markdown'`
+     * default (a lossy bulleted-bold-term hack that can't nest). `<dl>` is
+     * what Dogsbay's renderer natively understands (deflist → `deflist`
+     * TreeNode → `<dl>`). See plans/dlist-markdown-indentation.md and
+     * adoc2md-modular DD-009.
+     */
+    dlistFormat?: "markdown" | "html" | "pandoc";
+    /**
+     * Admonition output format passed to the engine. Dogsbay defaults to
+     * `'docusaurus'` (`:::note`) — its native callout directive, which
+     * renders as an Alert component — rather than the engine's generic
+     * `'html'` default (`<dl><dt>📌 NOTE</dt>…`). adoc2md-modular DD-010.
+     * All three admonition shapes respect this option — block-form
+     * `[NOTE]\n====`, bare `[NOTE]` + paragraph, and line-form
+     * `NOTE: …` (which the engine expands to block form internally).
+     */
+    admonitionFormat?: "html" | "mkdocs" | "docusaurus" | "github";
+    /**
+     * Attribute names the caller KNOWS are false — the corpus's other distro
+     * flags in a single-distro migrate (AsciiBinder loaders surface the full
+     * set on LoaderResult.distros). Drives the engine's conditional STATE
+     * tracking only; never drops output text.
+     */
+    falseAttributes?: string[];
+    /** Clamp over-declared rowspans to fitting rows (issue #031). Opt-in. */
+    clampRowspans?: boolean;
+    /**
+     * Docroot-relative slug of the source page (e.g. `"architecture/admission-plug-ins"`).
+     * Threaded into adoc2md-modular so cross-doc xref hrefs resolve to
+     * root-relative paths instead of file-relative `../…` (which is off by one
+     * under Astro's default directory-style URLs). See
+     * plans/xref-absolute-hrefs.md.
+     */
+    sourcePath?: string;
+    /**
+     * Antora corpus mode — passed through to the engine. Enables
+     * module-coordinate xref translation (`xref:module:page[]`),
+     * resource-ID include resolution (`include::partial$…[]`), and
+     * output-relative `{% include %}` paths. Set by cli.ts when the
+     * antora corpus loader was picked. See plans/antora-support-gaps.md.
+     */
+    antora?: boolean;
+    /**
+     * Emit `[role]`/`[.role]` as markdown-it-attrs classes and keep
+     * role-styled inline marks as `<span class>` — only safe when the
+     * downstream parser runs markdown-it-attrs (the migrate → dogsbay-md
+     * flow). Fragments always had this on; pages did not, so a page and
+     * its own fragment copy disagreed on every role (#076 follow-up).
+     */
+    blockRoles?: boolean;
+    /** Antora playbook mode (#067): loaded components by name → {dir, prefix}. */
+    antoraComponents?: Record<string, {
+        dir: string;
+        prefix: string;
+    }>;
+}
+/**
+ * Parse an AsciiDoc source string into TreeNode[].
+ *
+ * Async because Minja's renderer is async (handles I/O for includes
+ * and supports timeout enforcement).
+ *
+ * Mirrors `parseToTree` from `format-mkdocs` in shape: takes a
+ * markdown-it instance + source, returns `{ tree, env }`.
+ */
+export declare function parseAsciidocToTree(md: MarkdownIt, src: string, opts?: ParseAsciidocOptions): Promise<{
+    tree: TreeNode[];
+    env: Record<string, unknown>;
+    /**
+     * Raw engine output — `asciidocToMarkdown(src)` — before any
+     * Minja evaluation, before markdown-it tokenisation. The most
+     * faithful possible markdown rendition of the AsciiDoc source:
+     *
+     *   - `{% set %}` directives intact (build-time preprocessor
+     *     evaluates them when it has the attribute context).
+     *   - `{% include %}` directives intact (not inlined here —
+     *     build-time preprocessor handles inclusion against the
+     *     resolved attribute context).
+     *   - `{%- if %}` directives with whitespace-control intact
+     *     (`-` stripping fires at *resolution* time, not parse
+     *     time; preserving it keeps the migrated file rendering
+     *     identically to the original `.adoc` once a real build
+     *     resolves the conditionals).
+     *   - `{{ var }}` references intact, regardless of whether
+     *     `opts.attributes` supplied a value.
+     *
+     * Surfaced for `migrate-asciidoc`'s benefit: writing this to disk
+     * preserves the line structure of the original `.adoc` (each
+     * `ifdef`/`endif` block on its own line, blank lines between
+     * major blocks). Running Minja at migrate time would collapse
+     * lines (`-` trim fuses adjacent lines), consume `{% set %}`
+     * metadata, and inline `{% include %}` content — all undesirable
+     * for editable source.
+     *
+     * The `tree` field is the post-Minja-preserve, fully-parsed
+     * TreeNode shape — that's what the runtime path (format-astro
+     * emit, direct `from: asciidoc` builds) consumes. The two
+     * fields exist for two different downstream consumers; they're
+     * NOT derived from each other.
+     */
+    intermediateMd: string;
+}>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAK1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,MAAM,WAAW,oBAAoB;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEvC;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;IAE7C;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,QAAQ,CAAC;IAE/D;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpE;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC;IACT,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC,CAiGD"}

package/dist/parse.js

@@ -0,0 +1,150 @@
+import { dirname } from "node:path";
+import { asciidocToMarkdown } from "@dogsbay/adoc2md-modular";
+import { render as minjaRender, FileSystemLoader } from "@dogsbay/minja";
+import { maskMinjaInCode, unmaskMinjaInCode, stripInlineMinjaMarkers } from "@dogsbay/format-dogsbay-md";
+import { tokensToTree } from "./walker.js";
+/**
+ * Parse an AsciiDoc source string into TreeNode[].
+ *
+ * Async because Minja's renderer is async (handles I/O for includes
+ * and supports timeout enforcement).
+ *
+ * Mirrors `parseToTree` from `format-mkdocs` in shape: takes a
+ * markdown-it instance + source, returns `{ tree, env }`.
+ */
+export async function parseAsciidocToTree(md, src, opts = {}) {
+    // Stage 1 — AsciiDoc → Markdown-with-Minja-directives.
+    // Dogsbay house defaults: 'pandoc' dlists + 'docusaurus' admonitions —
+    // the shapes Dogsbay's renderer natively understands (<dl> via
+    // markdown-it-deflist; :::note → Alert). The engine keeps its generic
+    // 'markdown'/'html' defaults; the consumer selects. See DD-009/DD-010.
+    const intermediateMd = asciidocToMarkdown(src, {
+        attributes: opts.attributes,
+        basePath: opts.filePath,
+        dlistFormat: opts.dlistFormat ?? "pandoc",
+        admonitionFormat: opts.admonitionFormat ?? "docusaurus",
+        sourcePath: opts.sourcePath,
+        antora: opts.antora ?? false,
+        ...(opts.antoraComponents ? { antoraComponents: opts.antoraComponents } : {}),
+        blockRoles: opts.blockRoles ?? false,
+        falseAttributes: opts.falseAttributes ?? [],
+        clampRowspans: opts.clampRowspans ?? false,
+        // Tag-filtered includes splice file content at CONVERT time, below
+        // the Minja layer — the engine enforces the same containment there
+        // (#027 review finding F1).
+        includeRoot: opts.includeRoot,
+    });
+    // Stage 2 — resolve Minja directives. Preserve mode means unresolved
+    // refs survive as literal `{{ name }}` / `{% if … %}` text in the
+    // output. That text passes through markdown-it as part of the
+    // surrounding paragraph; the consumer can re-render with a richer
+    // context later if needed.
+    //
+    // basePath is the file's DIRECTORY (not the file itself) so
+    // Minja's FileSystemLoader can join relative `{% include %}`
+    // targets correctly. Earlier passes used `opts.filePath` directly,
+    // which produced ENOTDIR errors trying to treat the .adoc file as
+    // a directory.
+    //
+    // We wrap the render call in try/catch so that a Minja parse
+    // error (e.g. hyphenated identifiers in `{% if product-version %}`,
+    // which Minja's expression grammar doesn't accept) doesn't abort
+    // the entire import. Fall back to the engine output unchanged —
+    // every surviving directive lives on as literal text in the
+    // markdown, matching `preserve` mode's intent for whole-block
+    // failures the same way it handles single-variable failures. We
+    // log a warning so the user knows why some directives didn't
+    // resolve.
+    const basePath = opts.filePath ? dirname(opts.filePath) : "";
+    let resolvedMd;
+    try {
+        // Code regions are content, not directives: mask `{{`/`{%` openers
+        // inside fences and inline code before the string evaluator runs
+        // (the same shared guard site-build uses), restore verbatim after.
+        // Without this, a code example like Helm's `{{ .Values.name }}`
+        // whose name collides with a defined doc attribute was silently
+        // substituted at import.
+        const rendered = await minjaRender(maskMinjaInCode(intermediateMd), {
+            context: opts.attributes ?? {},
+            undefinedBehavior: "preserve",
+            hyphenToUnderscore: true,
+            basePath,
+            loader: new FileSystemLoader(process.cwd(), { root: opts.includeRoot }),
+        });
+        // The inline `{minja}` markers (engine-planted attr refs, #030) have
+        // done their job — strip them, or this parser (which deliberately
+        // excludes markdown-it-attrs) leaks them as literal text nodes.
+        resolvedMd = stripInlineMinjaMarkers(unmaskMinjaInCode(rendered));
+    }
+    catch (err) {
+        // A containment refusal (#027) is a security event, not a parse
+        // hiccup — rethrow so the caller's per-page handling surfaces it
+        // (cli.ts logs the page and counts the failure) instead of quietly
+        // preserving directives.
+        if (err instanceof Error && err.name === "IncludeContainmentError") {
+            throw err;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        const where = opts.filePath ? ` in ${opts.filePath}` : "";
+        console.warn(`asciidoc parse: Minja render failed${where}, preserving raw directives (${msg})`);
+        resolvedMd = stripInlineMinjaMarkers(intermediateMd);
+    }
+    // Stage 3 — markdown-it parse + walker.
+    const env = { ...(opts.envOverrides ?? {}) };
+    const tokens = md.parse(resolvedMd, env);
+    const tree = flattenProseWrappers(tokensToTree(tokens));
+    // `intermediateMd` is the RAW engine output — pre-Minja,
+    // pre-markdown-it. The faithful AsciiDoc → markdown
+    // translation. migrate-asciidoc writes this to disk so all
+    // `{% set %}` / `{% include %}` / `{%- if %}` directives
+    // survive verbatim for the build-time preprocessor to handle.
+    // (Returning `resolvedMd` here would consume `{% set %}` lines,
+    // inline `{% include %}` content, and fuse lines via `{%-`
+    // whitespace control — all wrong for editable migrated source.)
+    // The `tree` is parsed from the Minja-resolved form (`resolvedMd`)
+    // for accurate runtime rendering when used directly via
+    // `from: asciidoc` — a separate consumer with separate needs.
+    return { tree, env, intermediateMd };
+}
+/**
+ * Normalise the walker's "wrapped" shape into the "flat" shape that
+ * every other TreeNode consumer expects.
+ *
+ * The format-mkdocs walker (which we inherit) wraps inline content
+ * of heading / paragraph / list-item / dt / dd nodes in a single
+ * `{type:"prose", inline: [...]}` child instead of attaching
+ * `inline` directly to the parent. format-dogsbay-md's serializer
+ * and most downstream consumers read `node.inline`; lifting the
+ * inline up here means every consumer sees a single canonical shape
+ * and we don't have to thread cross-shape tolerance through every
+ * call site.
+ *
+ * Recursive — handles nested blocks (e.g. list_item containing a
+ * paragraph).
+ */
+function flattenProseWrappers(nodes) {
+    const FLATTENABLE = new Set([
+        "heading",
+        "paragraph",
+        "list_item",
+        "dt",
+        "dd",
+    ]);
+    return nodes.map((node) => {
+        let out = node;
+        if (FLATTENABLE.has(node.type) &&
+            Array.isArray(node.children) &&
+            node.children.length === 1 &&
+            node.children[0].type === "prose" &&
+            Array.isArray(node.children[0].inline)) {
+            const prose = node.children[0];
+            out = { ...node, inline: prose.inline };
+            delete out.children;
+        }
+        else if (Array.isArray(node.children)) {
+            out = { ...node, children: flattenProseWrappers(node.children) };
+        }
+        return out;
+    });
+}
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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"}

package/dist/tree.d.ts

@@ -0,0 +1,2 @@
+export type { TreeNode } from "@dogsbay/types";
+//# sourceMappingURL=tree.d.ts.map

package/dist/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../src/tree.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/tree.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tree.js.map

package/dist/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","sourceRoot":"","sources":["../src/tree.ts"],"names":[],"mappings":""}

package/dist/walker.d.ts

@@ -0,0 +1,8 @@
+import type Token from "markdown-it/lib/token.mjs";
+import type { TreeNode } from "./tree.js";
+/**
+ * Convert a markdown-it token stream into a TreeNode[].
+ * Handles open/close token pairs by recursively collecting children.
+ */
+export declare function tokensToTree(tokens: Token[]): TreeNode[];
+//# sourceMappingURL=walker.d.ts.map

package/dist/walker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walker.d.ts","sourceRoot":"","sources":["../src/walker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,2BAA2B,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAG1C;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,EAAE,CAkCxD"}