create-ailk 0.30.0 → 0.32.0

package/dist/lib/import-mdx.js

@@ -10,17 +10,40 @@
  * and reason and the run goes on. The seed step (U6b) and `migrate-content`
  * (U6c) both call it; this module adds no command.
  *
+ * A page whose frontmatter carries `sections` is converted (#10534): its
+ * words move into the Markdown body through the words codec
+ * (`sectionsToMarkdown`, ADR 0038), after the body it already had, and the
+ * sections — layout and data — go to the structure layer through
+ * `PUT …/structure` under the draft's structure token (#10643), never into the
+ * stored content. An unchanged layout writes nothing, so a re-run still
+ * reports `unchanged`; a changed layout on a live draft is refused
+ * `draft_is_live` and the page fails with that reason.
+ *
  * create-ailk ships one runtime dependency, so the adapter is never imported:
  * the caller injects it, and `loadSiteMdxAdapter` resolves the SITE's
- * installed copy from its `apps/web` at run time (the #6937 precedent).
+ * installed copy from its `apps/web` at run time (the #6937 precedent), and
+ * the codec from the validation package that copy depends on.
+ *
+ * Given `editorialRoot` — a site's `apps/web/content` — it also walks the
+ * docs-blog tree (#10701): each `<locale>/{blog,docs}/<slug>.mdx` or
+ * `<slug>/index.mdx` becomes a `BlogPosting` / `DocsDetail` page (the
+ * directory's own `index.mdx` its `BlogList` / `DocsList` index), its
+ * fumadocs frontmatter mapped to the stored vocabulary and written through the
+ * same converting path. Every outcome names the root it came from.
+ *
+ * Given `publish` (#10659 D2), each page with no Live version is set Live
+ * after it is written (`POST …/publish`, the draft tip); a page already Live
+ * is never published over. The first refused publish stops the publishes
+ * that follow, never the saves.
  *
  * The key travels only as `authorization: Bearer <key>`, never across a
  * redirect (`redirect: "error"`), and is never printed. Of an API answer only
  * a status and a `[a-z0-9_]` error code reach output (SEC-7876-S1).
  *
- * Spec: docs/specs/10203-import-mdx-one-mdx-artifact-spec.md.
+ * Spec: docs/specs/10203-import-mdx-one-mdx-artifact-spec.md; the editorial
+ * walk docs/specs/10701-import-mdx-walks-the-editorial-spec.md.
  */
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -30,8 +53,42 @@ import { TopologyError, normalizeHubUrl } from "../topology.js";
  * import specifier of a package create-ailk does not depend on appears here.
  */
 const CONTENT_ADAPTERS_PACKAGE = "@working-theory/content-adapters";
+/** Where the words codec lives: a dependency of the adapter package. */
+const VALIDATION_PACKAGE = "@working-theory/validation";
+/** The adapter package's frontmatter parser, resolved from its entry. */
+const FRONTMATTER_PACKAGE = "gray-matter";
 /** The adapter's locale shape (`BCP47_RE` in its `mdx/adapter.ts`). */
 const LOCALE = /^[a-z]{2}(-[A-Z]{2})?$/;
+/** `SLUG_PATTERN` in the adapter's `errors.ts`, restated: no runtime dep. */
+const SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+/** A `parent`'s shape (`ServiceFieldsSchema` in the adapter's `types.ts`), restated: no runtime dep. */
+const PARENT = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** Each editorial directory's page type and index type (`runtime-source.ts`). */
+const EDITORIAL_TYPES = {
+    blog: { page: "BlogPosting", index: "BlogList" },
+    docs: { page: "DocsDetail", index: "DocsList" },
+};
+/** The slug the runtime reads as a surface's own index. */
+const INDEX_SLUG = "index";
+const INDEX_TYPES = new Set(Object.values(EDITORIAL_TYPES).map((k) => k.index));
+/**
+ * `fumadocsToArtifactFrontmatter` (`apps/web/lib/runtime-source.ts`) restated —
+ * fumadocs key to stored key — less `tags`, which the store keeps itself, plus
+ * `sections`, which `convert` moves. Any other key is not sent.
+ */
+const EDITORIAL_FIELDS = {
+    title: "title",
+    description: "description",
+    date: "publishedAt",
+    updated: "updatedAt",
+    image: "image",
+    author: "author",
+    order: "order",
+    parent: "parent",
+    sections: "sections",
+};
+/** Keys not sent and not reported: the path decides both, and a strip marker. */
+const EDITORIAL_IGNORED = new Set(["type", "slug", "oss"]);
 /** `wksp_<uuidv7>` — the `@working-theory/ids` shape, restated: no runtime dep. */
 const WORKSPACE_ID = /^wksp_[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 /** A key is visible ASCII only: what an HTTP header can carry, with no space. */
@@ -55,16 +112,19 @@ export class ImportMdxRefusedError extends Error {
 function refuse(message) {
     throw new ImportMdxRefusedError(`import-mdx: ${message} Nothing was sent.`);
 }
-function checkOptions(opts, defaultLocale) {
-    let isDir;
+export function isDirectory(path) {
     try {
-        isDir = statSync(opts.contentRoot).isDirectory();
+        return statSync(path).isDirectory();
     }
     catch {
-        isDir = false;
+        return false;
     }
-    if (!isDir)
+}
+function checkOptions(opts, defaultLocale) {
+    if (!isDirectory(opts.contentRoot))
         refuse(`the content root ${opts.contentRoot} is not a directory.`);
+    if (opts.editorialRoot !== undefined && !isDirectory(opts.editorialRoot))
+        refuse(`the editorial root ${opts.editorialRoot} is not a directory.`);
     if (!KEY_SHAPE.test(opts.apiKey)) {
         refuse("the API key is empty or carries a space, a control character or a non-ASCII character.");
     }
@@ -108,10 +168,16 @@ function mdxFiles(root, prefix = []) {
             : [];
     });
 }
+/** Type, then slug, then a page with no `parent` before a series leaf (#10775 D4). */
 function byTypeThenSlug(a, b) {
     if (a.type !== b.type)
         return a.type < b.type ? -1 : 1;
-    return a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0;
+    if (a.slug !== b.slug)
+        return a.slug < b.slug ? -1 : 1;
+    return Number(a.parent !== undefined) - Number(b.parent !== undefined);
+}
+function byPath(a, b) {
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
 }
 function plan(contentRoot, types, defaultLocale) {
     const localePages = [];
@@ -123,6 +189,7 @@ function plan(contentRoot, types, defaultLocale) {
         const [first, second, third] = segments;
         if (link) {
             skipped.push({
+                root: "content",
                 path,
                 result: "skipped",
                 reason: "a symbolic link is not followed",
@@ -132,6 +199,7 @@ function plan(contentRoot, types, defaultLocale) {
             first === defaultLocale &&
             types.includes(second)) {
             localePages.push({
+                root: "content",
                 path,
                 type: second,
                 slug: slugOf(third),
@@ -140,6 +208,7 @@ function plan(contentRoot, types, defaultLocale) {
         }
         else if (segments.length === 2 && types.includes(first)) {
             legacyPages.push({
+                root: "content",
                 path,
                 type: first,
                 slug: slugOf(second),
@@ -150,6 +219,7 @@ function plan(contentRoot, types, defaultLocale) {
             LOCALE.test(first) &&
             first !== defaultLocale) {
             skipped.push({
+                root: "content",
                 path,
                 result: "skipped",
                 reason: `locale ${first} is not imported (only ${defaultLocale})`,
@@ -157,6 +227,7 @@ function plan(contentRoot, types, defaultLocale) {
         }
         else {
             skipped.push({
+                root: "content",
                 path,
                 result: "skipped",
                 reason: "not a page: the adapter reads <locale>/<Type>/<slug>.mdx",
@@ -172,6 +243,130 @@ function plan(contentRoot, types, defaultLocale) {
         skipped,
     };
 }
+/**
+ * The editorial walk (#10701 D2–D3, #10775 D2): `L/{blog,docs}/<slug>.mdx` and
+ * `<slug>/index.mdx` are posts and docs, the directory's own `index.mdx` its
+ * index page, and `L/blog/<series>/<post>.mdx` or `<post>/index.mdx` a post
+ * whose `parent` is the series. Every other file is skipped with the rule it
+ * failed.
+ */
+function planEditorial(editorialRoot, types, defaultLocale) {
+    const pages = [];
+    const skipped = [];
+    const skip = (path, reason) => skipped.push({ root: "editorial", path, result: "skipped", reason });
+    const found = mdxFiles(editorialRoot).map((f) => ({
+        ...f,
+        path: f.segments.join("/"),
+    }));
+    // Sorted by path first, so within one directory `<slug>.mdx` comes before
+    // `<slug>/index.mdx` and holds the address (`.` sorts before `/`).
+    for (const { segments, link, path } of found.sort(byPath)) {
+        const [locale, dir, file, nested, leafFile] = segments;
+        const kinds = dir !== undefined && Object.hasOwn(EDITORIAL_TYPES, dir)
+            ? EDITORIAL_TYPES[dir]
+            : undefined;
+        if (link) {
+            skip(path, "a symbolic link is not followed");
+            continue;
+        }
+        if (kinds !== undefined && locale !== defaultLocale && LOCALE.test(locale)) {
+            skip(path, `locale ${locale} is not imported (only ${defaultLocale})`);
+            continue;
+        }
+        if (kinds === undefined || locale !== defaultLocale) {
+            skip(path, `not a post or doc: only ${defaultLocale}/blog and ${defaultLocale}/docs are walked`);
+            continue;
+        }
+        let type;
+        let slug;
+        let parent;
+        if (segments.length === 3 && file === "index.mdx") {
+            type = kinds.index;
+            slug = INDEX_SLUG;
+        }
+        else if (segments.length === 3) {
+            type = kinds.page;
+            slug = file.slice(0, -".mdx".length);
+        }
+        else if (segments.length === 4 && nested === "index.mdx") {
+            type = kinds.page;
+            slug = file;
+        }
+        else if (dir === "docs") {
+            skip(path, "a nested doc: a doc is docs/<slug>.mdx or docs/<slug>/index.mdx");
+            continue;
+        }
+        else if (file === "category") {
+            skip(path, "under blog/category: /blog/category/<tag> is the blog's category index, so no post is served there");
+            continue;
+        }
+        else if (segments.length === 4 ||
+            (segments.length === 5 && leafFile === "index.mdx")) {
+            type = kinds.page;
+            slug = segments.length === 4 ? nested.slice(0, -".mdx".length) : nested;
+            parent = file;
+        }
+        else {
+            skip(path, "too deep: a post is blog/<slug>.mdx, blog/<slug>/index.mdx, or one series down at blog/<series>/<post>.mdx or blog/<series>/<post>/index.mdx");
+            continue;
+        }
+        const invalid = !SLUG.test(slug)
+            ? `not a valid slug: ${slug}`
+            : parent !== undefined && !PARENT.test(parent)
+                ? `not a valid series: ${parent} (a parent is lowercase words joined by single hyphens)`
+                : parent === slug
+                    ? `a post cannot share its series' slug: ${slug}`
+                    : !types.includes(type)
+                        ? `the site's adapter has no type ${type}`
+                        : undefined;
+        pages.push({
+            root: "editorial",
+            path,
+            type,
+            slug,
+            localeTree: true,
+            ...(invalid !== undefined && { invalid }),
+            ...(parent !== undefined && { parent }),
+        });
+    }
+    return { pages: pages.sort(byTypeThenSlug), skipped };
+}
+/** A YAML date as the store's string: a bare date as `YYYY-MM-DD`. */
+function dateString(value) {
+    if (!(value instanceof Date) || Number.isNaN(value.getTime()))
+        return value;
+    const iso = value.toISOString();
+    return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso;
+}
+/**
+ * An editorial file as the adapter would return a page (#10701 D4): its
+ * fumadocs frontmatter mapped to the stored vocabulary, the path deciding the
+ * type and slug — and, for a blog page, its `parent` (#10775 D3) — and the
+ * keys not sent named.
+ */
+function editorialSource(page, parsed) {
+    const frontmatter = {
+        type: page.type,
+        slug: page.slug,
+    };
+    const dropped = [];
+    const blog = page.type === "BlogPosting" || page.type === "BlogList";
+    for (const [key, value] of Object.entries(parsed.data)) {
+        const stored = Object.hasOwn(EDITORIAL_FIELDS, key) && !(blog && key === "parent")
+            ? EDITORIAL_FIELDS[key]
+            : undefined;
+        if (stored !== undefined)
+            frontmatter[stored] = dateString(value);
+        else if (!EDITORIAL_IGNORED.has(key))
+            dropped.push(key);
+    }
+    if (page.parent !== undefined)
+        frontmatter["parent"] = page.parent;
+    return {
+        source: { frontmatter, body: parsed.content },
+        dropped: dropped.sort(),
+    };
+}
 // ── "Unchanged" (D4) ────────────────────────────────────────────────────────
 function sortKeys(value) {
     if (Array.isArray(value))
@@ -186,6 +381,16 @@ function sortKeys(value) {
 function canonical(value) {
     return JSON.stringify(sortKeys(JSON.parse(JSON.stringify(value ?? null))));
 }
+/**
+ * Content without `tags`: the store's tagger writes them on every version and
+ * drops a sent value (#10342 D5), so they are never the importer's to compare.
+ */
+function withoutTags(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const { tags: _tags, ...rest } = value;
+    return rest;
+}
 function safeCode(value) {
     return typeof value === "string" && SAFE_CODE.test(value) ? value : "unknown";
 }
@@ -242,84 +447,114 @@ async function call(t, method, url, body, ifMatch) {
         };
     }
 }
-function failed(path, reason, halt) {
+function failed(at, reason, halt) {
     return {
-        outcome: { path, result: "failed", reason },
+        outcome: { root: at.root, path: at.path, result: "failed", reason },
         ...(halt !== undefined && { halt }),
     };
 }
 /** A non-success answer: 401/403 stops the run, anything else fails the page. */
-function refusedAnswer(path, answer) {
+function refusedAnswer(at, answer) {
     if ("network" in answer)
-        return failed(path, answer.network);
+        return failed(at, answer.network);
     const reason = `${answer.status} ${answer.code}`;
     return answer.status === 401 || answer.status === 403
-        ? failed(path, reason, `not sent: the API refused the key (${reason})`)
-        : failed(path, reason);
+        ? failed(at, reason, `not sent: the API refused the key (${reason})`)
+        : failed(at, reason);
 }
 /**
  * A success answered for another locale: the API does not serve `locale`. A
  * success with no locale at all is not the API's answer shape: that page fails.
  */
-function wrongLocale(path, answer, locale) {
+function wrongLocale(at, answer, locale) {
     if ("network" in answer || answer.data["locale"] === locale)
         return undefined;
     if (typeof answer.data["locale"] !== "string") {
-        return failed(path, `${answer.status} unknown`);
+        return failed(at, `${answer.status} unknown`);
     }
-    return failed(path, `the API does not serve locale ${locale}`, `not sent: the API does not serve locale ${locale}`);
+    return failed(at, `the API does not serve locale ${locale}`, `not sent: the API does not serve locale ${locale}`);
 }
-async function writePage(t, page, locale, content) {
-    const { path, type, slug } = page;
-    const address = `${t.base}/content/${encodeURIComponent(type)}/${encodeURIComponent(slug)}?locale=${encodeURIComponent(locale)}`;
-    const done = (result) => ({
-        outcome: { path, result, type, slug },
+async function writePage(t, page, locale, content, layout) {
+    const { root, path, type, slug } = page;
+    const pagePath = `${t.base}/content/${encodeURIComponent(type)}/${encodeURIComponent(slug)}`;
+    const query = `?locale=${encodeURIComponent(locale)}`;
+    const address = `${pagePath}${query}`;
+    // The route's `statusOf`: anything but `draft` has a Live version.
+    let live = false;
+    const outcome = (result) => ({
+        outcome: { root, path, result, type, slug },
+        live,
     });
+    // The words are written; now the layout, under the token the draft holds
+    // (`null` for a page that has none yet).
+    const done = async (result, structureToken = null) => {
+        if (layout === undefined)
+            return outcome(result);
+        const put = await call(t, "PUT", `${pagePath}/structure${query}`, {
+            structureToken,
+            structure: layout,
+        });
+        if ("network" in put || put.status !== 200)
+            return refusedAnswer(page, put);
+        return (wrongLocale(page, put, locale) ??
+            outcome(result === "unchanged" && put.data["written"] === true
+                ? "updated"
+                : result));
+    };
     for (let reread = false;; reread = true) {
         const read = await call(t, "GET", address);
         if ("network" in read)
-            return refusedAnswer(path, read);
+            return refusedAnswer(page, read);
         if (read.status === 200) {
-            const mismatch = wrongLocale(path, read, locale);
+            const mismatch = wrongLocale(page, read, locale);
             if (mismatch !== undefined)
                 return mismatch;
             const version = read.data["version"];
             if (typeof version !== "string")
-                return failed(path, "200 unknown");
-            if (canonical(read.data["content"]) === canonical(content)) {
-                return done("unchanged");
+                return failed(page, "200 unknown");
+            live = read.data["status"] !== "draft";
+            const token = read.data["structureToken"];
+            const structureToken = typeof token === "string" ? token : null;
+            if (canonical(withoutTags(read.data["content"])) ===
+                canonical(withoutTags(content))) {
+                return done("unchanged", structureToken);
             }
             // The token is the version just compared against, so a draft saved
             // since the read is a 409, never a silent overwrite.
             const saved = await call(t, "PATCH", address, content, version);
             if ("network" in saved || saved.status !== 200)
-                return refusedAnswer(path, saved);
-            return wrongLocale(path, saved, locale) ?? done("updated");
+                return refusedAnswer(page, saved);
+            // A save carries the structure token forward (#10330 D5).
+            return (wrongLocale(page, saved, locale) ?? done("updated", structureToken));
         }
         if (read.status !== 404 || reread)
-            return refusedAnswer(path, read);
+            return refusedAnswer(page, read);
         const created = await call(t, "POST", `${t.base}/content`, {
             ...content,
             locale,
         });
         if ("network" in created)
-            return refusedAnswer(path, created);
+            return refusedAnswer(page, created);
         if (created.status === 201) {
-            return wrongLocale(path, created, locale) ?? done("created");
+            return wrongLocale(page, created, locale) ?? done("created");
         }
         // 409 slug_taken: another type holds this page's registry link (#10268
         // D5) — reported as it is, since a re-read at this address finds nothing.
         // Any other 409: created by someone else since the read — read it once more.
         if (created.status !== 409 || created.code === "slug_taken") {
-            return refusedAnswer(path, created);
+            return refusedAnswer(page, created);
         }
     }
 }
 // ── The report (D6) ─────────────────────────────────────────────────────────
+/** An outcome's printed path: an editorial one says so (#10701 D6). */
+export function outcomePath(at) {
+    return at.root === "editorial" ? `editorial: ${at.path}` : at.path;
+}
 function outcomeLine(outcome) {
     return "reason" in outcome
-        ? `${outcome.path}: ${outcome.result} — ${outcome.reason}`
-        : `${outcome.path}: ${outcome.result}`;
+        ? `${outcomePath(outcome)}: ${outcome.result} — ${outcome.reason}`
+        : `${outcomePath(outcome)}: ${outcome.result}`;
 }
 /** The whole report, one line per page and a final count line. */
 export function formatImportMdxReport(result) {
@@ -331,9 +566,36 @@ export function formatImportMdxReport(result) {
 }
 // ── The importer ────────────────────────────────────────────────────────────
 /** One whitespace-collapsed line of at most `ADAPTER_REASON_MAX` characters. */
-function adapterReason(err) {
+function adapterReason(err, stage = "adapter") {
     const message = err instanceof Error ? err.message : String(err);
-    return `adapter: ${message.replace(/\s+/g, " ").trim().slice(0, ADAPTER_REASON_MAX)}`;
+    return `${stage}: ${message.replace(/\s+/g, " ").trim().slice(0, ADAPTER_REASON_MAX)}`;
+}
+/**
+ * What the page stores (#10534): with `sections` and a codec, its words after
+ * the body's own text and its sections as the layout; else the page as read.
+ */
+function convert(source, codec) {
+    const { sections, ...frontmatter } = source.frontmatter;
+    if (!Array.isArray(sections) ||
+        sections.length === 0 ||
+        codec === undefined) {
+        return { content: { ...source.frontmatter, body: source.body } };
+    }
+    let words;
+    try {
+        words = codec(sections);
+    }
+    catch (err) {
+        return { reason: adapterReason(err, "codec") };
+    }
+    const lead = source.body.trimEnd();
+    return {
+        content: {
+            ...frontmatter,
+            body: lead === "" ? words : `${lead}\n\n${words}`,
+        },
+        layout: { kind: "sections", sections },
+    };
 }
 export async function importMdx(opts) {
     const defaultLocale = opts.defaultLocale ?? "en";
@@ -347,7 +609,38 @@ export async function importMdx(opts) {
         onLine,
     };
     const contentRoot = resolve(opts.contentRoot);
-    const { pages, skipped } = plan(contentRoot, opts.adapters.SCHEMA_ORG_TYPES, defaultLocale);
+    const types = opts.adapters.SCHEMA_ORG_TYPES;
+    const content = plan(contentRoot, types, defaultLocale);
+    const editorialRoot = opts.editorialRoot === undefined ? undefined : resolve(opts.editorialRoot);
+    const editorial = editorialRoot === undefined
+        ? { pages: [], skipped: [] }
+        : planEditorial(editorialRoot, types, defaultLocale);
+    const parseFrontmatter = opts.adapters.parseFrontmatter;
+    // #10701 D3 — one route path holds one page, so an editorial index the run
+    // will write supersedes a content page of its type at another slug (the
+    // scaffold's teaser), which the create would refuse `slug_taken`.
+    const indexTypes = new Set(parseFrontmatter === undefined
+        ? []
+        : editorial.pages
+            .filter((p) => p.invalid === undefined && INDEX_TYPES.has(p.type))
+            .map((p) => p.type));
+    const superseded = (p) => indexTypes.has(p.type) && p.slug !== INDEX_SLUG;
+    const pages = [
+        ...content.pages.filter((p) => !superseded(p)),
+        ...editorial.pages,
+    ];
+    const skipped = [
+        ...[
+            ...content.skipped,
+            ...content.pages.filter(superseded).map((p) => ({
+                root: "content",
+                path: p.path,
+                result: "skipped",
+                reason: "superseded by the editorial index page",
+            })),
+        ].sort(byPath),
+        ...editorial.skipped,
+    ];
     const reader = opts.adapters.createMdxAdapter({ contentRoot, defaultLocale });
     const outcomes = [];
     const record = (outcome) => {
@@ -360,46 +653,98 @@ export async function importMdx(opts) {
     // types may share a slug (#10268 D7): the store addresses by type too.
     const addresses = new Map();
     let halt;
+    let publishRefused;
+    let live = 0;
+    let published = 0;
     for (const page of pages) {
         const address = `${page.type}/${page.slug}`;
         const holder = addresses.get(address);
+        const fail = (reason) => record({ root: page.root, path: page.path, result: "failed", reason });
+        if (page.invalid !== undefined) {
+            fail(page.invalid);
+            continue;
+        }
         if (holder !== undefined) {
-            record({
-                path: page.path,
-                result: "failed",
-                reason: `same address as ${holder} (a page is addressed by locale, type and slug)`,
-            });
+            fail(`same address as ${holder} (a page is addressed by locale, type and slug)`);
             continue;
         }
-        addresses.set(address, page.path);
+        addresses.set(address, outcomePath(page));
         if (halt !== undefined) {
-            record({ path: page.path, result: "failed", reason: halt });
+            fail(halt);
             continue;
         }
         let source;
-        try {
-            source = page.localeTree
-                ? await reader.getPageSource(page.type, page.slug, defaultLocale)
-                : await reader.getPageSource(page.type, page.slug);
+        if (page.root === "editorial") {
+            if (parseFrontmatter === undefined) {
+                fail(`editorial: no frontmatter parser — update the site's ${CONTENT_ADAPTERS_PACKAGE} and re-run`);
+                continue;
+            }
+            let read;
+            try {
+                read = editorialSource(page, parseFrontmatter(readFileSync(join(editorialRoot, page.path), "utf8")));
+            }
+            catch (err) {
+                fail(adapterReason(err, "editorial"));
+                continue;
+            }
+            source = read.source;
+            if (read.dropped.length > 0) {
+                onLine(`${page.path}: not imported — ${read.dropped.join(", ")} (the editorial walk sends only the fields the store keeps from a caller)`);
+            }
         }
-        catch (err) {
-            record({ path: page.path, result: "failed", reason: adapterReason(err) });
-            continue;
+        else {
+            try {
+                source = page.localeTree
+                    ? await reader.getPageSource(page.type, page.slug, defaultLocale)
+                    : await reader.getPageSource(page.type, page.slug);
+            }
+            catch (err) {
+                fail(adapterReason(err));
+                continue;
+            }
         }
         if (source === null) {
-            record({
-                path: page.path,
-                result: "failed",
-                reason: "adapter: not read",
-            });
+            fail("adapter: not read");
             continue;
         }
-        const result = await writePage(t, page, defaultLocale, {
-            ...source.frontmatter,
-            body: source.body,
-        });
+        const converted = convert(source, opts.adapters.sectionsToMarkdown);
+        if ("reason" in converted) {
+            fail(converted.reason);
+            continue;
+        }
+        if (converted.layout === undefined &&
+            Array.isArray(source.frontmatter["sections"]) &&
+            source.frontmatter["sections"].length > 0) {
+            onLine(`${page.path}: keeps its words in sections — the site's ${VALIDATION_PACKAGE} has no words codec; update its dependencies and re-run`);
+        }
+        const result = await writePage(t, page, defaultLocale, converted.content, converted.layout);
         halt = result.halt;
-        record(result.outcome);
+        if (opts.publish !== true || "reason" in result.outcome) {
+            record(result.outcome);
+            continue;
+        }
+        if (result.live === true) {
+            live += 1;
+            record(result.outcome);
+            continue;
+        }
+        // #10659 D2 — a page with no Live version is set Live from its draft tip;
+        // after one refused publish, the rest are saved and not sent.
+        let unpublished = publishRefused;
+        if (unpublished === undefined) {
+            const answer = await call(t, "POST", `${t.base}/content/${encodeURIComponent(page.type)}/${encodeURIComponent(page.slug)}/publish?locale=${encodeURIComponent(defaultLocale)}`, {});
+            if (!("network" in answer) && answer.status === 200) {
+                published += 1;
+                live += 1;
+                record(result.outcome);
+                continue;
+            }
+            unpublished = `saved as a draft; not published (${"network" in answer ? answer.network : `${answer.status} ${answer.code}`})`;
+            if (!("network" in answer) && (answer.status === 401 || answer.status === 403)) {
+                publishRefused = unpublished;
+            }
+        }
+        fail(unpublished);
     }
     skipped.forEach(record);
     const counts = {
@@ -411,7 +756,11 @@ export async function importMdx(opts) {
     };
     for (const outcome of outcomes)
         counts[outcome.result] += 1;
-    return { pages: outcomes, counts };
+    return {
+        pages: outcomes,
+        counts,
+        ...(opts.publish === true && { live, published }),
+    };
 }
 // ── The site's own adapter (D1) ─────────────────────────────────────────────
 /** Whether a `node_modules` at or above `dir` holds the adapter package. */
@@ -457,5 +806,36 @@ export async function loadSiteMdxAdapter(siteRoot) {
         !types.every((type) => typeof type === "string")) {
         throw new ImportMdxRefusedError(`import-mdx: ${CONTENT_ADAPTERS_PACKAGE} in ${web} does not export createMdxAdapter and SCHEMA_ORG_TYPES. Install the site's dependencies (pnpm install) first. Nothing was sent.`);
     }
-    return mod;
+    // The codec the adapter's own validation package carries (#10534); one
+    // that predates it, or none, leaves pages unconverted and the run says so.
+    let codec;
+    try {
+        const validation = createRequire(entry).resolve(VALIDATION_PACKAGE);
+        codec = (await import(pathToFileURL(validation).href))["sectionsToMarkdown"];
+    }
+    catch {
+        // Not resolvable from the adapter: no codec.
+    }
+    // The adapter's own frontmatter parser (#10701 D1), for the editorial tree;
+    // none leaves every editorial page failed, and the run says so.
+    let matter;
+    try {
+        const parser = createRequire(entry).resolve(FRONTMATTER_PACKAGE);
+        matter = (await import(pathToFileURL(parser).href))["default"];
+    }
+    catch {
+        // Not resolvable from the adapter: no parser.
+    }
+    return {
+        ...mod,
+        ...(typeof codec === "function" && {
+            sectionsToMarkdown: codec,
+        }),
+        ...(typeof matter === "function" && {
+            parseFrontmatter: (raw) => {
+                const { data, content } = matter(raw);
+                return { data, content };
+            },
+        }),
+    };
 }