visualproof 0.3.0 → 0.4.0

package/dist/server/usage.js

@@ -18,6 +18,7 @@
 // again. A module that cannot be elaborated is reported and keeps the text-based context and no
 // notation edges; the others are not held back by it.
 import { spawn } from "node:child_process";
+import { childEnv, DETACH, grouped } from "./children.js";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -62,7 +63,8 @@ export function traceOptions(p, module) {
  *  Asked once per pass, and every worker started with it, rather than through `lake env` each. */
 function lakeEnv(root) {
     return new Promise((resolveP, reject) => {
-        const child = spawn("lake", ["env", "env", "-0"], { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
+        // the server's own variables are not the workers': they are given this environment
+        const child = grouped(spawn("lake", ["env", "env", "-0"], { cwd: root, stdio: ["ignore", "pipe", "pipe"], detached: DETACH, env: childEnv() }));
         const out = [];
         let err = "";
         child.stdout.on("data", (b) => out.push(b));

package/dist/server/version.js

@@ -0,0 +1,183 @@
+// Versions: this package's own, and the ranges package.json's `engines` writes, as `visualproof
+// doctor` checks Node against them and a server checks a release it would take (server/updates.ts).
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let own = null;
+/** The version of this package: read once, as the process started it, so that a package installed
+ *  over it meanwhile does not change what it says it runs (UpdateSpec decision 5). */
+export function packageVersion() {
+    return (own ??= JSON.parse(readFileSync(join(import.meta.dirname, "..", "..", "package.json"), "utf8")).version);
+}
+export function parseVersion(v) {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(v);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+export function cmp(a, b) {
+    for (let i = 0; i < 3; i++)
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    return 0;
+}
+/** npm's order: by the numbers, then a prerelease before its release, then the prerelease
+ *  identifiers one by one (numbers before words, numbers by value, words as text), fewer first. */
+function order(a, b) {
+    const c = cmp(a.v, b.v);
+    if (c)
+        return c;
+    if (!a.pre.length || !b.pre.length)
+        return (b.pre.length ? 1 : 0) - (a.pre.length ? 1 : 0);
+    for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+        const x = a.pre[i], y = b.pre[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        if (x === y)
+            continue;
+        if (typeof x === "number" && typeof y === "number")
+            return x - y;
+        if (typeof x === "number")
+            return -1;
+        if (typeof y === "number")
+            return 1;
+        return x < y ? -1 : 1;
+    }
+    return 0;
+}
+/** Prerelease identifiers, as npm takes them: none empty, a number without a leading zero. */
+function prerelease(text) {
+    if (text === undefined)
+        return [];
+    const ids = text.split(".");
+    if (ids.some((id) => !/^[0-9A-Za-z-]+$/.test(id) || /^0\d+$/.test(id)))
+        return null;
+    return ids.map((id) => (/^\d+$/.test(id) ? Number(id) : id));
+}
+const NUM = "0|[1-9]\\d*";
+const PART = `(${NUM}|[xX*])`;
+const PARTIAL = new RegExp(`^v?${PART}(?:\\.${PART})?(?:\\.${PART})?(?:-([^+]+))?(?:\\+[0-9A-Za-z.-]+)?$`);
+function partial(text) {
+    const m = PARTIAL.exec(text);
+    if (!m)
+        return null;
+    const part = (x) => (x === undefined || /^[xX*]$/.test(x) ? null : Number(x));
+    const p = [part(m[1]), part(m[2]), part(m[3])];
+    // a wildcard leaves the parts after it wild (`1.x.3` is `1.x`)
+    for (let i = 1; i < 3; i++)
+        if (p[i - 1] === null)
+            p[i] = null;
+    const pre = prerelease(m[4]);
+    if (pre === null || (pre.length && p[2] === null))
+        return null;
+    return { p, pre };
+}
+/** the least version a partial one covers: a version written whole is itself; one with a wild part
+ *  (`22`, `22.18.x`) starts at its first prerelease (`22.0.0-0`), as npm's includePrerelease has it */
+const lower = (x) => ({ v: [x.p[0] ?? 0, x.p[1] ?? 0, x.p[2] ?? 0], pre: x.pre.length ? x.pre : x.p[2] === null ? [0] : [] });
+/** the first version past what a partial version covers (`1.2` covers 1.2.x: up to 1.3.0's first
+ *  prerelease, 1.3.0-0); null for `*` */
+function past(x) {
+    const [a, b, c] = x.p;
+    if (a === null)
+        return null;
+    if (b === null)
+        return { v: [a + 1, 0, 0], pre: [0] };
+    if (c === null)
+        return { v: [a, b + 1, 0], pre: [0] };
+    return { v: [a, b, c + 1], pre: [0] };
+}
+/** One comparator as npm reads it (node-semver's desugaring), as bounds; null where it is no comparator. */
+function bounds(op, text) {
+    const x = partial(text);
+    if (!x)
+        return null;
+    const lo = lower(x);
+    const hi = past(x);
+    const wild = x.p[2] === null;
+    switch (op) {
+        case "":
+        case "=":
+            // one version, or an x-range
+            return !wild ? [["=", lo]] : hi ? [[">=", lo], ["<", hi]] : [];
+        case ">=":
+            return [[">=", lo]];
+        case ">":
+            // past what it covers: `>1.2` is `>=1.3.0`; `>*`, nothing
+            return !wild ? [[">", lo]] : hi ? [[">=", hi]] : [["<", { v: [0, 0, 0], pre: [0] }]];
+        case "<":
+            return [["<", lo]];
+        case "<=":
+            return !wild ? [["<=", lo]] : hi ? [["<", hi]] : [];
+        case "~":
+        case "~>": {
+            // patches of the minor given (of the major, where only it is)
+            const [a, b] = x.p;
+            if (a === null)
+                return [];
+            return [[">=", lo], ["<", { v: b === null ? [a + 1, 0, 0] : [a, b + 1, 0], pre: [0] }]];
+        }
+        case "^": {
+            // the same leftmost part that is not zero
+            const [a, b, c] = x.p;
+            if (a === null)
+                return [];
+            const top = a > 0 || b === null ? [a + 1, 0, 0] : b > 0 || c === null ? [0, b + 1, 0] : [0, 0, c + 1];
+            return [[">=", lo], ["<", { v: top, pre: [0] }]];
+        }
+    }
+    return null;
+}
+/** an operator, spaces, a version: `>= 22.0.0` as `>=22.0.0`; never `> = 22` */
+const COMPARATOR = /^(<=|>=|<|>|=|\^|~>|~)?\s*([^\s<>=^~]+)\s*/;
+/** One alternative of a range (no `||`): a hyphen range, or comparators joined by spaces; null where
+ *  npm could not read it. */
+function alternative(text) {
+    const t = text.trim();
+    if (!t)
+        return [];
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(t);
+    if (hyphen) {
+        const a = partial(hyphen[1]);
+        const b = partial(hyphen[2]);
+        if (!a || !b)
+            return null;
+        const top = b.p[2] === null ? past(b) : null;
+        return [[">=", lower(a)], ...(b.p[0] === null ? [] : top ? [["<", top]] : [["<=", lower(b)]])];
+    }
+    const out = [];
+    for (let rest = t; rest;) {
+        const m = COMPARATOR.exec(rest);
+        if (!m)
+            return null;
+        const b = bounds(m[1] ?? "", m[2]);
+        if (!b)
+            return null;
+        out.push(...b);
+        rest = rest.slice(m[0].length);
+    }
+    return out;
+}
+/** Whether `version` meets a range as package.json's `engines` writes one, as npm checks a Node
+ *  against engines (npm-install-checks: semver with includePrerelease): alternatives joined by
+ *  `||`, each a hyphen range (`22.18.0 - 24`) or comparators joined by spaces — `>=`, `>`, `<=`,
+ *  `<`, `=`, `^`, `~`, a version, an x-range (`22`, `22.x`, `22.18.*`, `*`) — an operator apart from
+ *  its version or not. An empty range, or one of spaces alone, is any version; one npm could not
+ *  read, in any of its alternatives, none. Prereleases in npm's order — 22.18.0 is past
+ *  22.18.0-rc.1, so `<=22.18.0-rc.1` excludes it — and a prerelease Node is taken as any version
+ *  (`24.0.0-rc.1` meets `>=22`; `22.0.0-rc.1` meets `22`, which starts at `22.0.0-0`). */
+export function satisfies(version, range) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(version.trim());
+    const pre = m ? prerelease(m[4]) : null;
+    if (!m || pre === null)
+        return false;
+    const v = { v: [Number(m[1]), Number(m[2]), Number(m[3])], pre };
+    if (range === undefined || range === null || !range.trim())
+        return true;
+    const alts = range.split("||").map(alternative);
+    if (alts.some((a) => a === null))
+        return false;
+    return alts.some((bs) => bs.every(([op, w]) => {
+        const c = order(v, w);
+        return op === ">=" ? c >= 0 : op === ">" ? c > 0 : op === "<=" ? c <= 0 : op === "<" ? c < 0 : c === 0;
+    }));
+}

package/dist/shared/timeline.js

@@ -15,6 +15,11 @@ import { SITE_BODY, SITE_STMT } from "./graph.js";
 import { byName } from "./review.js";
 /** at most this many names are listed in one event; the counts stay exact */
 export const NAMES_LISTED = 100;
+/** An event as a read-only reader and an agent are told it (UpdateSpec decision 11): a version set
+ *  aside without why (what this machine and its servers said of it). */
+export function withoutReasons(e) {
+    return e.kind === "tool" && e.setAside ? { ...e, setAside: { version: e.setAside.version } } : e;
+}
 /** The graph as the TCB needs it: names, content hashes, statement and body edges. */
 export class TcbIndex {
     names;