@mapled/cli 0.14.5 → 0.14.6

package/README.md

@@ -206,12 +206,18 @@ Mapled doctor — Dolphin Landing
 1 warning.
 ```
 
-The repository side: the link, the sign-in, the generated types, the schema pin, the site manifest (and whether it matches what was pushed), the integration hash — one line saying whether the pin and the manifest here describe the same integration Mapled holds, and if not, what moved (the schema, the bindings, or edits made in Mapled) and which command catches up — `MAPLED.md` (and whether it is what Mapled would render now), `MAPLED_KEY` and `MAPLED_WEBHOOK_SECRET` in your env files (names only — values are never read out), env files or Mapled secrets tracked by git, the installed `@mapled/next` and CLI versions, the revalidation and preview routes of a Next.js site, and its live updates — ○ «Not used» while no page mounts `<MapledLive />` or calls `watchRelease`, ✓ when the route they ask answers its `GET` with `createReleaseHandler` (`GET` is the handler, or always returns its call: every return is that call, the last statement is one, and nothing throws), ⚠ when it is missing (the tabs would poll a 404) with the file to add, when the route's `GET` isn't seen to answer with the handler (exported as `POST` they would get a 405; a `GET` that only mentions it, calls it and returns something else, or answers something else on another branch, answers without the release), or when no route can be checked against the endpoint — it is relative to the page, a full address (the tab asks it as written, and doctor can't tell it's the site's own), computed, or comes from spread props; a path from the site's root is checked against the route the App Router picks for it, dynamic and catch-all folders included, among route files with the site's page extensions (`pageExtensions` in next.config; `tsx`, `ts`, `jsx`, `js` by default) and under its `basePath`; ⚠ too when a page of either router, more specific than the route, takes that path first, when the dynamic route that answers sets `dynamicParams`, when the route may set `dynamic` to anything but `"auto"` or `"force-dynamic"` (a copy Next builds without the tab's request), sets `"force-dynamic"` while `createReleaseHandler` there isn't seen to keep a `revalidate` above 0 (its default does; with `false` or `0` Next reads the release past the cache tag) or `fetchCache` to anything but `"auto"` (the release read past the cache tag, before the webhook refreshes the pages), when next.config sets `output: "export"` (no server runs the route), or when next.config may set `pageExtensions`, `basePath` or `output` where doctor can't read them — it reads them only as literals, once, in the object the file exports, and only while the file is declarative: type imports, declarations of data, one export of the config object itself, and functions only as Next's hooks (`webpack`, `headers` …) in it. A module the file loads (a plugin such as `withMDX`, a `path` helper, an env check), a config exported as a function, any other code, a spread or a getter leaves the config unread. With a `basePath`, a listener that gives no endpoint asks under it from `@mapled/next` 0.10.0 — doctor reads the version the site has installed, and it's a ⚠ when that is older or missing. A `middleware` file (`proxy` in Next 16) next to the folder Next reads is a ⚠ unless its matcher, read the way Next's build reads `export const config`, surely leaves the route's path alone: it has no matcher, doctor can't read it, a source may take the path, or next.config has locales (`i18n`). `src/app` or `src/pages` counts only when the root has no `app` or `pages`, as Next reads them. On the Pages Router the route is an API route — a file of the pages folder at `/api` or under it — whose default export is `createPagesReleaseHandler` or always returns its call, and the listener is `<MapledLive />` from `@mapled/next/live/pages` in `pages/_app`: a listener without it gets the API route to add (`pages/api/mapled/release.ts` by default; an endpoint outside `/api` no API route can answer). ⚠ there too when the API route may run on the edge runtime — `runtime` or `config.runtime` other than `"nodejs"`, or written where doctor can't read it (Next reads both only as literals) — where the handler has no Node request and response; when a listener the App Router may run asks it — a file of `app/`, or on a site with both folders one either router may render: the API route answers Mapled's live release, which moves before the webhook refreshes what App Router pages read; and when `<MapledLive />` from `@mapled/next/live/pages` sits in the App Router's folder, where it can't mount. doctor reads the files, not how Next serves them at run time: rewrites and what a middleware does on the path aren't checked, and neither is whether a page renders the component that listens; `revalidate` on the route is no ⚠ — the handler's read names its own. The Mapled side, from the same status the AI agent's `check_integration` tool reads: whether the site has read content with the delivery key (for a project with a staging channel, through which key: production's or staging's — the key decides which releases a deployment shows), the publish webhook and its last delivery, the preview route on the deployed site, the bindings health.
+The repository side: the link, the sign-in, the generated types, the schema pin, the site manifest (and whether it matches what was pushed), the integration hash — one line saying whether the pin and the manifest here describe the same integration Mapled holds, and if not, what moved (the schema, the bindings, or edits made in Mapled) and which command catches up — `MAPLED.md` (and whether it is what Mapled would render now), `MAPLED_KEY` and `MAPLED_WEBHOOK_SECRET` in your env files (names only — values are never read out), env files or Mapled secrets tracked by git, the installed `@mapled/next` and CLI versions, the revalidation and preview routes of a Next.js site, and its live updates — ○ «Not used» while no page mounts `<MapledLive />` or calls `watchRelease`, ✓ when the route they ask answers its `GET` with `createReleaseHandler` (`GET` is the handler, or always returns its call: every return is that call, the last statement is one, and nothing throws), ⚠ when it is missing (the tabs would poll a 404) with the file to add, when the route's `GET` isn't seen to answer with the handler (exported as `POST` they would get a 405; a `GET` that only mentions it, calls it and returns something else, or answers something else on another branch, answers without the release), or when no route can be checked against the endpoint — it is relative to the page, a full address (the tab asks it as written, and doctor can't tell it's the site's own), computed, or comes from spread props; a path from the site's root is checked against the route the App Router picks for it, dynamic and catch-all folders included, among route files with the site's page extensions (`pageExtensions` in next.config; `tsx`, `ts`, `jsx`, `js` by default) and under its `basePath`; ⚠ too when a page of either router, more specific than the route, takes that path first, when the dynamic route that answers sets `dynamicParams`, when the route may set `dynamic` to anything but `"auto"` or `"force-dynamic"` (a copy Next builds without the tab's request), sets `"force-dynamic"` while `createReleaseHandler` there isn't seen to keep a `revalidate` above 0 (its default does; with `false` or `0` Next reads the release past the cache tag) or `fetchCache` to anything but `"auto"` (the release read past the cache tag, before the webhook refreshes the pages), when next.config sets `output: "export"` (no server runs the route), or when next.config may set `pageExtensions`, `basePath` or `output` where doctor can't read them — it reads them only as literals, once, in the object the file exports, and only while the file is declarative: type imports, declarations of data, one export of the config object itself, and functions only as Next's hooks (`webpack`, `headers` …) in it. A module the file loads (a plugin such as `withMDX`, a `path` helper, an env check), a config exported as a function, any other code, a spread or a getter leaves the config unread — `mapled doctor --load-config` then has the site's own installed Next load the file (see below). With a `basePath`, a listener that gives no endpoint asks under it from `@mapled/next` 0.10.0 — doctor reads the version the site has installed, and it's a ⚠ when that is older or missing. A `middleware` file (`proxy` in Next 16) next to the folder Next reads is a ⚠ unless its matcher, read the way Next's build reads `export const config`, surely leaves the route's path alone: it has no matcher, doctor can't read it, a source may take the path, or next.config has locales (`i18n`). `src/app` or `src/pages` counts only when the root has no `app` or `pages`, as Next reads them. On the Pages Router the route is an API route — a file of the pages folder at `/api` or under it — whose default export is `createPagesReleaseHandler` or always returns its call, and the listener is `<MapledLive />` from `@mapled/next/live/pages` in `pages/_app`: a listener without it gets the API route to add (`pages/api/mapled/release.ts` by default; an endpoint outside `/api` no API route can answer). ⚠ there too when the API route may run on the edge runtime — `runtime` or `config.runtime` other than `"nodejs"`, or written where doctor can't read it (Next reads both only as literals) — where the handler has no Node request and response; when a listener the App Router may run asks it — a file of `app/`, or on a site with both folders one either router may render: the API route answers Mapled's live release, which moves before the webhook refreshes what App Router pages read; and when `<MapledLive />` from `@mapled/next/live/pages` sits in the App Router's folder, where it can't mount. doctor reads the files, not how Next serves them at run time: rewrites and what a middleware does on the path aren't checked, and neither is whether a page renders the component that listens; `revalidate` on the route is no ⚠ — the handler's read names its own. The Mapled side, from the same status the AI agent's `check_integration` tool reads: whether the site has read content with the delivery key (for a project with a staging channel, through which key: production's or staging's — the key decides which releases a deployment shows), the publish webhook and its last delivery, the preview route on the deployed site, the bindings health.
 
 A site rendered in the visitor's browser — a React single-page app (Vite and the like), plain HTML — is checked for what it has: the package line is `@mapled/react`, Environment wants `VITE_MAPLED_KEY` and no webhook secret, and the routes and the webhook read ○ «Not needed» — such a site shows a publish on its next load and trades Mapled's preview link on the page itself; Live updates reads ○ as well: `live` on `MapledProvider` or `data-mapled-live` asks Mapled directly, with no route of the site's. Plain HTML installs nothing: the line is `@mapled/vanilla`, read from the script tag in the pages (or from a copy of the file next to them) — ⚠ when the address has no version or an older one, and before that when a page's tag has an `integrity` a browser won't pass: from another origin without `crossorigin` (a browser checks only a file that came with CORS), `crossorigin="use-credentials"` on jsDelivr or unpkg (their `*` answer fails a request with credentials, integrity or not), or a digest that isn't the file's — for a copy next to the pages, the copy's own; for a jsDelivr or unpkg address, the released file's of the version in it (another host may serve a file of its own; an address with a query isn't checked — `?meta` answers with something else), which doctor knows without the network for the releases up to its own, or from `node_modules/@mapled/vanilla` of that version — and Generated types and Environment read ○: the fields are named in attributes, the delivery key sits in the page. doctor takes the framework from `mapled.json`, or works it out from `package.json` (no `package.json` and an `index.html` is plain HTML). Whatever the framework, a server key or a signing secret under a public prefix (`VITE_…`, `NEXT_PUBLIC_…`) is a ✗: it would ship to every visitor.
 
 Exit code 1 when something is marked ✗; `--json` prints the checks for scripts and agents.
 
+```bash
+npx @mapled/cli doctor --load-config
+```
+
+`--load-config` is for a next.config doctor can't read — one that calls a plugin (`withMDX(nextConfig)`), imports an env check (`import "./src/env.js"`), sets a value in a statement or exports a function. Doctor then loads it the way `next build` does: the site's installed Next (`loadConfig`) in a process of its own, in the site's folder, and takes `pageExtensions`, `basePath`, `output` and whether `i18n` is set from the result — nothing else of the config leaves that process. **This runs the site's code**: next.config and every module it loads, with your rights, as `next build` would. Without the flag doctor runs nothing of the site, and no agent tool sets it. The process gets 20 seconds and your environment without the variables named `MAPLED_*` — the site's `.env` files still load, as Next loads them, so keep `MAPLED_KEY` there if the config checks for it. A config doctor reads on its own is never loaded. When the loading fails — Next (or, for `next.config.ts`, TypeScript) isn't installed, the config throws, it doesn't finish in time — the line stays a ⚠ with the reason; doctor never guesses the settings. Of an error the config throws doctor prints only its class, and only one of JavaScript's own (`TypeError` …) — the message is the site's and may quote a value of its environment; `next build` shows it in full.
+
 ## Read the setup report
 
 ```bash
