@vincentt-xr/cli 0.16.0 → 0.18.0

package/dist/lib/detect.js

@@ -0,0 +1,867 @@
+// Detection on joining: how does this app run? Text matching over package.json,
+// the lockfile's NAME, and at most one bundler config. Nothing is executed,
+// evaluated, required or installed, because joining is the moment a cloned
+// (possibly hostile) repository is first touched. Every read is capped at 256 KB
+// and every scan below is a single linear pass: no backtracking pattern ever
+// sees repository text.
+//
+// Rules and their order are the contract (how-it-works 2A.2). The first match
+// wins, and a value the CLI cannot read is "not found", never the default.
+import path from "node:path";
+export const DETECT_MAX_BYTES = 256 * 1024;
+const CANDIDATES = ["dev", "serve", "start", "develop"];
+const DEV_DEFAULT_PORT = {
+    vite: 5173,
+    "webpack-dev-server": 8080,
+    parcel: 1234,
+    astro: 4321,
+    "react-scripts": 3000,
+    "http-server": 8080,
+    serve: 3000,
+    "live-server": 8080,
+};
+const BUILD_DEFAULT_OUTPUT = {
+    webpack: "dist",
+    vite: "dist",
+    parcel: "dist",
+    "react-scripts": "build",
+    astro: "dist",
+};
+const VITE_CONFIGS = [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs",
+    "vite.config.cts",
+];
+const WEBPACK_CONFIGS = [
+    "webpack.config.js",
+    "webpack.config.cjs",
+    "webpack.config.mjs",
+    "webpack.config.ts",
+    "webpack.config.cts",
+    "webpack.config.mts",
+];
+/** Split a script body on `&&`, `||`, `;`, `|` and `&`, honouring quotes. Linear. */
+export function splitScript(body) {
+    const commands = [];
+    let words = [];
+    let word = "";
+    let inWord = false;
+    let quote = null;
+    let start = 0;
+    const endWord = () => {
+        if (inWord)
+            words.push(word);
+        word = "";
+        inWord = false;
+    };
+    const endCommand = (end) => {
+        endWord();
+        if (words.length > 0)
+            commands.push({ words: unwrap(words), text: body.slice(start, end).trim() });
+        words = [];
+    };
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (quote) {
+            if (c === "\\" && quote === '"' && i + 1 < body.length) {
+                word += body[++i];
+            }
+            else if (c === quote) {
+                quote = null;
+            }
+            else {
+                word += c;
+            }
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            quote = c;
+            inWord = true;
+            continue;
+        }
+        if (c === "&" || c === "|" || c === ";") {
+            endCommand(i);
+            if ((c === "&" || c === "|") && body[i + 1] === c)
+                i++;
+            start = i + 1;
+            continue;
+        }
+        if (c === " " || c === "\t" || c === "\n") {
+            endWord();
+            continue;
+        }
+        word += c;
+        inWord = true;
+    }
+    endCommand(body.length);
+    return commands.filter((c) => c.words.length > 0);
+}
+const ENV_ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+/** Drop env assignments and the runners that only locate a binary. */
+function unwrap(words) {
+    // An index, never a re-slice per word: a script of 50,000 `A=1` words would
+    // otherwise copy the array once per word.
+    let i = 0;
+    for (let guard = 0; guard < 4; guard++) {
+        while (i < words.length && ENV_ASSIGN.test(words[i]))
+            i++;
+        const head = words[i];
+        if (head === "npx" || head === "bunx" || head === "cross-env") {
+            i++;
+            while (i < words.length && words[i].startsWith("-"))
+                i++;
+            continue;
+        }
+        if ((head === "pnpm" || head === "npm" || head === "yarn") &&
+            (words[i + 1] === "exec" || words[i + 1] === "dlx")) {
+            i += 2;
+            continue;
+        }
+        break;
+    }
+    const w = words.slice(i);
+    if (w.length > 0)
+        w[0] = path.posix.basename(w[0]);
+    return w;
+}
+function subcommand(words) {
+    return words.slice(1).find((w) => !w.startsWith("-"));
+}
+function serverMarker(c) {
+    const [head] = c.words;
+    const sub = subcommand(c.words);
+    if ((head === "next" || head === "nuxt" || head === "nuxi") &&
+        (sub === "dev" || sub === "start")) {
+        return `${head} ${sub}`;
+    }
+    if (head !== undefined && head.startsWith("remix"))
+        return head;
+    if (head === "nodemon")
+        return "nodemon";
+    return undefined;
+}
+function devTool(c) {
+    const [head] = c.words;
+    const sub = subcommand(c.words);
+    switch (head) {
+        case "vite":
+            if (sub === "build" || sub === "preview" || sub === "optimize")
+                return undefined;
+            return { tool: "vite", runs: "vite" };
+        case "webpack":
+            return sub === "serve"
+                ? { tool: "webpack-dev-server", runs: "webpack serve" }
+                : undefined;
+        case "webpack-dev-server":
+            return { tool: "webpack-dev-server", runs: "webpack-dev-server" };
+        case "parcel":
+            return sub === "build" ? undefined : { tool: "parcel", runs: "parcel" };
+        case "astro":
+            return sub === "dev" ? { tool: "astro", runs: "astro dev" } : undefined;
+        case "react-scripts":
+            return sub === "start"
+                ? { tool: "react-scripts", runs: "react-scripts start" }
+                : undefined;
+        case "http-server":
+        case "serve":
+        case "live-server":
+            return { tool: head, runs: head };
+        default:
+            return undefined;
+    }
+}
+function buildTool(c) {
+    const [head] = c.words;
+    const sub = subcommand(c.words);
+    if (head === "webpack" || head === "webpack-cli")
+        return sub === "serve" ? undefined : "webpack";
+    if (head === "vite" && sub === "build")
+        return "vite";
+    if (head === "parcel" && sub === "build")
+        return "parcel";
+    if (head === "react-scripts" && sub === "build")
+        return "react-scripts";
+    if (head === "astro" && sub === "build")
+        return "astro";
+    return undefined;
+}
+/** The value of `--name v`, `--name=v`, or a short alias `-x v`. */
+function optionValue(words, long, short) {
+    for (let i = 1; i < words.length; i++) {
+        const w = words[i];
+        if (w === long || (short !== undefined && w === short))
+            return words[i + 1];
+        if (w.startsWith(`${long}=`))
+            return w.slice(long.length + 1);
+    }
+    return undefined;
+}
+function shortBody(body) {
+    const flat = body.replace(/\s+/g, " ").trim();
+    return flat.length > 48 ? `${flat.slice(0, 47)}…` : flat;
+}
+const REGEX_PRECEDERS = new Set([
+    "(",
+    ",",
+    "=",
+    ":",
+    "[",
+    "!",
+    "&",
+    "|",
+    "?",
+    "{",
+    "}",
+    ";",
+    "+",
+    "-",
+    "*",
+    "%",
+    "<",
+    ">",
+    "~",
+    "^",
+]);
+/** A JS/TS tokenizer just good enough to find object keys. One pass, no backtracking. */
+export function tokenize(src) {
+    const out = [];
+    let i = 0;
+    const n = src.length;
+    const isIdStart = (c) => /[A-Za-z_$]/.test(c);
+    const isId = (c) => /[A-Za-z0-9_$]/.test(c);
+    const prevAllowsRegex = () => {
+        const prev = out[out.length - 1];
+        if (!prev)
+            return true;
+        if (prev.t === "p")
+            return REGEX_PRECEDERS.has(prev.v);
+        return prev.t === "ident" && (prev.v === "return" || prev.v === "typeof");
+    };
+    while (i < n) {
+        const c = src[i];
+        if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+            i++;
+            continue;
+        }
+        if (c === "/" && src[i + 1] === "/") {
+            const nl = src.indexOf("\n", i);
+            i = nl === -1 ? n : nl + 1;
+            continue;
+        }
+        if (c === "/" && src[i + 1] === "*") {
+            const end = src.indexOf("*/", i + 2);
+            i = end === -1 ? n : end + 2;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            let j = i + 1;
+            let v = "";
+            while (j < n && src[j] !== c && src[j] !== "\n") {
+                if (src[j] === "\\" && j + 1 < n) {
+                    v += src[j + 1];
+                    j += 2;
+                    continue;
+                }
+                v += src[j];
+                j++;
+            }
+            out.push({ t: "str", v });
+            i = j + 1;
+            continue;
+        }
+        if (c === "`") {
+            let j = i + 1;
+            let v = "";
+            let interpolated = false;
+            while (j < n && src[j] !== "`") {
+                if (src[j] === "\\" && j + 1 < n) {
+                    v += src[j + 1];
+                    j += 2;
+                    continue;
+                }
+                if (src[j] === "$" && src[j + 1] === "{")
+                    interpolated = true;
+                v += src[j];
+                j++;
+            }
+            out.push({ t: "tpl", v, interpolated });
+            i = j + 1;
+            continue;
+        }
+        if (c === "/" && prevAllowsRegex()) {
+            let j = i + 1;
+            let inClass = false;
+            while (j < n && src[j] !== "\n") {
+                const d = src[j];
+                if (d === "\\") {
+                    j += 2;
+                    continue;
+                }
+                if (d === "[")
+                    inClass = true;
+                else if (d === "]")
+                    inClass = false;
+                else if (d === "/" && !inClass)
+                    break;
+                j++;
+            }
+            j++;
+            while (j < n && /[a-z]/.test(src[j]))
+                j++;
+            out.push({ t: "re" });
+            i = j;
+            continue;
+        }
+        if (isIdStart(c)) {
+            let j = i + 1;
+            while (j < n && isId(src[j]))
+                j++;
+            out.push({ t: "ident", v: src.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if (/[0-9]/.test(c)) {
+            let j = i + 1;
+            while (j < n && /[0-9A-Za-z_.]/.test(src[j]))
+                j++;
+            out.push({ t: "num", v: src.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if (c === "." && src[i + 1] === "." && src[i + 2] === ".") {
+            out.push({ t: "p", v: "..." });
+            i += 3;
+            continue;
+        }
+        out.push({ t: "p", v: c });
+        i++;
+    }
+    return out;
+}
+const MAX_KEY_DEPTH = 4;
+/**
+ * Every object key whose objects nest DIRECTLY from an anonymous root, keyed by
+ * its dotted path (`devServer.port`, `build.outDir`). A key inside a function
+ * body, an array, a call argument that is not the config itself, or any value
+ * expression is not recorded: its value is judged as "an expression", which
+ * detection reports as not found.
+ */
+export function scanConfigKeys(src) {
+    const toks = tokenize(src);
+    const keys = new Map();
+    const record = (p, v) => {
+        const k = p.join(".");
+        const list = keys.get(k);
+        if (list)
+            list.push(v);
+        else
+            keys.set(k, [v]);
+    };
+    const stack = [];
+    // Frames opened by a key. Counted rather than searched, so nesting stays linear.
+    let named = 0;
+    const closeFor = { "}": "{", "]": "[", ")": "(" };
+    let i = 0;
+    while (i < toks.length) {
+        const tok = toks[i];
+        const top = stack[stack.length - 1];
+        if (tok.t === "p" && (tok.v === "{" || tok.v === "[" || tok.v === "(")) {
+            // An anonymous opener keeps the key path only while every frame so far is
+            // anonymous: that is the config object itself, however it is exported.
+            stack.push({
+                open: tok.v,
+                key: null,
+                spread: false,
+                path: tok.v === "{" && named === 0 ? [] : null,
+            });
+            i++;
+            continue;
+        }
+        if (tok.t === "p" && closeFor[tok.v]) {
+            const frame = stack.pop();
+            if (frame && frame.key !== null) {
+                named--;
+                if (frame.path)
+                    record(frame.path, { kind: "object", spread: frame.spread });
+            }
+            i++;
+            continue;
+        }
+        const inObject = top?.open === "{" && top.path !== null;
+        if (inObject && tok.t === "p" && tok.v === "...") {
+            top.spread = true;
+            i++;
+            continue;
+        }
+        const prev = toks[i - 1];
+        const atKeyPosition = inObject &&
+            prev !== undefined &&
+            prev.t === "p" &&
+            (prev.v === "{" || prev.v === ",");
+        if (atKeyPosition && (tok.t === "ident" || tok.t === "str")) {
+            const next = toks[i + 1];
+            const keyPath = [...top.path, tok.v];
+            if (next?.t === "p" && next.v === ":") {
+                const after = toks[i + 2];
+                if (after?.t === "p" && after.v === "{") {
+                    // Paths deeper than any key detection looks up are not tracked, which
+                    // also keeps the copy above constant-sized on hostile nesting.
+                    stack.push({
+                        open: "{",
+                        key: tok.v,
+                        spread: false,
+                        path: keyPath.length <= MAX_KEY_DEPTH ? keyPath : null,
+                    });
+                    named++;
+                    i += 3;
+                    continue;
+                }
+                const end = valueEnd(toks, i + 2);
+                record(keyPath, classify(toks.slice(i + 2, end)));
+                i = end;
+                continue;
+            }
+            if (next?.t === "p" && (next.v === "," || next.v === "}")) {
+                // Shorthand `{ port }`: present, from a variable.
+                record(keyPath, { kind: "expr" });
+                i++;
+                continue;
+            }
+        }
+        i++;
+    }
+    return keys;
+}
+/** Index just past a value: the next `,` or closer at depth zero. */
+function valueEnd(toks, from) {
+    let depth = 0;
+    for (let j = from; j < toks.length; j++) {
+        const t = toks[j];
+        if (t.t !== "p")
+            continue;
+        if (t.v === "{" || t.v === "[" || t.v === "(")
+            depth++;
+        else if (t.v === "}" || t.v === "]" || t.v === ")") {
+            if (depth === 0)
+                return j;
+            depth--;
+        }
+        else if (t.v === "," && depth === 0)
+            return j;
+    }
+    return toks.length;
+}
+function classify(v) {
+    if (v.length === 1) {
+        const t = v[0];
+        if (t.t === "num" && /^[0-9]+$/.test(t.v))
+            return { kind: "number", value: Number(t.v) };
+        if (t.t === "str")
+            return { kind: "string", value: t.v };
+        if (t.t === "tpl" && !t.interpolated)
+            return { kind: "string", value: t.v };
+        return { kind: "expr" };
+    }
+    // path.resolve(__dirname, 'a', "b") / path.join(...)
+    const [a, dot, fn, open] = v;
+    const last = v[v.length - 1];
+    if (a?.t === "ident" &&
+        a.v === "path" &&
+        dot?.t === "p" &&
+        dot.v === "." &&
+        fn?.t === "ident" &&
+        (fn.v === "resolve" || fn.v === "join") &&
+        open?.t === "p" &&
+        open.v === "(" &&
+        last?.t === "p" &&
+        last.v === ")") {
+        const inner = v.slice(4, -1);
+        const args = [[]];
+        for (const t of inner) {
+            if (t.t === "p" && t.v === ",")
+                args.push([]);
+            else
+                args[args.length - 1].push(t);
+        }
+        if (args.length > 1 && args[args.length - 1].length === 0)
+            args.pop();
+        const [first, ...rest] = args;
+        if (first?.length !== 1 || first[0].t !== "ident" || first[0].v !== "__dirname") {
+            return { kind: "expr" };
+        }
+        const literals = [];
+        for (const arg of rest) {
+            const t = arg[0];
+            if (arg.length !== 1 ||
+                !t ||
+                !(t.t === "str" || (t.t === "tpl" && !t.interpolated))) {
+                return { kind: "expr" };
+            }
+            literals.push(t.v);
+        }
+        return { kind: "dirname", fn: fn.v, args: literals };
+    }
+    return { kind: "expr" };
+}
+// ---- detection -----------------------------------------------------------------
+const ROOT = "/__vincentt_root__";
+/** A config-relative literal joined against the config's own directory, as repo-relative. */
+function insideRepo(joined) {
+    const rel = path.posix.relative(ROOT, joined);
+    if (rel === "")
+        return { ok: false, why: "root" };
+    if (rel.startsWith("..") || path.posix.isAbsolute(rel))
+        return { ok: false, why: "outside" };
+    return { ok: true, rel };
+}
+function resolveDirname(configDir, v) {
+    const base = path.posix.join(ROOT, configDir);
+    return v.fn === "join"
+        ? path.posix.join(base, ...v.args)
+        : path.posix.resolve(base, ...v.args);
+}
+/** One key's single meaning: absent, a value, or ambiguous. */
+function lookup(cfg, key) {
+    const parts = key.split(".");
+    for (let k = 1; k < parts.length; k++) {
+        const parent = cfg.keys.get(parts.slice(0, k).join("."));
+        if (parent && parent.some((p) => p.kind !== "object"))
+            return "ambiguous";
+    }
+    const values = cfg.keys.get(key);
+    if (!values || values.length === 0) {
+        const parent = cfg.keys.get(parts.slice(0, -1).join("."));
+        if (parent && parent.some((p) => p.kind === "object" && p.spread))
+            return "ambiguous";
+        return "absent";
+    }
+    const first = JSON.stringify(values[0]);
+    if (values.some((v) => JSON.stringify(v) !== first))
+        return "ambiguous";
+    return values[0];
+}
+function pmOf(lockfile) {
+    if (lockfile === "pnpm-lock.yaml")
+        return "pnpm";
+    if (lockfile === "yarn.lock")
+        return "yarn";
+    if (lockfile === "bun.lockb" || lockfile === "bun.lock")
+        return "bun";
+    return "npm";
+}
+function allMissing(read, reason, pm) {
+    return {
+        read,
+        fields: {},
+        pm,
+        missing: ["dev.command", "dev.port", "build.command", "build.output"].map((field) => ({
+            field,
+            reason,
+        })),
+    };
+}
+export async function detect(probes) {
+    const read = ["package.json"];
+    let lockfile;
+    for (const name of [
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "bun.lockb",
+        "bun.lock",
+        "package-lock.json",
+    ]) {
+        if (await probes.exists(name)) {
+            lockfile = name;
+            break;
+        }
+    }
+    if (lockfile)
+        read.push(lockfile);
+    const pm = pmOf(lockfile);
+    const pkgRead = await probes.readText("package.json");
+    if ("missing" in pkgRead || "notFile" in pkgRead) {
+        return allMissing(read, "there is no package.json", pm);
+    }
+    if ("tooLarge" in pkgRead) {
+        return allMissing(read, "file too large to read (package.json, over 256 KB)", pm);
+    }
+    let scripts = {};
+    try {
+        const pkg = JSON.parse(pkgRead.text);
+        const raw = pkg?.scripts;
+        if (typeof raw === "object" && raw !== null) {
+            scripts = Object.fromEntries(Object.entries(raw).filter((e) => typeof e[1] === "string"));
+        }
+    }
+    catch {
+        return allMissing(read, "package.json is not valid JSON", pm);
+    }
+    const fields = {};
+    const missing = [];
+    const run = (script) => `${pm} run ${script}`;
+    // The ONE config read, shared by the port and the output rules.
+    let config;
+    const readConfig = async (script, words, candidates) => {
+        const named = optionValue(words, "--config", "-c");
+        let rel;
+        if (named !== undefined) {
+            const norm = path.posix.normalize(named);
+            if (path.posix.isAbsolute(norm) || norm.split("/").includes("..")) {
+                return {
+                    refused: `script "${script}" uses a config outside this project, which Vincentt does not read`,
+                };
+            }
+            rel = norm;
+        }
+        else {
+            for (const c of candidates) {
+                if (await probes.exists(c)) {
+                    rel = c;
+                    break;
+                }
+            }
+            if (rel === undefined)
+                return { absent: true };
+        }
+        if (config) {
+            return config.rel === rel
+                ? config
+                : {
+                    refused: `script "${script}" uses ${rel}, a second config Vincentt did not read`,
+                };
+        }
+        const r = await probes.readText(rel);
+        if ("text" in r)
+            read.push(rel);
+        if ("missing" in r)
+            config = { rel, unreadable: `${rel} is not there` };
+        else if ("tooLarge" in r)
+            config = { rel, unreadable: `file too large to read (${rel}, over 256 KB)` };
+        else if ("notFile" in r)
+            config = { rel, unreadable: `${rel} is not a regular file, so it was not read` };
+        else
+            config = { rel, keys: scanConfigKeys(r.text) };
+        return config;
+    };
+    // ---- dev.command ----
+    let chosen;
+    let serverRun;
+    for (const name of CANDIDATES) {
+        const body = scripts[name];
+        if (body === undefined)
+            continue;
+        for (const c of splitScript(body)) {
+            const marker = serverMarker(c);
+            if (marker) {
+                serverRun ??= `script "${name}" runs ${marker}, which needs a server. Vincentt hosts static builds only.`;
+            }
+        }
+    }
+    if (serverRun) {
+        missing.push({ field: "dev.command", reason: serverRun });
+    }
+    else {
+        outer: for (const name of CANDIDATES) {
+            const body = scripts[name];
+            if (body === undefined)
+                continue;
+            for (const c of splitScript(body)) {
+                const tool = devTool(c);
+                if (tool) {
+                    chosen = { script: name, command: c, ...tool };
+                    break outer;
+                }
+            }
+        }
+        if (chosen) {
+            fields["dev.command"] = {
+                value: run(chosen.script),
+                evidence: `script "${chosen.script}" runs ${chosen.runs}`,
+            };
+        }
+        else {
+            const first = CANDIDATES.find((n) => scripts[n] !== undefined);
+            missing.push({
+                field: "dev.command",
+                reason: first === undefined
+                    ? "package.json has no dev, serve, start or develop script"
+                    : `script "${first}" runs ${shortBody(scripts[first])}, which Vincentt can't read.`,
+            });
+        }
+    }
+    // ---- dev.port ----
+    if (!chosen) {
+        missing.push({
+            field: "dev.port",
+            reason: "no dev command was found to read a port from",
+        });
+    }
+    else {
+        const flagged = optionValue(chosen.command.words, "--port") ??
+            optionValue(chosen.command.words, "-p");
+        if (flagged !== undefined) {
+            const n = /^[0-9]+$/.test(flagged) ? Number(flagged) : Number.NaN;
+            if (Number.isInteger(n) && n >= 1 && n <= 65535) {
+                fields["dev.port"] = {
+                    value: n,
+                    evidence: `script "${chosen.script}" passes --port ${n}`,
+                };
+            }
+            else {
+                missing.push({
+                    field: "dev.port",
+                    reason: `script "${chosen.script}" sets --port from a variable`,
+                });
+            }
+        }
+        else if (chosen.tool === "vite" || chosen.tool === "webpack-dev-server") {
+            const key = chosen.tool === "vite" ? "server.port" : "devServer.port";
+            const cfg = await readConfig(chosen.script, chosen.command.words, chosen.tool === "vite" ? VITE_CONFIGS : WEBPACK_CONFIGS);
+            const fallback = () => {
+                fields["dev.port"] = {
+                    value: DEV_DEFAULT_PORT[chosen.tool],
+                    evidence: `default for ${chosen.tool}`,
+                };
+            };
+            if ("absent" in cfg)
+                fallback();
+            else if ("refused" in cfg)
+                missing.push({ field: "dev.port", reason: cfg.refused });
+            else if (cfg.unreadable)
+                missing.push({ field: "dev.port", reason: cfg.unreadable });
+            else {
+                const v = lookup(cfg, key);
+                if (v === "absent")
+                    fallback();
+                else if (v !== "ambiguous" &&
+                    v.kind === "number" &&
+                    v.value >= 1 &&
+                    v.value <= 65535) {
+                    fields["dev.port"] = { value: v.value, evidence: `${cfg.rel} ${key}` };
+                }
+                else {
+                    missing.push({
+                        field: "dev.port",
+                        reason: `${cfg.rel} sets ${key} from a variable`,
+                    });
+                }
+            }
+        }
+        else {
+            fields["dev.port"] = {
+                value: DEV_DEFAULT_PORT[chosen.tool],
+                evidence: `default for ${chosen.tool}`,
+            };
+        }
+    }
+    // ---- build.command ----
+    const buildBody = scripts.build;
+    const buildCommands = buildBody === undefined ? [] : splitScript(buildBody);
+    if (buildBody === undefined) {
+        missing.push({ field: "build.command", reason: "package.json has no build script" });
+    }
+    else if (buildCommands.some((c) => devTool(c) !== undefined || serverMarker(c) !== undefined)) {
+        missing.push({ field: "build.command", reason: `script "build" runs a dev server` });
+    }
+    else {
+        fields["build.command"] = { value: run("build"), evidence: `script "build"` };
+    }
+    // ---- build.output ----
+    if (buildBody === undefined) {
+        missing.push({ field: "build.output", reason: "package.json has no build script" });
+    }
+    else {
+        let tool;
+        let cmd;
+        for (const c of buildCommands) {
+            tool = buildTool(c);
+            if (tool) {
+                cmd = c;
+                break;
+            }
+        }
+        const put = (rel, evidence) => {
+            fields["build.output"] = { value: rel, evidence };
+        };
+        const miss = (reason) => {
+            missing.push({ field: "build.output", reason });
+        };
+        const judge = (joined, evidence, what) => {
+            const inside = insideRepo(joined);
+            if (inside.ok)
+                put(inside.rel, evidence);
+            else
+                miss(inside.why === "root"
+                    ? `${what} is this project's own folder`
+                    : `${what} is outside this project`);
+        };
+        if (!tool || !cmd) {
+            miss(`script "build" runs ${shortBody(buildBody)}, which Vincentt can't read.`);
+        }
+        else if (tool === "parcel") {
+            const dir = optionValue(cmd.words, "--dist-dir");
+            if (dir === undefined)
+                put("dist", "default for parcel");
+            else
+                judge(path.posix.join(ROOT, dir), `script "build" passes --dist-dir ${dir}`, `--dist-dir ${dir}`);
+        }
+        else if (tool === "webpack" || tool === "vite") {
+            const cfg = await readConfig("build", cmd.words, tool === "vite" ? VITE_CONFIGS : WEBPACK_CONFIGS);
+            const def = () => put(BUILD_DEFAULT_OUTPUT[tool], `default for ${tool}`);
+            if ("absent" in cfg)
+                def();
+            else if ("refused" in cfg)
+                miss(cfg.refused);
+            else if (cfg.unreadable)
+                miss(cfg.unreadable);
+            else if (tool === "webpack") {
+                const v = lookup(cfg, "output.path");
+                const configDir = path.posix.dirname(cfg.rel);
+                if (v === "absent")
+                    def();
+                else if (v !== "ambiguous" && v.kind === "dirname") {
+                    judge(resolveDirname(configDir, v), `${cfg.rel} output.path`, `${cfg.rel} output.path`);
+                }
+                else
+                    miss(`${cfg.rel} sets output.path from a variable`);
+            }
+            else {
+                const configDir = path.posix.dirname(cfg.rel);
+                let base = path.posix.join(ROOT, configDir);
+                const root = lookup(cfg, "root");
+                let rootOk = true;
+                if (root !== "absent") {
+                    if (root !== "ambiguous" && root.kind === "string")
+                        base = path.posix.resolve(base, root.value);
+                    else if (root !== "ambiguous" && root.kind === "dirname")
+                        base = resolveDirname(configDir, root);
+                    else {
+                        rootOk = false;
+                        miss(`${cfg.rel} sets root from a variable`);
+                    }
+                }
+                if (rootOk) {
+                    const v = lookup(cfg, "build.outDir");
+                    if (v === "absent") {
+                        judge(path.posix.join(base, "dist"), "default for vite", "vite's default output");
+                    }
+                    else if (v !== "ambiguous" && v.kind === "string") {
+                        judge(path.posix.resolve(base, v.value), `${cfg.rel} build.outDir`, `${cfg.rel} build.outDir`);
+                    }
+                    else if (v !== "ambiguous" && v.kind === "dirname") {
+                        judge(resolveDirname(configDir, v), `${cfg.rel} build.outDir`, `${cfg.rel} build.outDir`);
+                    }
+                    else
+                        miss(`${cfg.rel} sets build.outDir from a variable`);
+                }
+            }
+        }
+        else {
+            put(BUILD_DEFAULT_OUTPUT[tool], `default for ${tool}`);
+        }
+    }
+    return { read, fields, missing, pm };
+}