# Plan One list of what is still to do, organized to be picked up and executed. Nothing here is done; done work is described in the design notes below, which also hold the rationale each section links to. Sizes: **S** ≈ an hour, **M** ≈ a day, **L** = multi-day, or wants a design conversation first. Items are numbered so a commit or a conversation can name one. ## How to work in this repo (read first) - Full check: `PATH="$PWD/node_modules/.bin:$PATH" TEST_browser=true TEST_cli=true TEST_server=true npx mocha packages/*/test/*test.js -C -R dot` (`npm run test-all` adds `TEST_sparql`/`TEST_wikidata`, which need the network). The pre-commit hook runs the *ungated* suite; the gates hide their own fixtures, so a green ungated run says less than it looks. - TypeScript packages compile per package: `cd packages/

&& npx tsc`. The compiled `lib/*.js` is **built, not committed** (B3): `npm run compile` (`make ALL`) builds every package in order, and the `prepare` script runs it on `npm install`/`npm ci`, so a source change is not also a `lib/` change to stage. What stays tracked in `lib/` are the sources that live there: the `.jison` grammars, the `.wat`/`.wasm`, and shex-cli's three hand-written `.js` (no `src/` counterpart). - The browser bundles in `packages/*/doc/webpacks/` are **gitignored and built on demand**: `npm run webpack` (all three) or `npm run webpacks-all` (n3js too). Rebuild after changing any bundled package, or the browser tests run stale code. The app's page scripts are TypeScript, `packages/shex-webapp/src/app/*.ts` compiled into `doc/` by `npm run build` there; served raw, not bundled. - `doc/tests-manifest.yaml` is generated: `node tools/aggregate-manifests.js` after editing any of the three package manifests (a test checks it). `manifest.json` and `manifest.yaml` must stay deep-equal where both exist. - jsdom smoke tests (`TEST_browser=true`) drive the real pages: prefixed names in fixtures (relative IRIs resolve against the page URL); drive a click, then `await shared.promise`; the app refuses a second validate within 100 ms of a failure ("see shape map errors above"); gutter breakpoints are line-granular; `Harness.expectClean(errors)` in an `after` fails on console errors the suite did not expect. - ShExC gotcha: cardinality precedes semActs (`:p . ? %Map:{ :v %}`). - CLIs: `--help`/usage exits 1; a status-0 run leaves stderr empty. - HTTP test fixtures serve on literal `127.0.0.1`, never `localhost`. - Commits end with a `Co-Authored-By:` trailer for the model. ## Design notes | note | about | where it stands | | --- | --- | --- | | [plugins.md](plugins.md) | the plugin contract | normative; keep current | | [editor-integration-plan.md](editor-integration-plan.md) | editors, source ranges, error anchoring | phases 0–4 done; leftovers in §D | | [debugger-design.md](debugger-design.md) | stepping, breakpoints, capture + replay | phases 1–6 done (live worker-gate stepping + one unified panel); only E12 deferred | | [error-reporting.md](error-reporting.md), [error-normalization.md](error-normalization.md), [error-reporting-comparison.md](error-reporting-comparison.md) | structured errors, repairs | F0–F6 done and merged; one decision left, §G | | [../packages/extension-map/doc/threaded-materializer.md](../packages/extension-map/doc/threaded-materializer.md) | the NFA materializer | design; leftovers in §F | ## B. Web app The split, the harness, the manifest runner, `app.settled()`, WorkerTask, the one page, the dependency cleanup, plugin-borne data sources, the page scripts' move to TypeScript and the untracked `.map`s are done (B1–B10, 2026-08-28). What is left: - **B1 (done 2026-08-29) The app's TypeScript, narrowed.** Every class in `packages/shex-webapp/src/app/*.ts` declares its fields and takes typed parameters; the index signatures are gone (the few left are on interfaces for genuinely open records: a worker message's payload, a plugin descriptor's own keys); the mixin files declare what they add (`interface ShExBaseApp {…}` merged per file, `mixin()` typed with `ThisType`); `tsconfig.app.json` is `strict: true` with `useDefineForClassFields: false` (a declared field must not emit). `noImplicitThis` found three nested functions reading `this` as the app -- the drag-and-drop `inject`, the LOG_PROGRESS trace's `sm`, the shape-map menu's failure report -- each a TypeError waiting; fixed. Left `any`, honestly: what arrives through the bundles' globals. `RdfJs` now types against `@rdfjs/types` (#453); the rest stay `any` -- jQuery, CodeMirror, marked, N3js and IRI are CDN-loaded with no `@types/*`, and `ShExWebApp` (the repo's own bundle) has no `types` entry -- narrowing them wants `@types/*` added and a `strict` cascade absorbed, deferred. `extension-wasi*` are TypeScript too (same day), and so is the CLI: `shex-cli/src/validate.ts` -> `lib/validate.js` behind a two-line `bin/validate` (`module: node16`, which keeps the script's native `import()`); `ShExUtil.warnDuplicates`, which did not exist, is `Merger.warnDuplicates` now, and `--invocation`/`--dry-run` have their help text back (`desc` was never read). Nothing in the app or the CLI is JS by accident any more: the two worker threads and the vendored iri.js are, on purpose. - **B2 (done 2026-08-29) Plugin packaging.** `ShExMapPlugin.js` is built from `packages/extension-map/src/plugin/ShExMapPlugin.ts` (`tsconfig.plugin.json`, the app's page-script arrangement: classic script, declared fields, no index signatures; `npm run build` there compiles both the library and the plugin). Not a webpack bundle, and not a package of its own -- decided (2026-08-29): the plugin has no dependencies to pack, `doc/webpacks/` is gitignored and CI-built so a bundled plugin would be missing from a fresh checkout, and a package move would change the `packages/extension-map/doc/` URLs the site and the permalinks use. Revisit only if the plugin grows dependencies of its own. - **B3 (done 2026-09-04) `lib/*.js` is built, not committed.** A `prepare` script (`make ALL`) builds it on `npm install`/`npm ci`, and `ci.yml` runs `npm run compile` in the test, webpack and coverage jobs -- so a `src` change that stops compiling fails CI instead of passing on a stale committed `lib/`, and `lib/` is out of every diff. It surfaced exactly that: a from-clean build caught neighborhood-wikibase no longer compiling under the `@rdfjs/types` 2 bump (fixed in the commit before). `.gitignore` ignores `packages/*/lib/*.js` with three exceptions -- shex-cli's hand-written `ExitCode`/`ProgressLoadController`/`ShExDebugRepl` `.js`, which have no `src/`; the `.jison`, `.wat` and `.wasm` beside them are sources too and stay tracked. Published tarballs are unaffected (`files` lists `lib`, and `prepare`/`prepublishOnly` build it before pack). The `.map` files are untracked (`.gitignore`: `packages/*/lib/*.map`) and are not what debugging a minified bundle needs: that is the *bundle's* map, which webpack would write beside `doc/webpacks/*.min.js` (`devtool: "source-map"`, not set today) and chain back to the `.ts` through `source-map-loader` reading the `lib/*.js.map` tsc leaves on disk at bundle time -- present after `npm run build`, never committed. ## C. Plugins The trust prompt for a plugin from another origin is in (C2, 2026-08-28; plugins.md, "Trust"), and the two layout decisions are recorded there: a link that names a plugin opens on the validator's screen unless it says `screen=` (C3), and panes share a column unless `panel:` says otherwise (C4). - **C1 (closed 2026-09-04 — won't do)** Publishing the skeleton as a repository of its own buys nothing right now: it has no dependencies to pack, no consumer is waiting on an installable package (a plugin author copies `doc/plugin-skeleton/`, they don't `npm i` it), and a separate repo is standing overhead — a release to keep in step with the plugin contract in `plugins.md`. `doc/plugin-skeleton/` stays in-tree as the worked reference (README + package.json, 2026-08-28); revisit only if someone actually needs to `npm create` a plugin. - **C6 (done 2026-08-31) Eval and Test in the WebApp.** Each has a plugin (`extension-eval/doc/ShExEvalPlugin.js`, `extension-test/doc/ShExTestPlugin.js`) -- one classic-script file with both faces: on the page it registers a descriptor whose `register` installs the handler, and, named as its own `worker`, the same file registers the same handler where a worker app's matcher is -- and an `examples/manifest.yaml` (pass and fail each), aggregated into doc/tests-manifest.yaml. Loading either lib file directly as `?plugin=` still works (handler-only, no worker half). Found on the way: the Eval extension's documented bool return was "unsupported response" against today's validator, untested since ever -- a bool is normalized now (lib and plugin), and extension-eval has tests. The stale `@shexjs/util` dependencies (neither extension requires anything) are gone. - **C7 (done 2026-08-31) WASI in the WebApp.** A bundle (`extension-wasi/doc/webpacks/shexwasi-webapp.js`, wabt and both WASI extensions over the core bundle's global; `npm run webpack` builds it beside the others) and two dual-face plugins: `ShExWasiPlugin.js` (WAT semantic actions compiled by wabt in the page) and, in extension-wasi-test/doc, `ShExWasiTestPlugin.js` (the wasm Test module, its bytes fetched from lib/ and handed to `configure({wasm, stdout: false})` -- both options new: a browser has no file descriptors and no `__dirname`). What it took: the prelude is a generated module (`tools/gen-prelude.js`, so no Fs in `prelude()`), the shim paths speak Uint8Array rather than Buffer, `WasmPath` is computed lazily (the bundle externalizes the node builtins to undefined, and a top-level `Path.join` was the whole bundle failing to evaluate), a plugin `init` may return a promise that rides `applied` (wabt and the wasm fetch finish before a manifest entry validates), and the repo test server read every file as utf8 -- a .wasm served as text is a CompileError. Each extension has a pass/fail manifest, aggregated (41 entries from 7 manifests). The worker race is closed too (same day): a worker plugin hands `registerWorkerPlugin` a `ready` promise -- wabt, the wasm fetch -- and the worker thread awaits every plugin's `ready` before serving any request, as the page awaits `init` through `applied`. - **C5 (note)** The worker is classic; an ESM worker (`type: "module"`) would need a different loader. Not now. ## D. Editors The query map is the third managed editor (D1: the shape-map grammar records where each pair was written, `parseShapeMap` lints and locates it, its pairs point at the schema and the data), hovers say what they point at (D2, `HoverRegion.title`), completion reads the schema pane as it stands (D3), the harness checks consoles (D4, `Harness.expectClean`), a ShExJ, ShExR or DCTAP schema is located in the text it was written in (D5, `synthesizeLocations`; `lintSchema` lints each in its own language), and `parseShExC`/`parseTurtle` key their memo on every option (D9) -- all 2026-08-28. millan (D6) had been superseded by lezer-turtle before this list was written; the data pane's two parses (lezer for provenance, N3 for validation) are memoized and stay. The schema pane parses ShExC with a Lezer grammar of its own (D7, 2026-08-29): `packages/lezer-shexc` ports the specification's grammar in the LALR shape `ShExJison.jison` gives it, every schema in the ShEx test suite parses without an error node, and a half-typed schema parses around its error -- exact colours by role (a shape's label, a reference, a predicate, a datatype), folding, bracket matching, incremental re-parse. `@shexjs/parser` still makes the schema; the tree is the editor's. ts-jison's empty-production location wart (D8) is fixed upstream and published: `@ts-jison/parser` and `@ts-jison/common` 0.4.1-alpha.3 (ts-jison branch `empty-production-locations`, tag `v0.4.1-alpha.3`); the parsers depend on it and `tripleConstraint` takes its merged `@$` as is (2026-08-29). Nothing is left in this section. ## E. Debugger The capture is by the selected engine and the replay by eval-simple-1err's stepper, the status saying so when they differ (E1), and a replay runs no semantic action: they answer from what was recorded at capture (E3, `recordingSemActHandler`/`replayingSemActHandler` in validator-api); the validator's tracker is the typed shape-level event source (E8, `ShapeDebugEvent`/`eventTracker`, which `shex-debug` rides); the regex hooks say which thread asks and what came of each constraint (E7, `ConstraintThreadView`, `onConstraintResult`); hovering a thread in the web debugger lights its matched partition in the data pane (E2, `quadRanges`); the web debugger takes `bp PREDICATE` and `bn NODE` breakpoints as shex-debug does and shows a thread's state as a table (E4); a gutter breakpoint is the constraint its line begins and ctrl-alt-b sets one at the cursor (E5, `toggleBreakpointAt`, `exprsStartingIn`); the two CLI debuggers share one REPL skeleton (E6, `DebugRepl` in editor-services: I/O, located schema, prefixes, breakpoint records, the command loop), their transcripts unchanged -- all 2026-08-29. Short, high value: Larger, design conversation first: - **E9 (engine done 2026-09-04)** Live whole-validation stepping's suspension mechanism: `worker-gate.ts` in `@shexjs/eval-validator-api`. `WorkerGate.gate(event)` runs in the worker -- the validator's tracker and the regex engines' `debugHooks.onConstraint` call it (same wiring as `shex-debug`) -- and on a pause posts the (serialized) event and `Atomics.wait`s on a command cell in a SharedArrayBuffer; `GateController` in the controlling thread writes into/over/out/continue/abort and `Atomics.notify`s, abort throwing `DebugAbort` out of the engine. The breakpoint model is **decided**: frozen while the worker runs, editable only while paused -- a resume carries the (possibly edited) breakpoints as a JSON payload in the same buffer (shapes/predicates/nodes by lexical string, constraints by `schemaTripleConstraints` ordinal, the clone-safe key both ends derive from their schema copy), so the worker adopts them the instant it wakes and never races the controller mid-search. The CI harness the plan asked for is `WorkerGate-test.js`: it runs the real validator in a `worker_threads` worker and drives it from the test thread (into walks the event tree; continue runs free; a predicate or ordinal breakpoint *set during a pause* fires; over skips a shape's body; abort reports aborted). `shex-serve --coi` and clone-safe anchors were already in place. What remains is browser-only and lands with E10 (see there). - **E10 (browser live-stepping done 2026-09-04)** The browser end of E9's mechanism, wired into the existing validation debug panel. The capture+replay 🐞 stays the default (no isolation needed); a new 🐞▶ beside it steps the *whole* live validation. `ShExWorkerThread.js` gained a `debugValidate` request that builds a `WorkerGate` over a page-supplied SAB and runs a gated `validateShapeMap` (the browser twin of `worker-gate-worker.js`); `shex-webapp.js` re-exports the gate primitives onto the `ShExWebApp` global; `startValidationDebugSessionLive` runs a *dedicated* worker (so ⏹ terminating it never disturbs the app's own validator) and drives it through a `GateController`, reusing the panel's step controls, gutter/predicate/node breakpoints and status line and reading the breakpoints fresh at each step (`currentValWireBreakpoints`, the editable-while-paused half of the model; constraints cross by `schemaTripleConstraints` ordinal). The 🐞▶ button shows only when `crossOriginIsolated` (`shex-serve --coi`). CI covers the wiring (button present/titled/hidden-without-isolation) and the unchanged capture+replay path; the live stepping itself needs a truly-blocking worker thread the in-process shim can't provide, so it rides E9's `worker_threads` harness for the mechanism and a cross-origin-isolated browser for the glue. **Unified panel done (2026-09-04):** the validation debugger and the ShExMap materializer debugger now share one control strip, status line and thread list (core, in `shex.html`/`shex-app.css`) -- they never step at once (a validation finishes before its materialization starts), so the app's `activeDebugSession` is whichever is live and the shared buttons route to it. `ShExMapPlugin` stops generating its own strip and keeps only the `#debugMaterialize` trigger; every ShExMap page redirects to `shex.html`, so the static strip is always present. - **E11 (done 2026-09-04)** Worker-app materializer debugging. The step session's `MaterializerDebugger` runs in the page even when the app validates in a worker (`app.remote`): its inputs -- output schema, bindings, shape map -- are all in-page panes (the worker's validation populates the bindings pane), so re-materialization is deterministic and its `accepts`/`lastReport`/breakpoints never need to cross `postMessage`. `shexmap-editors-smoke-test.js` pins it with a worker-mode stepping test (breakpoint, step, accept, rendered graph). The clone-safe anchoring the design worried about is only the *whole*-materialize path's, which already names constraints by ordinal (`RemoteShExMaterializer`). - **E12 (deferred)** A steppable eval-threaded-nerr is a rewrite (recursive matcher, hot-path generators); only when "why these N errors" becomes a debugging goal. ## F. Materializer (`ThreadedMaterializer`) The acceptance order is pluggable (F2, `options.prefer`: a caller weighs forfeited bindings or coverage as it likes; the default order stands), a cycle through And/Or references is refused by name rather than overflowing the stack and ShapeNot stays a clean error (F3), and `options.requireBindingsInSubshapes` drops the islands a static-only optional subshape would emit unasked (F4) -- all 2026-08-29. - **F1 (worklist dedup done 2026-09-04; lazy-DFA deferred)** The PikeVM worklist dedups on (stateNo, callStack, cursor, repeats), pruning redundant threads at pop (`ThreadedMaterializer`'s `seen` set, reported as `lastReport.configsPruned`); it subsumes the post-accept `exploreSteps` budget that could settle for a suboptimal accept. The lazy-DFA the design note sketches beyond it stays deferred -- a further optimization, not a correctness gap. ## G. Errors and validation A closed shape's refusals are repairs (G2, 2026-08-29): "remove it", added to every way the bag has, or alone where the bag was fine. The feasibility layer was checked where it looks away (G4, `FeasibilityCoupling-test`): over every small bag of five coupled expressions it never refutes one the language accepts; what the check found wrong was elsewhere, and is fixed -- the parser copied a group's cardinality onto a single constraint over the constraint's own (`( :a . {2} ){1,3}` became `:a . {1,3}`; it is a one-element EachOf now), and both engines mishandled a group taken zero times over a node with none of its arcs (the threaded one answered nothing and the validator fell over it; the stepper reported a missing property). The old notes are settled (G5): the EXTENDS-over-a-twice-constrained- predicate question is a test (`ExtendsRepeatedPredicate-test`), the ShEx-1-era CLI cases are gone already, and the writer rename is in §I3. - **G1 (decided 2026-08-29)** Rather than replace the classic errors with the repairs outright, the reader chooses: `explain` = `both` (repairs, then the errors under them; the default), `repairs` or `errors` -- `errsToSimple`'s option, `validate --human --explain`, the app's "explain failures" menu item, `?explain=` and a manifest key. A failure the validator put no repair to keeps its errors whatever was asked. Replacing for good, and rewriting the failure fixtures once, waits on the repairs having been read in anger (error-normalization §4, step 4). - **G3 (done 2026-09-04)** Assignment when several constraints could take a triple (a predicate constrained twice with different value expressions): the repair search now carries the satisfaction relation (which constraints each triple could satisfy, the validator's `t2tcs`) and assigns each triple to one it satisfies, pricing every resulting count-vector -- a min-cost bipartite assignment, capped at `DEALS`. Same-value-expression duplicates fall out as the special case (every triple satisfies both), reproducing the old stars-and-bars deal. `{ :p [a b c] ; :p [a b] }` over a, b, c now says "remove 1 :p", not "remove 2 :p and add 1 :p". (`Repairs-test`; `NearestAcceptedBag.deals` in `repairs.ts`, fed from `shex-validator.ts`.) ## H. Data sources - **H1 (not blocking; QLever optional)** The SPARQL suite does **not** need QLever: its default endpoint is in-process **Comunica** (`@comunica/query-sparql-rdfjs`, a devDependency) over an `N3.Store` (`neighborhood-sparql/test/sparql-test-server.js`, started in a Worker by `launchEndpoint`), and the "results re-writer" is already there -- `termToJson` + the `{head,results}` envelope on the producing side, `ShExUtil.parseSparqlJsonResults` on the consuming side (SPARQL 1.1 JSON, round-trip proven by the suite passing). The fixtures are tiny, so an in-JS engine suffices; large scale (Wikidata) is a *runtime* concern that points `neighborhood-sparql` at a remote HTTP endpoint, not the local test engine. QLever stays an **optional** conformance target (`SPARQL_ENDPOINT=…`) -- a real third-party store exercises bnode relabeling, literal normalization and long-query POST that Comunica is too lenient to; the suite already passes on a native QLever build once `neighborhood-sparql` emits correlated `MINUS` rather than `NOT EXISTS` (which it does, at `neighborhood-sparql.ts:502`). The `NOT EXISTS` planner blowup (draft PR ad-freiburg/qlever#3190) now matters only for emitting `NOT EXISTS` directly; keep the repro. ## I. Toolchain and repo hygiene The Makefile is hand-maintained; the generator it grew out of (`tools/makeMake.js`) had stopped running and is gone (I2, 2026-08-29). - **I1 (done 2026-08-29)** `perf/fhir/corpus/examples`: 2,172 tracked files, 33 MB of an 82 MB pack -- tracked from before `.gitignore` got `perf/*/corpus/` and `perf/fhir/fetch.sh` was written to fetch the published FHIR build, which is what `bench.js` means to run against. Recommendation (2026-08-29): `git rm -r --cached perf/fhir/corpus` and nothing else -- the fetch script is the corpus's source of truth; a fresh clone runs `perf/fhir/fetch.sh` once. The 33 MB stays in history (the pack shrinks only with a history rewrite, which a public repository with forks should not do for 33 MB; `git clone --depth 1` is the cheap clone). Not git-lfs: quota and bandwidth on GitHub, `git lfs install` for every contributor, and a corpus that is an upstream artifact anyway. Not a fixture repository: a submodule's friction buys nothing for files nobody hand-edits. - **I4 (done -- published 2026-08-31, completed 2026-09-05)** What a `publish-ordered` run needs first. Never published: `lezer-shexc`, `@shexjs/editor-services`, `@shexjs/neighborhood-wikibase`, `@shexjs/extension-wasi`, `@shexjs/extension-wasi-test` (the order handles them; `extension-wasi` now has `publishConfig.access: public`, without which a scoped publish is refused, and `extension-wasi-test` no longer needs `wat2wasm` on the publishing machine). `lezer-turtle` is a `github:` dependency of `editor-services` and `cli` -- published 2026-08-30, and depended on as `^0.1.0`. `npm pack` includes whatever `doc/webpacks/` holds on disk (the root `.gitignore` does not reach a workspace's tarball), so `prepublishOnly` in `webapp`, `extension-map` and `extension-reduce` builds the bundles first. Then `node tools/bumpVersions.js 1.0.0-alpha.30`, `npm install`, the suite, tag, `node tools/publish-ordered.js --tag latest` (npm 11 refuses a prerelease with no dist-tag, and the alphas have always been `latest`; the tool insists on one up front). A dry run on 2026-08-30 (`--dry-run --tag latest`, before the suite bump) published nine and skipped twenty whose versions the registry already had. Published for real 2026-08-31 (tag `v1.0.0-alpha.30`, fff21dfe); a partial run left seven behind (editor-services, extension-reduce{,-js}, extension-wasi{,-test}, neighborhood-wikibase, semact-overlay), published from the tag 2026-09-05 to complete 29/29. - **I5 (done 2026-08-30) Two version lines.** Packages with an audience outside shex.js -- `shape-map`, `lezer-shexc`, `lezer-turtle` (its own repository, on npm as of today) -- are on version lines of their own; their shared base is `@shexjs/term`, independent too. `Start` is defined once, in term (`Start`, `isStart` for a copy that came through JSON or a worker), and `neighborhood-api`, the validator and the ShapeMap parser all read that object -- the `ShapeMap.Start = Validator.Start` assignments are gone. `unescapeText` lives in term; util re-exports it; `shape-map` and `shex-parser` depend on term, not util. Root package.json's `shexjs.independent` lists the tier: `bumpVersions.js` leaves those versions and the ranges pointing at them alone, and `publish-ordered.js` skips a package whose version the registry already has. Rule: suite -> tier with `^`; tier -> tier; tier never -> suite. Their versions are theirs to move: `shape-map` published `1.0.0` with alpha.30 (no util); `1.1.0` is staged in-tree for the next release. - **I6 (staged 2026-08-30) `lezer-shexc` is its own repository**, `shexjs/lezer-shexc` (the org, not a personal account: the rdfjs model, where the same maintainers hold the implementation and its grammars -- as `rdfjs/N3.js` publishes `n3`, `shexjs/lezer-shexc` publishes unscoped `lezer-shexc`). It had no `@shexjs/*` dependency, one consumer (`editor-services`, as `^0.1.0`, the way it already takes `lezer-turtle`), an ESM/lezer-generator toolchain foreign to this repo, and a Lezer contributor should need `npm i && npm test` on a grammar and a corpus, not this monorepo. It tests against `shex-test` as its own `github:` devDependency (or `SHEX_TEST=../shexTest`), commits the generated parser with a `prepare` build and a CI check that they agree. Gone from `shexjs.independent`, the Makefile and the workspace; published as 0.1.0 and pushed the same day, and package-lock.json resolves editor-services' `^0.1.0` from the registry. A wrinkle worth knowing: with the old lock still declaring a `packages/lezer-shexc` workspace, `npm install` was a no-op -- the range read as satisfied, and `npm ci` re-made a dangling link to the missing directory (`EditorPanes` then fails with "Cannot find module lezer-shexc") -- so the two `lezer-shexc` entries had to be deleted from the lock by hand before `npm install` would ask the registry. `semact-overlay` stays: it imports `@shexjs/visitor`, sits on the lockstep line and co-owns the validator's `semActIndex` contract with `extension-reduce`; a package leaves when its dependency on shex.js is on a released API rather than a co-developed one. - **I3 (done 2026-09-05)** The dependency majors, taken. The eight-safe batch landed in #444 (chai 6, eslint 10, glob 13, js-yaml 5, koa 3, n3 2, jquery 4; jsonld was already `^9`), green on the CI Node-20 lane. The ESM-only pair went to built-ins rather than the bumps -- **node-fetch dropped for the global `fetch`** and **chalk for an inline TTY underline** (#445; both were ESM-only, breaking `require()` on Node 18-20.18). `rdf-data-factory` 2 (#446) and `webpack-cli` 7 (#447) followed; **`typescript` 7 stays out** -- it is the native Go port ("tsgo"), whose main entry no longer exports the classic compiler API `ts-jison`/`ts-loader` need. The dev-major tail `mocha` 12 + `sinon` 22 is in (#450), **pre-commit → husky** done (#451, clearing the `cross-spawn` audit finding), and the `ShExWriter` → `ShExCWriter` rename done (#452). Remaining `npm audit` findings are in `@ts-jison`'s transitive chain. ## Decisions wanted - **ShExMap's IRI ends in `#`.** Every other extension is named `http://shex.io/extensions//`; Map's is `http://shex.io/extensions/Map/#`, so its prefix declarations read `PREFIX Map: ` and its plugin id, the `screen=` value and `semActHandler.results` key all carry the `#`. Either normalize it (a breaking change for every ShExMap schema, so with a period of registering the handler under both IRIs) or document it as the one exception. Surfaced while listing the extensions on index.html. - (`shape-map` published `1.0.0` with alpha.30; `1.1.0` is staged for the next release.)