visualproof 0.0.0-stage → 0.2.0

package/dist/shared/ring.js

@@ -0,0 +1,366 @@
+// The ring around a board (AttachmentSpec decision 16, the owner's of 2026-10-11): a circle just
+// outside every cluster of the board, at the board's own extent, where the notes that have no
+// cluster on the board are — at the top level of its clustering, where someone let one go, or with
+// no place under that clustering yet, at the angle of what it is about. Notes on the ring keep their
+// order and a fixed gap on the screen between them; where one ring cannot hold them all so at the
+// zoom, the rest go on rings further out, concentric with it, a fixed step apart on the screen (the
+// owner's decision of 2026-10-11). This file is the geometry, the same in the pages and the tests:
+// angles are kept in degrees clockwise from the top, and worked in radians in the board's
+// coordinates, whose y grows downwards as the screen's does. Which ring a note is on is the layout's,
+// never kept: its place is its angle.
+import { noteLook } from "./sticky.js";
+/** How near the middle of the board, as a fraction of the ring's radius, the centre of what a note
+ *  is about points nowhere: the note goes in the order notes were written instead. */
+export const RING_NEAR = 0.2;
+/** how far outside the farthest circle the ring is, as a fraction of its radius, and at least */
+const RING_OUT = 0.03;
+const RING_OUT_MIN = 12;
+/** the room left between two notes on a ring, in pixels of the screen, whatever the zoom */
+export const RING_GAP_PX = 6;
+/** how much farther out each ring is than the one inside it, in pixels of the screen: an icon's
+ *  24 px and 8 px between two icons at one angle */
+export const RING_STEP_PX = 32;
+/** the farthest a note is drawn from the angle it wants, along its ring, in radians: an eighth of
+ *  the turn, so that it still points toward what it is about; where its angle is too crowded to hold
+ *  it so near, it goes on a ring further out */
+export const RING_REACH = Math.PI / 4;
+/** The ring around discs (the board's top-level circles, and its top-level declarations as small
+ *  ones): centred on the middle of what they cover, just outside the farthest; null for nothing. */
+export function ringAround(discs) {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    const all = [];
+    for (const d of discs) {
+        all.push(d);
+        x0 = Math.min(x0, d.x - d.r);
+        y0 = Math.min(y0, d.y - d.r);
+        x1 = Math.max(x1, d.x + d.r);
+        y1 = Math.max(y1, d.y + d.r);
+    }
+    if (!all.length)
+        return null;
+    const x = (x0 + x1) / 2, y = (y0 + y1) / 2;
+    let r = 0;
+    for (const d of all)
+        r = Math.max(r, Math.hypot(d.x - x, d.y - y) + d.r);
+    return { x, y, r: r + Math.max(RING_OUT_MIN, r * RING_OUT) };
+}
+/** Degrees clockwise from the top as an angle in the board's coordinates, and back. */
+export const ringRadians = (deg) => ((deg - 90) * Math.PI) / 180;
+export const ringDegrees = (rad) => {
+    const d = (rad * 180) / Math.PI + 90;
+    return Math.round((((d % 360) + 360) % 360) * 10) / 10;
+};
+/** The angle of a spot of the board seen from the ring's centre, in degrees clockwise from the top:
+ *  where a note let go at the top level goes on the ring. */
+export const angleOf = (ring, x, y) => ringDegrees(Math.atan2(y - ring.y, x - ring.x));
+/** The angle, in radians, of what a note is about — the centre of its declarations on the board —
+ *  or null where that centre is too near the middle to point anywhere (RING_NEAR). */
+export function aboutAngle(ring, centre) {
+    if (!centre)
+        return null;
+    const dx = centre[0] - ring.x, dy = centre[1] - ring.y;
+    return Math.hypot(dx, dy) < RING_NEAR * ring.r ? null : Math.atan2(dy, dx);
+}
+const TOP = -Math.PI / 2;
+const TURN = 2 * Math.PI;
+/** How much of a ring a note takes at angle a, along the ring: its icon's diameter, or, where its
+ *  card shows (`cards`), the box's extent across the ray. */
+function across(it, a, cards) {
+    if (!it.open || !cards)
+        return it.icon;
+    const [w, h] = it.open;
+    return Math.max(it.icon, Math.abs(w * Math.sin(a)) + Math.abs(h * Math.cos(a)));
+}
+/** Writing order, oldest first, then the order given: which note a ring keeps first. */
+const written = (items) => (a, b) => (items[a].order < items[b].order ? -1 : items[a].order > items[b].order ? 1 : a - b);
+/** The radius on the screen of ring `j` when the innermost is `rpx` pixels: each RING_STEP_PX
+ *  farther out than the one inside it. */
+export const ringPx = (rpx, j) => Math.max(rpx, 1) + j * RING_STEP_PX;
+/** The positions along a circle `c` pixels round, in pixels from the top, of notes that want
+ *  positions `u` (in their order round it, unwrapped from the top) and must keep `g[i]` pixels
+ *  between note i and the next (the last's to the first, round the top): each moved as little as
+ *  the gaps need, their order kept — the least squares of their moves, by isotonic regression of
+ *  the positions less the gaps before them, its spread held within what the circle leaves. Null
+ *  where the gaps alone go round more than the circle. */
+function spreadOn(u, g, c) {
+    const n = u.length;
+    if (n === 1)
+        return [u[0]];
+    let total = 0;
+    for (const x of g)
+        total += x;
+    const slack = c - total;
+    if (slack < -1e-9)
+        return null;
+    const before = new Array(n).fill(0);
+    for (let i = 1; i < n; i++)
+        before[i] = before[i - 1] + g[i - 1];
+    const z = u.map((x, i) => x - before[i]);
+    // pool adjacent violators: blocks of equal value, merged while one is above the next
+    const val = [], wt = [];
+    for (const x of z) {
+        val.push(x);
+        wt.push(1);
+        while (val.length > 1 && val[val.length - 2] > val[val.length - 1]) {
+            const w = wt[wt.length - 2] + wt[wt.length - 1];
+            const v = (val[val.length - 2] * wt[wt.length - 2] + val[val.length - 1] * wt[wt.length - 1]) / w;
+            val.splice(-2, 2, v);
+            wt.splice(-2, 2, w);
+        }
+    }
+    let y = [];
+    val.forEach((v, k) => {
+        for (let j = 0; j < wt[k]; j++)
+            y.push(v);
+    });
+    // the last must stay clear of the first round the top: the values are held within a window as
+    // wide as the slack, placed where the squares are least — where their slope, rising with where
+    // the window starts, is nought, found by halving
+    if (y[n - 1] - y[0] > slack) {
+        const slope = (a) => y.reduce((s, v, i) => s + (v < a ? a - z[i] : v > a + slack ? a + slack - z[i] : 0), 0);
+        let lo = y[0], hi = y[n - 1] - slack;
+        for (let k = 0; k < 48; k++) {
+            const mid = (lo + hi) / 2;
+            if (slope(mid) < 0)
+                lo = mid;
+            else
+                hi = mid;
+        }
+        const a = (lo + hi) / 2;
+        y = y.map((v) => Math.min(a + slack, Math.max(a, v)));
+    }
+    return y.map((v, i) => v + before[i]);
+}
+/** How far apart along a ring of radius `r` two points must be for the straight line between them to
+ *  be `d` pixels long: on a small ring the line is shorter than the arc. None, on a ring narrower
+ *  than `d`. */
+const along = (d, r) => (d > 2 * r ? Infinity : 2 * r * Math.asin(d / (2 * r)));
+/** Notes `ks` laid out on ring `j` with the innermost `rpx` pixels round on the screen, their cards
+ *  shown or not (`cards`). Those that want an angle first: in their order round the ring, spread so
+ *  that RING_GAP_PX is between each two on the screen (spreadOn); what a card takes along the ring is
+ *  read at the angle the note wants, then again where the first spreading put it, the larger kept, as
+ *  a box's extent across the ray changes with the angle. Then those that want none, in the order
+ *  written, each from the top clockwise at the first place the others leave room for. Their angles,
+ *  in the order of `ks`; with `strict`, null where they do not fit: the gaps go round more than the
+ *  ring, one that wants an angle is more than RING_REACH from it, or those that want none come round
+ *  to the top again. */
+function layRing(items, ks, rpx, j, strict, cards) {
+    const r = ringPx(rpx, j);
+    const c = TURN * r;
+    // how far apart two notes taking `e1` and `e2` along the ring are kept: on a ring too narrow for
+    // both, as far as it goes, where the layout is not being tried
+    const apart = (e1, e2) => {
+        const d = along((e1 + e2) / 2 + RING_GAP_PX, r);
+        return Number.isFinite(d) || strict ? d : Math.PI * r;
+    };
+    const at = new Map();
+    // those that want an angle, at it as near as the gaps let them be, in their order round the ring
+    const norm = (a) => ((((a - TOP) % TURN) + TURN) % TURN) + TOP;
+    const seq = ks.filter((k) => items[k].want !== null).sort((a, b) => norm(items[a].want) - norm(items[b].want) || written(items)(a, b));
+    const placed = [];
+    if (seq.length) {
+        const u = seq.map((k) => (norm(items[k].want) - TOP) * r);
+        let th = seq.map((k) => norm(items[k].want));
+        let ext = seq.map((k, i) => across(items[k], th[i], cards));
+        let x = null;
+        for (let pass = 0; pass < 2; pass++) {
+            const g = seq.map((_, i) => apart(ext[i], ext[(i + 1) % seq.length]));
+            x = spreadOn(u, g, c);
+            if (!x) {
+                if (strict)
+                    return null;
+                x = u;
+            }
+            th = x.map((v) => TOP + v / r);
+            ext = seq.map((k, i) => Math.max(ext[i], across(items[k], th[i], cards)));
+        }
+        if (strict && x.some((v, i) => Math.abs(v - u[i]) > RING_REACH * r + 1e-6))
+            return null;
+        seq.forEach((k, i) => {
+            at.set(k, th[i]);
+            placed.push({ x: ((x[i] % c) + c) % c, e: ext[i] });
+        });
+    }
+    // those that want none, from the top clockwise in the order written, each at the first place
+    // clear of those laid already, round the ring once at most: the others in their order round it,
+    // once more on either side for the turn, are passed one after the other
+    const loose = ks.filter((k) => items[k].want === null).sort(written(items));
+    if (!loose.length)
+        return ks.map((k) => at.get(k));
+    placed.sort((a, b) => a.x - b.x);
+    const others = [...placed.map((q) => ({ x: q.x - c, e: q.e })), ...placed, ...placed.map((q) => ({ x: q.x + c, e: q.e }))];
+    const widest = others.reduce((m, q) => Math.max(m, q.e), 0);
+    let p = 0;
+    let prev = null;
+    let first = null;
+    for (const k of loose) {
+        let e = across(items[k], TOP + p / r, cards);
+        if (prev)
+            p = Math.max(p, prev.x + apart(prev.e, e));
+        for (let again = 0; again < 2; again++) {
+            // the first of the others that could reach this far back, by halving
+            const back = p - apart(e, widest);
+            let i = 0, hi = others.length;
+            while (i < hi) {
+                const mid = (i + hi) >> 1;
+                if (others[mid].x < back)
+                    i = mid + 1;
+                else
+                    hi = mid;
+            }
+            for (; i < others.length && others[i].x < p + apart(e, others[i].e); i++)
+                if (Math.abs(p - others[i].x) < apart(e, others[i].e) - 1e-9)
+                    p = others[i].x + apart(e, others[i].e);
+            const wider = across(items[k], TOP + p / r, cards);
+            if (wider <= e)
+                break;
+            e = wider;
+        }
+        // round to the top again: the first that wanted none is there
+        if (strict && (!Number.isFinite(p) || p >= c || (first && p + apart(e, first.e) > first.x + c + 1e-9)))
+            return null;
+        first ??= { x: p, e };
+        prev = { x: p, e };
+        at.set(k, TOP + p / r);
+    }
+    return ks.map((k) => at.get(k));
+}
+/** The zooms packing decides at: the innermost ring 2^(m/12) pixels round on the screen, twelve to a
+ *  doubling, from 1 pixel to 2^20. A view between two is packed as at the smaller, where every ring
+ *  holds what it is given at least as easily — its cards counted where they show anywhere between
+ *  the two. */
+const STEPS = 12;
+const M_TOP = 20 * STEPS;
+const levelPx = (m) => 2 ** (m / STEPS);
+const cardsAt = (m) => noteLook(true, levelPx(m + 1)) === "open";
+/** The notes packed for the last set asked about, kept while the set stays the same (every frame
+ *  while only the zoom changes, and every zoom Fit tries): the lowest zoom at which one ring holds
+ *  them all (`top`), and which ring each is on at each zoom below it, worked out as far down as was
+ *  asked (`low`). */
+let packed = null;
+/** Which ring each note is on at zoom `m` (levelPx), from where they are at the zoom above it
+ *  (`above`): in the order they were written, each on the ring it was on there, or further out
+ *  where that ring no longer holds it with the older ones on it — so that zooming out never brings
+ *  one in, and moves one out only when it must. Those that want no angle keep their order ring after
+ *  ring: one never goes inside an earlier one. A ring with nothing on it yet takes anything. */
+function ringsAt(items, above, m) {
+    const rings = [];
+    const out = new Array(items.length);
+    let looseFrom = 0;
+    for (const k of items.map((_, k) => k).sort(written(items))) {
+        let j = Math.max(above[k], items[k].want === null ? looseFrom : 0);
+        while (rings[j]?.length && !layRing(items, [...rings[j], k], levelPx(m), j, true, cardsAt(m)))
+            j++;
+        (rings[j] ??= []).push(k);
+        out[k] = j;
+        if (items[k].want === null)
+            looseFrom = j;
+    }
+    return out;
+}
+/** Where the notes on the rings go when the innermost is `rpx` pixels round on the screen (the
+ *  owner's decision of 2026-10-11): each on a ring at the angle it wants — those that want none from
+ *  the top, clockwise, in the order they were written — at least RING_GAP_PX from its neighbours
+ *  along the ring, its order round the ring kept. A ring holds only as many as fit so at this zoom,
+ *  each within RING_REACH of its angle; the rest go to rings further out, RING_STEP_PX apart. Zoomed
+ *  in far enough, one ring holds them all; zooming out, a note moves out a ring only when the ring it
+ *  is on no longer holds it with the older ones there — where its angle is too crowded, near its
+ *  angle, the newest of a crowd first — and never back in until the view is zoomed in again past
+ *  the same zoom: at a given zoom the rings are always the same. In the order given. */
+export function packRings(items, rpx) {
+    const n = items.length;
+    if (!n)
+        return [];
+    // the angles a note wants read to the degree: while the board settles they drift every frame, and
+    // packing is worked out again only as they move by more
+    const key = items.map((it) => `${it.want === null ? "-" : Math.round((it.want * 180) / Math.PI)}|${it.order}|${it.icon}|${it.open ? it.open.map(Math.round).join("x") : ""}`).join("\n");
+    if (packed?.key !== key) {
+        // the lowest zoom at which one ring holds them all, found by halving between 1 pixel and 2^20
+        const all = items.map((_, k) => k);
+        const fits = (m) => !!layRing(items, all, levelPx(m), 0, true, cardsAt(m));
+        let lo = 0, hi = M_TOP;
+        if (fits(0))
+            hi = 0;
+        else
+            while (hi - lo > 1) {
+                const mid = (lo + hi) >> 1;
+                if (fits(mid))
+                    hi = mid;
+                else
+                    lo = mid;
+            }
+        packed = { key, top: hi, low: hi, at: new Map() };
+    }
+    const P = packed;
+    const m = Math.max(0, Math.floor(STEPS * Math.log2(Math.max(rpx, 1)) + 1e-9));
+    let ring = new Array(n).fill(0);
+    if (m < P.top) {
+        // from the lowest zoom worked out so far down to this one, each from the zoom above it
+        if (P.low < P.top)
+            ring = P.at.get(P.low);
+        for (let z = P.low - 1; z >= m; z--) {
+            ring = ringsAt(items, ring, z);
+            P.at.set(z, ring);
+            P.low = z;
+        }
+        ring = P.at.get(m);
+    }
+    const rings = [];
+    ring.forEach((j, k) => (rings[j] ??= []).push(k));
+    const out = new Array(n);
+    const cards = noteLook(true, rpx) === "open";
+    rings.forEach((ks, j) => {
+        if (!ks)
+            return;
+        const a = layRing(items, ks, rpx, j, false, cards) ?? ks.map((k) => items[k].want ?? TOP);
+        ks.forEach((k, i) => (out[k] = { ring: j, a: a[i] }));
+    });
+    return out;
+}
+/** Where a note's box goes for a point of the ring at angle `a` (screen pixels): outside the ring,
+ *  touching the point with the side that faces the middle — to its right on the right, above it at
+ *  the top. The top left corner. */
+export function ringBox(px, py, a, w, h) {
+    return [px + (w / 2) * (Math.cos(a) - 1), py + (h / 2) * (Math.sin(a) - 1)];
+}
+/** The view that fits what `boxes(k)` gives at zoom `k` into `vw` × `vh` pixels: the largest zoom, at
+ *  most `kMax`, at which it all fits, and the point of the world to put in the middle. The boxes are
+ *  asked for at each zoom tried, since notes on the ring are spread by how large the ring is on the
+ *  screen. Null where nothing fits however far out the view goes: notes alone wider or taller than
+ *  the room, which the caller then leaves out. */
+export function fitFrame(boxes, vw, vh, kMax) {
+    const extent = (k) => {
+        let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+        for (const b of boxes(k)) {
+            x0 = Math.min(x0, b.x * k + b.dx0);
+            y0 = Math.min(y0, b.y * k + b.dy0);
+            x1 = Math.max(x1, b.x * k + b.dx1);
+            y1 = Math.max(y1, b.y * k + b.dy1);
+        }
+        return { x0, y0, x1, y1 };
+    };
+    const fits = (k) => {
+        const e = extent(k);
+        return e.x1 - e.x0 <= vw && e.y1 - e.y0 <= vh;
+    };
+    if (!Number.isFinite(extent(kMax).x0))
+        return null;
+    let k = kMax;
+    if (!fits(kMax)) {
+        // the extent grows with the zoom once the board outweighs the notes: the largest zoom that fits
+        // is found by halving the interval between one that fits and one that does not
+        let lo = kMax * 1e-6, hi = kMax;
+        if (!fits(lo))
+            return null;
+        for (let n = 0; n < 48; n++) {
+            const mid = Math.sqrt(lo * hi);
+            if (fits(mid))
+                lo = mid;
+            else
+                hi = mid;
+        }
+        k = lo;
+    }
+    const e = extent(k);
+    return { k, x: (e.x0 + e.x1) / 2 / k, y: (e.y0 + e.y1) / 2 / k };
+}

