@mapled/cli 0.12.0 → 0.13.0

package/dist/live.js

@@ -1,4 +1,4 @@
-import { readFile, stat } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 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
@@ -14,6 +14,9 @@ import { appRoute, listFiles, tokenize } from "./scan.js";
     does an imported name the file binds again. */
 /** Where `<MapledLive />` and `watchRelease` ask when no endpoint is given. */
 export const RELEASE_ROUTE = "/api/mapled/release";
+/** The `@mapled/next` from which that default follows the site's basePath —
+    before it, a listener with no endpoint asks RELEASE_ROUTE as written. */
+export const BASE_PATH_SINCE = "0.10.0";
 /** The extensions a route file may have when next.config doesn't set `pageExtensions`. */
 export const PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js"];
 // the config files Next reads, in its order
@@ -95,9 +98,10 @@ const literal = (t) => t?.kind === "string" && !t.unclosed && t.value !== "${}";
 const OPTIONS_TOKENS = 2000;
 /** The endpoint of a JSX element's attributes, from just after its name.
     The last of `endpoint=` and spread props wins, as in JSX; null when the
-    code decides it — an expression, or spread props that may carry one. */
+    code decides it — an expression, or spread props that may carry one —
+    and undefined when the element gives none: the SDK's default. */
 function jsxEndpoint(tokens, from) {
-    let endpoint = RELEASE_ROUTE;
+    let endpoint = undefined;
     let depth = 0;
     for (let k = from; k < tokens.length; k++) {
         if (k >= from + OPTIONS_TOKENS)
@@ -169,11 +173,12 @@ function propertyKey(tokens, k) {
     read property by property: the last `endpoint: "…"` or spread wins;
     null when the code decides it — options from elsewhere, a spread, a
     key the reading can't read (`[key]`), or an `endpoint` that isn't a
-    plain string: a shorthand, a method, a getter, an expression. */
+    plain string: a shorthand, a method, a getter, an expression — and
+    undefined when the options give none: the SDK's default. */
 function callEndpoint(tokens, paren) {
     if (!isPunct(tokens[paren + 1], "{"))
         return null;
-    let endpoint = RELEASE_ROUTE;
+    let endpoint = undefined;
     let depth = 0;
     let property = false;
     for (let k = paren + 1; k < tokens.length && k < paren + OPTIONS_TOKENS; k++) {
@@ -834,6 +839,7 @@ export function liveInFile(file, text) {
         return isPunct(tokens[k - 1], ".") && ns?.kind === "ident" && namespaces.has(ns.value) && !isPunct(tokens[k - 3], ".") && !read().bound.has(ns.value);
     };
     const listeners = [];
+    const listener = (via, endpoint) => endpoint === undefined ? { file, via, endpoint: RELEASE_ROUTE, byDefault: true } : { file, via, endpoint };
     for (let k = 0; k < tokens.length; k++) {
         const t = tokens[k];
         if (t.kind !== "ident")
@@ -841,10 +847,10 @@ export function liveInFile(file, text) {
         if (names.live.has(t.value) && isPunct(tokens[k - 1], "<")) {
             if (read().bound.has(t.value))
                 continue;
-            listeners.push({ file, via: "<MapledLive />", endpoint: jsxEndpoint(tokens, k + 1) });
+            listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1)));
         }
         else if (t.value === "MapledLive" && isPunct(tokens[k - 3], "<") && ofNamespace(k, names.ns.live)) {
-            listeners.push({ file, via: "<MapledLive />", endpoint: jsxEndpoint(tokens, k + 1) });
+            listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1)));
         }
         else if (names.watch.has(t.value) && isPunct(tokens[k + 1], "(") && !isPunct(tokens[k - 1], ".")) {
             const prev = tokens[k - 1];
@@ -852,23 +858,107 @@ export function liveInFile(file, text) {
                 continue;
             if (read().bound.has(t.value))
                 continue;
-            listeners.push({ file, via: "watchRelease", endpoint: callEndpoint(tokens, k + 1) });
+            listeners.push(listener("watchRelease", callEndpoint(tokens, k + 1)));
         }
         else if (t.value === "watchRelease" && isPunct(tokens[k + 1], "(") && ofNamespace(k, names.ns.watch)) {
-            listeners.push({ file, via: "watchRelease", endpoint: callEndpoint(tokens, k + 1) });
+            listeners.push(listener("watchRelease", callEndpoint(tokens, k + 1)));
         }
     }
-    // `dynamicParams` as the route exports it, or an export the reading can't list
-    const params = tokens.some((u, k) => namesParams(u) || isWord(u, "exports") || (isWord(u, "export") && isPunct(tokens[k + 1], "*"))) && setsParams(tokens, read().b.after);
-    return { listeners, handler: releaseHandlerOf(tokens, names, read), params };
+    // `dynamicParams` and the segment settings as the route exports them, or an export the reading can't list
+    const listing = tokens.some((u, k) => isWord(u, "exports") || (isWord(u, "export") && isPunct(tokens[k + 1], "*")));
+    const sets = (name, keeps) => (listing || tokens.some((u) => isName(u, name))) && setsExport(tokens, read().b.after, name, keeps);
+    const params = sets("dynamicParams", (t) => isWord(t ?? undefined, "true"));
+    // "force-dynamic" keeps the route only while the handler's read names its own window (keepsWindow)
+    const forced = () => sets("dynamic", (t) => literal(t ?? undefined) && t.value === "auto") && !windowsKept(tokens, names, read().b.after);
+    const segment = sets("dynamic", SEGMENT_KEEPS.dynamic) ? "dynamic" : forced() ? "force-dynamic" : sets("fetchCache", SEGMENT_KEEPS.fetchCache) ? "fetchCache" : undefined;
+    return { listeners, handler: releaseHandlerOf(tokens, names, read), params, ...(segment ? { segment } : {}) };
 }
