visualproof 0.0.0-stage → 0.2.0

package/docs/agent-api/tcb.md

@@ -0,0 +1,135 @@
+# Targets and their TCB
+
+Targets, the members of a target's TCB that need review, its key declarations, why something is in
+a TCB, and references (`uses`, `users`): any level. Then marking targets and keys, and trust (needs
+full). Terms: [Words](words.md). MCP: `review` (actions `targets`, `tcb`, `keys`, `why`); `refs`
+(actions `uses`, `users`); `mark` (actions `target`, `key`); `trust`.
+
+## `GET /api/agent/targets`
+
+```json
+{"targets": [{"name": "Hilbert91", "markedBy": "Bob", "at": "…", "inGraph": true,
+   "counts": {"needReview": 16, "approved": 1, "commented": 0, "stale": 0, "unreviewed": 15,
+              "advised": 2, "agentComments": 0, "advisedByYou": 2,
+              "key": {"total": 4, "approved": 1, "commented": 0, "stale": 0, "unreviewed": 3}}},
+  {"name": "FltRegular.caseI", "markedBy": "Alice's AI", "markedByAgent": true, …}, …]}
+```
+
+`approved` … `unreviewed`: people's statuses, summing to `needReview`. `advised`, `agentComments`,
+`advisedByYou`: agents' advice on present versions, counted apart. `key`: the second level of
+progress, the target's key declarations (the target among them).
+
+## `GET /api/agent/tcb?target=&include=&todo=&key=&offset=&limit=`
+
+The members of `target`'s TCB that need review, in review order; any declaration may be the target
+(`isTarget`: whether it is marked). `limit` 1–500, default 50; `next`: the next `offset`, null at
+the end.
+
+| parameter | effect |
+|---|---|
+| `todo=1` | only members you have not advised on in their present version (to resume a pre-review); with `include=review` only; 400 if you do not say who you are |
+| `key=first`, `key=only` | key declarations first, then the rest; or key declarations alone (the review list's ◆ Key); each in review order |
+| `include` | `review` (default); `trusted`: the trusted members; `all`: those needing review, then the trusted, `position` counting within each |
+
+```json
+{"target": "Hilbert91", "isTarget": true, "order": "review: …", "counts": {"needReview": 16, …},
+ "trustedNotCounted": 195, "axioms": [], "include": "review", "offset": 0, "limit": 50, "total": 16, "next": null,
+ "members": [{"position": 2, "name": "RelativeUnits", "kind": "def", "module": "…", "key": true,
+              "status": "approved", "advice": [], "youAdvised": false},
+             {"position": 7, …, "advice": [{"by": "Claude", "verdict": "approve"}], "youAdvised": true}, …]}
+```
+
+- `position`: place in the whole review order (also with `todo`, `key`); `total`: what the filter
+  keeps. The target comes last. `counts.key` counts the `key: true` members by status.
+- No "next to review", for people or agents: the review set is read as a list.
+- `axioms`: every axiom beyond the three standard ones the target rests on, through statements,
+  bodies or proofs, as `#print axioms` finds them (`sorryAx` included); each
+  `{name, inGraph, status, usedIn}`, `usedIn` the declarations using it. They need review whatever
+  is trusted, come first, count in `needReview`; `why` answers `inTcb: false, inReview: true` and
+  `usedIn` for them.
+- `include=trusted`: each member's `trustedBy`, the prefixes covering it (`"@external"`: the whole
+  outside world) or `"standard axiom"`; the project's own first, then by prefix, then by name.
+  `trusted` sums them: `{project, external, byPrefix: {"Init": 6, …}}`.
+
+## `GET /api/agent/keys?target=&members=`
+
+A target's key declarations top-down: the target, then each a layer below every key declaration
+resting on it (within a layer, later in review order first). Each with `doc`, `restsOn` (the key
+declarations it rests on directly) and its `support` (members it reaches through non-key members)
+by status; plus the key graph's `edges`. `members=0`: support counts only, no names.
+
+```json
+{"target": "Hilbert91", "isTarget": true, "order": "top-down: …", "note": "…",
+ "counts": {"key": {"total": 4, "approved": 1, …}, "all": {"total": 16, …}, "offBoardAxioms": 0},
+ "keys": [{"name": "Hilbert91", "target": true, "status": "none", "doc": null, "restsOn": ["RelativeUnits", …], …},
+   {"name": "systemOfUnits.IsFundamental", "kind": "def", "markedBy": "Alice", "markedAt": "…", "restsOn": ["systemOfUnits"],
+    "support": {"total": 5, "unreviewed": 5, …, "members": ["CyclotomicIntegers", …]}, …}, …],
+ "edges": [["systemOfUnits.IsFundamental", "systemOfUnits"], …], "viaProof": []}
+```
+
+`viaProof`: non-standard axioms the target rests on through proofs alone (no statement or body
+reaches them), part of its support. `marksOutsideReview`, when any: marks on declarations the review
+no longer holds (trusted since, or out of the TCB), kept, counted for nothing.
+
+## `GET /api/agent/why?target=&name=`
+
+The shortest chain of statement and body references from the target to the declaration.
+
+```json
+{"target": "Hilbert91", "name": "CyclotomicIntegers", "inTcb": true,
+ "chain": [{"name": "Hilbert91", "kind": "theorem", "module": "…"},
+   {"name": "relativeUnitsModule", "kind": "instance", …, "usedIn": "the statement of Hilbert91"},
+   {"name": "CyclotomicIntegers", …, "usedIn": "the statement of relativeUnitsModule"}],
+ "reviewPosition": {"position": 1, "of": 16}}
+```
+
+`inTcb: false`, `chain` null: nothing in the statement, nor in the body of a definition it reaches,
+refers to it.
+
+## `GET /api/agent/uses?name=&where=&offset=&limit=` and `GET /api/agent/users?…`
+
+`uses`: what the declaration refers to by name; `users`: what refers to it. Each reference with
+`where` it sits (in the declaration for `uses`, in the user for `users`): `statement`, `body`,
+`proof`, or `grammar` (syntax that only declares grammar). Order: statement, body, then proof and
+grammar; the project before the outside world; then name. `where=statement|body|proof|grammar`
+filters; `counts` cover all (statement, body, proof; grammar only in `total`). `limit` 1–1000,
+default 100; `next`: the next `offset`. A folded name counts as its owner; references to itself are
+left out.
+
+```json
+{"name": "flt_regular", "direction": "uses", "note": "…", "offset": 0, "limit": 4, "total": 65, "next": 4,
+ "counts": {"total": 65, "statement": 8, "body": 0, "proof": 65, "project": 3, "external": 62, "trusted": 62},
+ "refs": [{"name": "Fact", "kind": "class", "module": "Mathlib.Logic.Basic", "external": true,
+           "where": ["statement", "proof"], "trusted": true, "trustedBy": ["Mathlib"]}, …]}
+```
+
+**Notation** in `uses`: units of `kind: notation` (with `display`). The macro or elaborator that ran
+on the text is at `statement` or `body`; the syntax the text parses with (helper syntax a parent
+notation consumes included) at `where: ["grammar"]`, `grammar: true`, outside the TCB. Notation used
+only in proofs: `where: ["proof"]`, not in the TCB. `where=grammar` lists just the grammar. A
+rule's `uses`: the syntax it interprets (grammar), the meta code it calls, the notation its
+expansion emits.
+
+## Marking targets and keys, and trust (level full)
+
+At level full you do what a person can through the page; below it, 403 saying which level refused.
+Each is checked as the page's requests are and recorded under your name in your own review log,
+`"agent": true`, with your mark in the timeline.
+
+Names resolve as everywhere (`didYouMean`, folded names). `on` defaults to true. The answer says
+whether anything `changed`; if so, `recorded` is the event written; if it was so already, nothing is
+written.
+
+| request | what |
+|---|---|
+| `POST /api/agent/target {name, on}` | mark a project declaration as a target (☆ Target) or take it off. Marking makes no view: `view` (its linked view) is `null` after marking; `next`: the request that puts you on its view, a temporary view of its TCB where it has none. Taken off, its view (if any) stays, unlinked; marked again, nothing relinks it |
+| `POST /api/agent/key {target, name, on}` or `{target, names: […], on}` | mark or unmark key declarations of a target's review; `names` up to 100, each answered on its own (`results`, with `status`). 409 if `target` is not a target; the name must be in its review (`tcb?target=` lists it); the target is always key (400) |
+| `POST /api/agent/trust {prefix, on}` | trust without review, or stop trusting (a default too): a module or namespace, a whole dotted component, or `@external` (everything outside the project). Answers `covers` (`{project, outside}`) and `trusted`, the list after |
+
+```json
+{"ok": true, "changed": true,
+ "recorded": {"op": "target", "at": "…", "by": "Alice's AI", "name": "FltRegular.caseI", "on": true, "agent": true},
+ "view": null, "next": "POST /api/agent/view {\"review\": \"FltRegular.caseI\"} puts you on its view …"}
+```
+
+Views, pins and undoing a layout: [Views](views.md).