package/dist/shared/scope.js

@@ -0,0 +1,255 @@
+// What is in force where a declaration is written, read from its file as Lean would read it: the
+// namespaces and sections around it, the `open` commands (an `open … in` right before it
+// included), the `variable`s, `universe`s, options and section-local commands. The page reads the
+// namespaces and opens to link the short names in a declaration's source (web/src/scope.ts); the
+// agents' API answers with all of it (server/agent.ts, `context`); shared/context.ts writes it as
+// the block of Lean shown above a declaration's source and recorded with what an opinion judged.
+// This is the text, read without elaborating it: where Lean is running, what Lean says wins.
+/** The namespaces that exist in the graph: every proper prefix of a declaration's name. */
+const namespaceSets = new WeakMap();
+export function namespacesOf(g) {
+    let s = namespaceSets.get(g);
+    if (!s) {
+        s = new Set();
+        for (const v of g.nodes) {
+            let k = v.name.indexOf(".");
+            while (k > 0) {
+                s.add(v.name.slice(0, k));
+                k = v.name.indexOf(".", k + 1);
+            }
+        }
+        namespaceSets.set(g, s);
+    }
+    return s;
+}
+const frame = (kind, ns, name, line) => ({
+    kind, ns, name, line, opens: [], aliases: new Map(), open: [], variables: [], universes: [], options: [], local: [],
+});
+const NAMESPACE = /^namespace\s+(\S+)/;
+const SECTION = /^(?:@\[[^\]]*\]\s*)?(?:(?:noncomputable|public|private)\s+)*section\b(?:\s+([^\s-]\S*))?/;
+const MUTUAL = /^mutual\b/;
+const END = /^end\b(?:\s+([^\s-]\S*))?/;
+const OPEN = /^open\s+(.*)$/;
+const VARIABLE = /^variable\b\s*(.*)$/;
+const UNIVERSE = /^universe\s+(.*)$/;
+const OPTION = /^set_option\s+(.*)$/;
+/** what holds to the end of its section besides the above */
+const LOCAL = /^(?:(?:local|scoped)[\s[]|attribute\s*\[\s*(?:local|scoped)\b|include\b|omit\b)/;
+/** attributes alone on their line belong to the declaration below */
+const ATTRIBUTES = /^@\[[^\]]*\]$/;
+/** `… in`: the command holds for the next command only. Only these commands are read so; a
+ *  declaration's text that happens to end in `in` is not one. */
+const IN = /\sin$/;
+const IN_HEAD = /^(?:open|set_option|variable|universe|include|omit|attribute|local|scoped)\b/;
+/** A line without its comments, and how deep in nested block comments it ends. String literals
+ *  are kept whole, so that `"--"` in a notation is not a comment. */
+function stripComments(line, depth) {
+    let out = "";
+    for (let k = 0; k < line.length; k++) {
+        const c = line[k], d = line[k + 1];
+        if (depth > 0) {
+            if (c === "/" && d === "-") {
+                depth++;
+                k++;
+            }
+            else if (c === "-" && d === "/") {
+                depth--;
+                k++;
+            }
+            continue;
+        }
+        if (c === "/" && d === "-") {
+            depth++;
+            k++;
+            continue;
+        }
+        if (c === "-" && d === "-")
+            break;
+        if (c === '"') {
+            let j = k + 1;
+            while (j < line.length && line[j] !== '"')
+                j += line[j] === "\\" ? 2 : 1;
+            out += line.slice(k, j + 1);
+            k = j;
+            continue;
+        }
+        out += c;
+    }
+    return { text: out, depth };
+}
+/** Read a file up to line `upto` (0-based, the line a declaration's text starts on): the frames in
+ *  force there, and the commands written `… in` right before it. */
+function walk(lines, upto, hasNamespace) {
+    const stack = [frame("top", "", null, 0)];
+    /** `open … in` and the like apply to the next command only */
+    let pending = null;
+    const current = () => stack.map((f) => f.ns).filter(Boolean).join(".");
+    /** What `open X` opens: X under the namespaces around it, innermost first, or X itself. */
+    const resolveNs = (x) => {
+        const cur = current().split(".").filter(Boolean);
+        const out = [];
+        for (let k = cur.length; k >= 0; k--) {
+            const n = [...cur.slice(0, k), x].join(".");
+            if (hasNamespace(n))
+                out.push(n);
+        }
+        return out;
+    };
+    /** `open …` (its arguments): what it opens, into a frame, and the command as written. */
+    const open = (args, cmd, into) => {
+        const words = args.trim().split(/\s+/);
+        const scoped = words[0] === "scoped";
+        const spaces = [];
+        const rest = scoped ? args.trim().slice("scoped".length) : args;
+        // `open A (x y)`, `open A hiding x`, `open A renaming x → y`
+        const paren = /^([^\s(]+)\s*\(([^)]*)\)/.exec(rest.trim());
+        const renaming = /^([^\s]+)\s+renaming\s+(.*)$/.exec(rest.trim());
+        if (paren) {
+            for (const ns of resolveNs(paren[1])) {
+                spaces.push(ns);
+                if (!scoped)
+                    for (const x of paren[2].trim().split(/\s+/))
+                        if (x)
+                            into.aliases.set(x, `${ns}.${x}`);
+            }
+        }
+        else if (renaming) {
+            for (const ns of resolveNs(renaming[1])) {
+                spaces.push(ns);
+                if (!scoped)
+                    for (const pair of renaming[2].split(",")) {
+                        const [from, to] = pair.split(/→|->/).map((s) => s.trim());
+                        if (from && to)
+                            into.aliases.set(to, `${ns}.${from}`);
+                    }
+            }
+        }
+        else {
+            const hiding = rest.indexOf(" hiding ");
+            for (const w of (hiding >= 0 ? rest.slice(0, hiding) : rest).trim().split(/\s+/)) {
+                if (!w)
+                    continue;
+                const ns = resolveNs(w);
+                spaces.push(...ns);
+                // scoped opens bring notation and instances, no names
+                if (!scoped)
+                    into.opens.push(...ns);
+            }
+        }
+        into.open.push({ ...cmd, namespaces: [...new Set(spaces)], ...(scoped ? { scoped: true } : {}) });
+    };
+    /** What a whole command does, once all its lines are read. */
+    const finish = (text, line) => {
+        let m;
+        if ((m = NAMESPACE.exec(text))) {
+            stack.push(frame("namespace", m[1], m[1], line));
+            pending = null;
+            return;
+        }
+        if ((m = SECTION.exec(text))) {
+            const f = frame("section", "", m[1] ?? null, line);
+            if (/\bnoncomputable\s+section\b/.test(text))
+                f.noncomputable = true;
+            stack.push(f);
+            pending = null;
+            return;
+        }
+        if (MUTUAL.test(text)) {
+            stack.push(frame("mutual", "", null, line));
+            pending = null;
+            return;
+        }
+        if ((m = END.exec(text))) {
+            // `end A.B` closes as many namespaces as its name has parts, `namespace A.B` being one
+            let parts = m[1] ? m[1].split(".").length : 1;
+            while (parts > 0 && stack.length > 1)
+                parts -= (stack.pop().name ?? "_").split(".").length;
+            pending = null;
+            return;
+        }
+        if (ATTRIBUTES.test(text))
+            return;
+        const head = IN_HEAD.test(text);
+        // `open A in def x …` on one line holds for that command alone, which is not the one asked about
+        if (head && !VARIABLE.test(text) && /\sin\s/.test(text)) {
+            pending = null;
+            return;
+        }
+        const onlyNext = head && IN.test(text);
+        const body = onlyNext ? text.replace(IN, "") : text;
+        // a command that is not `… in` uses up what was pending: a declaration, or anything else
+        const into = onlyNext ? (pending ??= frame("top", "", null, line)) : stack[stack.length - 1];
+        if (!onlyNext)
+            pending = null;
+        const cmd = (t) => ({ line: line + 1, text: t, ...(onlyNext ? { in: true } : {}) });
+        if ((m = OPEN.exec(body)))
+            open(m[1], cmd(body), into);
+        else if ((m = VARIABLE.exec(body)))
+            into.variables.push(cmd(m[1]));
+        else if ((m = UNIVERSE.exec(body)))
+            into.universes.push(cmd(m[1]));
+        else if ((m = OPTION.exec(body)))
+            into.options.push(cmd(m[1]));
+        else if (LOCAL.test(body))
+            into.local.push(cmd(body.length > 400 ? body.slice(0, 400) + "…" : body));
+    };
+    let depth = 0;
+    /** the command being read: its first line, and its text so far */
+    let reading = null;
+    for (let l = 0; l < upto && l < lines.length; l++) {
+        const line = lines[l];
+        const inComment = depth > 0;
+        const s = stripComments(line, depth);
+        depth = s.depth;
+        const text = s.text.replace(/\s+/g, " ").trim();
+        if (!text)
+            continue;
+        // a command starts at the line's first column, outside a comment; anything else continues it
+        if (!inComment && !/^\s/.test(line)) {
+            if (reading)
+                finish(reading.text, reading.line);
+            reading = { line: l, text };
+        }
+        else if (reading)
+            reading.text += " " + text;
+    }
+    if (reading)
+        finish(reading.text, reading.line);
+    return { stack, pending };
+}
+/** The scope at line `upto` of a file (the line a declaration's text starts on): what a short name
+ *  written there can mean. */
+export function scopeAt(lines, upto, hasNamespace) {
+    const { stack, pending } = walk(lines, upto, hasNamespace);
+    const frames = pending ? [...stack, pending] : stack;
+    const cur = stack.map((f) => f.ns).filter(Boolean).join(".").split(".").filter(Boolean);
+    const namespaces = [];
+    for (let k = cur.length; k > 0; k--)
+        namespaces.push(cur.slice(0, k).join("."));
+    const aliases = new Map();
+    for (const f of frames)
+        for (const [k, v] of f.aliases)
+            aliases.set(k, v);
+    return { namespaces, opens: [...new Set(frames.flatMap((f) => f.opens))], aliases };
+}
+/** Everything in force at line `upto` of a file, as written: the context a declaration there is
+ *  read in. */
+export function contextAt(lines, upto, hasNamespace) {
+    const { stack, pending } = walk(lines, upto, hasNamespace);
+    const frames = pending ? [...stack, pending] : stack;
+    const namespace = stack.map((f) => f.ns).filter(Boolean).join(".");
+    const cur = namespace.split(".").filter(Boolean);
+    const namespaces = [];
+    for (let k = cur.length; k > 0; k--)
+        namespaces.push(cur.slice(0, k).join("."));
+    return {
+        namespace,
+        namespaces,
+        blocks: stack.slice(1).map((f) => ({ kind: f.kind, name: f.name, line: f.line + 1, ...(f.noncomputable ? { noncomputable: true } : {}) })),
+        opens: frames.flatMap((f) => f.open),
+        variables: frames.flatMap((f) => f.variables),
+        universes: frames.flatMap((f) => f.universes),
+        options: frames.flatMap((f) => f.options),
+        local: frames.flatMap((f) => f.local),
+    };
+}