-const namesParams = (u) => (u?.kind === "ident" || u?.kind === "string") && u.value === "dynamicParams";
-/** Whether the route may export `dynamicParams` as anything but the
-    default written out (`export const dynamicParams = true`). Next reads
-    only the module's export: a local variable, a property or a string that
-    says the name is nothing to it. An export the reading can't list —
-    `export *`, CommonJS — may be it. */
-function setsParams(tokens, after) {
+/** Whether every release handler the file makes keeps a window of its own
+    for the pointer's read (keepsWindow), with the factory only ever called
+    where it's named: `const make = createReleaseHandler`, a namespace
+    passed on or taken apart, make handlers the reading doesn't see. */
+function windowsKept(tokens, names, after) {
+    // the import clauses name them without calling: `import … from`, never past a string — `import "server-only"` has no clause
+    const clause = new Uint8Array(tokens.length);
+    for (let i = 0; i < tokens.length; i++) {
+        if (!isWord(tokens[i], "import") || isPunct(tokens[i - 1], ".") || isPunct(tokens[i + 1], "("))
+            continue;
+        let j = i + 1;
+        while (j < tokens.length && j < i + 200 && !isWord(tokens[j], "from") && tokens[j].kind !== "string" && !isPunct(tokens[j], ";"))
+            j = isPunct(tokens[j], "{") ? after[j] : j + 1;
+        if (isWord(tokens[j], "from"))
+            clause.fill(1, i, j + 1);
+    }
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        if (t.kind !== "ident" || clause[k] === 1)
+            continue;
+        const ns = names.ns.handler.has(t.value) && !isPunct(tokens[k - 1], ".");
+        if (ns && !isPunct(tokens[k + 1], "."))
+            return false;
+        const direct = names.handler.has(t.value) && !isPunct(tokens[k - 1], ".");
+        const member = t.value === "createReleaseHandler" && isPunct(tokens[k - 1], ".") && tokens[k - 2]?.kind === "ident" && names.ns.handler.has(tokens[k - 2].value) && !isPunct(tokens[k - 3], ".");
+        if ((direct || member) && !(isPunct(tokens[k + 1], "(") && keepsWindow(tokens, after, k + 1)))
+            return false;
+    }
+    return true;
+}
+/** Whether a `createReleaseHandler` call, from its opening parenthesis,
+    leaves the pointer's read a window of its own: options written out as
+    an object whose `revalidate` is absent (3600) or digits above 0. On a
+    `force-dynamic` route Next 15 and later fetch a read with no window —
+    `revalidate: false` counts as none — uncached, past the `mapled` tag,
+    and the release moves before the webhook refreshes the pages. False
+    where the reading can't tell: options from elsewhere, a spread, a key
+    the code decides, a `revalidate` that isn't plain digits. */
+function keepsWindow(tokens, after, paren) {
+    const open = paren + 1;
+    if (!isPunct(tokens[open], "{") || !isPunct(tokens[after[open]], ")"))
+        return false;
+    let kept = true;
+    for (const [a, z] of itemsOf(tokens, after, open)) {
+        if (a === z)
+            continue;
+        if (isSpread(tokens, a))
+            return false;
+        const { name, next } = propertyKey(tokens, a);
+        if (name === null)
+            return false;
+        if (name !== "revalidate")
+            continue;
+        // the last one wins, as in the object: `revalidate: 60`, `revalidate: 0.5`
+        const digits = tokens.slice(next + 1, z).map((u) => (u.kind === "punct" ? u.value : " ")).join("");
+        kept = isPunct(tokens[next], ":") && /^(\d+\.?\d*|\.\d+)$/.test(digits) && Number(digits) > 0;
+    }
+    return kept;
+}
+/** Whether the token is the name — as an identifier or a string: `export { x as "name" }`. */
+const isName = (u, name) => (u?.kind === "ident" || u?.kind === "string") && u.value === name;
+/** The route segment settings that change how Next serves the release
+    route or reads what the handler reads, in the order doctor names them:
+    `dynamic` can make it a static copy built without the tab's request,
+    and `fetchCache` can make the handler's read skip the `mapled` cache
+    tag, so the release moves before the webhook refreshes the pages.
+    `revalidate` isn't one: it only fills in fetches that don't name their
+    own window, and the handler's names one (Next 14's fetch patch; the
+    live smoke with `revalidate = 1` on Next 15). "force-dynamic" is the
+    third: harmless while the handler keeps its read's window, and past
+    the tag when it doesn't (keepsWindow). */
+export const SEGMENT_SETTINGS = ["dynamic", "fetchCache"];
+/** For each, the values written out that leave the route as the handler
+    sets it up: the default, and for `dynamic` also "force-dynamic" — the
+    route reads its request, so it is dynamic anyway; what it does to the
+    handler's read is checked apart (windowsKept). */
+const SEGMENT_KEEPS = {
+    dynamic: (t) => literal(t ?? undefined) && (t.value === "auto" || t.value === "force-dynamic"),
+    fetchCache: (t) => literal(t ?? undefined) && t.value === "auto",
+};
+/** Whether the route may export `name` as anything but a value `keeps`
+    accepts, written out on a `const`. Next reads only the module's
+    export: a local variable, a property or a string that says the name is
+    nothing to it. An export the reading can't list — `export *`,
+    CommonJS — may be it. */
+function setsExport(tokens, after, name, keeps) {
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
         // CommonJS: `module.exports = { dynamicParams: false }`, `exports.dynamicParams = false`
@@ -888,7 +978,7 @@ function setsParams(tokens, after) {
         // a clause, with or without `from`: `export { x as dynamicParams }`, `export { dynamicParams }`, `export { x as "dynamicParams" }`
         if (isPunct(tokens[j], "{")) {
             for (let k = j + 1; k < after[j] - 1; k++)
-                if (namesParams(tokens[k]) && !isWord(tokens[k + 1], "as"))
+                if (isName(tokens[k], name) && !isWord(tokens[k + 1], "as"))
                     return true;
             continue;
         }
@@ -897,8 +987,8 @@ function setsParams(tokens, after) {
         const declare = tokens[j];
         if (declare?.kind !== "ident" || !DECLARE.has(declare.value)) {
             // `export function dynamicParams`, `export class …`, `export import dynamicParams = …`
-            const name = isPunct(tokens[j + 1], "*") ? j + 2 : j + 1;
-            if (namesParams(tokens[name]))
+            const named = isPunct(tokens[j + 1], "*") ? j + 2 : j + 1;
+            if (isName(tokens[named], name))
                 return true;
             continue;
         }
@@ -907,13 +997,13 @@ function setsParams(tokens, after) {
             let next;
             if (isPunct(tokens[k], "{") || isPunct(tokens[k], "[")) {
                 for (let p = k + 1; p < after[k] - 1; p++)
-                    if (namesParams(tokens[p]))
+                    if (isName(tokens[p], name))
                         return true;
                 next = after[k];
             }
             else if (tokens[k].kind === "ident") {
-                // only a `const` keeps the default: a `let` or `var` may change it later
-                if (namesParams(tokens[k]) && (declare.value !== "const" || !paramsDefault(tokens, after, k)))
+                // only a `const` keeps its value: a `let` or `var` may change it later
+                if (isName(tokens[k], name) && (declare.value !== "const" || !keeps(writtenValue(tokens, after, k))))
                     return true;
                 next = k + 1;
             }
@@ -932,15 +1022,16 @@ function setsParams(tokens, after) {
     }
     return false;
 }
-/** Whether the mention of `dynamicParams` at `k` writes out the default:
-    `dynamicParams = true`, with or without a type (`: boolean`), the `true`
-    in parentheses or followed by `as` / `satisfies` / `!`. */
-function paramsDefault(tokens, after, k) {
+/** The one token a declaration at `k` writes as its value: `name = true`,
+    with or without a type (`: boolean`), the value in parentheses or
+    followed by `as` / `satisfies` / `!`. Null when the value is anything
+    else — an expression, more than one token — or there is none. */
+function writtenValue(tokens, after, k) {
     if (tokens[k].kind !== "ident")
-        return false;
+        return null;
     const eq = isPunct(tokens[k + 1], ":") ? typeEnd(tokens, after, k + 2, tokens.length) : k + 1;
     if (eq < 0 || !isPunct(tokens[eq], "=") || isPunct(tokens[eq + 1], "="))
-        return false;
+        return null;
     let from = eq + 1;
     let to = initializerEnd(tokens, after, from);
     for (;;) {
@@ -958,7 +1049,7 @@ function paramsDefault(tokens, after, k) {
         while (end > from + 1 && isPunct(tokens[end - 1], "!"))
             end--;
         if (!isPunct(tokens[from], "(") || after[from] !== end)
-            return end === from + 1 && isWord(tokens[from], "true");
+            return end === from + 1 ? tokens[from] : null;
         from++;
         to = end - 1;
     }
@@ -1008,267 +1099,983 @@ async function atRoot(dir, name) {
 const SETTINGS = ["pageExtensions", "basePath"];
 // calls that set a property of an object they're given, by a name or from another object, or give it a prototype that may carry one
 const COPIES = new Set(["assign", "defineProperty", "defineProperties", "Reflect", "setPrototypeOf", "__defineGetter__", "__defineSetter__", "__proto__"]);
-/** next.config's `pageExtensions` and `basePath`, read only where the file
-    writes them out: a literal, once, directly in the object it exports —
-    `module.exports = {…}`, `export default nextConfig`, or passed to a
-    plugin: `withMDX(nextConfig)`. Null when it may set either anywhere
-    else: a value or a name the code builds (`["page" + "Extensions"]`, an
-    escaped identifier, `Object.assign`, `defineProperty`, a prototype
-    set by `setPrototypeOf` or `__proto__`, a member in a loop's head), an object from
-    another file or spread in, a member (`config.basePath = …`), a nested
-    object, any other mention — then no route can be checked. */
-export function nextConfigOf(config) {
-    if (config === null)
-        return { pageExtensions: PAGE_EXTENSIONS, basePath: "" };
-    const tokens = tokenize(config);
-    const b = bracketsOf(tokens);
-    const declarations = declarationsOf(tokens, b.after);
-    const declaredAt = new Set(declarations.map((d) => d.at));
+// Next's hooks: the functions a config may hold, which Next calls only once it has loaded the config — webpack's as it builds, the routes' as it collects them
+const HOOKS = new Set(["webpack", "headers", "redirects", "rewrites", "generateBuildId", "exportPathMap"]);
+// the names the subset reads without a binding, which the file may not bind
+const AMBIENT = new Set(["process", "require", "module", "exports", "URL", "undefined", "NaN", "Infinity", "globalThis", "eval", "arguments"]);
+// the words that start a statement of the subset; none goes on with the expression a line break comes after
+const STARTS = new Set(["import", "export", "const", "let", "var", "module"]);
+// words after which JavaScript reads a `/` as a regex, not a division — the contextual ones (`of`, `await`, `let`) either way
+const BEFORE_REGEX = new Set(["return", "typeof", "case", "delete", "do", "else", "in", "instanceof", "new", "of", "throw", "void", "yield", "await", "extends", "let"]);
+// words no value ends with: past a line break after one, the expression goes on
+const GOES_ON = new Set([...BEFORE_REGEX, "as", "satisfies", "keyof", "default", "export", "import", "const", "var"]);
+// brackets and what closes each
+const OPENS = new Map([
+    ["(", ")"],
+    ["[", "]"],
+    ["{", "}"],
+]);
+// how deep values may nest, so a deep file can't overflow the stack
+const DEPTH = 200;
+const isDigit = (t) => t?.kind === "punct" && /^\d$/.test(t.value);
+/** Whether every bracket closes with its own kind, and none closes nothing. */
+function balanced(tokens, b) {
     for (let k = 0; k < tokens.length; k++) {
         const t = tokens[k];
-        // an identifier with an escape in its name, or a call that sets or copies properties
-        if (isPunct(t, "\\") || (t.kind === "ident" && (t.escaped === true || COPIES.has(t.value))) || (t.kind === "string" && t.value === "__proto__"))
-            return null;
-        // a setting's name inside a longer string: JSON the code parses
-        if (t.kind === "string" && !SETTINGS.includes(t.value) && SETTINGS.some((s) => t.value.includes(s)))
-            return null;
-        if (!isPunct(t, "["))
-            continue;
-        // a computed key or member written to, unless a lone string or digits name it: `{ [name]: … }`, `config[name] = …`, not `rules[0] = …`
-        const close = b.after[k] - 1;
-        if (close === k + 2 && literal(tokens[k + 1]))
-            continue;
-        let digits = k + 1;
-        while (digits < close && tokens[digits].kind === "punct" && /^\d$/.test(tokens[digits].value))
-            digits++;
-        if (digits === close && close > k + 1)
+        if (t.kind !== "punct")
             continue;
-        const prev = tokens[k - 1];
-        const key = (isPunct(prev, "{") || isPunct(prev, ",") || isPunct(prev, "*") || (prev?.kind === "ident" && KEY_PREFIX.has(prev.value))) && (isPunct(tokens[close + 1], ":") || isPunct(tokens[close + 1], "("));
-        // a loop's head writes each value to it: `for (config[name] of values)`
-        const head = b.parent[k];
-        const loop = head >= 0 && isPunct(tokens[head], "(") && (isWord(tokens[head - 1], "for") || (isWord(tokens[head - 1], "await") && isWord(tokens[head - 2], "for"))) && (isWord(tokens[close + 1], "of") || isWord(tokens[close + 1], "in"));
-        const member = (prev?.kind === "ident" || isPunct(prev, ")") || isPunct(prev, "]")) && (assigned(tokens, close) || loop);
-        if (key || member)
-            return null;
+        const close = OPENS.get(t.value);
+        if (close !== undefined) {
+            const at = b.after[k] - 1;
+            if (!isPunct(tokens[at], close) || b.open[at] !== k)
+                return false;
+        }
+        else if ((t.value === ")" || t.value === "]" || t.value === "}") && b.open[k] < 0)
+            return false;
     }
-    // what the file exports: `module.exports = …`, `export default …`, `export { config as default }`
-    const exported = [];
-    const names = exportClauses(tokens).get("default") ?? [];
+    return true;
+}
+/** Whether each `/` of the tokens is what JavaScript reads there: a
+    division after a value — a name, a literal, `]`, a `)` that closes no
+    `if (…)` — and a regex anywhere else. The tokens read a regex only after
+    punctuation that ends no value (and `return`, `typeof`), so they differ
+    after `+`, after `else`, after `if (x)`: a brace in such a regex would
+    move every bracket after it. After `}` JavaScript can read either. */
+function slashesAgree(tokens, b) {
     for (let k = 0; k < tokens.length; k++) {
-        if (isWord(tokens[k], "module") && !isPunct(tokens[k - 1], ".") && isPunct(tokens[k + 1], ".") && isWord(tokens[k + 2], "exports") && isPunct(tokens[k + 3], "=") && !isPunct(tokens[k + 4], "=")) {
-            exported.push([k + 4, initializerEnd(tokens, b.after, k + 4, false)]);
+        const t = tokens[k];
+        const regex = t.kind === "regex";
+        if (!regex && !isPunct(t, "/"))
+            continue;
+        const p = tokens[k - 1];
+        let division;
+        if (p === undefined)
+            division = false;
+        else if (p.kind === "ident")
+            division = !BEFORE_REGEX.has(p.value) || isPunct(tokens[k - 2], ".");
+        else if (p.kind === "string" || p.kind === "regex" || isDigit(p) || p.value === "]")
+            division = true;
+        else if (p.value === ")") {
+            const open = b.open[k - 1];
+            const head = open >= 0 ? tokens[open - 1] : undefined;
+            const condition = head?.kind === "ident" && !isPunct(tokens[open - 2], ".") && (["if", "while", "for", "with"].includes(head.value) || (head.value === "await" && isWord(tokens[open - 2], "for")));
+            division = !condition;
         }
-        else if (isWord(tokens[k], "export") && isWord(tokens[k + 1], "default"))
-            exported.push([k + 2, initializerEnd(tokens, b.after, k + 2, false)]);
-    }
-    // `export { default } from "./base.mjs"`: the config is another module's
-    const reexported = tokens.some((t, k) => isWord(t, "export") && isPunct(tokens[k + 1], "{") && isWord(tokens[b.after[k + 1]], "from") && tokens.slice(k + 2, b.after[k + 1] - 1).some((u) => isWord(u, "default")));
-    // the objects the config is made of, and whether any part comes from elsewhere
-    const objects = new Set();
-    let opaque = reexported || exported.length + names.length > 1;
-    const byName = new Map();
-    for (const d of declarations) {
-        const list = byName.get(d.name);
-        if (list)
-            list.push(d);
+        else if (p.value === "}")
+            return false;
         else
-            byName.set(d.name, [d]);
+            division = false;
+        if (regex === division)
+            return false;
     }
-    const reassigned = new Set(tokens.flatMap((u, k) => (u.kind === "ident" && !isPunct(tokens[k - 1], ".") && !declaredAt.has(k) && changes(tokens, k) ? [u.value] : [])));
-    // and every name in a pattern assigned to — `({ config } = presets)`, `[a, config] = list` — as a running count: nested patterns stay linear
-    const patterns = new Int32Array(tokens.length + 1);
-    for (let k = 0; k < tokens.length; k++) {
-        const after = b.after[k];
-        if ((isPunct(tokens[k], "{") || isPunct(tokens[k], "[")) && !DECLARE.has(tokens[k - 1]?.value ?? "") && isPunct(tokens[after], "=") && !isPunct(tokens[after + 1], "=")) {
-            patterns[k]++;
-            patterns[after]--;
+    return true;
+}
+/** The file as the declarative subset nextConfigOf reads (see there), or
+    null when anything in it is outside the subset. */
+function declarative(tokens, b) {
+    const bindings = new Map();
+    const props = new Map();
+    const configs = [];
+    let exported = null;
+    let exports = 0;
+    let depth = 0;
+    const guard = (fail, f) => {
+        if (depth >= DEPTH)
+            return fail;
+        depth++;
+        try {
+            return f();
+        }
+        finally {
+            depth--;
         }
-    }
-    for (let k = 0, depth = 0; k < tokens.length; k++) {
-        depth += patterns[k];
-        if (depth > 0 && tokens[k].kind === "ident")
-            reassigned.add(tokens[k].value);
-        // a loop's head without a declaration: `for (config of variants)`
-        const loop = isPunct(tokens[k - 1], "(") && (isWord(tokens[k - 2], "for") || (isWord(tokens[k - 2], "await") && isWord(tokens[k - 3], "for")));
-        if (loop && tokens[k].kind === "ident" && (isWord(tokens[k + 1], "of") || isWord(tokens[k + 1], "in")))
-            reassigned.add(tokens[k].value);
-    }
-    // names taken from a file of the site — `import x from "./x"`, `const x = require("./x")`: a plugin there may set anything
-    const relative = (k) => (isWord(tokens[k], "require") || isWord(tokens[k], "import")) && isPunct(tokens[k + 1], "(") && tokens[k + 2]?.kind === "string" && tokens[k + 2].value.startsWith(".");
-    const loadsBefore = new Int32Array(tokens.length + 1);
-    for (let k = 0; k < tokens.length; k++)
-        loadsBefore[k + 1] = loadsBefore[k] + (relative(k) ? 1 : 0);
-    const local = new Set(declarations.filter((d) => loadsBefore[d.to] > loadsBefore[d.from]).map((d) => d.name));
-    for (let k = 0; k < tokens.length; k++) {
-        if (!isWord(tokens[k], "import") || isPunct(tokens[k + 1], "("))
-            continue;
-        const bound = [];
-        let j = k + 1;
-        for (; j < tokens.length && j < k + 200 && !isPunct(tokens[j], ";") && !isWord(tokens[j], "from"); j++)
-            if (tokens[j].kind === "ident")
-                bound.push(tokens[j].value);
-        if (isWord(tokens[j], "from") && tokens[j + 1]?.kind === "string" && tokens[j + 1].value.startsWith("."))
-            for (const name of bound)
-                local.add(name);
-    }
-    // each name is read once: a name passed twice, or one that names itself, adds nothing
-    const visited = new Set();
-    const fromName = (name, depth) => {
-        if (visited.has(name))
-            return;
-        visited.add(name);
-        const ds = byName.get(name) ?? [];
-        // declared once, with a value, never assigned again: that value; anything else — an import, a parameter — is from elsewhere
-        if (ds.length !== 1 || reassigned.has(name) || ds[0].fn || ds[0].from === ds[0].to)
-            opaque = true;
-        else
-            visit(ds[0].from, ds[0].to, depth + 1);
     };
-    const visit = (from, to, depth) => {
-        if (opaque)
-            return;
-        if (depth > 16 || from >= to) {
-            opaque = true;
-            return;
+    // the items between the brackets that open at `open`: a trailing comma adds none, a hole makes it null
+    const listOf = (open) => {
+        const items = itemsOf(tokens, b.after, open);
+        if (items.length === 1 && items[0][0] === items[0][1])
+            return [];
+        if (items.length > 1 && items[items.length - 1][0] === items[items.length - 1][1])
+            items.pop();
+        return items.some(([x, y]) => x === y) ? null : items;
+    };
+    // [from, to) split at its commas outside brackets
+    const splitAt = (from, to) => {
+        const out = [];
+        let start = from;
+        for (let k = from; k <= to; k++) {
+            const t = tokens[k];
+            if (k < to && t?.kind === "punct" && OPENS.has(t.value))
+                k = b.after[k] - 1;
+            else if (k === to || isPunct(t, ",")) {
+                out.push([start, k]);
+                start = k + 1;
+            }
         }
-        // where the value ends: `x as T` and `x satisfies T` are x, and a line
-        // without a semicolon ends before a name that starts the next one
-        let end = to;
+        return out;
+    };
+    // a value's last token: a line break after it may end the statement
+    const endsValue = (t) => t !== undefined && (t.kind === "string" || t.kind === "regex" || (t.kind === "ident" && !GOES_ON.has(t.value)) || isDigit(t) || isPunct(t, ")") || isPunct(t, "]") || isPunct(t, "}"));
+    // where the statement at `k` ends: its `;`, or a line that starts another after a value
+    const statementEnd = (k) => {
+        for (let j = k; j < tokens.length; j++) {
+            const t = tokens[j];
+            if (isPunct(t, ";"))
+                return j;
+            if (j > k && t.nl === true && t.kind === "ident" && STARTS.has(t.value) && endsValue(tokens[j - 1]))
+                return j;
+            if (t.kind === "punct" && OPENS.has(t.value))
+                j = b.after[j] - 1;
+        }
+        return tokens.length;
+    };
+    const bind = (k, binding) => {
+        const t = tokens[k];
+        if (t?.kind !== "ident" || AMBIENT.has(t.value) || bindings.has(t.value))
+            return false;
+        bindings.set(t.value, { ...binding, at: k, uses: 0 });
+        return true;
+    };
+    // a type as next.config writes one: `NextConfig`, `import("next").NextConfig`, with type arguments of the same and `[]` after; `const`
+    const simpleType = (j, to, level = 0) => {
+        if (level > 8 || j >= to)
+            return -1;
+        if (isWord(tokens[j], "const"))
+            return j + 1;
+        if (isWord(tokens[j], "import")) {
+            if (!(isPunct(tokens[j + 1], "(") && literal(tokens[j + 2]) && isPunct(tokens[j + 3], ")") && isPunct(tokens[j + 4], ".")))
+                return -1;
+            j += 5;
+        }
+        if (tokens[j]?.kind !== "ident")
+            return -1;
+        j++;
+        while (isPunct(tokens[j], ".") && tokens[j + 1]?.kind === "ident")
+            j += 2;
+        if (isPunct(tokens[j], "<")) {
+            do {
+                j = simpleType(j + 1, to, level + 1);
+                if (j < 0)
+                    return -1;
+            } while (isPunct(tokens[j], ","));
+            if (!isPunct(tokens[j], ">"))
+                return -1;
+            j++;
+        }
+        while (isPunct(tokens[j], "[") && isPunct(tokens[j + 1], "]"))
+            j += 2;
+        return j <= to ? j : -1;
+    };
+    // what may follow a value to the end of its range: `as T`, `satisfies T`, on its line
+    const suffix = (j, to) => {
+        while (j < to) {
+            if (!(isWord(tokens[j], "as") || isWord(tokens[j], "satisfies")) || tokens[j].nl === true)
+                return false;
+            j = simpleType(j + 1, to);
+            if (j < 0)
+                return false;
+        }
+        return j === to;
+    };
+    // where the value in [from, to) ends before its types, or -1
+    const valueEnd = (from, to) => {
         for (let k = from; k < to; k++) {
-            const u = tokens[k];
-            const p = tokens[k - 1];
-            if (k > from && (isWord(u, "as") || isWord(u, "satisfies")))
-                end = k;
-            else if (k > from && u.nl === true && u.kind === "ident" && u.value !== "in" && u.value !== "instanceof" && (p.kind !== "punct" || ")]}".includes(p.value) || /^\d$/.test(p.value)))
-                end = k;
-            else if (u.kind === "punct" && "([{".includes(u.value))
+            const t = tokens[k];
+            if (t.kind === "punct" && OPENS.has(t.value))
                 k = b.after[k] - 1;
-            if (end !== to)
-                break;
+            else if ((isWord(t, "as") || isWord(t, "satisfies")) && k > from && !isPunct(tokens[k - 1], "."))
+                return suffix(k, to) ? k : -1;
         }
-        let k = from;
-        while (k < end && isWord(tokens[k], "await"))
-            k++;
-        if (k >= end) {
-            opaque = true;
-            return;
+        return to;
+    };
+    // a use of the name at `k` in a role, after its binding: the first settles what the binding's value is for that role
+    const use = (k, role) => {
+        const binding = bindings.get(tokens[k].value);
+        if (binding === undefined || binding.at >= k || binding.busy === true)
+            return false;
+        if (binding.role !== undefined && binding.role !== role)
+            return false;
+        binding.role = role;
+        binding.uses++;
+        // the config is taken once: a second use would hand it to more code
+        if (role === "config" && binding.uses > 1)
+            return false;
+        if (binding.uses > 1)
+            return true;
+        binding.busy = true;
+        const fine = settle(binding, role);
+        delete binding.busy;
+        return fine;
+    };
+    const settle = (binding, role) => {
+        switch (role) {
+            case "config":
+                return binding.kind === "value" && configValue(binding.from, binding.to);
+            case "data":
+                return binding.kind === "none" || (binding.kind === "value" && data(binding.from, binding.to));
         }
-        const t = tokens[k];
-        if ((isPunct(t, "{") || isPunct(t, "(")) && b.after[k] === end) {
-            if (t.value === "{")
-                objects.add(k);
+    };
+    // the config in [from, to): the object, or a name of it — a plugin's call is code the reading doesn't run (block 348)
+    const configValue = (from, to) => guard(false, () => {
+        const end = valueEnd(from, to);
+        if (end <= from)
+            return false;
+        const t = tokens[from];
+        if (isPunct(t, "(") && b.after[from] === end)
+            return configValue(from + 1, end - 1);
+        if (isPunct(t, "{") && b.after[from] === end) {
+            configs.push(from);
+            return object(from, true);
+        }
+        return t.kind === "ident" && from + 1 === end && use(from, "config");
+    });
+    // an object literal's properties: values that are data, a shorthand's name; functions only as Next's hooks, at the config's top
+    const object = (open, config) => guard(false, () => {
+        const items = listOf(open);
+        if (items === null)
+            return false;
+        const list = [];
+        for (const [x, y] of items) {
+            // `async` or `get` is a key itself when what follows ends one: `{ get: 1 }`, `{ async }`
+            const endsKey = (j) => j === y || isPunct(tokens[j], ":") || isPunct(tokens[j], "(");
+            let k = x;
+            const async = isWord(tokens[k], "async") && !endsKey(k + 1);
+            if (async)
+                k++;
+            // a generator, a spread, a getter or a setter: code the reading doesn't run, or properties from elsewhere
+            if (isPunct(tokens[k], "*") || isPunct(tokens[k], ".") || ((isWord(tokens[k], "get") || isWord(tokens[k], "set")) && !endsKey(k + 1)))
+                return false;
+            const t = tokens[k];
+            let key;
+            let at = k;
+            let next = k + 1;
+            if (t?.kind === "ident" || literal(t))
+                key = t.value;
+            else if (isPunct(t, "[") && literal(tokens[k + 1]) && isPunct(tokens[k + 2], "]")) {
+                key = tokens[k + 1].value;
+                at = k + 1;
+                next = k + 3;
+            }
             else
-                visit(k + 1, end - 1, depth + 1);
-            return;
+                return false;
+            // `__proto__: …` sets the object's prototype
+            if (key === "__proto__")
+                return false;
+            const hook = config && HOOKS.has(key);
+            if (next === y) {
+                if (async || t?.kind !== "ident" || !use(k, "data"))
+                    return false;
+                list.push({ key, at, kind: "shorthand", from: k, to: y });
+            }
+            else if (isPunct(tokens[next], ":") && !async) {
+                if (functionOf(tokens, b.after, next + 1, y) !== null) {
+                    if (!hook)
+                        return false;
+                    list.push({ key, at, kind: "hook", from: next + 1, to: y });
+                }
+                else {
+                    if (!data(next + 1, y))
+                        return false;
+                    list.push({ key, at, kind: "value", from: next + 1, to: y });
+                }
+            }
+            else if (isPunct(tokens[next], "(")) {
+                // a method: `async headers() {…}`
+                const body = bodyAfter(tokens, b.after[next]);
+                if (!hook || body === null || b.after[body] !== y)
+                    return false;
+                list.push({ key, at, kind: "hook", from: next, to: y });
+            }
+            else
+                return false;
         }
-        // a function: its code is here, and whatever it sets, the mentions below see
-        if (isWord(t, "function") || (isWord(t, "async") && isWord(tokens[k + 1], "function")) || functionOf(tokens, b.after, k, end))
-            return;
-        // a plugin's name or option: `require("@next/mdx")`, `{ enabled: true }`
-        if (t?.kind === "string" || (t?.kind === "punct" && /^\d$/.test(t.value)) || isWord(t, "true") || isWord(t, "false") || isWord(t, "null") || isWord(t, "undefined"))
-            return;
-        if (t?.kind !== "ident") {
-            opaque = true;
-            return;
+        props.set(open, list);
+        return true;
+    });
+    // data in [from, to), to its end but for types
+    const data = (from, to) => guard(false, () => {
+        const e = expr(from, to);
+        return e > from && (e === to || suffix(e, to));
+    });
+    const expr = (k, to) => guard(-1, () => {
+        let j = binary(k, to);
+        if (j < 0 || j >= to || !isPunct(tokens[j], "?") || isPunct(tokens[j + 1], "?") || isPunct(tokens[j + 1], "."))
+            return j;
+        j = expr(j + 1, to);
+        if (j < 0 || j >= to || !isPunct(tokens[j], ":"))
+            return -1;
+        return expr(j + 1, to);
+    });
+    const binary = (k, to) => {
+        let j = unary(k, to);
+        while (j >= 0 && j < to) {
+            const n = operator(j);
+            if (n <= 0)
+                return n < 0 ? -1 : j;
+            j = unary(j + n, to);
         }
-        let j = k + 1;
-        while (j < end && isPunct(tokens[j], ".") && tokens[j + 1]?.kind === "ident")
-            j += 2;
-        if (j === end) {
-            // a name, or a member (`base.config`) — a value from elsewhere
-            if (j === k + 1)
-                fromName(t.value, depth);
+        return j;
+    };
+    // the binary operator at `j`, by its tokens: 0 where the operand ends, -1 for an assignment or an operator the subset doesn't read
+    const operator = (j) => {
+        const t = tokens[j];
+        const u = tokens[j + 1];
+        const v = tokens[j + 2];
+        if (t?.kind !== "punct")
+            return 0;
+        switch (t.value) {
+            case "=":
+            case "!":
+                return isPunct(u, "=") ? (isPunct(v, "=") ? 3 : 2) : -1;
+            case "&":
+            case "|":
+            case "?":
+                if (!isPunct(u, t.value))
+                    return t.value === "?" ? 0 : -1;
+                return isPunct(v, "=") ? -1 : 2;
+            case "+":
+                return isPunct(u, "+") || isPunct(u, "=") ? -1 : 1;
+        }
+        return 0;
+    };
+    const unary = (k, to) => {
+        let j = k;
+        while (j < to && j < k + 16 && (isPunct(tokens[j], "!") || (isPunct(tokens[j], "-") && !isPunct(tokens[j + 1], "-"))))
+            j++;
+        return primary(j, to);
+    };
+    const numberEnd = (k, to) => {
+        let j = k;
+        let point = false;
+        while (j < to && (j === k || tokens[j].nl !== true)) {
+            if (isDigit(tokens[j]))
+                j++;
+            else if (isPunct(tokens[j], ".") && !point && isDigit(tokens[j + 1])) {
+                point = true;
+                j++;
+            }
             else
-                opaque = true;
-            return;
+                break;
         }
-        // a call, or calls: `withMDX(nextConfig)`, `createMDX()(config)` — a
-        // plugin from a package keeps the config it's given; `require("…")`, a
-        // plugin from the site's own files, or a call given no config — its
-        // value comes from elsewhere
-        if (!isPunct(tokens[j], "(") || (isWord(t, "require") && j === k + 1 && b.after[j] === end) || relative(k) || local.has(t.value)) {
-            opaque = true;
-            return;
+        return j;
+    };
+    // the arguments of the call that opens at `open`, each data
+    const args = (open, to) => {
+        const close = b.after[open];
+        const items = close <= to ? listOf(open) : null;
+        return items !== null && items.every(([x, y]) => data(x, y)) ? close : -1;
+    };
+    const primary = (k, to) => {
+        const t = tokens[k];
+        if (t === undefined || k >= to)
+            return -1;
+        if (t.kind === "string")
+            return literal(t) ? k + 1 : -1;
+        if (t.kind === "regex")
+            return k + 1;
+        if (t.kind === "punct") {
+            if (isDigit(t) || (t.value === "." && isDigit(tokens[k + 1])))
+                return numberEnd(k, to);
+            const close = b.after[k];
+            if (!OPENS.has(t.value) || close > to)
+                return -1;
+            if (t.value === "(")
+                return data(k + 1, close - 1) ? close : -1;
+            if (t.value === "[")
+                return listOf(k)?.every(([x, y]) => data(x, y)) ? close : -1;
+            return object(k, false) ? close : -1;
         }
-        const literal = (u) => u?.kind === "string" || (u?.kind === "punct" && /^\d$/.test(u.value)) || isWord(u, "true") || isWord(u, "false") || isWord(u, "null") || isWord(u, "undefined");
-        let given = false;
-        for (; j < end && isPunct(tokens[j], "("); j = b.after[j]) {
-            let start = j + 1;
-            const close = b.after[j] - 1;
-            given = false;
-            for (let a = start; a <= close; a++) {
-                const u = tokens[a];
-                if (a < close && u.kind === "punct" && "([{".includes(u.value))
-                    a = b.after[a] - 1;
-                else if (a === close || isPunct(u, ",")) {
-                    if (a > start) {
-                        given ||= !literal(tokens[start]);
-                        visit(start, a, depth + 1);
-                    }
-                    start = a + 1;
+        const next = tokens[k + 1];
+        switch (t.value) {
+            case "true":
+            case "false":
+            case "null":
+            case "undefined":
+            case "NaN":
+            case "Infinity":
+                return k + 1;
+            case "process":
+                // `process.env.NAME`, `process.env["NAME"]`, `process.cwd()`
+                if (!isPunct(next, "."))
+                    return -1;
+                if (isWord(tokens[k + 2], "env") && isPunct(tokens[k + 3], ".") && tokens[k + 4]?.kind === "ident")
+                    return k + 5;
+                if (isWord(tokens[k + 2], "env") && isPunct(tokens[k + 3], "[") && literal(tokens[k + 4]) && isPunct(tokens[k + 5], "]"))
+                    return k + 6;
+                return isWord(tokens[k + 2], "cwd") && isPunct(tokens[k + 3], "(") && isPunct(tokens[k + 4], ")") ? k + 5 : -1;
+            case "import":
+                // `import.meta.dirname`, `.filename`, `.url`
+                return isPunct(next, ".") && isWord(tokens[k + 2], "meta") && isPunct(tokens[k + 3], ".") && ["dirname", "filename", "url"].some((w) => isWord(tokens[k + 4], w)) ? k + 5 : -1;
+            case "require":
+                // `require.resolve("m")`: a path; nothing is loaded
+                return isPunct(next, ".") && isWord(tokens[k + 2], "resolve") && isPunct(tokens[k + 3], "(") && literal(tokens[k + 4]) && isPunct(tokens[k + 5], ")") ? k + 6 : -1;
+            case "new":
+                // `new URL("…")`
+                return isWord(next, "URL") && isPunct(tokens[k + 2], "(") ? args(k + 2, to) : -1;
+        }
+        if ((t.value === "__dirname" || t.value === "__filename") && !bindings.has(t.value))
+            return k + 1;
+        // a name declared with data — not a member of it or a call
+        return !isPunct(next, ".") && !isPunct(next, "(") && use(k, "data") ? k + 1 : -1;
+    };
+    // statements
+    const exportValue = (from, e) => {
+        if (from >= e)
+            return false;
+        exports++;
+        exported = { from, to: e };
+        return true;
+    };
+    // `import type { NextConfig } from "next"`, `import type X from "m"`, `import type * as M from "m"`: types, erased — the only import, since a module
+    // loaded runs its code, and which module a name loads the spelling doesn't show (Node's self-reference, a next.config.ts's tsconfig paths)
+    const typeImport = (k, e) => {
+        if (!isWord(tokens[k + 1], "type") || !(e >= k + 5 && isWord(tokens[e - 2], "from") && literal(tokens[e - 1])))
+            return false;
+        const stop = e - 2;
+        const j = k + 2;
+        if (isPunct(tokens[j], "{"))
+            return b.after[j] === stop;
+        if (isPunct(tokens[j], "*"))
+            return isWord(tokens[j + 1], "as") && tokens[j + 2]?.kind === "ident" && j + 3 === stop;
+        return tokens[j]?.kind === "ident" && !isWord(tokens[j], "from") && j + 1 === stop;
+    };
+    const exportStatement = (k, e) => {
+        const t = tokens[k + 1];
+        if (isWord(t, "default"))
+            return exportValue(k + 2, e);
+        // `export type { T }`, `export type { T } from "m"`: types, erased
+        if (isWord(t, "type") && isPunct(tokens[k + 2], "{")) {
+            const close = b.after[k + 2];
+            return close === e || (close + 2 === e && isWord(tokens[close], "from") && literal(tokens[close + 1]));
+        }
+        // `export { config as default }`: the one export
+        if (!isPunct(t, "{") || b.after[k + 1] !== e)
+            return false;
+        const items = listOf(k + 1);
+        if (items === null || items.length !== 1)
+            return false;
+        const [x, y] = items[0];
+        const named = isWord(tokens[x + 2], "default") || (literal(tokens[x + 2]) && tokens[x + 2].value === "default");
+        if (!(y === x + 3 && tokens[x].kind === "ident" && isWord(tokens[x + 1], "as") && named))
+            return false;
+        exports++;
+        exported = { name: x };
+        return true;
+    };
+    const declaration = (j, e) => {
+        if (j >= e)
+            return false;
+        for (const [x, y] of splitAt(j, e)) {
+            if (x === y)
+                return false;
+            const t = tokens[x];
+            if (t.kind === "ident") {
+                let v = x + 1;
+                // a type: `const nextConfig: NextConfig = …`
+                if (isPunct(tokens[v], ":")) {
+                    v = simpleType(v + 1, y);
+                    if (v < 0)
+                        return false;
                 }
+                if (v === y) {
+                    if (!bind(x, { kind: "none" }))
+                        return false;
+                    continue;
+                }
+                if (!isPunct(tokens[v], "=") || isPunct(tokens[v + 1], "=") || v + 1 >= y || !bind(x, { kind: "value", from: v + 1, to: y }))
+                    return false;
             }
+            else
+                return false;
         }
-        if (j !== end || !given)
-            opaque = true;
+        return true;
     };
-    for (const [from, to] of exported)
-        visit(from, to, 0);
-    for (const name of names)
-        fromName(name, 0);
-    if (opaque)
+    const statement = (k, e) => {
+        const t = tokens[k];
+        // a directive: "use strict"
+        if (e === k + 1 && literal(t))
+            return true;
+        if (t.kind !== "ident")
+            return false;
+        switch (t.value) {
+            case "import":
+                return typeImport(k, e);
+            case "export":
+                return exportStatement(k, e);
+            case "const":
+            case "let":
+            case "var":
+                return declaration(k + 1, e);
+            case "module":
+                return isPunct(tokens[k + 1], ".") && isWord(tokens[k + 2], "exports") && isPunct(tokens[k + 3], "=") && !isPunct(tokens[k + 4], "=") && exportValue(k + 4, e);
+        }
+        return false;
+    };
+    for (let k = 0; k < tokens.length;) {
+        if (isPunct(tokens[k], ";")) {
+            k++;
+            continue;
+        }
+        const e = statementEnd(k);
+        if (e === k || !statement(k, e))
+            return null;
+        k = e;
+    }
+    if (exports > 1)
+        return null;
+    const out = exported;
+    if (out !== null && !("name" in out ? use(out.name, "config") : configValue(out.from, out.to)))
+        return null;
+    // a name the load doesn't use still has its value computed: data, or a module loaded
+    for (const binding of bindings.values()) {
+        if (binding.uses > 0 || binding.kind !== "value")
+            continue;
+        binding.role = "data";
+        binding.uses++;
+        if (!data(binding.from, binding.to))
+            return null;
+    }
+    return { configs, props };
+}
+/** next.config's `pageExtensions`, `basePath` and `output`, read only when
+    the file is written in a declarative subset of JavaScript, where no code
+    runs while Next loads it — neither the file's nor a module's:
+
+    - statements: type imports (`import type { NextConfig } from "next"`),
+      declarations, and one export of the config object itself —
+      `module.exports = {…}`, `export default nextConfig` or `export {
+      config as default }`;
+    - values: literals, and arrays and objects of them, `process.env.NAME`,
+      `process.cwd()`, `__dirname`, `import.meta.dirname`, `new URL(…)`,
+      `require.resolve("…")`, names declared so; `!`, `+`, comparisons,
+      `&&`, `||`, `??` and `? :` over them; a type after `as` or
+      `satisfies`;
+    - functions only as Next's hooks (`webpack`, `headers`, `redirects`,
+      `rewrites`, `generateBuildId`, `exportPathMap`) at the top of the
+      exported object: Next calls them once it has loaded the config.
+
+    Anything else makes it null: a module loaded in any way (`import "…"`,
+    `import x from "…"`, `require(…)`) — its code runs, and which module a
+    name loads its spelling doesn't show (Node's self-reference, a
+    next.config.ts's tsconfig `paths`); so a plugin's call around the
+    config (`withMDX(nextConfig)`) and a `path` helper too (block 348). And
+    any other statement, a function or class of the file, a getter, a
+    spread, a member of a value, a call, a name bound twice or over one the
+    subset reads (`require`, `process`), the config's name used twice. Each
+    setting: a literal, once, in that object — `pageExtensions` or
+    `basePath` named anywhere else in the file makes it null, and an
+    `output` the reading can't take (an expression, a second one, one a
+    hook's code writes) makes only `output` null. `live.test.ts` holds the
+    reading to Next's own `loadConfig` over generated configs.
+
+    What the reading trusts: Next calls the hooks only after loading, and a
+    hook leaves the settings it loaded alone. */
+export function nextConfigOf(config) {
+    if (config === null)
+        return { pageExtensions: PAGE_EXTENSIONS, basePath: "" };
+    // what JavaScript reads apart from the tokens: a hashbang line, CommonJS's `<!--` and `-->` comments — `-->` may follow a `/* … */` on its line — anywhere
+    if (config.startsWith("#!") || /<!--|-->/.test(config))
+        return null;
+    // every line terminator JavaScript knows ends a `//` comment: `\r`, U+2028 and U+2029 too
+    config = config.replace(/\r\n?|[\u2028\u2029]/g, "\n");
+    const hidden = [];
+    const ambiguous = [];
+    const tokens = tokenize(config, hidden, ambiguous, true);
+    const b = bracketsOf(tokens);
+    if (!balanced(tokens, b) || !slashesAgree(tokens, b))
+        return null;
+    // the code of each template's `${…}` — a hook's only, since data has no such template — read for the names it mentions
+    const all = [...tokens];
+    for (let i = 0; i < hidden.length; i++) {
+        if (i >= 1000)
+            return null;
+        const part = tokenize(`;\n${hidden[i]}\n;`, hidden, ambiguous, true);
+        if (!slashesAgree(part, bracketsOf(part)))
+            return null;
+        for (const t of part)
+            all.push(t);
+    }
+    // a `/` right after `}`, in the file or a template's code, may start a regex that holds a brace
+    if (ambiguous.length > 0)
+        return null;
+    // an identifier with an escape in its name, a backslash outside a string, a string a line break cut off
+    if (all.some((t) => isPunct(t, "\\") || (t.kind === "ident" && t.escaped === true) || (t.kind === "string" && t.unclosed === true)))
+        return null;
+    const subset = declarative(tokens, b);
+    if (subset === null)
         return null;
-    // each setting: a literal, directly in one of those objects, and not mentioned anywhere else
+    // each setting: a literal, once, in the config object
     const settings = {};
     const accepted = new Set();
-    for (const open of objects) {
-        const last = b.after[open] - 1;
-        let property = true;
-        for (let k = open + 1; k < last; k++) {
-            if (property) {
-                property = false;
-                if (isSpread(tokens, k))
+    // `output` never makes the config unreadable: only its value is in doubt — undefined while unset, null when it can't be read
+    let output;
+    for (const open of subset.configs) {
+        for (const p of subset.props.get(open) ?? []) {
+            // what Next takes before the keys: `then` — it awaits the config — and `default`, which a next.config.ts transpiled to CommonJS is read from
+            if (p.key === "then" || p.key === "default")
+                return null;
+            const value = tokens[p.from];
+            const single = p.kind === "value" && p.to === p.from + 1 && literal(value);
+            if (p.key === "basePath") {
+                // a path from the root, without a trailing slash — anything else Next refuses
+                if (settings.basePath !== undefined || !single || (value.value !== "" && !/^\/[^?#\s]*[^/?#\s]$/.test(value.value)))
                     return null;
-                const { name, next } = propertyKey(tokens, k);
-                if (name === "pageExtensions" || name === "basePath") {
-                    if (settings[name] !== undefined || !isPunct(tokens[next], ":"))
-                        return null;
-                    const v = next + 1;
-                    const valueEnd = name === "basePath" ? v + 1 : isPunct(tokens[v], "[") ? b.after[v] : v;
-                    if (valueEnd === v || (!isPunct(tokens[valueEnd], ",") && valueEnd !== last))
+                settings.basePath = value.value;
+                accepted.add(p.at);
+            }
+            else if (p.key === "pageExtensions") {
+                if (settings.pageExtensions !== undefined || p.kind !== "value" || !isPunct(value, "[") || b.after[p.from] !== p.to)
+                    return null;
+                const list = [];
+                for (const [x, y] of itemsOf(tokens, b.after, p.from)) {
+                    if (x === y)
+                        continue;
+                    if (y !== x + 1 || !literal(tokens[x]))
                         return null;
-                    const plain = (u) => u?.kind === "string" && !u.unclosed && u.value !== "${}";
-                    if (name === "basePath") {
-                        const value = tokens[v];
-                        // a path from the root, without a trailing slash — anything else Next refuses
-                        if (!plain(value) || (value.value !== "" && !/^\/[^?#\s]*[^/?#\s]$/.test(value.value)))
-                            return null;
-                        settings[name] = value.value;
-                    }
-                    else {
-                        const list = [];
-                        for (let j = v + 1; j < valueEnd - 1; j++) {
-                            if (plain(tokens[j]) && (isPunct(tokens[j + 1], ",") || j + 1 === valueEnd - 1))
-                                list.push(tokens[j].value);
-                            else if (!isPunct(tokens[j], ","))
-                                return null;
-                        }
-                        settings[name] = list;
-                    }
-                    accepted.add(isPunct(tokens[next - 1], "]") ? next - 2 : next - 1);
+                    list.push(tokens[x].value);
                 }
+                settings.pageExtensions = list;
+                accepted.add(p.at);
             }
-            const t = tokens[k];
-            if (t.kind === "punct" && "([{".includes(t.value))
-                k = b.after[k] - 1;
-            else if (isPunct(t, ","))
-                property = true;
+            else if (p.key === "output")
+                output = output === undefined && single ? value.value : null;
         }
     }
-    if (tokens.some((t, k) => (t.kind === "ident" || t.kind === "string") && SETTINGS.includes(t.value) && !accepted.has(k)))
+    // a setting's name anywhere else — a nested object, a hook's code, a string — or inside a longer string (JSON the code parses)
+    if (all.some((t, k) => (t.kind === "ident" || t.kind === "string") && SETTINGS.includes(t.value) && !accepted.has(k)))
         return null;
-    return { pageExtensions: settings.pageExtensions ?? PAGE_EXTENSIONS, basePath: settings.basePath ?? "" };
+    if (all.some((t) => t.kind === "string" && !SETTINGS.includes(t.value) && SETTINGS.some((s) => t.value.includes(s))))
+        return null;
+    // a hook's code that copies properties, sets a prototype or writes a member by a name it computes — `config[name] = …`, `for (config[name] of …)`:
+    // Next runs it after loading, and what it writes the reading can't place
+    const ball = bracketsOf(all);
+    for (let k = 0; k < all.length; k++) {
+        const t = all[k];
+        if ((t.kind === "ident" && COPIES.has(t.value)) || (t.kind === "string" && t.value === "__proto__"))
+            return null;
+        if (!isPunct(t, "["))
+            continue;
+        // unless a lone string or digits name it: `rules[0] = …`
+        const close = ball.after[k] - 1;
+        if (close === k + 2 && literal(all[k + 1]))
+            continue;
+        let digits = k + 1;
+        while (digits < close && isDigit(all[digits]))
+            digits++;
+        if (digits === close && close > k + 1)
+            continue;
+        const prev = all[k - 1];
+        const key = (isPunct(prev, "{") || isPunct(prev, ",") || isPunct(prev, "*") || (prev?.kind === "ident" && KEY_PREFIX.has(prev.value))) && (isPunct(all[close + 1], ":") || isPunct(all[close + 1], "("));
+        const head = ball.parent[k];
+        const loop = head >= 0 && isPunct(all[head], "(") && (isWord(all[head - 1], "for") || (isWord(all[head - 1], "await") && isWord(all[head - 2], "for"))) && (isWord(all[close + 1], "of") || isWord(all[close + 1], "in"));
+        const member = (prev?.kind === "ident" || isPunct(prev, ")") || isPunct(prev, "]")) && (assigned(all, close) || loop);
+        if (key || member)
+            return null;
+    }
+    // and `output` a hook's code writes — `config.output = …`, `config["output"] = …`, in a pattern or a loop's head — or deletes
+    const patterns = new Int32Array(all.length + 1);
+    for (let k = 0; k < all.length; k++) {
+        const after = ball.after[k];
+        if ((isPunct(all[k], "{") || isPunct(all[k], "[")) && !DECLARE.has(all[k - 1]?.value ?? "") && isPunct(all[after], "=") && !isPunct(all[after + 1], "=")) {
+            patterns[k]++;
+            patterns[after]--;
+        }
+    }
+    for (let k = 0, inPattern = 0; k < all.length; k++) {
+        inPattern += patterns[k];
+        const t = all[k];
+        const dotted = t.kind === "ident" && t.value === "output" && isPunct(all[k - 1], ".");
+        const bracketed = t.kind === "string" && t.value === "output" && isPunct(all[k - 1], "[") && isPunct(all[k + 1], "]");
+        if (!dotted && !bracketed)
+            continue;
+        // parentheses around the target, TypeScript's `!` after it: `(config.output) = …`, `config.output! = …`
+        let end = bracketed ? k + 1 : k;
+        while (isPunct(all[end + 1], ")") || isPunct(all[end + 1], "!"))
+            end++;
+        const head = ball.parent[k - 1];
+        const loop = head >= 0 && isPunct(all[head], "(") && (isWord(all[head - 1], "for") || (isWord(all[head - 1], "await") && isWord(all[head - 2], "for"))) && (isWord(all[end + 1], "of") || isWord(all[end + 1], "in"));
+        if (changes(all, end) || inPattern > 0 || loop)
+            output = null;
+    }
+    for (let k = 0; k < all.length; k++) {
+        if (!isWord(all[k], "delete") || isPunct(all[k - 1], "."))
+            continue;
+        const to = initializerEnd(all, ball.after, k + 1);
+        for (let j = k + 1; j < to; j++)
+            if ((isWord(all[j], "output") && isPunct(all[j - 1], ".")) || (all[j].kind === "string" && all[j].value === "output"))
+                output = null;
+    }
+    const read = { pageExtensions: settings.pageExtensions ?? PAGE_EXTENSIONS, basePath: settings.basePath ?? "" };
+    if (output !== undefined)
+        read.output = output;
+    if (all.some((t) => (t.kind === "ident" || t.kind === "string") && t.value === "i18n"))
+        read.i18n = true;
+    return read;
+}
+/** Whether the tokens from `from` up to `to` are a value Next's build
+    reads out of a module's `config` (extractValue): a string, a number,
+    true, false, null or undefined, or an array or object of them — no
+    spread, hole, computed key, shorthand, method or expression. */
+function extractable(tokens, after, from, to) {
+    if (from >= to)
+        return false;
+    const t = tokens[from];
+    if (to === from + 1 && (literal(t) || isWord(t, "true") || isWord(t, "false") || isWord(t, "null") || isWord(t, "undefined")))
+        return true;
+    // digits, and one decimal point: `12`, `1.5`
+    if (/^\d$/.test(t.kind === "punct" ? t.value : "")) {
+        let points = 0;
+        for (let k = from; k < to; k++) {
+            const u = tokens[k];
+            if (u.kind !== "punct" || !/^[\d.]$/.test(u.value) || (u.value === "." && ++points > 1))
+                return false;
+        }
+        return true;
+    }
+    if ((!isPunct(t, "[") && !isPunct(t, "{")) || after[from] !== to)
+        return false;
+    return itemsOf(tokens, after, from).every(([a, z], i, all) => {
+        // a trailing comma leaves nothing after it
+        if (a === z)
+            return i === all.length - 1 && all.length > 1;
+        if (isSpread(tokens, a))
+            return false;
+        if (t.value === "[")
+            return extractable(tokens, after, a, z);
+        const key = tokens[a];
+        return (key.kind === "ident" || literal(key)) && isPunct(tokens[a + 1], ":") && extractable(tokens, after, a + 2, z);
+    });
+}
+/** The items of the array or object that opens at `open`, as token ranges
+    between its top-level commas. */
+function itemsOf(tokens, after, open) {
+    const close = after[open] - 1;
+    const items = [];
+    let start = open + 1;
+    for (let k = start; k <= close; k++) {
+        const u = tokens[k];
+        if (k < close && u.kind === "punct" && "([{".includes(u.value))
+            k = after[k] - 1;
+        else if (k === close || isPunct(u, ",")) {
+            items.push([start, k]);
+            start = k + 1;
+        }
+    }
+    return items;
+}
+/** The matcher of a middleware file, read as Next's build reads it: only
+    `export const config = { … }` (a type or `satisfies` allowed), every
+    value in it a literal (extractable), `matcher` a string or an array of
+    strings and `{ source }` objects. Anything else Next can't read either
+    and runs the middleware on every path — or reads what doctor can't. */
+export function middlewareMatcher(text) {
+    const tokens = tokenize(text);
+    const b = bracketsOf(tokens);
+    let config = null;
+    let declared = -1;
+    for (let i = 0; i < tokens.length; i++) {
+        if (!isWord(tokens[i], "export") || isPunct(tokens[i - 1], ".") || !isWord(tokens[i + 1], "const") || !isWord(tokens[i + 2], "config"))
+            continue;
+        if (config !== null)
+            return "unread";
+        declared = i + 2;
+        let eq = i + 3;
+        if (isPunct(tokens[eq], ":"))
+            eq = typeEnd(tokens, b.after, eq + 1, tokens.length);
+        if (eq < 0 || !isPunct(tokens[eq], "=") || isPunct(tokens[eq + 1], "=") || !isPunct(tokens[eq + 1], "{"))
+            return "unread";
+        const open = eq + 1;
+        const end = b.after[open];
+        // the statement ends there — `;`, `,`, a new line, the file — or goes on with `satisfies T`, which Next reads through
+        const tail = tokens[end];
+        if (tail && !isPunct(tail, ";") && !isPunct(tail, ",") && !isWord(tail, "satisfies") && !(tail.nl === true && tail.kind === "ident"))
+            return "unread";
+        if (!extractable(tokens, b.after, open, end))
+            return "unread";
+        config = "none";
+        for (const [a, z] of itemsOf(tokens, b.after, open)) {
+            if (a === z || tokens[a].value !== "matcher")
+                continue;
+            if (config !== "none")
+                return "unread";
+            const v = a + 2;
+            if (z === v + 1 && literal(tokens[v]))
+                config = [tokens[v].value];
+            else if (isPunct(tokens[v], "[")) {
+                const sources = [];
+                for (const [c, d] of itemsOf(tokens, b.after, v)) {
+                    if (c === d)
+                        continue;
+                    if (d === c + 1 && literal(tokens[c]))
+                        sources.push(tokens[c].value);
+                    else if (isPunct(tokens[c], "{")) {
+                        const source = itemsOf(tokens, b.after, c).filter(([e]) => tokens[e]?.value === "source" && isPunct(tokens[e + 1], ":"));
+                        if (source.length !== 1 || source[0][1] !== source[0][0] + 3 || !literal(tokens[source[0][0] + 2]))
+                            return "unread";
+                        sources.push(tokens[source[0][0] + 2].value);
+                    }
+                    else
+                        return "unread";
+                }
+                config = sources;
+            }
+            else
+                return "unread";
+        }
+        i = end - 1;
+    }
+    // any other export that may be `config` — `export { config }`, `export let config`, a later declarator, `export *`, CommonJS — Next's reading doesn't see
+    const rest = declared === -1 ? tokens : tokens.map((t, k) => (k === declared ? { ...t, value: "" } : t));
+    if (setsExport(rest, b.after, "config", () => false))
+        return "unread";
+    return config ?? "none";
+}
+/** Whether `c` is one of the characters — never for the end of the string. */
+const oneOf = (chars, c) => c !== undefined && c.length === 1 && chars.includes(c);
+// what a path may hold for doctor to place it among a matcher's sources: nothing a URL would encode
+const PLAIN_PATH = /^\/[A-Za-z0-9/_.~-]*$/;
+/** Whether a matcher source may take the path `at` (without the basePath,
+    which Next puts in front of both). False only when it surely can't: the
+    literal the source starts with isn't how the path starts, or right
+    after it comes a group — path-to-regexp's `(…)`, kept verbatim in the
+    regex Next builds — that matches no start of the rest, in either case.
+    Everything else may. */
+export function sourceMayTake(source, at) {
+    if (!source.startsWith("/") || !PLAIN_PATH.test(at))
+        return true;
+    let i = 0;
+    while (i < source.length && !":(){}*+?\\".includes(source[i]))
+        i++;
+    // a `/` or `.` right before a param or a group is its prefix, which a modifier makes optional: `/blog/:path*` takes `/blog`
+    const required = oneOf(":(", source[i]) && oneOf("/.", source[i - 1]) ? i - 1 : i;
+    const start = source.slice(0, required).toLowerCase();
+    // the tab may ask with a trailing slash that Next takes off
+    const paths = [at, at === "/" ? at : `${at}/`].map((p) => p.toLowerCase());
+    if (!paths.some((p) => p.startsWith(start)))
+        return false;
+    if (source[i] !== "(" || source[i + 1] === "?")
+        return true;
+    // the group as path-to-regexp reads it: to its balanced `)`, a backslash taking the next character along
+    let depth = 1;
+    let j = i + 1;
+    for (; j < source.length && depth > 0; j++) {
+        const c = source[j];
+        if (c === "\\")
+            j++;
+        else if (c === ")")
+            depth--;
+        // a capturing group inside is refused
+        else if (c === "(" && source[j + 1] !== "?")
+            return true;
+        else if (c === "(")
+            depth++;
+    }
+    // a modifier may skip the group; a backreference numbers groups differently inside Next's regex
+    if (depth !== 0 || oneOf("?*+", source[j]) || /\\\d/.test(source.slice(i, j)))
+        return true;
+    // without a modifier the group's prefix is required: the group starts right after the whole literal
+    const literalStart = source.slice(0, i).toLowerCase();
+    const group = source.slice(i + 1, j - 1);
+    try {
+        for (const flags of ["y", "iy"]) {
+            const re = new RegExp(group, flags);
+            for (const [n, p] of paths.entries()) {
+                if (!p.startsWith(literalStart))
+                    continue;
+                // matched as the tab asks it, case and all
+                re.lastIndex = literalStart.length;
+                if (re.test(n === 0 ? at : `${at}/`))
+                    return true;
+            }
+        }
+    }
+    catch {
+        return true;
+    }
+    return false;
+}
+/** Why a middleware file may run on `at` (a path without the basePath), or null when it surely doesn't. */
+function middlewareOn(m, at, i18n) {
+    if (m.matcher === "none" || m.matcher === "unread")
+        return { reason: m.matcher };
+    const source = m.matcher.find((s) => sourceMayTake(s, at));
+    if (source !== undefined)
+        return { reason: "matcher", source };
+    // with locales Next puts one in front of each source, and of the path
+    return i18n && m.matcher.length > 0 ? { reason: "i18n" } : null;
+}
+/** Whether a version is at least `min`, by its major, minor and patch —
+    false for one that doesn't start with three numbers. */
+export function atLeast(version, min) {
+    const parts = (v) => /^v?(\d+)\.(\d+)\.(\d+)/.exec(v)?.slice(1).map(Number) ?? null;
+    const a = parts(version);
+    const b = parts(min);
+    if (!a)
+        return false;
+    for (let i = 0; i < 3; i++)
+        if (a[i] !== b[i])
+            return a[i] > b[i];
+    return true;
+}
+/** The version of a package the site's code resolves: the package's
+    folder under the nearest node_modules, from the site's folder up — as
+    Node and Next's bundler find it. Null when none is there. */
+async function installedVersion(dir, pkg) {
+    for (let at = path.resolve(dir);;) {
+        try {
+            const raw = await readFile(path.join(at, "node_modules", ...pkg.split("/"), "package.json"), "utf8");
+            const version = JSON.parse(raw).version;
+            return typeof version === "string" ? version : null;
+        }
+        catch {
+            // not here: the folder above
+        }
+        const up = path.dirname(at);
+        if (up === at)
+            return null;
+        at = up;
+    }
+}
+/** The middleware files Next runs for the site — `middleware`, and
+    `proxy` unless the installed Next is older than 16, which names it so —
+    with one of its page extensions, in the folder that holds the pages
+    folder it reads, or else the app folder: the root, or `src/`. Read from
+    the folder itself, not the file list, which may stop before it. */
+async function middlewareFiles(dir, extensions, next) {
+    const folder = async (name) => ((await atRoot(dir, name)) ? name : (await atRoot(dir, `src/${name}`)) ? `src/${name}` : null);
+    const read = (await folder("pages")) ?? (await folder("app"));
+    const at = read?.startsWith("src/") ? "src" : "";
+    let names;
+    try {
+        names = (await readdir(path.join(dir, at), { withFileTypes: true })).filter((e) => e.isFile()).map((e) => e.name).sort();
+    }
+    catch {
+        return [];
+    }
+    const kinds = next === null || atLeast(next, "16.0.0") ? ["middleware", "proxy"] : ["middleware"];
+    // Next's own test: the extensions joined into a pattern as they are
+    let test;
+    try {
+        const re = new RegExp(`^(?:${kinds.join("|")})\\.(?:${extensions.join("|")})$`);
+        test = (name) => re.test(name);
+    }
+    catch {
+        test = (name) => extensions.some((ext) => kinds.some((kind) => name === `${kind}.${ext}`));
+    }
+    const found = [];
+    for (const name of names.filter(test)) {
+        const file = at ? `${at}/${name}` : name;
+        let text;
+        try {
+            text = await readFile(path.join(dir, file), "utf8");
+        }
+        catch {
+            found.push({ file, matcher: "unread" });
+            continue;
+        }
+        found.push({ file, matcher: text.length > 2_000_000 ? "unread" : middlewareMatcher(text) });
+    }
+    return found;
 }
 export async function findLive(dir, maxFiles = 4000) {
     const { files } = await listFiles(dir, maxFiles);
@@ -1312,7 +2119,7 @@ export async function findLive(dir, maxFiles = 4000) {
         const found = words ? liveInFile(file, text) : { listeners: [], handler: null, params: false };
         listeners.push(...found.listeners);
         if (route !== null)
-            routes.push({ file, path: route, handler: found.handler, ...(found.params ? { params: true } : {}) });
+            routes.push({ file, path: route, handler: found.handler, ...(found.params ? { params: true } : {}), ...(found.segment ? { segment: found.segment } : {}) });
     }
     const facts = { listeners, routes, pages, routeExtension };
     if (appDir)
@@ -1321,6 +2128,18 @@ export async function findLive(dir, maxFiles = 4000) {
         facts.basePath = settings.basePath;
     if (settings === null && config)
         facts.config = config;
+    if (config && settings && (settings.output === "export" || settings.output === null))
+        facts.output = { file: config, value: settings.output };
+    const sdk = await installedVersion(dir, "@mapled/next");
+    if (sdk !== null)
+        facts.sdk = sdk;
+    if (settings?.i18n)
+        facts.i18n = true;
+    if (extensions !== null) {
+        const middleware = await middlewareFiles(dir, extensions, await installedVersion(dir, "next"));
+        if (middleware.length > 0)
+            facts.middleware = middleware;
+    }
     return facts;
 }
 /** Whether a literal endpoint names its own origin — `https://…`, `//host/…`
@@ -1464,11 +2283,21 @@ export function liveState(facts) {
                 return { kind: "missing", listener, endpoint: null };
             return { kind: "unresolved", listener };
         }
-        const at = sitePath(listener.endpoint);
-        if (at === null)
+        const written = sitePath(listener.endpoint);
+        if (written === null)
             return { kind: "unresolved", listener };
         if (facts.config)
             return { kind: "config", listener, file: facts.config };
+        // 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 };
+        let at = written;
+        // no endpoint given: from BASE_PATH_SINCE the SDK asks under the basePath Next writes into the bundle, before it at the root
+        if (listener.byDefault && base !== "") {
+            if (facts.sdk === undefined || !atLeast(facts.sdk, BASE_PATH_SINCE))
+                return { kind: "default_base", listener, basePath: base, sdk: facts.sdk ?? null };
+            at = `${base}${RELEASE_ROUTE}`;
+        }
         // with a basePath, Next answers only under it: a route file's path follows it
         if (base !== "" && at !== base && !at.startsWith(`${base}/`))
             return { kind: "outside", listener, endpoint: at, basePath: base };
@@ -1489,6 +2318,14 @@ export function liveState(facts) {
             return { kind: "not_get", listener, route };
         if (route.params && dynamicRoute(route))
             return { kind: "params", listener, route, endpoint: at };
+        if (route.segment)
+            return { kind: "segment", listener, route, setting: route.segment };
+        // middleware runs before the route: whatever it does there, the reading can't see
+        for (const m of facts.middleware ?? []) {
+            const on = middlewareOn(m, base === "" ? at : at.slice(base.length) || "/", facts.i18n === true);
+            if (on)
+                return { kind: "middleware", listener, route, path: at, file: m.file, ...on };
+        }
         served ??= { listener, route, path: at };
     }
     return { kind: "served", ...served };