create-ailk 0.29.1 → 0.31.0

package/dist/lib/render-comparison.d.ts

@@ -0,0 +1,200 @@
+/** The two viewports every page is compared at. */
+export declare const VIEWPORTS: readonly [{
+    readonly name: "desktop";
+    readonly width: 1440;
+    readonly height: 900;
+}, {
+    readonly name: "mobile";
+    readonly width: 390;
+    readonly height: 844;
+}];
+/** Requests in flight at once, for a sweep or a crawl. */
+export declare const IN_FLIGHT = 4;
+/** The page's words: `main`'s rendered text, else `body`'s. */
+export declare const TEXT_EXPRESSION = "(() => { const root = document.querySelector(\"main\") ?? document.body; return root ? root.innerText : \"\"; })()";
+/** Every JSON-LD script's text, in document order. */
+export declare const JSONLD_EXPRESSION = "Array.from(document.querySelectorAll('script[type=\"application/ld+json\"]'), (s) => s.textContent ?? \"\")";
+/** An image as 8-bit RGBA, row-major. */
+export interface RgbaImage {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export type DecodedPng = {
+    ok: true;
+    image: RgbaImage;
+} | {
+    ok: false;
+    reason: "unsupported-png";
+};
+/**
+ * An 8-bit RGB or RGBA, non-interlaced PNG as RGBA, every scanline filter
+ * undone. Anything else — another depth or colour type, interlacing, a
+ * truncated or corrupt stream — is `unsupported-png`.
+ */
+export declare function decodePng(png: Buffer): DecodedPng;
+/** How many pixels differ in any channel, or `size-differs`. */
+export declare function diffPixels(a: RgbaImage, b: RgbaImage): number | "size-differs";
+export type TextVerdict = {
+    verdict: "same";
+} | {
+    verdict: "differs";
+    line: number;
+    before: string;
+    after: string;
+} | {
+    verdict: "not-compared";
+};
+export type JsonLdVerdict = {
+    verdict: "same";
+} | {
+    verdict: "differs";
+    index: number;
+    before: string | null;
+    after: string | null;
+} | {
+    verdict: "not-compared";
+};
+export type PixelVerdict = {
+    verdict: "same" | "within-tolerance" | "differs";
+    differing: number;
+    total: number;
+} | {
+    verdict: "size-differs" | "unsupported-png" | "not-compared";
+};
+/** Whitespace runs collapsed, then line for line; `differs` names the first differing line (1-based). */
+export declare function compareText(before: string, after: string): TextVerdict;
+/** `same` only when the two arrays are equal string for string — never after a parse. */
+export declare function compareJsonLd(before: readonly string[], after: readonly string[]): JsonLdVerdict;
+/** The slice of a Playwright `Page` the comparison uses. */
+export interface ComparisonPage {
+    setViewportSize(size: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    goto(url: string, options: {
+        waitUntil: "load";
+        timeout: number;
+    }): Promise<{
+        status(): number;
+    } | null>;
+    url(): string;
+    evaluate(expression: string): Promise<unknown>;
+    screenshot(options: {
+        fullPage: true;
+        animations: "disabled";
+    }): Promise<Buffer>;
+}
+export interface ViewportComparison {
+    viewport: string;
+    /** `ok`, or why that side did not render. */
+    render: {
+        before: string;
+        after: string;
+    };
+    text: TextVerdict;
+    jsonLd: JsonLdVerdict;
+    /** Absent when the comparison takes no screenshots (the verify step). */
+    pixels?: PixelVerdict;
+    shots?: {
+        before: string;
+        after: string;
+    };
+}
+export interface PageComparison {
+    path: string;
+    n: number;
+    pass: boolean;
+    viewports: ViewportComparison[];
+}
+interface Side {
+    origin: string;
+    page: ComparisonPage;
+}
+export interface ComparePageOptions {
+    path: string;
+    /** The page's number in the run, naming its screenshots. */
+    n: number;
+    before: Side;
+    after: Side;
+    /** The share of pixels that may differ; `0` is exact. */
+    tolerance: number;
+    screenshots: boolean;
+    /** Stores one screenshot under `shots/<name>`. */
+    writeShot: (name: string, png: Buffer) => void;
+}
+/** One frozen URL at every viewport, before against after. */
+export declare function comparePage(o: ComparePageOptions): Promise<PageComparison>;
+/** `fn` over `items`, at most `limit` at once; results in input order. */
+export declare function mapLimit<T, R>(items: readonly T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]>;
+export interface SweepResult {
+    pass: boolean;
+    /** One row per path, in the order given; `status` 0 for a network failure. */
+    results: {
+        path: string;
+        status: number;
+    }[];
+}
+/** Every path on `origin` must answer 200 directly; a redirect is not a 200. */
+export declare function sweep(o: {
+    origin: string;
+    paths: readonly string[];
+    fetch: typeof globalThis.fetch;
+    headers?: Record<string, string>;
+}): Promise<SweepResult>;
+export interface ComparisonReport {
+    before: string;
+    after: string;
+    pages: PageComparison[];
+    sweep: SweepResult;
+}
+/** The eye-read table: one row per URL and viewport, linking its screenshot pair. */
+export declare function comparisonMarkdown(report: ComparisonReport): string;
+/** `comparison.json` and `comparison.md` in `dir`; the screenshots are already in `dir/shots`. */
+export declare function writeComparisonEvidence(dir: string, report: ComparisonReport): void;
+/** The slice of a Playwright route the header scoping uses. */
+interface RouteLike {
+    request(): {
+        url(): string;
+        headers(): Record<string, string>;
+    };
+    continue(options?: {
+        headers?: Record<string, string>;
+    }): Promise<void>;
+}
+/** The slice of Playwright's `chromium` the comparison launches. */
+export interface ChromiumLike {
+    launch(): Promise<{
+        newContext(): Promise<{
+            newPage(): Promise<ComparisonPage & {
+                route(url: string, handler: (route: RouteLike) => Promise<void>): Promise<void>;
+            }>;
+        }>;
+        close(): Promise<void>;
+    }>;
+}
+export declare const PLAYWRIGHT_INSTALL_HINT = "pnpm add -D @playwright/test && pnpm exec playwright install chromium";
+/** `chromium` from `playwright` or `@playwright/test`, resolved from each dir in turn. */
+export declare function loadChromium(dirs: readonly string[]): ChromiumLike | undefined;
+export interface RunComparisonOptions {
+    chromium: ChromiumLike;
+    before: string;
+    after: string;
+    /** Headers the `after` origin's requests carry (a preview's protection bypass). */
+    afterHeaders?: Record<string, string>;
+    /** The frozen page paths compared in the browser. */
+    pages: readonly string[];
+    /** Every frozen path swept on `after`. */
+    sweepPaths: readonly string[];
+    tolerance: number;
+    screenshots: boolean;
+    /** Where `comparison.json`, `comparison.md` and `shots/` go. */
+    dir: string;
+    fetch: typeof globalThis.fetch;
+    onLine?: (line: string) => void;
+}
+/** Every page compared, the sweep run, the evidence written; `pass` gates the step. */
+export declare function runComparison(o: RunComparisonOptions): Promise<ComparisonReport & {
+    pass: boolean;
+}>;
+export {};

package/dist/lib/render-comparison.js

@@ -0,0 +1,374 @@
+/**
+ * The cutover comparison (#10648, spec
+ * docs/specs/10648-the-cutover-kit-frozen-inventory-spec.md D9).
+ *
+ * Per frozen page URL, at two viewports, in Chromium, on both origins: the
+ * render (a direct 200 that settles on the requested path, `render-verdict.ts`'s
+ * rule), the text of `main`, every JSON-LD script string for string, and a
+ * full-page screenshot compared pixel by pixel. Then a sweep: every frozen URL
+ * must answer 200 with no redirect. A DOM diff alone is never the evidence
+ * (roadmap § 9, rules/outcome-evidence.md): the pixels gate the verdict, and
+ * `comparison.md` links every before/after pair for the eye read.
+ *
+ * create-ailk has one runtime dependency, so nothing here imports Playwright:
+ * the PNG decode and diff are pure functions over buffers (`node:zlib` only),
+ * a page is reached only through the `ComparisonPage` slice it is handed, and
+ * `loadChromium` resolves the site's own Playwright at run time. Jest drives
+ * all of it without a browser.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { inflateSync } from "node:zlib";
+/** The two viewports every page is compared at. */
+export const VIEWPORTS = [
+    { name: "desktop", width: 1440, height: 900 },
+    { name: "mobile", width: 390, height: 844 },
+];
+/** How long one navigation may take before the render fails. */
+const NAVIGATION_TIMEOUT_MS = 60_000;
+/** How long one sweep request may take. */
+const SWEEP_TIMEOUT_MS = 15_000;
+/** Requests in flight at once, for a sweep or a crawl. */
+export const IN_FLIGHT = 4;
+/** The page's words: `main`'s rendered text, else `body`'s. */
+export const TEXT_EXPRESSION = '(() => { const root = document.querySelector("main") ?? document.body; return root ? root.innerText : ""; })()';
+/** Every JSON-LD script's text, in document order. */
+export const JSONLD_EXPRESSION = 'Array.from(document.querySelectorAll(\'script[type="application/ld+json"]\'), (s) => s.textContent ?? "")';
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+/**
+ * An 8-bit RGB or RGBA, non-interlaced PNG as RGBA, every scanline filter
+ * undone. Anything else — another depth or colour type, interlacing, a
+ * truncated or corrupt stream — is `unsupported-png`.
+ */
+export function decodePng(png) {
+    const unsupported = { ok: false, reason: "unsupported-png" };
+    try {
+        if (png.length < 8 || !png.subarray(0, 8).equals(PNG_SIGNATURE))
+            return unsupported;
+        let width = 0;
+        let height = 0;
+        let channels = 0;
+        const idat = [];
+        for (let at = 8; at + 8 <= png.length;) {
+            const length = png.readUInt32BE(at);
+            const type = png.toString("ascii", at + 4, at + 8);
+            const data = png.subarray(at + 8, at + 8 + length);
+            if (type === "IHDR") {
+                width = data.readUInt32BE(0);
+                height = data.readUInt32BE(4);
+                const [depth, colour, compression, filter, interlace] = data.subarray(8, 13);
+                if (depth !== 8 || compression !== 0 || filter !== 0 || interlace !== 0)
+                    return unsupported;
+                if (colour === 2)
+                    channels = 3;
+                else if (colour === 6)
+                    channels = 4;
+                else
+                    return unsupported;
+            }
+            else if (type === "IDAT") {
+                idat.push(data);
+            }
+            else if (type === "IEND") {
+                break;
+            }
+            at += 12 + length;
+        }
+        if (channels === 0 || width === 0 || height === 0)
+            return unsupported;
+        const raw = inflateSync(Buffer.concat(idat));
+        const stride = width * channels;
+        if (raw.length !== height * (stride + 1))
+            return unsupported;
+        const rgba = new Uint8Array(width * height * 4);
+        let prev = new Uint8Array(stride);
+        for (let y = 0; y < height; y++) {
+            const filter = raw[y * (stride + 1)];
+            const row = Uint8Array.from(raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1)));
+            for (let i = 0; i < stride; i++) {
+                const a = i >= channels ? row[i - channels] : 0;
+                const b = prev[i];
+                const c = i >= channels ? prev[i - channels] : 0;
+                const predicted = filter === 0 ? 0
+                    : filter === 1 ? a
+                        : filter === 2 ? b
+                            : filter === 3 ? (a + b) >> 1
+                                : filter === 4 ? paeth(a, b, c)
+                                    : -1;
+                if (predicted < 0)
+                    return unsupported;
+                row[i] = (row[i] + predicted) & 0xff;
+            }
+            for (let x = 0; x < width; x++) {
+                const to = (y * width + x) * 4;
+                const from = x * channels;
+                rgba[to] = row[from];
+                rgba[to + 1] = row[from + 1];
+                rgba[to + 2] = row[from + 2];
+                rgba[to + 3] = channels === 4 ? row[from + 3] : 255;
+            }
+            prev = row;
+        }
+        return { ok: true, image: { width, height, data: rgba } };
+    }
+    catch {
+        return unsupported;
+    }
+}
+/** How many pixels differ in any channel, or `size-differs`. */
+export function diffPixels(a, b) {
+    if (a.width !== b.width || a.height !== b.height)
+        return "size-differs";
+    let differing = 0;
+    for (let i = 0; i < a.data.length; i += 4) {
+        if (a.data[i] !== b.data[i] ||
+            a.data[i + 1] !== b.data[i + 1] ||
+            a.data[i + 2] !== b.data[i + 2] ||
+            a.data[i + 3] !== b.data[i + 3]) {
+            differing += 1;
+        }
+    }
+    return differing;
+}
+function textLines(text) {
+    return text
+        .split("\n")
+        .map((line) => line.replace(/\s+/g, " ").trim())
+        .filter((line) => line !== "");
+}
+/** Whitespace runs collapsed, then line for line; `differs` names the first differing line (1-based). */
+export function compareText(before, after) {
+    const a = textLines(before);
+    const b = textLines(after);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        if (a[i] !== b[i]) {
+            return { verdict: "differs", line: i + 1, before: a[i] ?? "", after: b[i] ?? "" };
+        }
+    }
+    return { verdict: "same" };
+}
+/** `same` only when the two arrays are equal string for string — never after a parse. */
+export function compareJsonLd(before, after) {
+    for (let i = 0; i < Math.max(before.length, after.length); i++) {
+        if (before[i] !== after[i]) {
+            return { verdict: "differs", index: i, before: before[i] ?? null, after: after[i] ?? null };
+        }
+    }
+    return { verdict: "same" };
+}
+function pixelVerdict(before, after, tolerance) {
+    const a = decodePng(before);
+    const b = decodePng(after);
+    if (!a.ok || !b.ok)
+        return { verdict: "unsupported-png" };
+    const differing = diffPixels(a.image, b.image);
+    if (differing === "size-differs")
+        return { verdict: "size-differs" };
+    const total = a.image.width * a.image.height;
+    const verdict = differing === 0 ? "same" : differing / total <= tolerance ? "within-tolerance" : "differs";
+    return { verdict, differing, total };
+}
+function passes(v) {
+    return v.verdict === "same" || v.verdict === "within-tolerance";
+}
+async function renderSide(side, path, viewport, screenshot) {
+    const failed = (render) => ({ render, text: "", jsonLd: [] });
+    await side.page.setViewportSize({ width: viewport.width, height: viewport.height });
+    let status;
+    try {
+        const response = await side.page.goto(side.origin + path, {
+            waitUntil: "load",
+            timeout: NAVIGATION_TIMEOUT_MS,
+        });
+        status = response?.status();
+    }
+    catch (err) {
+        return failed(`navigation failed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
+    }
+    if (status !== 200)
+        return failed(status === undefined ? "no response" : `status ${status}, expected 200`);
+    const settled = new URL(side.page.url()).pathname;
+    if (settled !== path)
+        return failed(`requested "${path}" but the page settled on "${settled}"`);
+    const text = await side.page.evaluate(TEXT_EXPRESSION);
+    const jsonLd = await side.page.evaluate(JSONLD_EXPRESSION);
+    return {
+        render: "ok",
+        text: typeof text === "string" ? text : "",
+        jsonLd: Array.isArray(jsonLd) ? jsonLd.map(String) : [],
+        ...(screenshot && {
+            png: await side.page.screenshot({ fullPage: true, animations: "disabled" }),
+        }),
+    };
+}
+/** One frozen URL at every viewport, before against after. */
+export async function comparePage(o) {
+    const viewports = [];
+    for (const viewport of VIEWPORTS) {
+        const before = await renderSide(o.before, o.path, viewport, o.screenshots);
+        const after = await renderSide(o.after, o.path, viewport, o.screenshots);
+        const rendered = before.render === "ok" && after.render === "ok";
+        const result = {
+            viewport: viewport.name,
+            render: { before: before.render, after: after.render },
+            text: rendered ? compareText(before.text, after.text) : { verdict: "not-compared" },
+            jsonLd: rendered ? compareJsonLd(before.jsonLd, after.jsonLd) : { verdict: "not-compared" },
+        };
+        if (o.screenshots) {
+            if (before.png !== undefined && after.png !== undefined) {
+                const shots = {
+                    before: `${o.n}-${viewport.name}-before.png`,
+                    after: `${o.n}-${viewport.name}-after.png`,
+                };
+                o.writeShot(shots.before, before.png);
+                o.writeShot(shots.after, after.png);
+                result.pixels = pixelVerdict(before.png, after.png, o.tolerance);
+                result.shots = shots;
+            }
+            else {
+                result.pixels = { verdict: "not-compared" };
+            }
+        }
+        viewports.push(result);
+    }
+    const pass = viewports.every((v) => v.render.before === "ok" &&
+        v.render.after === "ok" &&
+        passes(v.text) &&
+        passes(v.jsonLd) &&
+        (v.pixels === undefined || passes(v.pixels)));
+    return { path: o.path, n: o.n, pass, viewports };
+}
+// ── The sweep (D9) ──────────────────────────────────────────────────────────
+/** `fn` over `items`, at most `limit` at once; results in input order. */
+export async function mapLimit(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const i = next++;
+            results[i] = await fn(items[i]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+/** Every path on `origin` must answer 200 directly; a redirect is not a 200. */
+export async function sweep(o) {
+    const results = await mapLimit(o.paths, IN_FLIGHT, async (path) => {
+        try {
+            const response = await o.fetch(o.origin + path, {
+                redirect: "manual",
+                ...(o.headers !== undefined && { headers: o.headers }),
+                signal: AbortSignal.timeout(SWEEP_TIMEOUT_MS),
+            });
+            return { path, status: response.status };
+        }
+        catch {
+            return { path, status: 0 };
+        }
+    });
+    return { pass: results.every((r) => r.status === 200), results };
+}
+function cell(v) {
+    return v === undefined ? "—" : v.verdict;
+}
+/** The eye-read table: one row per URL and viewport, linking its screenshot pair. */
+export function comparisonMarkdown(report) {
+    const lines = [
+        `# Comparison: ${report.before} → ${report.after}`,
+        "",
+        "| # | Path | Viewport | Render | Text | JSON-LD | Pixels | Screenshots |",
+        "| - | ---- | -------- | ------ | ---- | ------- | ------ | ----------- |",
+    ];
+    for (const page of report.pages) {
+        for (const v of page.viewports) {
+            const render = v.render.before === "ok" && v.render.after === "ok"
+                ? "ok"
+                : `before: ${v.render.before}; after: ${v.render.after}`;
+            const shots = v.shots === undefined
+                ? "—"
+                : `[before](shots/${v.shots.before}) · [after](shots/${v.shots.after})`;
+            lines.push(`| ${page.n} | \`${page.path}\` | ${v.viewport} | ${render.replace(/\|/g, "\\|")} | ${cell(v.text)} | ${cell(v.jsonLd)} | ${cell(v.pixels)} | ${shots} |`);
+        }
+    }
+    const failed = report.sweep.results.filter((r) => r.status !== 200);
+    lines.push("", `## Sweep: ${report.sweep.results.length} URL(s) on ${report.after}, ${failed.length} not 200`, "", ...failed.map((r) => `- \`${r.path}\` → ${r.status}`));
+    return `${lines.join("\n")}\n`;
+}
+/** `comparison.json` and `comparison.md` in `dir`; the screenshots are already in `dir/shots`. */
+export function writeComparisonEvidence(dir, report) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "comparison.json"), `${JSON.stringify(report, null, 2)}\n`);
+    writeFileSync(join(dir, "comparison.md"), comparisonMarkdown(report));
+}
+export const PLAYWRIGHT_INSTALL_HINT = "pnpm add -D @playwright/test && pnpm exec playwright install chromium";
+/** `chromium` from `playwright` or `@playwright/test`, resolved from each dir in turn. */
+export function loadChromium(dirs) {
+    for (const dir of dirs) {
+        for (const name of ["playwright", "@playwright/test"]) {
+            try {
+                const mod = createRequire(join(dir, "package.json"))(name);
+                if (mod.chromium !== undefined)
+                    return mod.chromium;
+            }
+            catch {
+                // Not installed here: the next candidate.
+            }
+        }
+    }
+    return undefined;
+}
+/** Every page compared, the sweep run, the evidence written; `pass` gates the step. */
+export async function runComparison(o) {
+    const shotsDir = join(o.dir, "shots");
+    if (o.screenshots)
+        mkdirSync(shotsDir, { recursive: true });
+    const browser = await o.chromium.launch();
+    const pages = [];
+    try {
+        const before = await (await browser.newContext()).newPage();
+        const after = await (await browser.newContext()).newPage();
+        const headers = o.afterHeaders;
+        if (headers !== undefined) {
+            // Only requests to the `after` origin carry the headers (a preview's
+            // protection bypass): never a third-party subresource, never another origin.
+            const origin = new URL(o.after).origin;
+            await after.route("**/*", (route) => new URL(route.request().url()).origin === origin
+                ? route.continue({ headers: { ...route.request().headers(), ...headers } })
+                : route.continue());
+        }
+        for (const [i, path] of o.pages.entries()) {
+            const result = await comparePage({
+                path,
+                n: i + 1,
+                before: { origin: o.before, page: before },
+                after: { origin: o.after, page: after },
+                tolerance: o.tolerance,
+                screenshots: o.screenshots,
+                writeShot: (name, png) => writeFileSync(join(shotsDir, name), png),
+            });
+            o.onLine?.(`${result.pass ? "same" : "DIFFERS"} ${path}`);
+            pages.push(result);
+        }
+    }
+    finally {
+        await browser.close();
+    }
+    const swept = await sweep({
+        origin: o.after,
+        paths: o.sweepPaths,
+        fetch: o.fetch,
+        ...(o.afterHeaders !== undefined && { headers: o.afterHeaders }),
+    });
+    const report = { before: o.before, after: o.after, pages, sweep: swept };
+    writeComparisonEvidence(o.dir, report);
+    return { ...report, pass: swept.pass && pages.every((p) => p.pass) };
+}

