@dogsbay/format-dogsbay-md 0.2.0-beta.130 → 0.2.0-beta.132

package/dist/browser.d.ts

@@ -22,3 +22,4 @@ export { maskMinjaInCode, unmaskMinjaInCode, maskAllMinjaOpeners, isMinjaProcess
 export { extractHeadings, slugifyHeadingText, type HeadingInfo } from "./headings.js";
 export { splitFrontmatter, type Frontmatter } from "./frontmatter.js";
 export { TemplatePages, TemplatePageError, declaresParams, ATTRIBUTE_BLOCK_OPEN, type TemplatePagesOptions } from "./template-pages.js";
+export { dogsbayMdPageFiles, mountCopies, carriedFrontmatter, MEDIA_EXTS, type AssetMount } from "./project.js";

package/dist/browser.js

@@ -22,3 +22,4 @@ export { maskMinjaInCode, unmaskMinjaInCode, maskAllMinjaOpeners, isMinjaProcess
 export { extractHeadings, slugifyHeadingText } from "./headings.js";
 export { splitFrontmatter } from "./frontmatter.js";
 export { TemplatePages, TemplatePageError, declaresParams, ATTRIBUTE_BLOCK_OPEN } from "./template-pages.js";
+export { dogsbayMdPageFiles, mountCopies, carriedFrontmatter, MEDIA_EXTS } from "./project.js";

package/dist/cli.d.ts

@@ -1,20 +1,3 @@
 import type { FormatPlugin } from "@dogsbay/types";
-/**
- * The source page's front matter, carried into the Dogsbay MD it becomes.
- * It used to be DROPPED (only title and redirect were written), so a
- * converted corpus lost `description`, `tags` and custom fields, and a
- * query listing (`::child-links{match=…}`) over it found nothing.
- *
- * Keys Dogsbay MD gives meaning to keep their value only when the value
- * MEANS that here; otherwise the key moves under `imported:` — kept, never
- * misread. Starlight's `template: splash` (a page template) must not turn a
- * page into a Jinja template page. A Dogsbay MD source round-trips unchanged:
- * its values are valid by construction.
- *
- * `title`, `redirect` and the template keys are written by the caller.
- * `layout` is free-form (a theme layout name) and passes as it is.
- * `imported:`, not `source:` — Cloudflare pages carry their own `source:`
- * (an origin URL, 91 pages), which the moved keys would have overwritten.
- */
-export declare function carriedFrontmatter(fm: Record<string, unknown> | undefined): Record<string, unknown>;
+export { carriedFrontmatter } from "./project.js";
 export declare const plugin: FormatPlugin;

package/dist/cli.js

@@ -4,15 +4,17 @@
  * Reads a directory of .md files, parses each via dogsbayMdToTree, builds nav
  * from directory structure + frontmatter, returns ExportPage[] + NavItem[].
  */
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join, relative, basename, dirname } from "node:path";
 import { extractHeadings } from "./headings.js";
 import { parseMeta } from "@dogsbay/types";
 import { dogsbayMdToTree } from "./parse.js";
-import { treeToDogsbayMd } from "./serialize.js";
 import { buildNavFromDirectory } from "./nav.js";
 import { renderDiagrams } from "./renderers/diagrams.js";
 import { DOGSBAY_MD_CAPABILITIES } from "./capabilities.js";
+import { dogsbayMdPageFiles, mountCopies } from "./project.js";
+import { readFolder } from "@dogsbay/corpus/folder";
+export { carriedFrontmatter } from "./project.js";
 /**
  * Detect whether a directory contains a Dogsbay MD source tree.
  *
@@ -221,79 +223,6 @@ function prettifyName(slug) {
  * is the include path. Mirrors migrate-asciidoc's fragment convention so the
  * build-time Minja preprocessor can `{% include %}` them.
  */
-/** Media files worth carrying into `_assets` from a media-only mount. */
-const MEDIA_EXTS = new Set([
-    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif",
-    ".svg", ".ico", ".pdf", ".mp4", ".webm",
-]);
-/** Recursively copy only media files, preserving relative structure. */
-function copyMediaTree(srcDir, destDir) {
-    for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
-        const full = join(srcDir, entry.name);
-        if (entry.isDirectory()) {
-            copyMediaTree(full, join(destDir, entry.name));
-            continue;
-        }
-        const dot = entry.name.lastIndexOf(".");
-        if (dot === -1 || !MEDIA_EXTS.has(entry.name.slice(dot).toLowerCase()))
-            continue;
-        mkdirSync(destDir, { recursive: true });
-        cpSync(full, join(destDir, entry.name));
-    }
-}
-/**
- * The source page's front matter, carried into the Dogsbay MD it becomes.
- * It used to be DROPPED (only title and redirect were written), so a
- * converted corpus lost `description`, `tags` and custom fields, and a
- * query listing (`::child-links{match=…}`) over it found nothing.
- *
- * Keys Dogsbay MD gives meaning to keep their value only when the value
- * MEANS that here; otherwise the key moves under `imported:` — kept, never
- * misread. Starlight's `template: splash` (a page template) must not turn a
- * page into a Jinja template page. A Dogsbay MD source round-trips unchanged:
- * its values are valid by construction.
- *
- * `title`, `redirect` and the template keys are written by the caller.
- * `layout` is free-form (a theme layout name) and passes as it is.
- * `imported:`, not `source:` — Cloudflare pages carry their own `source:`
- * (an origin URL, 91 pages), which the moved keys would have overwritten.
- */
-export function carriedFrontmatter(fm) {
-    if (!fm)
-        return {};
-    const out = {};
-    const source = {};
-    const valid = {
-        // `false` is the documented per-page opt-out of a source's `templates: jinja`.
-        template: (v) => v === "jinja" || v === false,
-        weight: (v) => typeof v === "number" && Number.isFinite(v),
-        order: (v) => typeof v === "number" && Number.isFinite(v),
-        draft: (v) => typeof v === "boolean",
-        status: (v) => typeof v === "string" && ["draft", "preview", "stable", "deprecated"].includes(v),
-        // `params:` declares a template PARTIAL's parameters: only with `template: jinja`.
-        params: (v) => Array.isArray(v) && fm.template === "jinja",
-    };
-    for (const [key, value] of Object.entries(fm)) {
-        if (key === "title" || key === "redirect" || value === undefined)
-            continue;
-        // A source that already has `imported:` keeps it: merged if a mapping,
-        // else nested under its own name.
-        if (key === "imported") {
-            if (value && typeof value === "object" && !Array.isArray(value))
-                Object.assign(source, value);
-            else
-                source.imported = value;
-            continue;
-        }
-        if (valid[key] && !valid[key](value))
-            source[key] = value;
-        else
-            out[key] = value;
-    }
-    if (Object.keys(source).length)
-        out.imported = source;
-    return out;
-}
 async function exportDogsbayMd(pages, nav, output, opts) {
     mkdirSync(output, { recursive: true });
     // Copy mounted asset dirs (e.g. Docusaurus `static/`) into `content/_assets/`,
@@ -303,51 +232,27 @@ async function exportDogsbayMd(pages, nav, output, opts) {
     // `content/_assets/**` through to `/_assets/**`. A mount may target an
     // `_assets` subdir (`into`) and restrict itself to media files (`mediaOnly`) —
     // used for docs-co-located images where the mount dir IS the docs tree.
+    // The copy is `mountCopies` over the mount read as a corpus — the list the browser import
+    // copies from its map, so both hosts copy the same files. A mount is someone else's repo:
+    // a symlink out of it (`public/leak.png -> ~/.ssh/id_rsa`) was copied as a link to that
+    // file, and `node_modules` / `.git` inside it were copied whole (2026-10-21).
     if (Array.isArray(opts.assetMounts)) {
         for (const mount of opts.assetMounts) {
             if (!existsSync(mount.dir))
                 continue;
-            // Per-mount root: `_assets` for an imported corpus, `images`/`assets`
-            // for hand-authored content. A hardcoded root would copy the file
-            // where the reference does not point.
-            const assetsRoot = join(output, mount.root ?? "_assets");
-            const dest = mount.into ? join(assetsRoot, mount.into) : assetsRoot;
-            if (mount.mediaOnly) {
-                copyMediaTree(mount.dir, dest);
-                continue;
+            const folder = readFolder(mount.dir);
+            for (const { from, to } of mountCopies(folder.paths, [{ ...mount, dir: "" }])) {
+                const dst = join(output, to);
+                mkdirSync(dirname(dst), { recursive: true });
+                copyFileSync(folder.absolute(from), dst);
             }
-            const skip = new Set(mount.exclude ?? []);
-            cpSync(mount.dir, dest, {
-                recursive: true,
-                ...(skip.size === 0 ? {} : {
-                    // Relative to the mount, so an exclusion cannot be accidentally
-                    // satisfied by a directory name somewhere above it on disk.
-                    filter: (src) => {
-                        const rel = relative(mount.dir, src);
-                        return rel === "" || !rel.split(/[\\/]/).some((seg) => skip.has(seg));
-                    },
-                }),
-            });
         }
     }
-    for (const page of pages) {
-        const slug = page.slug || "index";
-        const outPath = join(output, `${slug}.md`);
+    for (const [path, text] of dogsbayMdPageFiles(pages, nav)) {
+        const outPath = join(output, path);
         mkdirSync(dirname(outPath), { recursive: true });
-        // A template partial keeps its `params:` and the template flag, so the
-        // build treats it as a partial and checks every include against it.
-        const templateFm = page.template ? { template: "jinja", ...(page.templateParams ? { params: page.templateParams } : {}) } : {};
-        // A title-less template page still needs `template: jinja`, or the build
-        // renders it in content mode and shows the directives as text.
-        const frontmatter = page.fragment || !page.title
-            ? (page.template ? templateFm : undefined)
-            : { title: page.title, ...carriedFrontmatter(page.frontmatter), ...(page.redirect ? { redirect: page.redirect } : {}), ...templateFm };
-        const md = treeToDogsbayMd(page.tree, frontmatter ? { frontmatter } : undefined);
-        writeFileSync(outPath, md.endsWith("\n") ? md : md + "\n", "utf-8");
+        writeFileSync(outPath, text, "utf-8");
     }
-    // Nav as nav.json at the content root (the dogsbay-md importer + runtime
-    // loader both prefer nav.json). Fragments never appear here.
-    writeFileSync(join(output, "nav.json"), JSON.stringify(nav, null, 2) + "\n", "utf-8");
 }
 export const plugin = {
     name: "dogsbay-md",

package/dist/project.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A converted corpus as a Dogsbay MD project, as data: what `convert --to dogsbay-md` writes
+ * (each page as `<slug>.md`, the nav as `nav.json`, the importer's asset mounts under
+ * `_assets/`), without the file system. The exporter writes these files; the playground's
+ * browser imports (`@dogsbay/format-vitepress/migrate`) return them, so a migration in the
+ * browser is the one `convert` does.
+ */
+import type { ExportPage, NavItem } from "@dogsbay/types";
+/** Media files worth carrying into `_assets` from a media-only mount. */
+export declare const MEDIA_EXTS: Set<string>;
+/**
+ * The source page's front matter, carried into the Dogsbay MD it becomes.
+ * It used to be DROPPED (only title and redirect were written), so a
+ * converted corpus lost `description`, `tags` and custom fields, and a
+ * query listing (`::child-links{match=…}`) over it found nothing.
+ *
+ * Keys Dogsbay MD gives meaning to keep their value only when the value
+ * MEANS that here; otherwise the key moves under `imported:` — kept, never
+ * misread. Starlight's `template: splash` (a page template) must not turn a
+ * page into a Jinja template page. A Dogsbay MD source round-trips unchanged:
+ * its values are valid by construction.
+ *
+ * `title`, `redirect` and the template keys are written by the caller.
+ * `layout` is free-form (a theme layout name) and passes as it is.
+ * `imported:`, not `source:` — Cloudflare pages carry their own `source:`
+ * (an origin URL, 91 pages), which the moved keys would have overwritten.
+ */
+export declare function carriedFrontmatter(fm: Record<string, unknown> | undefined): Record<string, unknown>;
+/** Each page as `<slug>.md` and the nav as `nav.json`, relative to the content root. */
+export declare function dogsbayMdPageFiles(pages: ExportPage[], nav: NavItem[]): Map<string, string>;
+/** An importer's asset directory, as `ImportResult.assetMounts` declares it, relative to the corpus. */
+export interface AssetMount {
+    dir: string;
+    /** A subdirectory of the root to land in (`pages` → `_assets/pages/`). */
+    into?: string;
+    /** Media files only (`MEDIA_EXTS`): the mount is the docs tree itself. */
+    mediaOnly?: boolean;
+    /**
+     * Directory names to leave behind, matched at ANY depth in the mount.
+     *
+     * `mediaOnly` is the wrong tool when a mount is mostly wanted: it also drops scripts, YAML
+     * and text a corpus may legitimately carry. This skips named subtrees instead — e.g.
+     * Calico's `licenses/`, ~35 MB of third-party attribution HTML for versions the corpus does
+     * not even import, which nothing references. Matched at any depth on purpose: the first
+     * version compared only the FIRST path segment and silently did nothing, because the real
+     * tree is `_assets/calico/3.32/licenses/…`.
+     */
+    exclude?: string[];
+    /** Public root the mount lands in; `_assets` unless the source used another. */
+    root?: string;
+}
+/**
+ * The files the exporter copies for `mounts`, from a corpus's `paths`: corpus path → path in
+ * the content root. The same rules as the exporter's copy on disk: the whole mount minus
+ * excluded names, or its media only.
+ */
+export declare function mountCopies(paths: string[], mounts: AssetMount[]): {
+    from: string;
+    to: string;
+}[];

package/dist/project.js

@@ -0,0 +1,109 @@
+import { treeToDogsbayMd } from "./serialize.js";
+/** Media files worth carrying into `_assets` from a media-only mount. */
+export const MEDIA_EXTS = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif",
+    ".svg", ".ico", ".pdf", ".mp4", ".webm",
+]);
+/**
+ * The source page's front matter, carried into the Dogsbay MD it becomes.
+ * It used to be DROPPED (only title and redirect were written), so a
+ * converted corpus lost `description`, `tags` and custom fields, and a
+ * query listing (`::child-links{match=…}`) over it found nothing.
+ *
+ * Keys Dogsbay MD gives meaning to keep their value only when the value
+ * MEANS that here; otherwise the key moves under `imported:` — kept, never
+ * misread. Starlight's `template: splash` (a page template) must not turn a
+ * page into a Jinja template page. A Dogsbay MD source round-trips unchanged:
+ * its values are valid by construction.
+ *
+ * `title`, `redirect` and the template keys are written by the caller.
+ * `layout` is free-form (a theme layout name) and passes as it is.
+ * `imported:`, not `source:` — Cloudflare pages carry their own `source:`
+ * (an origin URL, 91 pages), which the moved keys would have overwritten.
+ */
+export function carriedFrontmatter(fm) {
+    if (!fm)
+        return {};
+    const out = {};
+    const source = {};
+    const valid = {
+        // `false` is the documented per-page opt-out of a source's `templates: jinja`.
+        template: (v) => v === "jinja" || v === false,
+        weight: (v) => typeof v === "number" && Number.isFinite(v),
+        order: (v) => typeof v === "number" && Number.isFinite(v),
+        draft: (v) => typeof v === "boolean",
+        status: (v) => typeof v === "string" && ["draft", "preview", "stable", "deprecated"].includes(v),
+        // `params:` declares a template PARTIAL's parameters: only with `template: jinja`.
+        params: (v) => Array.isArray(v) && fm.template === "jinja",
+    };
+    for (const [key, value] of Object.entries(fm)) {
+        if (key === "title" || key === "redirect" || value === undefined)
+            continue;
+        // A source that already has `imported:` keeps it: merged if a mapping,
+        // else nested under its own name.
+        if (key === "imported") {
+            if (value && typeof value === "object" && !Array.isArray(value))
+                Object.assign(source, value);
+            else
+                source.imported = value;
+            continue;
+        }
+        if (valid[key] && !valid[key](value))
+            source[key] = value;
+        else
+            out[key] = value;
+    }
+    if (Object.keys(source).length)
+        out.imported = source;
+    return out;
+}
+/** Each page as `<slug>.md` and the nav as `nav.json`, relative to the content root. */
+export function dogsbayMdPageFiles(pages, nav) {
+    const files = new Map();
+    for (const page of pages) {
+        const slug = page.slug || "index";
+        // A template partial keeps its `params:` and the template flag, so the
+        // build treats it as a partial and checks every include against it.
+        const templateFm = page.template ? { template: "jinja", ...(page.templateParams ? { params: page.templateParams } : {}) } : {};
+        // A title-less template page still needs `template: jinja`, or the build
+        // renders it in content mode and shows the directives as text.
+        const frontmatter = page.fragment || !page.title
+            ? (page.template ? templateFm : undefined)
+            : { title: page.title, ...carriedFrontmatter(page.frontmatter), ...(page.redirect ? { redirect: page.redirect } : {}), ...templateFm };
+        const md = treeToDogsbayMd(page.tree, frontmatter ? { frontmatter } : undefined);
+        files.set(`${slug}.md`, md.endsWith("\n") ? md : md + "\n");
+    }
+    // Nav as nav.json at the content root (the dogsbay-md importer + runtime
+    // loader both prefer nav.json). Fragments never appear here.
+    files.set("nav.json", JSON.stringify(nav, null, 2) + "\n");
+    return files;
+}
+/**
+ * The files the exporter copies for `mounts`, from a corpus's `paths`: corpus path → path in
+ * the content root. The same rules as the exporter's copy on disk: the whole mount minus
+ * excluded names, or its media only.
+ */
+export function mountCopies(paths, mounts) {
+    const out = [];
+    for (const mount of mounts) {
+        const dir = mount.dir.replace(/\/+$/, "");
+        const dest = [mount.root ?? "_assets", mount.into].filter(Boolean).join("/");
+        const skip = new Set(mount.exclude ?? []);
+        for (const path of paths) {
+            if (dir && !path.startsWith(dir + "/"))
+                continue;
+            const rel = dir ? path.slice(dir.length + 1) : path;
+            const segs = rel.split("/");
+            if (mount.mediaOnly) {
+                const name = segs[segs.length - 1];
+                const dot = name.lastIndexOf(".");
+                if (dot === -1 || !MEDIA_EXTS.has(name.slice(dot).toLowerCase()))
+                    continue;
+            }
+            else if (segs.some((s) => skip.has(s)))
+                continue;
+            out.push({ from: path, to: `${dest}/${rel}` });
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dogsbay/format-dogsbay-md",
-  "version": "0.2.0-beta.130",
+  "version": "0.2.0-beta.132",
   "description": "Dogsbay Markdown dialect — canonical format for TreeNode[] with directives, YAML bodies, and intelligent fallbacks",
   "type": "module",
   "main": "dist/index.js",
@@ -40,9 +40,10 @@
     "markdown-it-footnote": "^4.0.0",
     "markdown-it-front-matter": "^0.2.4",
     "pele": "1.6.0",
-    "@dogsbay/minja": "0.2.0-beta.130",
-    "@dogsbay/serialize-core": "0.2.0-beta.130",
-    "@dogsbay/types": "0.2.0-beta.130"
+    "@dogsbay/corpus": "0.2.0-beta.132",
+    "@dogsbay/minja": "0.2.0-beta.132",
+    "@dogsbay/serialize-core": "0.2.0-beta.132",
+    "@dogsbay/types": "0.2.0-beta.132"
   },
   "license": "MIT",
   "repository": {