@mapled/cli 0.10.0 → 0.12.0

package/dist/live.js

@@ -0,0 +1,1509 @@
+import { 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 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. */
+function jsxEndpoint(tokens, from) {
+    let endpoint = RELEASE_ROUTE;
+    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. */
+function callEndpoint(tokens, paren) {
+    if (!isPunct(tokens[paren + 1], "{"))
+        return null;
+    let endpoint = RELEASE_ROUTE;
+    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 = [];
+    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({ file, via: "<MapledLive />", endpoint: jsxEndpoint(tokens, k + 1) });
+        }
+        else if (t.value === "MapledLive" && isPunct(tokens[k - 3], "<") && ofNamespace(k, names.ns.live)) {
+            listeners.push({ file, via: "<MapledLive />", endpoint: jsxEndpoint(tokens, k + 1) });
+        }
+        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({ file, via: "watchRelease", endpoint: callEndpoint(tokens, k + 1) });
+        }
+        else if (t.value === "watchRelease" && isPunct(tokens[k + 1], "(") && ofNamespace(k, names.ns.watch)) {
+            listeners.push({ file, via: "watchRelease", endpoint: callEndpoint(tokens, k + 1) });
+        }
+    }
+    // `dynamicParams` as the route exports it, or an export the reading can't list
+    const params = tokens.some((u, k) => namesParams(u) || isWord(u, "exports") || (isWord(u, "export") && isPunct(tokens[k + 1], "*"))) && setsParams(tokens, read().b.after);
+    return { listeners, handler: releaseHandlerOf(tokens, names, read), params };
+}
+const namesParams = (u) => (u?.kind === "ident" || u?.kind === "string") && u.value === "dynamicParams";
+/** Whether the route may export `dynamicParams` as anything but the
+    default written out (`export const dynamicParams = true`). Next reads
+    only the module's export: a local variable, a property or a string that
+    says the name is nothing to it. An export the reading can't list —
+    `export *`, CommonJS — may be it. */
+function setsParams(tokens, after) {
+    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 (namesParams(tokens[k]) && !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 name = isPunct(tokens[j + 1], "*") ? j + 2 : j + 1;
+            if (namesParams(tokens[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 (namesParams(tokens[p]))
+                        return true;
+                next = after[k];
+            }
+            else if (tokens[k].kind === "ident") {
+                // only a `const` keeps the default: a `let` or `var` may change it later
+                if (namesParams(tokens[k]) && (declare.value !== "const" || !paramsDefault(tokens, after, k)))
+                    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;
+}
+/** Whether the mention of `dynamicParams` at `k` writes out the default:
+    `dynamicParams = true`, with or without a type (`: boolean`), the `true`
+    in parentheses or followed by `as` / `satisfies` / `!`. */
+function paramsDefault(tokens, after, k) {
+    if (tokens[k].kind !== "ident")
+        return false;
+    const eq = isPunct(tokens[k + 1], ":") ? typeEnd(tokens, after, k + 2, tokens.length) : k + 1;
+    if (eq < 0 || !isPunct(tokens[eq], "=") || isPunct(tokens[eq + 1], "="))
+        return false;
+    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 && isWord(tokens[from], "true");
+        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.config's `pageExtensions` and `basePath`, read only where the file
+    writes them out: a literal, once, directly in the object it exports —
+    `module.exports = {…}`, `export default nextConfig`, or passed to a
+    plugin: `withMDX(nextConfig)`. Null when it may set either anywhere
+    else: a value or a name the code builds (`["page" + "Extensions"]`, an
+    escaped identifier, `Object.assign`, `defineProperty`, a prototype
+    set by `setPrototypeOf` or `__proto__`, a member in a loop's head), an object from
+    another file or spread in, a member (`config.basePath = …`), a nested
+    object, any other mention — then no route can be checked. */
+export function nextConfigOf(config) {
+    if (config === null)
+        return { pageExtensions: PAGE_EXTENSIONS, basePath: "" };
+    const tokens = tokenize(config);
+    const b = bracketsOf(tokens);
+    const declarations = declarationsOf(tokens, b.after);
+    const declaredAt = new Set(declarations.map((d) => d.at));
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        // an identifier with an escape in its name, or a call that sets or copies properties
+        if (isPunct(t, "\\") || (t.kind === "ident" && (t.escaped === true || COPIES.has(t.value))) || (t.kind === "string" && t.value === "__proto__"))
+            return null;
+        // a setting's name inside a longer string: JSON the code parses
+        if (t.kind === "string" && !SETTINGS.includes(t.value) && SETTINGS.some((s) => t.value.includes(s)))
+            return null;
+        if (!isPunct(t, "["))
+            continue;
+        // a computed key or member written to, unless a lone string or digits name it: `{ [name]: … }`, `config[name] = …`, not `rules[0] = …`
+        const close = b.after[k] - 1;
+        if (close === k + 2 && literal(tokens[k + 1]))
+            continue;
+        let digits = k + 1;
+        while (digits < close && tokens[digits].kind === "punct" && /^\d$/.test(tokens[digits].value))
+            digits++;
+        if (digits === close && close > k + 1)
+            continue;
+        const prev = tokens[k - 1];
+        const key = (isPunct(prev, "{") || isPunct(prev, ",") || isPunct(prev, "*") || (prev?.kind === "ident" && KEY_PREFIX.has(prev.value))) && (isPunct(tokens[close + 1], ":") || isPunct(tokens[close + 1], "("));
+        // a loop's head writes each value to it: `for (config[name] of values)`
+        const head = b.parent[k];
+        const loop = head >= 0 && isPunct(tokens[head], "(") && (isWord(tokens[head - 1], "for") || (isWord(tokens[head - 1], "await") && isWord(tokens[head - 2], "for"))) && (isWord(tokens[close + 1], "of") || isWord(tokens[close + 1], "in"));
+        const member = (prev?.kind === "ident" || isPunct(prev, ")") || isPunct(prev, "]")) && (assigned(tokens, close) || loop);
+        if (key || member)
+            return null;
+    }
+    // what the file exports: `module.exports = …`, `export default …`, `export { config as default }`
+    const exported = [];
+    const names = exportClauses(tokens).get("default") ?? [];
+    for (let k = 0; k < tokens.length; k++) {
+        if (isWord(tokens[k], "module") && !isPunct(tokens[k - 1], ".") && isPunct(tokens[k + 1], ".") && isWord(tokens[k + 2], "exports") && isPunct(tokens[k + 3], "=") && !isPunct(tokens[k + 4], "=")) {
+            exported.push([k + 4, initializerEnd(tokens, b.after, k + 4, false)]);
+        }
+        else if (isWord(tokens[k], "export") && isWord(tokens[k + 1], "default"))
+            exported.push([k + 2, initializerEnd(tokens, b.after, k + 2, false)]);
+    }
+    // `export { default } from "./base.mjs"`: the config is another module's
+    const reexported = tokens.some((t, k) => isWord(t, "export") && isPunct(tokens[k + 1], "{") && isWord(tokens[b.after[k + 1]], "from") && tokens.slice(k + 2, b.after[k + 1] - 1).some((u) => isWord(u, "default")));
+    // the objects the config is made of, and whether any part comes from elsewhere
+    const objects = new Set();
+    let opaque = reexported || exported.length + names.length > 1;
+    const byName = new Map();
+    for (const d of declarations) {
+        const list = byName.get(d.name);
+        if (list)
+            list.push(d);
+        else
+            byName.set(d.name, [d]);
+    }
+    const reassigned = new Set(tokens.flatMap((u, k) => (u.kind === "ident" && !isPunct(tokens[k - 1], ".") && !declaredAt.has(k) && changes(tokens, k) ? [u.value] : [])));
+    // and every name in a pattern assigned to — `({ config } = presets)`, `[a, config] = list` — as a running count: nested patterns stay linear
+    const patterns = new Int32Array(tokens.length + 1);
+    for (let k = 0; k < tokens.length; k++) {
+        const after = b.after[k];
+        if ((isPunct(tokens[k], "{") || isPunct(tokens[k], "[")) && !DECLARE.has(tokens[k - 1]?.value ?? "") && isPunct(tokens[after], "=") && !isPunct(tokens[after + 1], "=")) {
+            patterns[k]++;
+            patterns[after]--;
+        }
+    }
+    for (let k = 0, depth = 0; k < tokens.length; k++) {
+        depth += patterns[k];
+        if (depth > 0 && tokens[k].kind === "ident")
+            reassigned.add(tokens[k].value);
+        // a loop's head without a declaration: `for (config of variants)`
+        const loop = isPunct(tokens[k - 1], "(") && (isWord(tokens[k - 2], "for") || (isWord(tokens[k - 2], "await") && isWord(tokens[k - 3], "for")));
+        if (loop && tokens[k].kind === "ident" && (isWord(tokens[k + 1], "of") || isWord(tokens[k + 1], "in")))
+            reassigned.add(tokens[k].value);
+    }
+    // names taken from a file of the site — `import x from "./x"`, `const x = require("./x")`: a plugin there may set anything
+    const relative = (k) => (isWord(tokens[k], "require") || isWord(tokens[k], "import")) && isPunct(tokens[k + 1], "(") && tokens[k + 2]?.kind === "string" && tokens[k + 2].value.startsWith(".");
+    const loadsBefore = new Int32Array(tokens.length + 1);
+    for (let k = 0; k < tokens.length; k++)
+        loadsBefore[k + 1] = loadsBefore[k] + (relative(k) ? 1 : 0);
+    const local = new Set(declarations.filter((d) => loadsBefore[d.to] > loadsBefore[d.from]).map((d) => d.name));
+    for (let k = 0; k < tokens.length; k++) {
+        if (!isWord(tokens[k], "import") || isPunct(tokens[k + 1], "("))
+            continue;
+        const bound = [];
+        let j = k + 1;
+        for (; j < tokens.length && j < k + 200 && !isPunct(tokens[j], ";") && !isWord(tokens[j], "from"); j++)
+            if (tokens[j].kind === "ident")
+                bound.push(tokens[j].value);
+        if (isWord(tokens[j], "from") && tokens[j + 1]?.kind === "string" && tokens[j + 1].value.startsWith("."))
+            for (const name of bound)
+                local.add(name);
+    }
+    // each name is read once: a name passed twice, or one that names itself, adds nothing
+    const visited = new Set();
+    const fromName = (name, depth) => {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        const ds = byName.get(name) ?? [];
+        // declared once, with a value, never assigned again: that value; anything else — an import, a parameter — is from elsewhere
+        if (ds.length !== 1 || reassigned.has(name) || ds[0].fn || ds[0].from === ds[0].to)
+            opaque = true;
+        else
+            visit(ds[0].from, ds[0].to, depth + 1);
+    };
+    const visit = (from, to, depth) => {
+        if (opaque)
+            return;
+        if (depth > 16 || from >= to) {
+            opaque = true;
+            return;
+        }
+        // where the value ends: `x as T` and `x satisfies T` are x, and a line
+        // without a semicolon ends before a name that starts the next one
+        let end = to;
+        for (let k = from; k < to; k++) {
+            const u = tokens[k];
+            const p = tokens[k - 1];
+            if (k > from && (isWord(u, "as") || isWord(u, "satisfies")))
+                end = k;
+            else if (k > from && u.nl === true && u.kind === "ident" && u.value !== "in" && u.value !== "instanceof" && (p.kind !== "punct" || ")]}".includes(p.value) || /^\d$/.test(p.value)))
+                end = k;
+            else if (u.kind === "punct" && "([{".includes(u.value))
+                k = b.after[k] - 1;
+            if (end !== to)
+                break;
+        }
+        let k = from;
+        while (k < end && isWord(tokens[k], "await"))
+            k++;
+        if (k >= end) {
+            opaque = true;
+            return;
+        }
+        const t = tokens[k];
+        if ((isPunct(t, "{") || isPunct(t, "(")) && b.after[k] === end) {
+            if (t.value === "{")
+                objects.add(k);
+            else
+                visit(k + 1, end - 1, depth + 1);
+            return;
+        }
+        // a function: its code is here, and whatever it sets, the mentions below see
+        if (isWord(t, "function") || (isWord(t, "async") && isWord(tokens[k + 1], "function")) || functionOf(tokens, b.after, k, end))
+            return;
+        // a plugin's name or option: `require("@next/mdx")`, `{ enabled: true }`
+        if (t?.kind === "string" || (t?.kind === "punct" && /^\d$/.test(t.value)) || isWord(t, "true") || isWord(t, "false") || isWord(t, "null") || isWord(t, "undefined"))
+            return;
+        if (t?.kind !== "ident") {
+            opaque = true;
+            return;
+        }
+        let j = k + 1;
+        while (j < end && isPunct(tokens[j], ".") && tokens[j + 1]?.kind === "ident")
+            j += 2;
+        if (j === end) {
+            // a name, or a member (`base.config`) — a value from elsewhere
+            if (j === k + 1)
+                fromName(t.value, depth);
+            else
+                opaque = true;
+            return;
+        }
+        // a call, or calls: `withMDX(nextConfig)`, `createMDX()(config)` — a
+        // plugin from a package keeps the config it's given; `require("…")`, a
+        // plugin from the site's own files, or a call given no config — its
+        // value comes from elsewhere
+        if (!isPunct(tokens[j], "(") || (isWord(t, "require") && j === k + 1 && b.after[j] === end) || relative(k) || local.has(t.value)) {
+            opaque = true;
+            return;
+        }
+        const literal = (u) => u?.kind === "string" || (u?.kind === "punct" && /^\d$/.test(u.value)) || isWord(u, "true") || isWord(u, "false") || isWord(u, "null") || isWord(u, "undefined");
+        let given = false;
+        for (; j < end && isPunct(tokens[j], "("); j = b.after[j]) {
+            let start = j + 1;
+            const close = b.after[j] - 1;
+            given = false;
+            for (let a = start; a <= close; a++) {
+                const u = tokens[a];
+                if (a < close && u.kind === "punct" && "([{".includes(u.value))
+                    a = b.after[a] - 1;
+                else if (a === close || isPunct(u, ",")) {
+                    if (a > start) {
+                        given ||= !literal(tokens[start]);
+                        visit(start, a, depth + 1);
+                    }
+                    start = a + 1;
+                }
+            }
+        }
+        if (j !== end || !given)
+            opaque = true;
+    };
+    for (const [from, to] of exported)
+        visit(from, to, 0);
+    for (const name of names)
+        fromName(name, 0);
+    if (opaque)
+        return null;
+    // each setting: a literal, directly in one of those objects, and not mentioned anywhere else
+    const settings = {};
+    const accepted = new Set();
+    for (const open of objects) {
+        const last = b.after[open] - 1;
+        let property = true;
+        for (let k = open + 1; k < last; k++) {
+            if (property) {
+                property = false;
+                if (isSpread(tokens, k))
+                    return null;
+                const { name, next } = propertyKey(tokens, k);
+                if (name === "pageExtensions" || name === "basePath") {
+                    if (settings[name] !== undefined || !isPunct(tokens[next], ":"))
+                        return null;
+                    const v = next + 1;
+                    const valueEnd = name === "basePath" ? v + 1 : isPunct(tokens[v], "[") ? b.after[v] : v;
+                    if (valueEnd === v || (!isPunct(tokens[valueEnd], ",") && valueEnd !== last))
+                        return null;
+                    const plain = (u) => u?.kind === "string" && !u.unclosed && u.value !== "${}";
+                    if (name === "basePath") {
+                        const value = tokens[v];
+                        // a path from the root, without a trailing slash — anything else Next refuses
+                        if (!plain(value) || (value.value !== "" && !/^\/[^?#\s]*[^/?#\s]$/.test(value.value)))
+                            return null;
+                        settings[name] = value.value;
+                    }
+                    else {
+                        const list = [];
+                        for (let j = v + 1; j < valueEnd - 1; j++) {
+                            if (plain(tokens[j]) && (isPunct(tokens[j + 1], ",") || j + 1 === valueEnd - 1))
+                                list.push(tokens[j].value);
+                            else if (!isPunct(tokens[j], ","))
+                                return null;
+                        }
+                        settings[name] = list;
+                    }
+                    accepted.add(isPunct(tokens[next - 1], "]") ? next - 2 : next - 1);
+                }
+            }
+            const t = tokens[k];
+            if (t.kind === "punct" && "([{".includes(t.value))
+                k = b.after[k] - 1;
+            else if (isPunct(t, ","))
+                property = true;
+        }
+    }
+    if (tokens.some((t, k) => (t.kind === "ident" || t.kind === "string") && SETTINGS.includes(t.value) && !accepted.has(k)))
+        return null;
+    return { pageExtensions: settings.pageExtensions ?? PAGE_EXTENSIONS, basePath: settings.basePath ?? "" };
+}
+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 } : {}) });
+    }
+    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;
+    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 at = sitePath(listener.endpoint);
+        if (at === null)
+            return { kind: "unresolved", listener };
+        if (facts.config)
+            return { kind: "config", listener, file: facts.config };
+        // 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 };
+        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"}`;
+}