package/dist/lib/scaffold-render-sweep.d.ts

@@ -143,7 +143,7 @@ export declare function assessConfigGatedRoute(input: {
  * The environment the sitemap sweep's server runs under (#8501): `env` with
  * every `CONFIG_GATED_ROUTES` variable removed.
  *
- * `/sitemap.xml` is prerendered at `next build`, from the content seeds, so it
+ * `/sitemap.xml` is rendered on request, from the content seeds, so it
  * describes the scaffold AS GENERATED — and a config-gated route's seeds are
  * served only while its variable is unset (the Free placeholder hand-off,
  * #6942). Set it and the route serves its live module page instead: `/meet`

package/dist/lib/scaffold-render-sweep.js

@@ -285,7 +285,7 @@ function headingTexts(html) {
  * The environment the sitemap sweep's server runs under (#8501): `env` with
  * every `CONFIG_GATED_ROUTES` variable removed.
  *
- * `/sitemap.xml` is prerendered at `next build`, from the content seeds, so it
+ * `/sitemap.xml` is rendered on request, from the content seeds, so it
  * describes the scaffold AS GENERATED — and a config-gated route's seeds are
  * served only while its variable is unset (the Free placeholder hand-off,
  * #6942). Set it and the route serves its live module page instead: `/meet`

package/dist/migrate-content.d.ts

@@ -1,3 +1,4 @@
+import { type LanguageImportResult } from "./language-import.js";
 import { type ImportMdxResult, type MdxAdapterModule } from "./lib/import-mdx.js";
 /** A refusal the CLI exits 2 on, thrown before any request is sent. */
 export declare class MigrateContentRefusedError extends Error {
@@ -27,12 +28,15 @@ export interface MigrateContentOptions {
 /**
  * A fetch that sends `GET`s through `inner` and never sends a write: a `POST`
  * is answered `201` and a `PATCH` `200` locally, with the one member of a
- * write's answer `importMdx` reads (`data.locale`). Any other method throws.
+ * write's answer `importMdx` reads (`data.locale`), and the structure write's
+ * `PUT` (#10534) `200` as a layout unchanged (`data.written: false`). Any
+ * other method throws.
  */
 export declare function readOnlyFetch(inner: typeof globalThis.fetch, locale: string): typeof globalThis.fetch;
 export declare function migrateContent(opts: MigrateContentOptions): Promise<{
     result: ImportMdxResult;
     exitCode: 0 | 1;
+    language?: LanguageImportResult;
 }>;
 export interface MigrateContentArgs {
     target: string | undefined;
@@ -41,5 +45,5 @@ export interface MigrateContentArgs {
     workspaceId: string | undefined;
     help: boolean;
 }
-export declare const MIGRATE_CONTENT_HELP = "create-ailk migrate-content \u2014 import an existing site's pages into its workspace.\n\nUsage:\n  AILK_AGENT_KEY=<key> create-ailk migrate-content [<dir>] [--apply] [--api-url <origin>] [--workspace <wksp_id>]\n\nArguments:\n  <dir>                    The site. Defaults to the current dir.\n\nOptions:\n  --apply                  Write the pages. Without it the command reads the\n                           workspace, prints what it would do, and writes\n                           nothing.\n  --api-url <origin>       The API origin that holds the workspace \u2014 on a\n                           spoke, its hub's. Else AILK_API_URL. https: only\n                           (http: on localhost or 127.0.0.1).\n  --workspace <wksp_id>    The workspace the pages are written to. Else\n                           AILK_WORKSPACE_ID.\n  -h, --help               Show this help.\n\nEach content/en/<Type>/<slug>.mdx page (and each legacy\ncontent/<Type>/<slug>.mdx) is written to the workspace as a draft through\nthe API's content routes, with the agent key, which is read from\nAILK_AGENT_KEY only and needs the content-edit grant. Nothing is published,\nso the live site does not change. The site needs no .ailk-site-manifest.json\nand may be a spoke; its dependencies must be installed.\n\nA dry run prints create, update, unchanged, skipped or failed per page. It\ncannot see a write the API would refuse at --apply (a conflict or a server\nerror), and a page whose content fails its page type is planned and saved\nwith errors the editor shows, not failed. --apply prints created, updated,\nunchanged, skipped or failed per page, so a re-run is safe. Exit 0 when no\npage failed, 1 when any did, 2 on a refusal (nothing is sent).\n";
+export declare const MIGRATE_CONTENT_HELP = "create-ailk migrate-content \u2014 import an existing site's pages into its workspace.\n\nUsage:\n  AILK_AGENT_KEY=<key> create-ailk migrate-content [<dir>] [--apply] [--api-url <origin>] [--workspace <wksp_id>]\n\nArguments:\n  <dir>                    The site. Defaults to the current dir.\n\nOptions:\n  --apply                  Write the pages. Without it the command reads the\n                           workspace, prints what it would do, and writes\n                           nothing.\n  --api-url <origin>       The API origin that holds the workspace \u2014 on a\n                           spoke, its hub's. Else AILK_API_URL. https: only\n                           (http: on localhost or 127.0.0.1).\n  --workspace <wksp_id>    The workspace the pages are written to. Else\n                           AILK_WORKSPACE_ID.\n  -h, --help               Show this help.\n\nEach content/en/<Type>/<slug>.mdx page (and each legacy\ncontent/<Type>/<slug>.mdx) is written to the workspace as a draft through\nthe API's content routes, with the agent key, which is read from\nAILK_AGENT_KEY only and needs the content-edit grant. Nothing is published,\nso the live site does not change. The site needs no .ailk-site-manifest.json\nand may be a spoke; its dependencies must be installed. A page whose\nfrontmatter carries sections is converted: its words are written to the\npage's Markdown and its sections to its layout.\n\nEach FAQ item and glossary-index term becomes one Language item of its kind,\nset Live when the run creates it, and its section pins the items in the\norder the file lists them. A question on several pages is one item, with\nthe FAQ page's words (the glossary page's, for a term). Lines prefixed\nlanguage: report each item, and each page the database read will not show\nas its file does. An API with no Language collection leaves them inline.\n\nWhen the site has apps/web/content, each blog post and docs page in it is\nwritten too: apps/web/content/en/blog/<slug>.mdx (or <slug>/index.mdx) as a\nBlogPosting, the same under docs as a DocsDetail, and each directory's own\nindex.mdx as its BlogList or DocsList index. Their lines are prefixed\neditorial: \u2014 each outcome's root is content or editorial.\n\nA dry run prints create, update, unchanged, skipped or failed per page. It\ncannot see a write the API would refuse at --apply (a conflict or a server\nerror), nor a layout change on a page whose words did not change, and a\npage whose content fails its page type is planned and saved\nwith errors the editor shows, not failed. --apply prints created, updated,\nunchanged, skipped or failed per page, so a re-run is safe. Exit 0 when no\npage failed, 1 when any did, 2 on a refusal (nothing is sent).\n";
 export declare function parseMigrateContentArgs(argv: string[]): MigrateContentArgs;