package/docs/agent-api/views.md

@@ -0,0 +1,125 @@
+# Views and the layout
+
+Views, their targets and focus, queries, the endpoints, past builds, pins on the Project view.
+
+## Views
+
+A view is a board everyone shares: its **scope** (a query) and arrangement (clustering, folds, pins,
+hidden levels of its cluster tree); each person's camera and selection are their own. The
+Project (`project`) holds everything; it cannot be deleted or renamed (400). A view on a query
+nobody arranges or names is not kept: it lives while someone (a page, or you) is on it; pinning,
+folding or naming keeps it.
+
+- **A target has at most one view**, or none, opened by clicking it anywhere. Marking makes and
+  links none. `views/link` sets it to any view; the view left keeps scope and arrangement.
+- **A view may have several targets** (`targets`, first linked first; a star by its title, which
+  stays as any view's, names them). Its focus starts as its first target; later links leave it.
+- Taking a target off unlinks it alone; its view stays. A target's view is rescoped, renamed and
+  deleted as any kept view; deleted, its targets have no view, and nothing gives them one by itself
+  (not marking, a restart, a build or a rename).
+- A click on a target with no view, or `view {review}` ([following](following.md)), gives it a
+  temporary view of its TCB (`tcb(<target>)`, at the latest build), focused on it and linked while
+  it lasts: kept (pinned, folded, named, rescoped, another target linked), it keeps the link; gone,
+  the target has none again. Making it is no timeline event; nothing else makes a target a view.
+- Views named `review:<target>` (made by marking before) are ordinary views.
+
+## The review is a focus
+
+A view has a focus target or none. With one, the page's review works there — the strip, its line
+of progress, marking key (`k`), why a declaration is in the TCB — over the focus's whole review set,
+whatever the board holds ([tcb](tcb.md)). `focus` (in every answer giving a view) is: as set (a
+target's Key view, opened from its panel: that target; Zoom in: the focus of the view it came from;
+by the first target linked; by anyone), else the first target linked, else the one target its
+board holds, else `null`. Your own focus (`POST view {focus}`) changes nothing of the view.
+
+## The query language
+
+`all`, `tcb(A, B)`, `uses(A)` (everything used), `usedBy(A)`, `refs(A)` (A and what it uses
+directly: the page's Direct), `decl(A, B)`, `key(T)` (the target and the declarations
+marked key for it that its review still holds; `key(targets)`: every target's), `ns(P)`, `file(P)`,
+`trusted`, `external`, `kind(theorem, def)`, `status(unreviewed|approved|commented|stale)`,
+`advice(approve|comment)`, `sorry`, `nonstandard`; joined left to right by `and`, `or`, `except`;
+parentheses group; a closure may take a query (`tcb(ns(P) except external)`); a name that needs it
+is in JSON quotes. A target's review set: `tcb(T) except trusted or (uses(T) and kind(axiom) and
+nonstandard)`. At most 20,000 characters, 32 levels of nesting, 1,000 parts, 2,000 names, 64
+closures (`tcb`, `uses`, `usedBy`, `refs`, each target of a `key(…)`); beyond, 400.
+
+## The endpoints
+
+Under `/api/agent/`; changes are for everyone on the view. MCP: `views`, action the path's last
+part (`list` for `GET views`, `read` for `views/view`).
+
+| request | needs | what |
+|---|---|---|
+| `GET views` | — | per view `{id, title, description, name, scope, clustering, kept, targets?, focus, by, at, version?, on}`: `title` as shown (people's name, else short, "… @ Oct 9 22:27" at a past build), `description` the scope in full, `by` null for the nameless (a private reader), `on` who is on it, `version` the snapshot it is kept at. `unreadable`: kept views the server cannot read now, left untouched |
+| `GET views/view?id=&mode=&members=` | — | scope; holdings `{project, outside}`; items `{add, remove}` (project notes added, taken out: `{id, text}`; `all: true` on the Project); folds; `hidden`; pins; clusters as laid out (`key, depth, count, r, parent, room, at, pinned`), in its own coordinates. `members=1`: its declarations (≤ 5,000) |
+| `POST views/open {scope, version?, clustering?, focus?}` | — | the view on that query (the open one with the same scope and build, or a new unkept one); you are on it: `{view, holds, note}`. `version`: a snapshot id (`null`, `0`, left out: latest); `clustering`, `focus` (the target it is made from): a new one's |
+| `POST views/create {name, scope?, clustering?, from?, version?}` | full | a kept, named view on a scope, or a copy of `from` (scope, clustering, pins, folds, items — on the Project, every note its scope would not give, as added — and build; with `scope`, that scope arranged as `from`); `version` keeps it at a build (the Time Machine's Save as new view), `null`/`0` latest |
+| `POST views/scope {id, scope}` | full | change what it holds (those on it are told) |
+| `POST views/items {id, add?, remove?}` | full | project notes (by id) added or taken out: on the add list only where the scope does not give it, the remove list only where it does. Not the Project (400; deleting is [`note/delete`](notes.md)); 404 for no project note. An Activity event, as a scope change: `{ok, changed, view, items: {add, remove}, notes: [{id, shown}]}` |
+| `POST views/focus {id, focus}` | full | the view's own focus: a target's full name, or `null`/left out; personal focuses stay: `{ok, changed, view}` |
+| `POST views/link {id, target}` | full | link a target (a view with targets takes another; an unkept one becomes kept); not the Project, nor a view at a past build (409): `{ok, changed, view, left?}`, `left` the view it leaves |
+| `POST views/arrange {id, clustering?, hide?, show?, fold?, unfold?, pins?, version?}` | full | `version`: the build it is kept at (Keep this version in this view; `null`/`0`: latest again; never on the Project or a target's view; a timeline event); clustering; `hide`/`show` levels (`[keys]`: a hidden cluster's contents sit in its parent, a fold on it goes, the export's sections follow; nothing on the board moves, pins in what moves keep their place); `fold`/`unfold` (`[keys]`); `pins` `[{name or cluster, at: [x, y] or null}]` in the board's coordinates after hiding/showing (≤ 500; beyond the parent's room brought inside): `{ok, view, changed, hidden, placed, note?}` |
+| `POST views/duplicate {id, name?}` | full | a kept copy (scope, clustering, pins, folds, items as for `create`), named `"<its title> (copy)"` (numbered while taken) unless named; you are on it: `{view, from}` |
+| `POST views/rename {id, name}` | full | `null` removes a kept view's name: `{ok, changed, view}` |
+| `POST views/delete {id}` | full | a kept view, with its pins, folds, layout; pages on it go to the Project. A target's view: `unlinked` names its targets; one timeline event: `{ok, deleted, title, scope, unlinked?, note}` |
+| `POST views/relayout {id}` | full | ⚙ Board's Re-layout: every pin goes, not undoable; folds stay; on the Project the whole graph is laid out anew: `{ok, view, dropped, note}` |
+
+## Views at a past build
+
+Its `version` is a snapshot ([history](history.md)): the pages show that build's graph (a clock on
+its tab, changes since marked), arranged as any view, with that build's layout memory. Not reviewed
+(the review is the latest build's); exported by its id as that build's document
+([export](export.md)); sources: `GET source?name=&snapshot=<version>`. These endpoints answer its
+holdings, clusters and pins at the latest build; a layout they make never becomes its memory. The
+companion shows who is in the Time Machine ([following](following.md)).
+
+## `GET /api/agent/place?name=|cluster=&mode=&near=&limit=` (any level)
+
+`place`, `pins` and `undo` are about the **Project view** (other views: `views/view`,
+`views/arrange`). MCP: `pins` (actions `place`, `pin`, `undo`).
+
+Where a declaration or cluster is (`mode`: `namespace`, default, or `module`), and what else is in
+its parent. Coordinates are in the **parent cluster's frame**, origin at its centre.
+`r`: radius (5 for a declaration); `room`: how far from the centre its centre may go;
+`parent.room`: the parent's usable radius (less its label's room), so a child of radius `r` goes up
+to `parent.room − r`. The page keeps a drop inside. A cluster's key is its full path
+(`systemOfUnits.IsFundamental`); a top-level one has `parent.cluster` and `room` null, in the
+canvas's frame.
+
+`pinned`: its pin (null: at `laidOut`); `pinnedBy`: `{name, agent, at}`, null if unknown (`name`
+null: a private reader, or a page that gave none). An undo's restored pins count
+as the undoer's. `siblings`: the rest of the parent (declarations, clusters), each with `r`, `at`
+(pin or layout), pinned and by whom, nearest first to `nearestTo` (your `near=x,y`, else the thing
+itself); `gap`: free space between the circles were the thing at `nearestTo` (below zero:
+overlap). `limit` 0–2000, default 100; `more`: the rest.
+
+```json
+{ "kind": "node", "key": "systemOfUnits.index", "r": 5, "room": 34.2, …,
+  "parent": { "cluster": "systemOfUnits", "r": 53.1, "room": 39.2 }, "laidOut": [-15.1, 22.9],
+  "pinned": [-10.8, -32.4], "pinnedBy": { "name": "Claude", "agent": true, "at": "…" },
+  "siblings": { "total": 10, "pinned": 1, "nearestTo": [-20, 30], "more": 8,
+    "list": [ { "key": "…", "declKind": "theorem", "at": [-25.4, 22.9], "gap": -1.1, … }, … ] } }
+```
+
+To avoid overlaps, ask with `near=` your spot and move until the first sibling's `gap` is positive:
+on the page a pin pushes aside what is not pinned (a declaration, or a cluster with its contents),
+and the later of two overlapping pins pushes the earlier, so an overlap moves things you did not
+mean to, others' pins included.
+
+## `POST /api/agent/pins` (needs full)
+
+```json
+{ "mode": "namespace", "pins": [ { "name": "systemOfUnits.index", "at": [-15, -45] },
+    { "name": "systemOfUnits.isMaximal", "at": null } ] }
+```
+
+`at` in the parent's frame (`place`); `null` lets go (back to the layout). ≤ 500 per request;
+beyond the parent's `room`, brought inside as a drag is. Pins are shared, live on every page. The
+request is **one batch** in the timeline ("Claude moved 3 declarations"), with each pin's previous
+place. Answer `{ok, id, count, placed: [{key, at}, …]}`; `id` null when nothing changed.
+
+## `POST /api/agent/undo {id}` (needs full)
+
+The batch's pins go back, except those moved since (`kept`): `{ok, id, restored, kept, note?}`; 409
+already undone; 404 no such batch. People undo from Activity. `views/arrange` pins are no batch.

package/docs/agent-api/words.md

@@ -0,0 +1,56 @@
+# Words
+
+The terms the other topics use.
+
+- **Declaration**: a Lean constant of the project (`kind`: def, theorem, structure, inductive,
+  class, instance, abbrev, opaque, axiom, notation, …) or outside it (`external: true`, no source).
+- **Unit**: a declaration of the graph is a command as written; what Lean generates from it unnamed
+  in the text (what a project's declaring command writes beside the declaration it names, `@[simps]`
+  lemmas) is part of it, in `also`, its references, axioms and content hash included.
+- **Folded names**: constructors, structure fields and projections, recursors, matchers, equation
+  lemmas, `also` names are not graph declarations; a reference to one is to its owner. Asked for,
+  an `also` name or a name one component below a declaration or `also` name
+  (`systemOfUnits.units`) is that declaration, unless a typo or two from a declaration beside it
+  (generated last parts like `mk`, `rec`, `eq_1` fold even then); the answer adds `asked`,
+  `foldedInto`, `foldedNote`. `describe` and `print` take the folded name.
+- **Notation** (`kind: notation`): a project syntax extension command (`syntax`, `notation`,
+  `macro`, `macro_rules`, `elab`, `elab_rules`, `declare_syntax_cat`; `local`, `scoped` too) as one
+  unit, its parser and `_aux_` macro or elaborator folded in. Statement: the command's text;
+  `display`: the page's name (`notation · I · in UnitLemmas`); `leanName`: its Lean constant where
+  its name is not one. Names: rules `<kind>.macro_rules`, `<kind>.elab_rules` (`_2`, … for later
+  rules of the kind in the module; `.<Module>` if not in the syntax's module), a syntax its kind, a
+  category `<category>.syntax_cat`. `describe` and `print` of a unit ask about its constant
+  (`unit` in the answer).
+- **Grammar** (`grammar: true`, flag `grammar`): a notation unit only declaring syntax (`syntax`,
+  `declare_syntax_cat`): in no TCB, no review; references to it are `where: grammar`, which a TCB
+  does not follow. A declaration depends on the macros and elaborators that actually ran on its
+  statement or body (of an overloaded kind's rules, that one; with no run in the info tree, the only
+  rule of a syntax its text parses): notation units with an implementation, declarations registered
+  `@[macro]`, `@[term_elab]`, `@[command_elab]`; and on the meta code they call (ordinary units,
+  flagged `meta`). Notation an expansion emits is a dependency of the rule emitting it. A rule
+  lists the syntax it `interprets`; a grammar unit, its `interpretedBy`. Unexpanders, delaborators:
+  in no TCB. Notation from outside the project is never recorded: no use listed, in no TCB.
+- **`where`** a reference sits, one or several: `statement` (the type), `body` (a definition's
+  value), `proof` (a subterm whose type is a proposition).
+- **TCB of T**: everything T's *statement* reaches through statement and body references, T
+  included; proof references never count. Includes the notation units interpreting their text
+  (never grammar) and the code they call. [Targets and their TCB](tcb.md).
+- **Instances of classes whose instances are all equal** (`Decidable`, `DecidableEq`, `Fintype`,
+  `Unique`, …): in no TCB; such an instance argument is a `proof` reference. Instances of classes
+  carrying data (`Add`, `Monad`, `Inhabited`, …) stay.
+- **Needs review**: a TCB member not *trusted*. Trusted: under a trusted prefix (by module, or by
+  name for the project's own; default `Batteries`, `Init`, `Lean`, `Mathlib`, `Std`), and the
+  standard axioms `propext`, `Classical.choice`, `Quot.sound`.
+- **Review order**: bottom-up (what a declaration uses before it; mutual users together), then
+  what more targets rest on, then name. A review judges a declaration assuming what it uses means
+  what it says.
+- **Status** (people's): `commented` if some reviewer's latest opinion on the present version is a
+  comment; else `approved` if one approves; else `stale` if it has opinions, none on the present
+  version; else `none`.
+- **Target**: a theorem whose TCB is reviewed; marked by people, or agents at level full
+  (`markedByAgent`).
+- **Key declaration**: a review member that matters for reading the target (central definitions,
+  the structures under them, the main theorem), marked per target as targets are; the target always
+  is one. A non-key member is **supported by** a key declaration reaching it by statement and body
+  references through non-key members; the **key graph** links key declarations reached so. People
+  review key declarations first.

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "visualproof",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "type": "module",
+  "description": "See a Lean codebase's declaration graph and the TCB of its theorems.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LucianoXu/VisualProof.git"
+  },
+  "bin": {
+    "visualproof": "dist/server/main.js"
+  },
+  "files": [
+    "dist/",
+    "docs/agent-api/",
+    "test/toolchains.json"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build",
+    "serve": "node src/server/main.ts serve",
+    "typecheck": "tsc --noEmit -p .",
+    "test": "node --test --import ./test/setup.ts \"test/*.test.ts\"",
+    "test:toolchains": "node scripts/test-toolchains.mjs",
+    "golden:update": "VP_GOLDEN_UPDATE=1 node --test --import ./test/setup.ts test/compat.test.ts"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.2.0"
+  },
+  "dependencies": {
+    "d3-hierarchy": "^3.1.2",
+    "pdfjs-dist": "6.3.289"
+  },
+  "devDependencies": {
+    "@types/d3-hierarchy": "^3.1.7",
+    "@types/node": "^24.0.0",
+    "esbuild": "^0.28.2",
+    "typescript": "^5.9.0"
+  }
+}

package/test/toolchains.json

@@ -0,0 +1,5 @@
+{
+  "policy": "The last six or so stable Lean releases, and whatever the showcase project needs (v4.34.0-rc2, for NavierStokesAndEuler); v4.28.0, for the sphere packing formalization (the showcase before it), stays the floor; the newest patch of each minor release.",
+  "floor": "v4.28.0",
+  "toolchains": ["v4.28.0", "v4.29.1", "v4.30.0", "v4.31.0", "v4.32.2", "v4.33.1", "v4.34.0-rc2", "v4.34.1", "v4.35.0"]
+}