visualproof 0.0.0-stage → 0.1.0

package/dist/shared/scopeedit.js

@@ -0,0 +1,81 @@
+// A view's scope changed by one part from the canvas's menu (ViewSpec, "The canvas's menu",
+// decided 2026-10-09): "Remove from this view" is `scope except part`, "Add to view" is
+// `scope or part`, a part being a declaration, `decl(X)`, or a cluster as the selection's cluster
+// picks write it, `ns(P) except external` or `file(P)` (web/src/selection.ts, clusterSet). The
+// scope stays short as the reader removes and adds: a declaration joins the `decl(…)` that ends the
+// scope with the same word (or that is the scope), and adding back what was taken out undoes the taking out rather than
+// piling a second part on the first. What is written is always exactly the set asked for; where a
+// caller can tell that a shorter scope holds the same set (`same`, evaluated on its graph and
+// review), that one is written, and a scope that holds the set asked for already is left as it is.
+import { sameQuery } from "./query.js";
+/** A declaration's one name, when the part is `decl(X)`. */
+const single = (q) => (q.op === "decl" && q.names.length === 1 ? q.names[0] : null);
+/** `q` without `name` in its trailing `decl(…)` (`a <op> decl(…)`): the `decl` shorter by one, or
+ *  `a` when it held that name alone; null when `q` does not end so. */
+function dropName(q, op, name) {
+    if (q.op !== op || q.b.op !== "decl" || !q.b.names.includes(name))
+        return null;
+    const names = q.b.names.filter((n) => n !== name);
+    return names.length ? { op, a: q.a, b: { op: "decl", names } } : q.a;
+}
+/** `q <op> decl(name)`, the name joining a trailing `decl(…)` of the same op. */
+function addName(q, op, name) {
+    if (q.op === op && q.b.op === "decl")
+        return q.b.names.includes(name) ? q : { op, a: q.a, b: { op: "decl", names: [...q.b.names, name] } };
+    return { op, a: q, b: { op: "decl", names: [name] } };
+}
+/** The scope that holds `part` too: `scope or part`, as short as it can be written. */
+export function scopeWith(scope, part, same) {
+    const next = withPart(scope, part, same);
+    return same?.(scope, next) ? scope : next;
+}
+/** The scope that leaves `part` out: `scope except part`, as short as it can be written. */
+export function scopeWithout(scope, part, same) {
+    const next = withoutPart(scope, part, same);
+    return same?.(scope, next) ? scope : next;
+}
+function withPart(scope, part, same) {
+    const name = single(part);
+    // a scope of declarations by name takes one more
+    if (name !== null && scope.op === "decl")
+        return scope.names.includes(name) ? scope : { op: "decl", names: [...scope.names, name] };
+    if (name !== null) {
+        // what was taken out comes back: the name leaves the `except decl(…)` that took it out
+        const back = dropName(scope, "except", name);
+        if (back) {
+            if (same?.(back, addName(back, "or", name)))
+                return back;
+            return addName(back, "or", name);
+        }
+        return addName(scope, "or", name);
+    }
+    // a cluster taken out comes back: what the scope was, and the cluster with it
+    if (scope.op === "except" && sameQuery(scope.b, part)) {
+        if (same?.(scope.a, { op: "or", a: scope.a, b: part }))
+            return scope.a;
+        return { op: "or", a: scope.a, b: part };
+    }
+    return { op: "or", a: scope, b: part };
+}
+function withoutPart(scope, part, same) {
+    const name = single(part);
+    // a scope of declarations by name loses one, while one is left
+    if (name !== null && scope.op === "decl" && scope.names.length > 1)
+        return { op: "decl", names: scope.names.filter((n) => n !== name) };
+    if (name !== null) {
+        // what was added goes: the name leaves the `or decl(…)` that added it
+        const back = dropName(scope, "or", name);
+        if (back) {
+            if (same?.(back, addName(back, "except", name)))
+                return back;
+            return addName(back, "except", name);
+        }
+        return addName(scope, "except", name);
+    }
+    if (scope.op === "or" && sameQuery(scope.b, part)) {
+        if (same?.(scope.a, { op: "except", a: scope.a, b: part }))
+            return scope.a;
+        return { op: "except", a: scope.a, b: part };
+    }
+    return { op: "except", a: scope, b: part };
+}