@@ -266,6 +272,7 @@ Prints a Preview link — the one the **Preview** button in Mapled opens: the si
 - `--api <origin>` — a Mapled API other than `https://api.mapled.io` (or set `MAPLED_API_URL`); `project link` remembers it in `mapled.json`
 - `--no-browser` — print the sign-in link instead of opening a browser
 - `--json` — machine-readable output (`doctor`, `integration report`, `schema diff`, `scan`, `manifest validate`, `forms list`, `preview`)
+- `--load-config` — `doctor` only: let the site's installed Next load a next.config doctor can't read; runs the site's code, as `next build` does
 - `MAPLED_CONFIG_DIR` — where credentials live (default: `$XDG_CONFIG_HOME/mapled` or `~/.config/mapled`)
 
 ## Files in the repository

package/dist/commands.js

@@ -731,7 +731,8 @@ export async function doctor(ctx, flags) {
     checks.push(framework === "plain-html" ? dr.checkScriptTag(await dr.findScriptTag(dir, status?.site?.url), status?.sdk[sdk]) : dr.checkSdk(await dr.installedVersion(dir, sdk), status?.sdk[sdk], sdk));
     checks.push(dr.checkCli(ctx.version, status?.sdk["@mapled/cli"]));
     // the live facts first: the revalidate route's answer matters once a page listens (#435)
-    const live = !framework || framework === "nextjs" ? await findLive(dir) : null;
+    // --load-config: a next.config the reading leaves unread is loaded by the site's own Next — the one place doctor runs the site's code
+    const live = !framework || framework === "nextjs" ? await findLive(dir, undefined, flags["load-config"] ? { loadConfig: { env: ctx.env } } : {}) : null;
     checks.push(dr.checkRoute("revalidate", await dr.findRoute(dir, "revalidate", framework), framework, (live?.listeners.length ?? 0) > 0));
     checks.push(dr.checkRoute("preview", await dr.findRoute(dir, "preview", framework), framework));
     // the code is read only where the check applies: a Next.js site (or one doctor can't place)

package/dist/doctor.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { parseDocument } from "./html5.js";
 import { integrationHash } from "./integrationHash.js";
-import { BASE_PATH_SINCE, fullAddress, liveState, pagesRouteFileFor, RELEASE_ROUTE, revalidateRouteFacts, routeFileFor, runsIn } from "./live.js";
+import { BASE_PATH_SINCE, CONFIG_LOAD_TIMEOUT_MS, fullAddress, liveState, pagesRouteFileFor, RELEASE_ROUTE, revalidateRouteFacts, routeFileFor, runsIn } from "./live.js";
 import { compareManifests, manifestSummary, MANIFEST_FILE } from "./manifest.js";
 import { SCHEMA_FILE } from "./pin.js";
 import { htmlPage } from "./scanHtml.js";
@@ -885,13 +885,25 @@ export function checkLive(facts, framework) {
                         ? `${who(state.listener)} asks ${state.listener.endpoint}, a full address — the tab asks it as written, and doctor can't tell it's this site's own, so no route can be checked. Give the route's path, like ${RELEASE_ROUTE}.`
                         : `${who(state.listener)} asks ${state.listener.endpoint}, which isn't a path from the site's root — each page resolves it against its own address, so no route can be checked. Give the route's path, like ${RELEASE_ROUTE}.`,
             };
-        case "config":
+        case "config": {
+            if (state.load) {
+                // --load-config had Next load it, and that gave no settings: the reason, never a guess
+                const why = {
+                    no_next: `Next isn't installed here, so nothing can load ${state.file} — install the site's dependencies and run \`mapled doctor --load-config\` again`,
+                    no_typescript: `TypeScript isn't installed here, and Next would install it to load ${state.file} — install the site's dependencies and run \`mapled doctor --load-config\` again`,
+                    threw: `Next couldn't load ${state.file} — it threw ${state.load.detail ?? "an error"}; \`next build\` shows the error`,
+                    timeout: `Next didn't finish loading ${state.file} in ${Math.round(CONFIG_LOAD_TIMEOUT_MS / 1000)} seconds, so doctor stopped it`,
+                    output: `Next loaded ${state.file} without settings doctor can read`,
+                };
+                return { key, label, status: "warning", detail: `${why[state.load.reason]}. No route can be checked for ${who(state.listener)}.` };
+            }
             return {
                 key,
                 label,
                 status: "warning",
-                detail: `${state.file} may set pageExtensions, basePath or output where doctor can't read them — code that runs as Next loads it, a plugin's or a function's result, a value or name the code builds, an object from another file or spread in — so no route can be checked for ${who(state.listener)}. Write them as literals in the object it exports, or leave them out.`,
+                detail: `${state.file} may set pageExtensions, basePath or output where doctor can't read them — code that runs as Next loads it, a plugin's or a function's result, a value or name the code builds, an object from another file or spread in — so no route can be checked for ${who(state.listener)}. Write them as literals in the object it exports, or leave them out — or run \`mapled doctor --load-config\` to load it as Next does: that runs the file and what it loads, as \`next build\` does.`,
             };
+        }
         case "export":
             return {
                 key,

package/dist/index.js

@@ -26,7 +26,7 @@ Usage
   mapled md pull [--force]                            Write MAPLED.md, the guide for the next agent, from the project
   mapled forms create <name> [--key <key>]            Create a form the site posts submissions to (--no-spam-protection to skip the honeypot)
   mapled forms list [--json]                          List the project's forms and where the site posts to
-  mapled doctor [--json]                              Check the integration end to end
+  mapled doctor [--json] [--load-config]              Check the integration end to end; --load-config runs a next.config doctor can't read, as next build does
   mapled integration report [--json] [--verify]       Show the last setup run's verification checklist and report
   mapled preview [<collection> [<slug>]] [--locale <code>] [--open]   Print a one-time Preview link that shows the drafts on the site
 

package/dist/live.d.ts

@@ -74,7 +74,8 @@ export type PageFile = {
     finds the package from the site's folder up — absent when none is
     installed. `output`: next.config sets `output: "export"` (value
     "export") or may set it where the reading can't tell (null) — then
-    there may be no server to run any route. */
+    there may be no server to run any route. `configLoad`: `mapled doctor
+    --load-config` had Next load that file and it didn't — why. */
 export type LiveFacts = {
     listeners: LiveListener[];
     routes: RouteFile[];
@@ -84,6 +85,7 @@ export type LiveFacts = {
     pagesDir?: string;
     basePath?: string;
     config?: string;
+    configLoad?: ConfigLoadFailure;
     sdk?: string;
     output?: {
         file: string;
@@ -148,6 +150,7 @@ export type LiveState = {
     kind: "config";
     listener: LiveListener;
     file: string;
+    load?: ConfigLoadFailure;
 } | {
     kind: "outside";
     listener: LiveListener;
@@ -298,7 +301,39 @@ export declare function sourceMayTake(source: string, at: string): boolean;
 /** Whether a version is at least `min`, by its major, minor and patch —
     false for one that doesn't start with three numbers. */
 export declare function atLeast(version: string, min: string): boolean;
-export declare function findLive(dir: string, maxFiles?: number): Promise<LiveFacts>;
+/** Why Next's own loading of next.config gave no settings: the site has no
+    Next installed (`no_next`) or, for a next.config.ts, no TypeScript
+    (`no_typescript` — Next would install it), the loading threw (`threw`, with the error's
+    class — never its message, the site's text), it didn't end in time (`timeout`), or it ended without
+    settings the reading takes (`output`). */
+export type ConfigLoadFailure = {
+    reason: "no_next" | "no_typescript" | "threw" | "timeout" | "output";
+    detail?: string;
+};
+/** `timeoutMs`: how long the loading may take (tests shorten it). `env`:
+    the environment the child starts from. */
+export type ConfigLoadOptions = {
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+};
+/** How long `mapled doctor --load-config` lets Next load next.config. */
+export declare const CONFIG_LOAD_TIMEOUT_MS = 20000;
+/** The site's next.config `file` as the site's installed Next loads it (`loadConfig`, the
+    reference `live.test.ts` holds `nextConfigOf` to) — for a config the
+    declarative reading leaves unread. Unlike that reading this RUNS the
+    site's code — the config and every module it loads, as `next build`
+    does — so only `mapled doctor --load-config` asks for it, never a tool
+    of an agent. It runs in a process of its own, in the site's folder, for
+    `timeoutMs` at most, without the `MAPLED_*` variables of doctor's own
+    environment (the site's .env files still load, as Next loads them);
+    its stdout and stderr go nowhere, and of the config only the settings
+    come back. Any failure is a reason, never a guess at the settings. */
+export declare function loadNextConfig(dir: string, file: string, options?: ConfigLoadOptions): Promise<NextConfig | ConfigLoadFailure>;
+/** `loadConfig`: `mapled doctor --load-config` — a next.config the reading
+    leaves unread is loaded by the site's Next (loadNextConfig). */
+export declare function findLive(dir: string, maxFiles?: number, options?: {
+    loadConfig?: ConfigLoadOptions;
+}): Promise<LiveFacts>;
 /** Whether a literal endpoint names its own origin — `https://…`, `//host/…`
     — which the code doesn't show to be the site's: `watchRelease` fetches it
     as written, and no route file of this site is known to answer it. */

package/dist/live.js

@@ -1,4 +1,6 @@
+import { spawn, spawnSync } from "node:child_process";
 import { readdir, readFile, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { appRoute, listFiles, tokenize } from "./scan.js";
 /** Live updates (§18.8) as the site's code shows them. A Next.js site
@@ -2246,7 +2248,158 @@ async function middlewareFiles(dir, extensions, next) {
     }
     return found;
 }
-export async function findLive(dir, maxFiles = 4000) {
+/** How long `mapled doctor --load-config` lets Next load next.config. */
+export const CONFIG_LOAD_TIMEOUT_MS = 20_000;
+// what the child may answer: four settings fit in far less
+const CONFIG_LOAD_MAX = 64 * 1024;
+// the error classes doctor names: JavaScript's own — any other name is the site's text
+const ERROR_CLASSES = ["Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError", "EvalError", "URIError", "AggregateError"];
+// The child: the site's installed Next loads the config as `next build` does — the site's .env files first, then
+// loadConfig — and answers on its own pipe (fd 3) with the settings doctor reads, nothing else of the config.
+const CONFIG_LOADER = `
+const { createRequire } = require("node:module");
+const { writeSync } = require("node:fs");
+const [next, dir] = process.argv.slice(1);
+const send = (answer) => {
+  try {
+    writeSync(3, JSON.stringify(answer) + "\\n");
+  } catch {}
+  process.exit(0);
+};
+// of an error only its class: the message is the site's text and may quote a value of its environment
+const failed = (e) => {
+  let name = "Error";
+  try {
+    name = String((e && e.name) || "Error");
+  } catch {}
+  send({ error: name });
+};
+process.on("uncaughtException", failed);
+process.on("unhandledRejection", failed);
+(async () => {
+  const require = createRequire(next);
+  process.env.NODE_ENV = process.env.NODE_ENV || "production";
+  // as the next CLI sets it before a build
+  process.env.NEXT_RUNTIME = "nodejs";
+  try {
+    require("@next/env").loadEnvConfig(dir, false, { info() {}, error() {} });
+  } catch {}
+  const loaded = require("next/dist/server/config");
+  const loadConfig = loaded.default ?? loaded;
+  const { PHASE_PRODUCTION_BUILD } = require("next/constants");
+  const c = await loadConfig(PHASE_PRODUCTION_BUILD, dir, { silent: true });
+  send({ settings: { pageExtensions: c.pageExtensions, basePath: c.basePath, output: c.output ?? null, i18n: c.i18n != null } });
+})().catch(failed);
+`;
+/** The site's next.config `file` as the site's installed Next loads it (`loadConfig`, the
+    reference `live.test.ts` holds `nextConfigOf` to) — for a config the
+    declarative reading leaves unread. Unlike that reading this RUNS the
+    site's code — the config and every module it loads, as `next build`
+    does — so only `mapled doctor --load-config` asks for it, never a tool
+    of an agent. It runs in a process of its own, in the site's folder, for
+    `timeoutMs` at most, without the `MAPLED_*` variables of doctor's own
+    environment (the site's .env files still load, as Next loads them);
+    its stdout and stderr go nowhere, and of the config only the settings
+    come back. Any failure is a reason, never a guess at the settings. */
+export async function loadNextConfig(dir, file, options = {}) {
+    let next;
+    try {
+        // resolved, not loaded: no code of the site runs here
+        next = createRequire(path.join(path.resolve(dir), "package.json")).resolve("next/package.json");
+    }
+    catch {
+        return { reason: "no_next" };
+    }
+    // Next installs TypeScript itself when a next.config.ts finds none: doctor changes nothing of the site
+    if (/\.m?ts$/.test(file)) {
+        try {
+            createRequire(path.join(path.resolve(dir), "package.json")).resolve("typescript");
+        }
+        catch {
+            return { reason: "no_typescript" };
+        }
+    }
+    const env = {};
+    for (const [name, value] of Object.entries(options.env ?? process.env))
+        if (!/^MAPLED_/i.test(name))
+            env[name] = value;
+    const answer = await new Promise((resolve) => {
+        let settled = false;
+        let text = "";
+        // a group of its own where the system has them (a tree ended by taskkill where it doesn't): what the config started ends with it
+        const grouped = process.platform !== "win32";
+        const child = spawn(process.execPath, ["-e", CONFIG_LOADER, next, path.resolve(dir)], { cwd: dir, env, stdio: ["ignore", "ignore", "ignore", "pipe"], windowsHide: true, detached: grouped });
+        const settle = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                if (child.pid === undefined) {
+                    // never started
+                }
+                else if (grouped)
+                    process.kill(-child.pid, "SIGKILL");
+                // Windows has no groups: taskkill ends the tree — to its end before the loader is killed below, which it finds the tree by
+                else
+                    spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 5000 });
+            }
+            catch {
+                // the group is gone already
+            }
+            child.kill("SIGKILL");
+            child.stdio[3]?.destroy();
+            resolve(value);
+        };
+        const timer = setTimeout(() => settle("timeout"), options.timeoutMs ?? CONFIG_LOAD_TIMEOUT_MS);
+        child.on("error", () => settle(null));
+        child.on("close", () => settle(null));
+        const pipe = child.stdio[3];
+        pipe?.on("error", () => settle(null));
+        pipe?.on("data", (chunk) => {
+            text += chunk.toString("utf8");
+            // the first line is the answer; whatever else the site's code writes there isn't read
+            const end = text.indexOf("\n");
+            if (end >= 0)
+                settle(text.slice(0, end));
+            else if (text.length > CONFIG_LOAD_MAX)
+                settle(null);
+        });
+    });
+    if (answer === "timeout")
+        return { reason: "timeout" };
+    if (answer === null || answer.length > CONFIG_LOAD_MAX)
+        return { reason: "output" };
+    let parsed;
+    try {
+        parsed = JSON.parse(answer);
+    }
+    catch {
+        return { reason: "output" };
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return { reason: "output" };
+    const { error, settings } = parsed;
+    // the class alone, and only one the language has: a name is the site's text too, and one made up may be a key
+    if (typeof error === "string")
+        return { reason: "threw", ...(ERROR_CLASSES.includes(error) ? { detail: error } : {}) };
+    if (typeof settings !== "object" || settings === null)
+        return { reason: "output" };
+    const { pageExtensions, basePath, output, i18n } = settings;
+    if (!Array.isArray(pageExtensions) || pageExtensions.length > 100 || !pageExtensions.every((ext) => typeof ext === "string" && ext.length <= 100))
+        return { reason: "output" };
+    if (typeof basePath !== "string" || basePath.length > 2000 || (output !== null && typeof output !== "string"))
+        return { reason: "output" };
+    const read = { pageExtensions, basePath };
+    if (output !== null)
+        read.output = output;
+    if (i18n === true)
+        read.i18n = true;
+    return read;
+}
+/** `loadConfig`: `mapled doctor --load-config` — a next.config the reading
+    leaves unread is loaded by the site's Next (loadNextConfig). */
+export async function findLive(dir, maxFiles = 4000, options = {}) {
     const { files } = await listFiles(dir, maxFiles);
     const config = NEXT_CONFIGS.find((name) => files.includes(name));
     let configText = null;
@@ -2258,7 +2411,15 @@ export async function findLive(dir, maxFiles = 4000) {
             // unreadable: the defaults
         }
     }
-    const settings = nextConfigOf(configText);
+    let settings = nextConfigOf(configText);
+    let configLoad;
+    if (settings === null && config && options.loadConfig) {
+        const loaded = await loadNextConfig(dir, config, options.loadConfig);
+        if ("reason" in loaded)
+            configLoad = loaded;
+        else
+            settings = loaded;
+    }
     const extensions = settings?.pageExtensions ?? null;
     const routeExtension = extensions === null || extensions.includes("ts") ? "ts" : (extensions[0] ?? "ts");
     // a folder under src/ that Next doesn't read: nothing in it runs
@@ -2305,6 +2466,8 @@ export async function findLive(dir, maxFiles = 4000) {
         facts.basePath = settings.basePath;
     if (settings === null && config)
         facts.config = config;
+    if (configLoad)
+        facts.configLoad = configLoad;
     if (config && settings && (settings.output === "export" || settings.output === null))
         facts.output = { file: config, value: settings.output };
     const sdk = await installedVersion(dir, "@mapled/next");
@@ -2488,7 +2651,7 @@ export function liveState(facts) {
         if (written === null)
             return { kind: "unresolved", listener };
         if (facts.config)
-            return { kind: "config", listener, file: facts.config };
+            return { kind: "config", listener, file: facts.config, ...(facts.configLoad ? { load: facts.configLoad } : {}) };
         // a static export has no server: no route runs, whatever the files say
         if (facts.output)
             return { kind: "export", listener, file: facts.output.file, output: facts.output.value };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapled/cli",
-  "version": "0.14.5",
+  "version": "0.14.6",
   "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms, preview drafts and check the site's integration.",
   "license": "MIT",
   "homepage": "https://mapled.io",