@mapled/cli 0.11.0 → 0.13.0

package/dist/live.js

@@ -0,0 +1,2346 @@
+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
+    follows Publish in open tabs with two pieces: `<MapledLive />` from
+    "@mapled/next/live" (or `watchRelease` from "@mapled/next") asks a
+    route of the site every few seconds, and that route answers with
+    `createReleaseHandler` from "@mapled/next/server". A listener without
+    the route polls a 404 forever and nothing says so — `mapled doctor`
+    reads both and says which is missing, and `mapled scan` records the
+    result in the manifest (`capabilities.realtime`, `releaseRoute`) so
+    MAPLED.md can tell the next agent. The code is read with the scanner's
+    tokenizer: comments and strings never count as a use, and neither
+    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
+const NEXT_CONFIGS = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.mts", "next.config.cjs"];
+// the three names as written, or an escape that may spell one: `import { w\u0061tchRelease as w }`
+const WORDS = /MapledLive|watchRelease|createReleaseHandler|\\u/;
+/** A member `object.name` as one name among the file's: no identifier
+    reads the same. A namespace's `ns.createReleaseHandler` is one — a
+    namespace can't be written to, so its member is the import wherever
+    `ns` itself is. */
+const memberName = (object, name) => `${object}.${name}`;
+/** The imports of the three exports, and of their modules as namespaces; type-only imports don't count. */
+function importsOf(tokens) {
+    const found = { live: new Set(), watch: new Set(), handler: new Set(), ns: { live: new Set(), watch: new Set(), handler: new Set() } };
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.kind !== "ident" || t.value !== "import")
+            continue;
+        if (tokens[i + 1]?.kind === "ident" && tokens[i + 1].value === "type")
+            continue;
+        const names = [];
+        let namespace = null;
+        let j = i + 1;
+        let source = null;
+        let inBraces = false;
+        for (; j < tokens.length && j < i + 200; j++) {
+            const u = tokens[j];
+            if (u.kind === "punct" && u.value === "{")
+                inBraces = true;
+            else if (u.kind === "punct" && u.value === "}")
+                inBraces = false;
+            else if (u.kind === "ident" && u.value === "from" && !inBraces) {
+                source = tokens[j + 1]?.kind === "string" ? tokens[j + 1].value : null;
+                break;
+            }
+            else if (u.kind === "punct" && u.value === ";")
+                break;
+            else if (!inBraces && u.kind === "punct" && u.value === "*" && tokens[j + 1]?.kind === "ident" && tokens[j + 1].value === "as" && tokens[j + 2]?.kind === "ident") {
+                // `import * as ns`, `import def, * as ns`
+                namespace = tokens[j + 2].value;
+                j += 2;
+            }
+            else if (inBraces && u.kind === "ident") {
+                if (u.value === "type")
+                    continue;
+                const prev = tokens[j - 1];
+                if (prev?.kind === "ident" && prev.value === "as")
+                    continue;
+                const local = tokens[j + 1]?.kind === "ident" && tokens[j + 1].value === "as" && tokens[j + 2]?.kind === "ident" ? tokens[j + 2].value : u.value;
+                names.push({ imported: u.value, local });
+            }
+        }
+        i = j;
+        for (const n of names) {
+            if (source === "@mapled/next/live" && n.imported === "MapledLive")
+                found.live.add(n.local);
+            if (source === "@mapled/next" && n.imported === "watchRelease")
+                found.watch.add(n.local);
+            if (source === "@mapled/next/server" && n.imported === "createReleaseHandler")
+                found.handler.add(n.local);
+        }
+        if (namespace !== null) {
+            if (source === "@mapled/next/live")
+                found.ns.live.add(namespace);
+            if (source === "@mapled/next")
+                found.ns.watch.add(namespace);
+            if (source === "@mapled/next/server")
+                found.ns.handler.add(namespace);
+        }
+    }
+    return found;
+}
+const isPunct = (t, value) => t?.kind === "punct" && t.value === value;
+const isWord = (t, value) => t?.kind === "ident" && t.value === value;
+const isSpread = (tokens, k) => isPunct(tokens[k], ".") && isPunct(tokens[k + 1], ".") && isPunct(tokens[k + 2], ".");
+/** A string the code writes out: closed, and not a template with a substitution (its value reads `${}`). */
+const literal = (t) => t?.kind === "string" && !t.unclosed && t.value !== "${}";
+// how far an element's attributes or a call's options are read; past it the endpoint can't be told
+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 —
+    and undefined when the element gives none: the SDK's default. */
+function jsxEndpoint(tokens, from) {
+    let endpoint = undefined;
+    let depth = 0;
+    for (let k = from; k < tokens.length; k++) {
+        if (k >= from + OPTIONS_TOKENS)
+            return null;
+        const t = tokens[k];
+        if (t.kind === "punct" && t.value === "{") {
+            if (depth === 0 && isSpread(tokens, k + 1))
+                endpoint = null;
+            depth++;
+        }
+        else if (t.kind === "punct" && t.value === "}") {
+            // the code around the element closes before it does
+            if (depth === 0)
+                return endpoint;
+            depth--;
+        }
+        else if (depth === 0 && t.kind === "punct" && (t.value === ">" || t.value === "<" || t.value === ";"))
+            return endpoint;
+        // the whole attribute name: `data-endpoint`, `x:endpoint` and `endpoint-x` are other attributes
+        else if (depth === 0 && isWord(t, "endpoint") && !isPunct(tokens[k - 1], "-") && !isPunct(tokens[k - 1], ":") && !isPunct(tokens[k + 1], "-") && !isPunct(tokens[k + 1], ":")) {
+            // `<MapledLive endpoint />` passes true, not the default; a JSX name takes no escapes, so an escaped one can't be read
+            if (!isPunct(tokens[k + 1], "=") || t.escaped === true) {
+                endpoint = null;
+                continue;
+            }
+            const v = tokens[k + 2];
+            // a string a line break cut off runs on in JSX: past it the element can't be read
+            if (v?.kind === "string" && v.unclosed)
+                return null;
+            // a JSX attribute's string reads no backslash escapes and decodes HTML entities: with either, it isn't the text the tokenizer read
+            if (v?.kind === "string")
+                endpoint = v.escaped || v.value.includes("&") ? null : v.value;
+            else if (isPunct(v, "{") && literal(tokens[k + 3]) && isPunct(tokens[k + 4], "}"))
+                endpoint = tokens[k + 3].value;
+            else
+                endpoint = null;
+        }
+    }
+    // the file ends after the attributes
+    return endpoint;
+}
+// words that may stand before a property's key: `get endpoint() {…}`, `async *endpoint() {…}`
+const KEY_PREFIX = new Set(["get", "set", "async", "static"]);
+/** The key of the object property that starts at `k` and the token after
+    it; `name` is null when the code decides the key — `[expr]` — and
+    undefined when no property starts there (`{}`, a trailing comma). */
+function propertyKey(tokens, k) {
+    // a prefix word is the key itself when what follows ends it: `{ get: 1 }`, `{ async }`, `{ set() {} }`
+    const ends = (u) => isPunct(u, ":") || isPunct(u, "(") || isPunct(u, ",") || isPunct(u, "}") || isPunct(u, "=");
+    while ((isPunct(tokens[k], "*") || (tokens[k]?.kind === "ident" && KEY_PREFIX.has(tokens[k].value) && !ends(tokens[k + 1]))) && k < tokens.length)
+        k++;
+    const t = tokens[k];
+    if (isPunct(t, "[")) {
+        // a literal computed key reads as written; any other — a template with a substitution too — is the code's
+        if (literal(tokens[k + 1]) && isPunct(tokens[k + 2], "]"))
+            return { name: tokens[k + 1].value, next: k + 3 };
+        return { name: null, next: k + 1 };
+    }
+    if (t?.kind === "string" && !literal(t))
+        return { name: null, next: k + 1 };
+    if (t?.kind === "ident" || t?.kind === "string")
+        return { name: t.value, next: k + 1 };
+    // a numeric key: `{ 1: … }`
+    if (t?.kind === "punct" && /^\d$/.test(t.value))
+        return { name: t.value, next: k + 1 };
+    return { name: undefined, next: k };
+}
+/** The endpoint of a call's options object, from its opening parenthesis,
+    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 — and
+    undefined when the options give none: the SDK's default. */
+function callEndpoint(tokens, paren) {
+    if (!isPunct(tokens[paren + 1], "{"))
+        return null;
+    let endpoint = undefined;
+    let depth = 0;
+    let property = false;
+    for (let k = paren + 1; k < tokens.length && k < paren + OPTIONS_TOKENS; k++) {
+        const t = tokens[k];
+        if (depth === 1 && property) {
+            property = false;
+            if (isSpread(tokens, k))
+                endpoint = null;
+            else {
+                const { name, next } = propertyKey(tokens, k);
+                if (name === null)
+                    endpoint = null;
+                else if (name === "endpoint") {
+                    const v = tokens[next + 1];
+                    const after = tokens[next + 2];
+                    endpoint = isPunct(tokens[next], ":") && literal(v) && (isPunct(after, ",") || isPunct(after, "}")) ? v.value : null;
+                }
+            }
+        }
+        if (t.kind === "punct" && (t.value === "{" || t.value === "(" || t.value === "[")) {
+            depth++;
+            if (depth === 1)
+                property = true;
+        }
+        else if (t.kind === "punct" && (t.value === "}" || t.value === ")" || t.value === "]")) {
+            depth--;
+            if (depth === 0)
+                return endpoint;
+        }
+        else if (depth === 1 && isPunct(t, ","))
+            property = true;
+    }
+    return null;
+}
+const DECLARE = new Set(["const", "let", "var"]);
+// words that start a statement and never continue an expression
+const STATEMENT = new Set(["export", "import", "const", "let", "var", "return", "if", "for", "while", "do", "throw", "try", "switch"]);
+const BEFORE_FUNCTION_VALUE = new Set(["async", "new", "await", "return", "typeof", "void", "yield", "default"]);
+function bracketsOf(tokens) {
+    const after = new Int32Array(tokens.length + 1).fill(tokens.length);
+    const open = new Int32Array(tokens.length).fill(-1);
+    const parent = new Int32Array(tokens.length).fill(-1);
+    const stack = [];
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        if (t.kind === "punct" && (t.value === "}" || t.value === ")" || t.value === "]")) {
+            const o = stack.pop();
+            if (o !== undefined) {
+                after[o] = k + 1;
+                open[k] = o;
+            }
+        }
+        parent[k] = stack.length > 0 ? stack[stack.length - 1] : -1;
+        if (t.kind === "punct" && (t.value === "{" || t.value === "(" || t.value === "["))
+            stack.push(k);
+    }
+    return { after, open, parent };
+}
+/** The token after the bracket that `open` opens, or the end. */
+function closing(tokens, open) {
+    let depth = 0;
+    for (let k = open; k < tokens.length; k++) {
+        const t = tokens[k];
+        if (t.kind !== "punct")
+            continue;
+        if (t.value === "{" || t.value === "(" || t.value === "[")
+            depth++;
+        else if (t.value === "}" || t.value === ")" || t.value === "]") {
+            depth--;
+            if (depth === 0)
+                return k + 1;
+        }
+    }
+    return tokens.length;
+}
+/** Where an initializer that starts at `from` ends: a `;` outside
+    brackets — or a `,`, between declarators; a return's value runs on
+    past a comma — the next statement, or the end of the block around it.
+    Brackets are stepped over whole (`after`, from `bracketsOf`), so
+    nested initializers don't make a deep file quadratic. */
+function initializerEnd(tokens, after, from, commas = true) {
+    for (let k = from; k < tokens.length; k++) {
+        const t = tokens[k];
+        if (t.kind === "punct" && (t.value === "{" || t.value === "(" || t.value === "["))
+            k = after[k] - 1;
+        else if (t.kind === "punct" && (t.value === "}" || t.value === ")" || t.value === "]"))
+            return k;
+        else if (t.kind === "punct" && (t.value === ";" || (commas && t.value === ",")))
+            return k;
+        else if (k > from && t.kind === "ident" && !isPunct(tokens[k - 1], ".")) {
+            if (STATEMENT.has(t.value))
+                return k;
+            // a type's commas (`as Record<string, X>`) aren't the declarator's
+            if (t.value === "as" || t.value === "satisfies") {
+                const end = typeEnd(tokens, after, k + 1, tokens.length);
+                if (end > k + 1)
+                    k = end - 1;
+                continue;
+            }
+            // a declaration after a line without a semicolon, not `= async function`
+            const prev = tokens[k - 1];
+            const valueFollows = prev.kind === "punct" ? !")]}".includes(prev.value) : prev.kind === "ident" && BEFORE_FUNCTION_VALUE.has(prev.value);
+            if ((t.value === "function" || t.value === "class") && !valueFollows)
+                return k;
+        }
+    }
+    return tokens.length;
+}
+/** Past a function's parameters and return type to the brace of its body. */
+function bodyAfter(tokens, from) {
+    let depth = 0;
+    for (let k = from; k < tokens.length && k < from + 400; k++) {
+        const u = tokens[k];
+        if (depth === 0 && isPunct(u, "{"))
+            return k;
+        // an overload signature has no body
+        if (depth === 0 && isPunct(u, ";"))
+            return null;
+        if (u.kind === "punct" && (u.value === "(" || u.value === "["))
+            depth++;
+        else if (u.kind === "punct" && (u.value === ")" || u.value === "]"))
+            depth--;
+    }
+    return null;
+}
+/** `const|let|var name = …` and `function name(…) { … }`, each with the
+    tokens of its value: the initializer, or the function's body; a name
+    declared without a value is here too, with none. */
+function declarationsOf(tokens, after) {
+    const out = [];
+    const exportedAt = (k) => {
+        const prev = tokens[k - 1];
+        if (prev?.kind === "ident" && prev.value === "async")
+            return tokens[k - 2]?.kind === "ident" && tokens[k - 2].value === "export";
+        return prev?.kind === "ident" && prev.value === "export";
+    };
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.kind !== "ident")
+            continue;
+        if (DECLARE.has(t.value) && !isPunct(tokens[i - 1], ".")) {
+            const exported = exportedAt(i);
+            let k = i + 1;
+            // one declarator after another: `const a = …, b = …`
+            while (tokens[k]?.kind === "ident") {
+                const name = tokens[k].value;
+                let eq = k + 1;
+                if (isPunct(tokens[eq], ":")) {
+                    // a type annotation up to the `=`
+                    let depth = 0;
+                    for (; eq < tokens.length && eq < k + 400; eq++) {
+                        const u = tokens[eq];
+                        if (u.kind !== "punct")
+                            continue;
+                        if (u.value === "{" || u.value === "(" || u.value === "[")
+                            depth++;
+                        else if (u.value === "}" || u.value === ")" || u.value === "]")
+                            depth--;
+                        else if (depth === 0 && (u.value === "=" || u.value === ";"))
+                            break;
+                    }
+                }
+                if (!isPunct(tokens[eq], "=")) {
+                    // `let h;`, `let a, b`, `for (const h of …)`: bound, to nothing the reading can see
+                    out.push({ name, at: k, exported, from: eq, to: eq, fn: false, async: false });
+                    if (!isPunct(tokens[eq], ","))
+                        break;
+                    k = eq + 1;
+                    continue;
+                }
+                const to = initializerEnd(tokens, after, eq + 1);
+                out.push({ name, at: k, exported, from: eq + 1, to, fn: false, async: false });
+                if (!isPunct(tokens[to], ","))
+                    break;
+                k = to + 1;
+            }
+        }
+        else if (t.value === "function" && tokens[i + 1]?.kind === "ident") {
+            const name = tokens[i + 1].value;
+            let open = i + 2;
+            while (open < tokens.length && open < i + 50 && !isPunct(tokens[open], "("))
+                open++;
+            if (!isPunct(tokens[open], "("))
+                continue;
+            const body = bodyAfter(tokens, after[open]);
+            if (body === null)
+                continue;
+            out.push({ name, at: i + 1, exported: exportedAt(i), from: body, to: after[body], fn: true, async: isWord(tokens[i - 1], "async") });
+        }
+    }
+    return out;
+}
+/** The local names an `export { a as GET, b }` clause exports, by exported
+    name; re-exports `from` another module don't count — their code is elsewhere. */
+function exportClauses(tokens) {
+    const out = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.kind !== "ident" || t.value !== "export" || !isPunct(tokens[i + 1], "{"))
+            continue;
+        const end = closing(tokens, i + 1);
+        const from = tokens[end];
+        if (from?.kind === "ident" && from.value === "from")
+            continue;
+        for (let k = i + 2; k < end - 1; k++) {
+            const u = tokens[k];
+            if (u.kind !== "ident" || u.value === "type")
+                continue;
+            const renamed = tokens[k + 1]?.kind === "ident" && tokens[k + 1].value === "as" && tokens[k + 2]?.kind === "ident";
+            const exported = renamed ? tokens[k + 2].value : u.value;
+            const list = out.get(exported);
+            if (list)
+                list.push(u.value);
+            else
+                out.set(exported, [u.value]);
+            if (renamed)
+                k += 2;
+        }
+        i = end - 1;
+    }
+    return out;
+}
+/** What a name is to the release, as a level: calling a `FACTORY` gives
+    a `HANDLER` (`createReleaseHandler` itself, or `make` in `function
+    make() { return createReleaseHandler(…) }`), calling a handler gives the
+    `RESPONSE` — the release the tab reads. A call goes one level down; a
+    function goes one level up from what it returns. */
+const RESPONSE = 0;
+const HANDLER = 1;
+const FACTORY = 2;
+const NOT_A_VALUE = new Set(["new", "typeof", "void", "delete", "function", "class", "this", "super", "null", "true", "false", "undefined", "async", "await", "yield", "return"]);
+const CONTROL = new Set(["if", "for", "while", "switch", "catch", "with"]);
+/** The term of the expression in [from, to), or null. A member `o.name`
+    is a term under `memberName`: a namespace's `ns.createReleaseHandler`
+    is seeded as the factory (`releaseHandlerOf`); any other member is a
+    name nothing gives a level. */
+function termOf(tokens, after, from, to, up, cap = FACTORY) {
+    let k = from;
+    while (k < to && isWord(tokens[k], "await"))
+        k++;
+    const t = tokens[k];
+    if (k >= to || t?.kind !== "ident" || NOT_A_VALUE.has(t.value))
+        return null;
+    let name = t.value;
+    let j = k + 1;
+    if (j + 1 < to && isPunct(tokens[j], ".") && tokens[j + 1]?.kind === "ident") {
+        name = memberName(name, tokens[j + 1].value);
+        j += 2;
+    }
+    let calls = 0;
+    while (j < to && isPunct(tokens[j], "(")) {
+        j = after[j];
+        calls++;
+    }
+    if (j > to || !typesOnly(tokens, after, j, to))
+        return null;
+    return { name, calls, up, cap };
+}
+/** Whether [j, to) is nothing but `as Type` / `satisfies Type`, once or
+    more: a type doesn't change the value, an operator past it (`h as T ||
+    other`, `h as T, other`) does. */
+function typesOnly(tokens, after, j, to) {
+    while (j < to) {
+        if (!isWord(tokens[j], "as") && !isWord(tokens[j], "satisfies"))
+            return false;
+        const end = typeEnd(tokens, after, j + 1, to);
+        if (end <= j + 1)
+            return false;
+        j = end;
+    }
+    return true;
+}
+// words a type goes on after: `keyof typeof x`, `readonly string[]`
+const TYPE_PREFIX = new Set(["keyof", "typeof", "readonly", "unique", "infer", "extends"]);
+/** The token after the type that starts at `j` and ends by `to` — `<…>`
+    held together with its commas, unions, intersections, function types
+    — or -1 when its brackets don't close by then. Two names in a row
+    outside `<…>` are a new statement, or the next `as`. */
+function typeEnd(tokens, after, j, to) {
+    let angles = 0;
+    let named = false;
+    for (let k = j; k < to; k++) {
+        const u = tokens[k];
+        if (u.kind !== "punct") {
+            if (angles === 0 && named && !TYPE_PREFIX.has(tokens[k - 1].value))
+                return k;
+            named = true;
+            continue;
+        }
+        if (u.value === "(" || u.value === "[" || u.value === "{") {
+            if (after[k] > to)
+                return -1;
+            k = after[k] - 1;
+            named = true;
+        }
+        else if (u.value === "<") {
+            angles++;
+            named = false;
+        }
+        else if (u.value === ">" && angles > 0) {
+            angles--;
+            named = true;
+        }
+        else if (/^\d$/.test(u.value))
+            named = true;
+        else if (u.value === "=>" || u.value === ".")
+            named = false;
+        // a union or an intersection; `||` and `&&` are the value's
+        else if ((u.value === "|" || u.value === "&") && !isPunct(tokens[k + 1], u.value))
+            named = false;
+        // type arguments, and conditional types inside them
+        else if (angles > 0 && (u.value === "," || u.value === "?" || u.value === ":"))
+            named = false;
+        else
+            return angles === 0 ? k : -1;
+    }
+    return angles === 0 ? to : -1;
+}
+/** The function a value in [from, to) is — `function (…) {…}`, `async (…)
+    => …`, `x => …` — as its block (the braces) or its expression; null
+    when the whole value isn't a function. */
+function functionOf(tokens, after, from, to) {
+    if (from >= to)
+        return null;
+    let k = from;
+    const async = isWord(tokens[k], "async");
+    if (async)
+        k++;
+    let arrow;
+    if (isWord(tokens[k], "function")) {
+        // a generator gives back an iterator, never a response
+        if (isPunct(tokens[k + 1], "*"))
+            return null;
+        let open = k + 1;
+        while (open < to && !isPunct(tokens[open], "("))
+            open++;
+        const body = open < to ? bodyAfter(tokens, after[open]) : null;
+        return body !== null && after[body] === to ? { block: true, from: body, to, async } : null;
+    }
+    if (tokens[k]?.kind === "ident" && isPunct(tokens[k + 1], "=>"))
+        arrow = k + 1;
+    else if (isPunct(tokens[k], "(")) {
+        arrow = after[k];
+        if (isPunct(tokens[arrow], ":")) {
+            // past a return type to the arrow
+            let depth = 0;
+            for (; arrow < to; arrow++) {
+                const u = tokens[arrow];
+                if (depth === 0 && isPunct(u, "=>"))
+                    break;
+                if (u.kind === "punct" && (u.value === "(" || u.value === "[" || u.value === "{"))
+                    depth++;
+                else if (u.kind === "punct" && (u.value === ")" || u.value === "]" || u.value === "}"))
+                    depth--;
+            }
+        }
+        if (!isPunct(tokens[arrow], "=>"))
+            return null;
+    }
+    else
+        return null;
+    const body = arrow + 1;
+    if (isPunct(tokens[body], "{"))
+        return after[body] === to ? { block: true, from: body, to, async } : null;
+    return body < to ? { block: false, from: body, to, async } : null;
+}
+// words a block of the statements around it follows: `else { … }`, `try { … }`
+const BLOCK_AFTER = new Set(["else", "try", "finally", "do", "catch"]);
+// words whose condition a block of the statements around it follows: `if (…) { … }`
+const BLOCK_AFTER_CONDITION = new Set(["if", "for", "while", "switch", "catch", "with"]);
+/** Whether the `{` at `k`, among statements, opens a block of them — `if
+    (…) {`, `else {`, `try {`, `case …: {`, a bare `{` — and not a
+    function, a method under any name, a class or anything else whose
+    returns are its own. The list is of what's known to be a block, not
+    of what's known not to be: whatever it doesn't name keeps its returns. */
+function blockAt(tokens, b, k) {
+    const prev = tokens[k - 1];
+    if (prev === undefined || isPunct(prev, ";") || isPunct(prev, "{") || isPunct(prev, ":"))
+        return true;
+    const word = (at, words) => tokens[at]?.kind === "ident" && words.has(tokens[at].value) && !isPunct(tokens[at - 1], ".");
+    if (word(k - 1, BLOCK_AFTER))
+        return true;
+    if (!isPunct(prev, ")"))
+        return false;
+    const open = b.open[k - 1];
+    return open > 0 && (word(open - 1, BLOCK_AFTER_CONDITION) || (isWord(tokens[open - 1], "await") && isWord(tokens[open - 2], "for")));
+}
+/** The returns of each function body in `bodies`, by its `{`, and the
+    bodies that throw. A return or a throw is the body's own when only
+    blocks of its statements (`blockAt`) stand between them; one inside
+    anything else — a nested function, a method under any name, a class —
+    belongs to that. */
+function returnsIn(tokens, b, bodies) {
+    // for each bracket: whose statements it holds (-1: none known), and whether it holds statements
+    const owner = new Int32Array(tokens.length).fill(-1);
+    const statements = new Uint8Array(tokens.length);
+    const out = new Map();
+    const throwing = new Set();
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        const p = b.parent[k];
+        if (t.kind === "punct" && (t.value === "{" || t.value === "(" || t.value === "[")) {
+            if (bodies.has(k)) {
+                owner[k] = k;
+                statements[k] = 1;
+            }
+            else if (t.value === "{" && (p === -1 || statements[p] === 1) && blockAt(tokens, b, k)) {
+                owner[k] = p === -1 ? -1 : owner[p];
+                statements[k] = 1;
+            }
+        }
+        else if (p !== -1 && (isWord(t, "return") || isWord(t, "throw")) && !isPunct(tokens[k - 1], ".") && !isPunct(tokens[k + 1], ":")) {
+            const body = owner[p];
+            if (body === -1)
+                continue;
+            if (t.value === "throw") {
+                throwing.add(body);
+                continue;
+            }
+            const list = out.get(body);
+            if (list)
+                list.push(k);
+            else
+                out.set(body, [k]);
+        }
+    }
+    return { returns: out, throwing };
+}
+/** Where the value a `return` at `k` gives ends: past commas; a line
+    break right after `return` ends the statement, and it returns nothing. */
+function returnEnd(tokens, after, k) {
+    return tokens[k + 1]?.nl ? k + 1 : initializerEnd(tokens, after, k + 1, false);
+}
+/** What a declaration gives, one value per way out: its value, the
+    expression its arrow returns, or each return of its function body —
+    a name is what all of them agree on, so a GET that answers the
+    handler's response on one branch and anything else on another isn't
+    a handler's answer. A body that throws, or whose last statement isn't
+    a return of its own (it may run off its end), gives one value the
+    reading can't see. Null: a value that isn't a term. */
+function valuesOf(tokens, b, d, fn, own) {
+    const after = b.after;
+    if (!fn)
+        return [termOf(tokens, after, d.from, d.to, 0)];
+    // an async function gives a promise: of a response that's still the answer a route awaits; of a handler it's no handler
+    const cap = fn.async ? HANDLER : FACTORY;
+    if (!fn.block)
+        return [termOf(tokens, after, fn.from, fn.to, 1, cap)];
+    const returns = own.returns.get(fn.from) ?? [];
+    const last = returns[returns.length - 1];
+    if (last === undefined || own.throwing.has(fn.from) || b.parent[last] !== fn.from)
+        return [null];
+    // the last return is a statement of the body, not the branch of an `if … else return`
+    const prev = tokens[last - 1];
+    const opener = isPunct(prev, ")") ? b.open[last - 1] : -1;
+    const head = (at) => (tokens[at]?.kind === "ident" && !isPunct(tokens[at - 1], ".") ? tokens[at].value : "");
+    const condition = opener > 0 && (BLOCK_AFTER_CONDITION.has(head(opener - 1)) || (head(opener - 1) === "await" && head(opener - 2) === "for"));
+    const statement = last - 1 === fn.from || isPunct(prev, ";") || isPunct(prev, "}") || (tokens[last].nl === true && prev.kind !== "ident" && !condition);
+    if (!statement)
+        return [null];
+    // nothing but `;` between the last return's value and the body's closing brace
+    let end = returnEnd(tokens, after, last);
+    while (isPunct(tokens[end], ";"))
+        end++;
+    if (end !== fn.to - 1)
+        return [null];
+    return returns.map((k) => termOf(tokens, after, k + 1, returnEnd(tokens, after, k), 1, cap));
+}
+/** `name = …`, `name += …` and every other assignment, `name++`, `--name`. */
+function changes(tokens, k) {
+    const punct = (at) => (tokens[at]?.kind === "punct" ? tokens[at].value : "");
+    const twice = (a, c) => punct(a) === c && punct(a + 1) === c;
+    return twice(k - 2, "+") || twice(k - 2, "-") || assigned(tokens, k);
+}
+/** Whether what ends at `k` — a name, a member `o[k]` — is assigned to or updated after it: `= …`, `??= …`, `++`. */
+function assigned(tokens, k) {
+    const punct = (at) => (tokens[at]?.kind === "punct" ? tokens[at].value : "");
+    const twice = (a, c) => punct(a) === c && punct(a + 1) === c;
+    if (twice(k + 1, "+") || twice(k + 1, "-"))
+        return true;
+    let j = k + 1;
+    let operator = "";
+    while (operator.length < 3 && punct(j).length === 1 && "+-*/%&|^?<>".includes(punct(j)))
+        operator += punct(j++);
+    if (punct(j) !== "=" || punct(j + 1) === "=")
+        return false;
+    // `<=` and `>=` compare; `<<=`, `**=`, `??=`, `||=` … assign
+    return operator !== "<" && operator !== ">" && operator !== "?";
+}
+/** Names the code binds or changes other than by a declaration the
+    reading follows: parameters, destructuring — in a declaration or an
+    assignment (`({ h } = other)`, `[h] = list`) —, `catch (e)`, a loop's
+    head, a class, an enum or a namespace, an assignment or an update.
+    Where such a name is read it may not be what its declaration says, so
+    the reading gives it no level, whichever function it's in: a GET that
+    answers through it is one doctor can't confirm. */
+function reboundNames(tokens, b, declared) {
+    // spans all of whose names are bound, as a running count: nested spans stay linear
+    const marks = new Int32Array(tokens.length + 1);
+    const span = (from, to) => {
+        if (from >= to)
+            return;
+        marks[from]++;
+        marks[to]--;
+    };
+    const out = new Set();
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        const prev = tokens[k - 1];
+        if (isPunct(t, "(")) {
+            const next = tokens[b.after[k]];
+            const head = prev?.kind === "ident" && !isPunct(tokens[k - 2], ".") ? prev.value : null;
+            const condition = head !== null && CONTROL.has(head) && head !== "catch" && head !== "for";
+            // `(…) =>`, `name(…) {`, `(…): Type`, `function (…)`; `catch (e)` and a loop's head
+            const binds = isPunct(next, "=>") || (!condition && (isPunct(next, "{") || isPunct(next, ":"))) || head === "function" || head === "catch" || head === "for" || isWord(tokens[k - 2], "function");
+            if (binds)
+                span(k + 1, b.after[k] - 1);
+        }
+        else if ((isPunct(t, "{") || isPunct(t, "[")) && isPunct(tokens[b.after[k]], "=") && !isPunct(tokens[b.after[k] + 1], "=")) {
+            // a pattern assigned to: every name in it may be bound (a member `o[k] = …` is taken as one too)
+            span(k + 1, b.after[k] - 1);
+        }
+        else if (t.kind === "ident" && !isPunct(prev, ".")) {
+            if (isPunct(tokens[k + 1], "=>") || isWord(prev, "class") || isWord(prev, "enum") || isWord(prev, "namespace"))
+                out.add(t.value);
+            else if (DECLARE.has(t.value) && (isPunct(tokens[k + 1], "{") || isPunct(tokens[k + 1], "[")))
+                span(k + 2, b.after[k + 1] - 1);
+            else if (!declared.has(k) && !isWord(prev, "type") && changes(tokens, k))
+                out.add(t.value);
+        }
+    }
+    let depth = 0;
+    for (let k = 0; k < tokens.length; k++) {
+        depth += marks[k];
+        if (depth > 0 && tokens[k].kind === "ident")
+            out.add(tokens[k].value);
+    }
+    return out;
+}
+function readingOf(tokens) {
+    const b = bracketsOf(tokens);
+    const declarations = declarationsOf(tokens, b.after);
+    const rebound = reboundNames(tokens, b, new Set(declarations.map((d) => d.at)));
+    const bound = new Set([...rebound, ...declarations.map((d) => d.name)]);
+    return { b, declarations, rebound, bound };
+}
+/** Whether the route's exported GET answers with the release handler:
+    GET is a handler — `export const GET = createReleaseHandler(…)`,
+    `export { release as GET }`, `const GET = make()` — or a function that
+    always returns a handler's response: `export async function GET(req) {
+    return release(req); }`. A GET that only mentions the handler, calls it
+    and drops the result, returns it uncalled (`() => release`), or answers
+    something else on another branch or by a throw doesn't. A name declared
+    more than once, or returned more than once, is what all its values agree on,
+    a name bound or changed any other way is nothing the reading knows,
+    and neither is `createReleaseHandler` where the file binds its name
+    again — or a namespace's `ns.createReleaseHandler` where it binds `ns` again. */
+function releaseHandlerOf(tokens, names, read) {
+    const handlers = names.handler;
+    // `createReleaseHandler(` under a name it's imported as, or `ns.createReleaseHandler(` under a namespace's — not `a.ns.createReleaseHandler(`, a member of something else
+    const member = (k) => tokens[k].value === "createReleaseHandler" && isPunct(tokens[k - 1], ".") && tokens[k - 2]?.kind === "ident" && names.ns.handler.has(tokens[k - 2].value) && !isPunct(tokens[k - 3], ".");
+    const calls = (k) => (handlers.has(tokens[k].value) || member(k)) && isPunct(tokens[k + 1], "(");
+    if (!tokens.some((u, k) => u.kind === "ident" && calls(k)))
+        return null;
+    const { b, declarations, rebound, bound } = read();
+    const after = b.after;
+    const fns = declarations.map((d) => (d.fn ? { block: true, from: d.from, to: d.to, async: d.async } : functionOf(tokens, after, d.from, d.to)));
+    const own = returnsIn(tokens, b, new Set(fns.flatMap((fn) => (fn?.block ? [fn.from] : []))));
+    // every value a name is given — each declaration's, each return's — with the term it reads
+    const values = [];
+    const readers = new Map();
+    const declared = new Map();
+    declarations.forEach((d, i) => {
+        for (const term of valuesOf(tokens, b, d, fns[i], own)) {
+            const v = values.push(d.name) - 1;
+            declared.set(d.name, (declared.get(d.name) ?? 0) + 1);
+            if (term === null)
+                continue;
+            const list = readers.get(term.name);
+            if (list)
+                list.push([v, term]);
+            else
+                readers.set(term.name, [[v, term]]);
+        }
+    });
+    // levels as bits: of each name, of each value, and how many values of a name reach each level
+    const levels = new Map();
+    const ofValue = new Uint8Array(values.length);
+    const agree = new Map();
+    const queue = [];
+    const grow = (name, bits) => {
+        if (rebound.has(name))
+            return;
+        const had = levels.get(name) ?? 0;
+        if ((had | bits) === had)
+            return;
+        levels.set(name, had | bits);
+        queue.push([name, bits & ~had]);
+    };
+    for (const h of handlers)
+        if (!bound.has(h))
+            grow(h, 1 << FACTORY);
+    // a namespace's member is the factory wherever the namespace is the import; bound again, neither is anything the reading knows
+    for (const ns of names.ns.handler)
+        if (!bound.has(ns))
+            grow(memberName(ns, "createReleaseHandler"), 1 << FACTORY);
+    while (queue.length > 0) {
+        const [name, bits] = queue.pop();
+        for (const [i, term] of readers.get(name) ?? []) {
+            let reached = 0;
+            for (let level = RESPONSE; level <= FACTORY; level++) {
+                const to = level - term.calls + term.up;
+                if (bits & (1 << level) && to >= RESPONSE && to <= term.cap)
+                    reached |= 1 << to;
+            }
+            const fresh = reached & ~ofValue[i];
+            if (fresh === 0)
+                continue;
+            ofValue[i] = ofValue[i] | fresh;
+            const d = values[i];
+            // a declaration under an import's name — the factory's or its namespace's — is nothing the reading knows either
+            if (handlers.has(d) || names.ns.handler.has(d))
+                continue;
+            const counts = agree.get(d) ?? [0, 0, 0];
+            agree.set(d, counts);
+            let all = 0;
+            for (let level = RESPONSE; level <= FACTORY; level++) {
+                if (!(fresh & (1 << level)))
+                    continue;
+                counts[level] = counts[level] + 1;
+                if (counts[level] === declared.get(d))
+                    all |= 1 << level;
+            }
+            if (all !== 0)
+                grow(d, all);
+        }
+    }
+    const serves = (name) => ((levels.get(name) ?? 0) & (1 << HANDLER)) !== 0;
+    const direct = serves("GET") && declarations.some((d) => d.name === "GET" && d.exported);
+    const clause = (exportClauses(tokens).get("GET") ?? []).some(serves);
+    return direct || clause ? "GET" : "other";
+}
+/** The listeners one file mounts and, for a route file, whether its GET
+    serves the release. An imported name the file binds again — a
+    parameter, a declaration, destructuring — may not be the import where
+    it's used, and the reading can't tell where: none of its uses count.
+    A namespace's name the same: its members count only where `ns` itself
+    is the import. */
+export function liveInFile(file, text) {
+    const tokens = tokenize(text);
+    const names = importsOf(tokens);
+    let reading = null;
+    const read = () => (reading ??= readingOf(tokens));
+    /** Whether the name at `k` is a member of one of `namespaces` as imported:
+        `ns.name`, not `a.ns.name` — a member of something else — and `ns` not bound again. */
+    const ofNamespace = (k, namespaces) => {
+        const ns = tokens[k - 2];
+        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")
+            continue;
+        if (names.live.has(t.value) && isPunct(tokens[k - 1], "<")) {
+            if (read().bound.has(t.value))
+                continue;
+            listeners.push(listener("<MapledLive />", jsxEndpoint(tokens, k + 1)));
+        }
+        else if (t.value === "MapledLive" && isPunct(tokens[k - 3], "<") && ofNamespace(k, names.ns.live)) {
+            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];
+            if (prev?.kind === "ident" && prev.value === "function")
+                continue;
+            if (read().bound.has(t.value))
+                continue;
+            listeners.push(listener("watchRelease", callEndpoint(tokens, k + 1)));
+        }
+        else if (t.value === "watchRelease" && isPunct(tokens[k + 1], "(") && ofNamespace(k, names.ns.watch)) {
+            listeners.push(listener("watchRelease", callEndpoint(tokens, k + 1)));
+        }
+    }
+    // `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 } : {}) };
+}
+/** 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`
+        if (isWord(t, "exports"))
+            return true;
+        if (!isWord(t, "export") || isPunct(tokens[i - 1], "."))
+            continue;
+        let j = i + 1;
+        // `export * from "./segment"` may carry it, and so may TypeScript's `export =`; `export * as ns` names only ns
+        if (isPunct(tokens[j], "="))
+            return true;
+        if (isPunct(tokens[j], "*")) {
+            if (!isWord(tokens[j + 1], "as"))
+                return true;
+            continue;
+        }
+        // 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 (isName(tokens[k], name) && !isWord(tokens[k + 1], "as"))
+                    return true;
+            continue;
+        }
+        while (isWord(tokens[j], "declare") || isWord(tokens[j], "async") || isWord(tokens[j], "abstract"))
+            j++;
+        const declare = tokens[j];
+        if (declare?.kind !== "ident" || !DECLARE.has(declare.value)) {
+            // `export function dynamicParams`, `export class …`, `export import dynamicParams = …`
+            const named = isPunct(tokens[j + 1], "*") ? j + 2 : j + 1;
+            if (isName(tokens[named], name))
+                return true;
+            continue;
+        }
+        // each declarator: `export const a = 1, dynamicParams = false`, `export const { dynamicParams } = config`
+        for (let k = j + 1; k < tokens.length;) {
+            let next;
+            if (isPunct(tokens[k], "{") || isPunct(tokens[k], "[")) {
+                for (let p = k + 1; p < after[k] - 1; p++)
+                    if (isName(tokens[p], name))
+                        return true;
+                next = after[k];
+            }
+            else if (tokens[k].kind === "ident") {
+                // 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;
+            }
+            else
+                break;
+            if (isPunct(tokens[next], ":"))
+                next = typeEnd(tokens, after, next + 1, tokens.length);
+            if (next < 0)
+                break;
+            if (isPunct(tokens[next], "="))
+                next = initializerEnd(tokens, after, next + 1);
+            if (!isPunct(tokens[next], ","))
+                break;
+            k = next + 1;
+        }
+    }
+    return false;
+}
+/** 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 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 null;
+    let from = eq + 1;
+    let to = initializerEnd(tokens, after, from);
+    for (;;) {
+        // where the value ends: `x as T`, `x satisfies T` and `x!` are x, and a
+        // line without a semicolon ends before a name that starts the next one
+        let end = to;
+        for (let j = from; j < end; j++) {
+            const u = tokens[j];
+            const p = tokens[j - 1];
+            if (j > from && (isWord(u, "as") || isWord(u, "satisfies") || (u.nl === true && u.kind === "ident" && (p.kind !== "punct" || ")]}".includes(p.value)))))
+                end = j;
+            else if (u.kind === "punct" && "([{".includes(u.value))
+                j = after[j] - 1;
+        }
+        while (end > from + 1 && isPunct(tokens[end - 1], "!"))
+            end--;
+        if (!isPunct(tokens[from], "(") || after[from] !== end)
+            return end === from + 1 ? tokens[from] : null;
+        from++;
+        to = end - 1;
+    }
+}
+/** The route files of the App Router with the path each answers. */
+export function routeFileOf(file, extensions = PAGE_EXTENSIONS) {
+    const m = /^(?:src\/)?app\/(?:(.+)\/)?route\.(.+)$/.exec(file);
+    if (!m || !extensions.includes(m[2]))
+        return null;
+    return appRoute(m[1] ? m[1].split("/") : []);
+}
+// Pages Router files that are no page of their own
+const PAGES_SPECIAL = new Set(["_app", "_document", "_error"]);
+/** The page files of both routers with the path each answers: an App
+    Router `page.<ext>`, and any Pages Router file but `_app`, `_document`
+    and `_error`, with the longest page extension its name ends in taken
+    off, as Next does, and `index` naming its folder. */
+export function pageFileOf(file, extensions = PAGE_EXTENSIONS) {
+    const app = /^(?:src\/)?app\/(?:(.+)\/)?page\.(.+)$/.exec(file);
+    if (app)
+        return extensions.includes(app[2]) ? appRoute(app[1] ? app[1].split("/") : []) : null;
+    const pages = /^(?:src\/)?pages\/(.+)$/.exec(file);
+    if (!pages)
+        return null;
+    const name = pages[1];
+    const ext = extensions.filter((e) => name.endsWith(`.${e}`)).sort((a, b) => b.length - a.length)[0];
+    if (ext === undefined || name.length === ext.length + 1)
+        return null;
+    const segments = name.slice(0, -(ext.length + 1)).split("/");
+    if (segments.length === 1 && PAGES_SPECIAL.has(segments[0]))
+        return null;
+    if (segments[segments.length - 1] === "index")
+        segments.pop();
+    return "/" + segments.join("/");
+}
+/** Whether the site has the folder at its root: Next reads `app` and
+    `pages` there, and under `src/` only when the root has none. */
+async function atRoot(dir, name) {
+    try {
+        return (await stat(path.join(dir, name))).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+// the settings of next.config that move where a file answers
+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'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];
+        if (t.kind !== "punct")
+            continue;
+        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;
+    }
+    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++) {
+        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 (p.value === "}")
+            return false;
+        else
+            division = false;
+        if (regex === division)
+            return false;
+    }
+    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--;
+        }
+    };
+    // 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;
+            }
+        }
+        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 t = tokens[k];
+            if (t.kind === "punct" && OPENS.has(t.value))
+                k = b.after[k] - 1;
+            else if ((isWord(t, "as") || isWord(t, "satisfies")) && k > from && !isPunct(tokens[k - 1], "."))
+                return suffix(k, to) ? k : -1;
+        }
+        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));
+        }
+    };
+    // 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
+                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;
+        }
+        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);
+        }
+        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
+                break;
+        }
+        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 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;
+        }
+        return true;
+    };
+    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, once, in the config object
+    const settings = {};
+    const accepted = new Set();
+    // `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;
+                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;
+                    list.push(tokens[x].value);
+                }
+                settings.pageExtensions = list;
+                accepted.add(p.at);
+            }
+            else if (p.key === "output")
+                output = output === undefined && single ? value.value : null;
+        }
+    }
+    // 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;
+    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);
+    const config = NEXT_CONFIGS.find((name) => files.includes(name));
+    let configText = null;
+    if (config) {
+        try {
+            configText = await readFile(path.join(dir, config), "utf8");
+        }
+        catch {
+            // unreadable: the defaults
+        }
+    }
+    const settings = nextConfigOf(configText);
+    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
+    const rootApp = await atRoot(dir, "app");
+    const ignored = [...(rootApp ? ["src/app/"] : []), ...((await atRoot(dir, "pages")) ? ["src/pages/"] : [])];
+    const appDir = rootApp ? "app" : (await atRoot(dir, "src/app")) ? "src/app" : undefined;
+    const listeners = [];
+    const routes = [];
+    const pages = [];
+    for (const file of files) {
+        if (ignored.some((prefix) => file.startsWith(prefix)))
+            continue;
+        const route = extensions === null ? null : routeFileOf(file, extensions);
+        const page = extensions === null ? null : pageFileOf(file, extensions);
+        if (page !== null)
+            pages.push({ file, path: page });
+        let text;
+        try {
+            text = await readFile(path.join(dir, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (text.length > 2_000_000)
+            continue;
+        const words = WORDS.test(text);
+        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 } : {}), ...(found.segment ? { segment: found.segment } : {}) });
+    }
+    const facts = { listeners, routes, pages, routeExtension };
+    if (appDir)
+        facts.appDir = appDir;
+    if (settings?.basePath)
+        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/…`
+    — 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. */
+export const fullAddress = (endpoint) => /^[a-z][a-z\d+.-]*:/i.test(endpoint) || /^[/\\][/\\]/.test(endpoint);
+const SITE = "http://site.invalid";
+/** The path on the site a literal endpoint asks — the only thing a route
+    file can answer: a path from the site's root. Null for anything else:
+    a relative endpoint resolves against each page's address, and a full
+    address may be another origin's — no one route file is their answer. */
+const sitePath = (endpoint) => {
+    if (!endpoint.startsWith("/") || fullAddress(endpoint))
+        return null;
+    let pathname;
+    try {
+        const url = new URL(endpoint, SITE);
+        // the parser drops tabs and line breaks and reads `\` as `/`: whatever reaches another host isn't a path
+        if (url.origin !== SITE)
+            return null;
+        pathname = url.pathname;
+    }
+    catch {
+        return null;
+    }
+    // the parser percent-encodes; route folders are named as written
+    try {
+        pathname = decodeURI(pathname);
+    }
+    catch {
+        // a stray % stays as it is
+    }
+    const bare = pathname.replace(/\/+$/, "");
+    return bare === "" ? "/" : bare;
+};
+/** How a route folder's segment matches a path's, most specific first —
+    as the App Router picks among routes that match: a static segment, a
+    dynamic `[x]` (one segment), a catch-all `[...x]` (one or more), an
+    optional catch-all `[[...x]]` (none or more). */
+const segmentRank = (segment) => (/^\[\[\.\.\.[^\]]+\]\]$/.test(segment) ? 3 : /^\[\.\.\.[^\]]+\]$/.test(segment) ? 2 : /^\[[^\]]+\]$/.test(segment) ? 1 : 0);
+const fileOf = (a) => (a.route ?? a.page).file;
+// the same ranks: a route before a page, then by file
+const before = (a, b) => !b || (a.route ? 0 : 1) - (b.route ? 0 : 1) < 0 || ((a.route ? 0 : 1) === (b.route ? 0 : 1) && fileOf(a) < fileOf(b));
+/** Looks paths up among the route files and pages: each file's segments
+    are read once, and a lookup walks only the folders its path can match —
+    each asked path once. */
+function answerer(routes, pages) {
+    const split = (p) => (p === "/" ? [] : p.slice(1).split("/"));
+    const root = { fixed: new Map() };
+    const add = (answer, answers) => {
+        const segments = split(answers);
+        const ranks = segments.map(segmentRank);
+        const a = { ...answer, ranks };
+        let n = root;
+        for (let i = 0; i < segments.length; i++) {
+            const rank = ranks[i];
+            if (rank >= 2) {
+                // a catch-all is the last segment, or the folder matches nothing
+                if (i !== segments.length - 1)
+                    return;
+                if (rank === 2 && before(a, n.rest))
+                    n.rest = a;
+                if (rank === 3 && before(a, n.optional))
+                    n.optional = a;
+                return;
+            }
+            if (rank === 1)
+                n = n.param ??= { fixed: new Map() };
+            else {
+                const next = n.fixed.get(segments[i]) ?? { fixed: new Map() };
+                n.fixed.set(segments[i], next);
+                n = next;
+            }
+        }
+        if (before(a, n.end))
+            n.end = a;
+    };
+    for (const route of routes)
+        add({ route }, route.path);
+    for (const page of pages)
+        add({ page }, page.path);
+    const order = (a, b) => {
+        for (let i = 0; i < Math.max(a.length, b.length); i++)
+            if ((a[i] ?? -1) !== (b[i] ?? -1))
+                return (a[i] ?? -1) - (b[i] ?? -1);
+        return 0;
+    };
+    const cache = new Map();
+    return (at) => {
+        if (cache.has(at))
+            return cache.get(at);
+        const asked = split(at);
+        const found = [];
+        // a tree: each node is reached one way, so a lookup visits it once at most
+        const walk = (n, i) => {
+            // a catch-all takes the rest: one segment or more, or — optional — none too
+            if (n.rest && asked.length > i)
+                found.push(n.rest);
+            if (n.optional)
+                found.push(n.optional);
+            if (i === asked.length) {
+                if (n.end)
+                    found.push(n.end);
+                return;
+            }
+            const fixed = n.fixed.get(asked[i]);
+            if (fixed)
+                walk(fixed, i + 1);
+            if (n.param)
+                walk(n.param, i + 1);
+        };
+        walk(root, 0);
+        let best;
+        for (const c of found) {
+            const o = best ? order(c.ranks, best.ranks) : -1;
+            if (o < 0 || (o === 0 && before(c, best)))
+                best = c;
+        }
+        cache.set(at, best);
+        return best;
+    };
+}
+/** Whether a route's folders take a param: `[x]`, `[...x]`, `[[...x]]`. */
+const dynamicRoute = (route) => route.path.split("/").some((s) => segmentRank(s) > 0);
+/** Whether every listener has a route that answers it. The first one
+    that doesn't is the one to name. */
+export function liveState(facts) {
+    // the conventional path first, then by file: the same answer every run
+    const rank = (r) => (r.path === RELEASE_ROUTE ? 0 : 1);
+    const handlerRoutes = facts.routes.filter((r) => r.handler === "GET").sort((a, b) => rank(a) - rank(b) || (a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
+    if (facts.listeners.length === 0)
+        return { kind: "unused", handlerRoute: handlerRoutes[0] ?? null };
+    const answerOf = answerer(facts.routes, facts.pages ?? []);
+    const base = facts.basePath ?? "";
+    let served = null;
+    for (const listener of facts.listeners) {
+        if (listener.endpoint === null) {
+            // the code decides where it asks: with no release route at all it's
+            // surely missing; with one — or routes the reading can't know — nothing says it's the route asked
+            if (handlerRoutes.length === 0 && !facts.config)
+                return { kind: "missing", listener, endpoint: null };
+            return { kind: "unresolved", listener };
+        }
+        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 };
+        const answer = answerOf(base === "" ? at : at.slice(base.length) || "/");
+        if (!answer)
+            return { kind: "missing", listener, endpoint: at };
+        if (answer.page) {
+            // a page takes the path: through a param, a route of its own at the path wins over it; a route can't share a page's path
+            if (answer.ranks.some((r) => r > 0))
+                return { kind: "missing", listener, endpoint: at };
+            return { kind: "taken", listener, page: answer.page, endpoint: at };
+        }
+        const route = answer.route;
+        // a dynamic route without the handler: a route of its own at the path wins over the param
+        if (route.handler === null)
+            return dynamicRoute(route) ? { kind: "missing", listener, endpoint: at } : { kind: "no_handler", listener, route };
+        if (route.handler === "other")
+            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 };
+}
+/** What `mapled scan` writes into the manifest: a listener nothing answers
+    isn't listening; the route is the path the tab asks, not a dynamic route's pattern. */
+export function capabilitiesOf(state) {
+    return state.kind === "served" ? { realtime: true, releaseRoute: state.path } : { realtime: false };
+}
+/** Where a route answering `endpoint` goes: in the App Router folder Next
+    reads — without one, under `src/app` when the site keeps its code there
+    — and without the basePath, which Next adds itself. */
+export function routeFileFor(endpoint, facts) {
+    const underSrc = [...facts.routes.map((r) => r.file), ...(facts.pages ?? []).map((p) => p.file), ...facts.listeners.map((l) => l.file)].some((f) => f.startsWith("src/"));
+    const base = facts.basePath ?? "";
+    const local = base !== "" && (endpoint === base || endpoint.startsWith(`${base}/`)) ? endpoint.slice(base.length) || "/" : endpoint;
+    return `${facts.appDir ?? (underSrc ? "src/app" : "app")}${local === "/" ? "" : local}/route.${facts.routeExtension ?? "ts"}`;
+}