package/dist/shared/search.js

@@ -0,0 +1,191 @@
+// The search (`/`): declarations by name first, then by what their statement says and what their
+// docstring says. A reviewer asks "which statements mention Matrix.unitaryGroup?" as often as
+// "where is flipAt?", and a docstring is where a paper's name and theorem number are written.
+//
+// Every word of the query has to be found, each in the name, the statement or the docstring. A
+// declaration ranks by the weakest place it needed: all words in the name come first, then those
+// that needed the statement, then those that needed the docstring. Each result shows that place
+// around the word that needed it, the words marked.
+//
+// The texts are lowercased once per graph, offset for offset, so a keystroke is a plain substring
+// scan, and a query that only adds to the last one looks through what the last one found.
+//
+// A unit is found by the names it folds too (ViewNode.also): `QOR.Name`, which Lean generated from
+// the command that writes `QOR`, finds `QOR`, as a name does, and the hit says which (`via`).
+//
+// The page's search box (web/src/search.ts) and the agent API (server/agent.ts) both search so.
+export const PLACES = ["name", "statement", "doc"];
+/** `s` lowercased with every offset kept: the few letters that lowercase to two (`İ`) stay as
+ *  they are, so that a place found in the lowercase text is the same place in `s`. */
+export function lowerKeepingOffsets(s) {
+    const l = s.toLowerCase();
+    if (l.length === s.length)
+        return l;
+    let out = "";
+    for (const c of s) {
+        const lc = c.toLowerCase();
+        out += lc.length === c.length ? lc : c;
+    }
+    return out;
+}
+/** The query's words, lowercased, each once. */
+export function queryWords(q) {
+    return [...new Set(lowerKeepingOffsets(q).split(/\s+/).filter(Boolean))];
+}
+export class SearchIndex {
+    n;
+    /** per place (name, statement, docstring), each declaration's text, "" where it has none */
+    text;
+    /** the same, lowercased offset for offset */
+    lower;
+    /** where the externals start: they rank after the project's declarations of the same fit */
+    projectCount;
+    /** per declaration, the names it folds (Searchable.also), as they are and lowercased */
+    also;
+    alsoLower;
+    constructor(nodes, projectCount = nodes.length) {
+        this.n = nodes.length;
+        this.projectCount = projectCount;
+        this.text = [nodes.map((v) => v.name), nodes.map((v) => v.type ?? ""), nodes.map((v) => v.doc ?? "")];
+        this.lower = this.text.map((xs) => xs.map(lowerKeepingOffsets));
+        this.also = nodes.map((v) => v.also ?? []);
+        this.alsoLower = this.also.map((xs) => xs.map(lowerKeepingOffsets));
+    }
+}
+const IDENT = /[\p{L}\p{N}_'!?₀-₉ₐ-ₜ]/u;
+const NOT_IDENT = /[^\p{L}\p{N}_'!?₀-₉ₐ-ₜ]/u;
+/** Search the index. `within`: the declarations to look at (the last query's `matched`, when this
+ *  one only adds to it); all of them when absent. */
+export function search(ix, query, within) {
+    const words = queryWords(query);
+    const hits = { name: [], statement: [], doc: [] };
+    const matched = [];
+    const found = { query, words, hits, matched: new Int32Array(0) };
+    if (!words.length)
+        return found;
+    // the longest word first: it rules out the most at the first look
+    const order = [...words].sort((a, b) => b.length - a.length);
+    const [names, stmts, docs] = ix.lower;
+    const m = within ? within.length : ix.n;
+    for (let k = 0; k < m; k++) {
+        const i = within ? within[k] : k;
+        const also = ix.alsoLower[i];
+        /** the first name it folds that holds `w`, when its own name does not */
+        const folded = (w) => (names[i].includes(w) ? -1 : also.findIndex((a) => a.includes(w)));
+        // the weakest place a word needed (0 name, 1 statement, 2 docstring), the first word that
+        // needed it, and how many did
+        let tier = 0, word = order[0], need = 0, ok = true;
+        for (const w of order) {
+            const t = names[i].includes(w) || folded(w) >= 0 ? 0 : stmts[i].includes(w) ? 1 : docs[i].includes(w) ? 2 : -1;
+            if (t < 0) {
+                ok = false;
+                break;
+            }
+            if (t > tier)
+                [tier, word, need] = [t, w, 1];
+            else if (t === tier)
+                need++;
+        }
+        if (!ok)
+            continue;
+        matched.push(i);
+        const ext = i >= ix.projectCount;
+        let score;
+        let via;
+        if (tier === 0) {
+            // as the search always ranked a name: the words in its last component, exactly, at its start,
+            // inside it; then the project before the outside world; then the shorter name. A word found
+            // in a name it folds counts as found in that name.
+            let name = names[i];
+            for (const w of order) {
+                const a = folded(w);
+                if (a >= 0) {
+                    name = also[a];
+                    via = ix.also[i][a];
+                    break;
+                }
+            }
+            const last = name.slice(name.lastIndexOf(".") + 1);
+            let fit = 0;
+            for (const w of order)
+                fit = Math.max(fit, last === w ? 0 : last.startsWith(w) ? 1 : last.includes(w) ? 2 : 3);
+            score = fit * 1000 + (ext ? 500 : 0) + Math.min(400, name.length);
+        }
+        else {
+            // fewer words that needed this place first (the rest are in the name), then a word found
+            // whole rather than inside another, then the shorter text
+            const text = (tier === 1 ? stmts : docs)[i];
+            const at = text.indexOf(word);
+            const whole = at === 0 || !IDENT.test(text[at - 1]);
+            score = need * 1e7 + (whole ? 0 : 1e6) + Math.min(999_999, text.length);
+        }
+        hits[PLACES[tier]].push({ i, where: PLACES[tier], score, word, ...(via !== undefined ? { via } : {}) });
+    }
+    for (const w of PLACES)
+        hits[w].sort((a, b) => a.score - b.score || a.i - b.i);
+    found.matched = Int32Array.from(matched);
+    return found;
+}
+/** Whether `next` can only find what `prev` found: it adds to it (the words grow or more come). */
+export function narrows(prev, next) {
+    const a = lowerKeepingOffsets(prev.trim()), b = lowerKeepingOffsets(next.trim());
+    return a.length > 0 && b.startsWith(a);
+}
+/** `text` from `from` to `to`, in pieces marked where the words occur (found in `lower`, its
+ *  lowercase); runs of white space become one space. */
+export function marked(text, lower, words, from = 0, to = text.length) {
+    const ranges = [];
+    for (const w of words) {
+        for (let at = lower.indexOf(w, Math.max(0, from - w.length + 1)); at >= 0 && at < to; at = lower.indexOf(w, at + 1)) {
+            ranges.push([Math.max(from, at), Math.min(to, at + w.length)]);
+        }
+    }
+    ranges.sort((a, b) => a[0] - b[0]);
+    const pieces = [];
+    const push = (a, b, mark) => {
+        if (b > a)
+            pieces.push({ text: text.slice(a, b).replace(/\s+/g, " "), mark });
+    };
+    let pos = from;
+    for (let k = 0; k < ranges.length; k++) {
+        let [a, b] = ranges[k];
+        // overlapping words are one mark
+        while (k + 1 < ranges.length && ranges[k + 1][0] <= b)
+            b = Math.max(b, ranges[++k][1]);
+        a = Math.max(a, pos);
+        push(pos, a, false);
+        push(a, b, true);
+        pos = Math.max(pos, b);
+    }
+    push(pos, to, false);
+    return pieces;
+}
+const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
+/** A short stretch of `text` around the first `focus`, beginning at a word where one begins
+ *  nearby, the words marked. `lead`: how much comes before the focus; `width`: how much in all
+ *  (the row cuts what does not fit). */
+export function snippet(text, lower, words, focus, width = 96, lead = 28) {
+    const at = Math.max(0, lower.indexOf(focus));
+    // close enough to the beginning: from the beginning
+    let start = at - lead <= 12 ? 0 : at - lead;
+    if (start > 0) {
+        // statements name everything in full, with no space for long stretches: a dot or a bracket is
+        // as good a place to begin
+        const gap = text.slice(start, at).search(NOT_IDENT);
+        if (gap >= 0 && gap < 12)
+            start += gap + 1;
+        // never between the two halves of a character
+        else if (isLowSurrogate(text.charCodeAt(start)))
+            start--;
+    }
+    let end = Math.min(text.length, Math.max(at + focus.length, start + width));
+    if (end < text.length && isLowSurrogate(text.charCodeAt(end)))
+        end++;
+    const pieces = marked(text, lower, words, start, end);
+    // the edges of the stretch: no white space where it is not cut
+    if (pieces.length && start === 0)
+        pieces[0].text = pieces[0].text.trimStart();
+    if (pieces.length && end === text.length)
+        pieces[pieces.length - 1].text = pieces[pieces.length - 1].text.trimEnd();
+    return { pieces: pieces.filter((p) => p.text), before: start > 0, after: end < text.length };
+}

package/dist/shared/separate.js

@@ -0,0 +1,178 @@
+// Separating the children of one cluster: the page's scene (web/src/scene.ts, "the layout event")
+// and the layout (shared/layout.ts, on the server and for boards on the page) both use it.
+//
+// Bodies are discs: a few large ones (sub-clusters) and up to a few thousand small ones
+// (declarations, all of radius LEAF_R). A round pushes every overlapping pair apart; what holds its
+// place (a drop) stays against what does not, and of two drops the later one stays. Only pairs
+// touching something that moved in the previous round are looked at again, and small bodies find
+// their neighbours through a hash grid kept in typed arrays, so a drop in a cluster of 2,000
+// declarations settles in milliseconds rather than rebuilding everything every round.
+/** Packed bodies touch exactly; only a real overlap counts. */
+const SLACK = 0.5;
+export class Separator {
+    head = new Int32Array(0);
+    next = new Int32Array(0);
+    mask = 0;
+    moved = new Uint8Array(0);
+    movedNext = new Uint8Array(0);
+    movedSmall = new Int32Array(0);
+    cell;
+    constructor(cell) {
+        this.cell = cell;
+    }
+    ensure(n, nSmall) {
+        if (this.next.length < n) {
+            this.next = new Int32Array(n);
+            this.moved = new Uint8Array(n);
+            this.movedNext = new Uint8Array(n);
+            this.movedSmall = new Int32Array(n);
+        }
+        let size = 64;
+        while (size < 2 * nSmall)
+            size <<= 1;
+        if (this.head.length !== size)
+            this.head = new Int32Array(size);
+        this.mask = size - 1;
+    }
+    key(x, y) {
+        return (Math.imul(Math.floor(x / this.cell), 73856093) ^ Math.imul(Math.floor(y / this.cell), 19349663)) & this.mask;
+    }
+    build(B) {
+        this.head.fill(-1);
+        for (let s = 0; s < B.small.length; s++) {
+            const k = B.small[s];
+            const h = this.key(B.x[k], B.y[k]);
+            this.next[k] = this.head[h];
+            this.head[h] = k;
+        }
+    }
+    /** Push a and b apart if they overlap; marks what moved. */
+    push(B, a, b) {
+        const dx = B.x[b] - B.x[a], dy = B.y[b] - B.y[a];
+        const need = B.r[a] + B.r[b];
+        const d2 = dx * dx + dy * dy;
+        if (d2 >= (need - SLACK) * (need - SLACK))
+            return false;
+        const pa = B.pinned[a], pb = B.pinned[b];
+        const fixA = pa && (!pb || B.seq[a] > B.seq[b]);
+        const fixB = pb && (!pa || B.seq[b] > B.seq[a]);
+        const d = Math.sqrt(d2) || 1e-3;
+        const over = need - d;
+        const ra = B.r[a] * B.r[a], rb = B.r[b] * B.r[b];
+        const wa = fixA ? 0 : fixB ? 1 : rb / (ra + rb);
+        const ux = d2 ? dx / d : 1, uy = d2 ? dy / d : 0;
+        if (wa > 0) {
+            B.x[a] -= ux * over * wa;
+            B.y[a] -= uy * over * wa;
+            this.movedNext[a] = 1;
+        }
+        if (wa < 1) {
+            B.x[b] += ux * over * (1 - wa);
+            B.y[b] += uy * over * (1 - wa);
+            this.movedNext[b] = 1;
+        }
+        return true;
+    }
+    overlap(B, a, b) {
+        const dx = B.x[b] - B.x[a], dy = B.y[b] - B.y[a];
+        const need = B.r[a] + B.r[b] - SLACK;
+        return dx * dx + dy * dy < need * need;
+    }
+    /**
+     * Up to `rounds` rounds of separation. After each round a body further from the origin than
+     * `limit[k]` is brought back to it (null: no limit). Returns whether anything still moved in
+     * the last round.
+     */
+    separate(B, rounds, limit) {
+        const { big, small } = B;
+        this.ensure(B.n, small.length);
+        const moved = this.moved, next = this.movedNext;
+        moved.fill(1, 0, B.n);
+        let any = false;
+        for (let round = 0; round < rounds; round++) {
+            any = false;
+            next.fill(0, 0, B.n);
+            this.build(B);
+            let nMovedSmall = 0;
+            for (let s = 0; s < small.length; s++)
+                if (moved[small[s]])
+                    this.movedSmall[nMovedSmall++] = small[s];
+            // large against large, and against the small ones (all of them when the large one moved)
+            for (let p = 0; p < big.length; p++) {
+                const a = big[p];
+                for (let q = p + 1; q < big.length; q++) {
+                    const b = big[q];
+                    if ((moved[a] || moved[b]) && this.push(B, a, b))
+                        any = true;
+                }
+                if (moved[a]) {
+                    for (let s = 0; s < small.length; s++)
+                        if (this.push(B, a, small[s]))
+                            any = true;
+                }
+                else {
+                    for (let s = 0; s < nMovedSmall; s++)
+                        if (this.push(B, a, this.movedSmall[s]))
+                            any = true;
+                }
+            }
+            // small against their grid neighbours, where one of the two moved
+            for (let s = 0; s < nMovedSmall; s++) {
+                const a = this.movedSmall[s];
+                const gx = Math.floor(B.x[a] / this.cell), gy = Math.floor(B.y[a] / this.cell);
+                for (let i = gx - 1; i <= gx + 1; i++) {
+                    for (let j = gy - 1; j <= gy + 1; j++) {
+                        const h = (Math.imul(i, 73856093) ^ Math.imul(j, 19349663)) & this.mask;
+                        for (let b = this.head[h]; b >= 0; b = this.next[b]) {
+                            if (b === a || (moved[b] && b < a))
+                                continue;
+                            if (this.push(B, a, b))
+                                any = true;
+                        }
+                    }
+                }
+            }
+            if (limit) {
+                for (let k = 0; k < B.n; k++) {
+                    const d = Math.hypot(B.x[k], B.y[k]);
+                    if (d > limit[k]) {
+                        B.x[k] *= limit[k] / d;
+                        B.y[k] *= limit[k] / d;
+                        next[k] = 1;
+                    }
+                }
+            }
+            moved.set(next.subarray(0, B.n));
+            if (!any)
+                break;
+        }
+        return any;
+    }
+    /** Whether any two bodies overlap (two drops on each other included). */
+    overlaps(B) {
+        const { big, small } = B;
+        this.ensure(B.n, small.length);
+        for (let p = 0; p < big.length; p++) {
+            for (let q = p + 1; q < big.length; q++)
+                if (this.overlap(B, big[p], big[q]))
+                    return true;
+            for (let s = 0; s < small.length; s++)
+                if (this.overlap(B, big[p], small[s]))
+                    return true;
+        }
+        this.build(B);
+        for (let s = 0; s < small.length; s++) {
+            const a = small[s];
+            const gx = Math.floor(B.x[a] / this.cell), gy = Math.floor(B.y[a] / this.cell);
+            for (let i = gx - 1; i <= gx + 1; i++) {
+                for (let j = gy - 1; j <= gy + 1; j++) {
+                    const h = (Math.imul(i, 73856093) ^ Math.imul(j, 19349663)) & this.mask;
+                    for (let b = this.head[h]; b >= 0; b = this.next[b])
+                        if (b > a && this.overlap(B, a, b))
+                            return true;
+                }
+            }
+        }
+        return false;
+    }
+}