@fossil-lang/wasm 0.3.0-alpha.2 → 0.3.0-alpha.20

package/pkg/fossil_wasm.js

@@ -6,6 +6,24 @@
  *
  * `Copy + Clone + Eq + Hash` so it can be a `HashMap` key on the Rust
  * side; `#[wasm_bindgen]` so JS can pass it back across the boundary.
+ *
+ * # Every exported method takes `&FileHandle`, and it has to
+ *
+ * wasm-bindgen CONSUMES an exported struct passed by value: the generated glue
+ * calls `__destroy_into_raw()` on the JS wrapper, which nulls its pointer. A
+ * handle passed by value is therefore good for exactly one call, and the second
+ * throws *"null pointer passed to rust"* — from inside a method that has nothing
+ * wrong with it, naming no handle and no file.
+ *
+ * `Copy` does not save it. The derive is a Rust-side property; nothing about it
+ * reaches the JS boundary, where this is a class holding a pointer like any
+ * other. The three methods a host calls repeatedly with one handle
+ * (`update_file`, `close_file`, `diagnostics_for`) take `&FileHandle` so
+ * wasm-bindgen borrows instead, and the handle stays live across the whole
+ * lifetime `open_file`'s doc comment promises.
+ *
+ * This was reachable from the FIRST loop an editor runs: `updateFile(h, text)` on
+ * every check, with the handle `openFile` returned once.
  */
 export class FileHandle {
     static __wrap(ptr) {
@@ -28,143 +46,238 @@ export class FileHandle {
 if (Symbol.dispose) FileHandle.prototype[Symbol.dispose] = FileHandle.prototype.free;
 
 /**
- * JS-facing handle for the Fossil compiler running inside a WASM module.
+ * The JS-facing workspace — `FossilWorkspace` on the JS side, and a
+ * `RefCell` around the Rust one.
+ *
+ * # Why the interior `RefCell`, and it is not a style choice
+ *
+ * `wasm-bindgen` wraps every exported struct in its own `WasmRefCell`. A
+ * method taking `&mut self` borrows that cell EXCLUSIVELY for the call, and a
+ * failed borrow does not return — it panics, with
+ * *"recursive use of an object detected which would lead to unsafe aliasing in
+ * rust"*. On `wasm32-unknown-unknown` a panic is an abort: the trap unwinds
+ * nothing, so the borrow flag it was holding is never cleared, and **every
+ * later call on that object fails the same way for the life of the module.**
+ * One bad call poisons the workspace permanently.
+ *
+ * That is a real defect and it was reachable from correct host code: an
+ * editor reproduced it by typing sixteen characters faster than its
+ * debounce, and had to carry a `busy` flag and a 120 ms coalesce to stay
+ * out of it. A mitigation a host has to remember is not a fix — and an editor
+ * is precisely the workload that forgets.
  *
- * One instance owns one [`WasmDb`] (Salsa store + injected [`WasmSystem`]
- * + `Arc<OutputDescriptorKind>`). Hosts construct a single playground per
- * browser tab / Node process and reuse it across all method calls to
- * amortise the Salsa interning + memoisation overhead.
+ * So no exported method takes `&mut self`. Every one takes `&self`, which
+ * wasm-bindgen borrows SHARED — shared borrows nest, so re-entry cannot fail
+ * there — and the mutation goes through this `RefCell` with
+ * `try_borrow_mut`. Genuine re-entry (a JS callback that calls back in while a
+ * call is live) now returns a catchable `Error` naming what happened, and
+ * **the workspace is still usable afterwards**, because a returned `Err` drops
+ * its guard where a panic did not.
+ *
+ * The Rust-side [`FossilWorkspace`] keeps its `&mut self` signatures
+ * untouched: the native tests drive it directly. Only the JS boundary changed.
  */
-export class FossilPlayground {
+export class FossilWorkspace {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FossilPlaygroundFinalization.unregister(this);
+        FossilWorkspaceFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fossilplayground_free(ptr, 0);
+        wasm.__wbg_fossilworkspace_free(ptr, 0);
     }
     /**
-     * Run `parse → def_map → typecheck_mapping` across every open file and
-     * return a flat JS array of `{ uri, range, severity, message }` rows
-     * keyed by file URI. The LSP Worker (07-03) republishes these grouped
-     * by URI as `textDocument/publishDiagnostics` notifications.
+     * Every open **program**'s diagnostics as a flat JS array of
+     * [`CheckRow`]s keyed by file URI — the diagnostics panel's view. It is
+     * NOT the LSP wire's shape; see [`CheckRow`].
+     *
+     * A buffer the installed provider catalogue claims — a `.shex` being
+     * edited, a `.csv`, a `.parquet` — is an INPUT and is not parsed as fossil.
+     * [`fossil_ide::diagnostics()`] is where that is said and measured, for both
+     * hosts.
      *
      * `range` is the UTF-16 LSP range (via `fossil_ide::LineIndex` — the
-     * rust-analyzer model from 06-05). `severity` is the LSP integer
-     * constant (1 = error, 2 = warning, 3 = info). `message` carries any
-     * `suggestion_source` as a `\nhelp: ...` suffix (mirroring `fossil-lsp`
-     * `to_lsp_diagnostic` in 06-09).
+     * rust-analyzer model). `severity` is the LSP integer constant
+     * (1 = error, 2 = warning, 3 = info). `message` is the problem rendered
+     * and nothing else; `help` is its own field.
      *
      * # Errors
      *
-     * Returns a JS error only if the result fails to serialize to `JsValue`.
+     * Returns a JS error if the workspace is busy, or if the result fails to
+     * serialize to `JsValue`.
      * @returns {any}
      */
     check() {
-        const ret = wasm.fossilplayground_check(this.__wbg_ptr);
+        const ret = wasm.fossilworkspace_check(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Return the stdlib classification manifest as a JS array of
-     * `{ name, wasm_class }` objects (STDL-07).
+     * Close a file in the workspace. Idempotent in spirit but strict in
+     * signal: closing an unknown / already-closed handle is an error so
+     * JS-side bugs surface loudly (mirrors `ty_wasm`).
      *
-     * `wasm_class` is the string `"pure_sql"` or `"native_udf_only"`. The
-     * playground reads this once at startup to render `native_udf_only`
-     * functions as disabled with a "native-only — unavailable in the browser"
-     * tooltip (SC#1 playground half). `DuckDB`-WASM cannot register the Rust
-     * UDFs those functions need (Pitfall 3), so the classification is the
-     * authority on what is runnable in-browser.
+     * # Errors
      *
-     * This is pure read-only data projected from the `&'static`-ready
-     * `fossil_registry::FunctionRegistry` — no `DuckDB`, no native UDF code,
-     * WASM-clean.
+     * Returns a JS error if `handle` was never opened or was already closed,
+     * or if the workspace is busy.
+     * @param {FileHandle} handle
+     */
+    close_file(handle) {
+        _assertClass(handle, FileHandle);
+        const ret = wasm.fossilworkspace_close_file(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The completion candidates at a position: `{ label, kind, detail, insert }` rows,
+     * already narrowed by the receiver — `str.` offers string members and no
+     * reader, a property key position offers the target shape's predicates and
+     * no catalogue row.
+     *
+     * `kind` is the LSP `CompletionItemKind` **by name** (`"function"`,
+     * `"field"`). See [`ide::CompletionRow`] for why a number does not cross
+     * this boundary.
      *
      * # Errors
      *
-     * Returns a JS error only if the manifest fails to serialize to `JsValue`.
+     * Returns a JS error if the workspace is busy, or if the result fails to
+     * serialize to `JsValue`. An unknown handle is an empty array.
+     * @param {FileHandle} handle
+     * @param {number} line
+     * @param {number} character
      * @returns {any}
      */
-    classification() {
-        const ret = wasm.fossilplayground_classification(this.__wbg_ptr);
+    completions(handle, line, character) {
+        _assertClass(handle, FileHandle);
+        const ret = wasm.fossilworkspace_completions(this.__wbg_ptr, handle.__wbg_ptr, line, character);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Close a file in the workspace. Idempotent in spirit but strict in
-     * signal: closing an unknown / already-closed handle is an error so
-     * JS-side bugs surface loudly (mirrors `ty_wasm`).
+     * Per-file diagnostic drain: `check()` returns the workspace-wide flat
+     * array, this returns one file's rows, so a host can refresh one buffer's
+     * panel without partitioning the workspace array on the JS side. It is NOT
+     * the LSP wire's shape — that is [`fossil_ide::lsp_diagnostics`].
      *
      * # Errors
      *
-     * Returns a JS error if `handle` was never opened or was already closed.
+     * Returns a JS error if `handle` is unknown, if the workspace is busy, or
+     * if serialization fails.
      * @param {FileHandle} handle
+     * @returns {any}
      */
-    close_file(handle) {
+    diagnostics_for(handle) {
         _assertClass(handle, FileHandle);
-        var ptr0 = handle.__destroy_into_raw();
-        const ret = wasm.fossilplayground_close_file(this.__wbg_ptr, ptr0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+        const ret = wasm.fossilworkspace_diagnostics_for(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Per-file diagnostic drain — the B3 follow-up accessor the LSP Worker
-     * (07-03) consumes for its per-file `publishDiagnostics` notifications.
-     * `check()` returns the workspace-wide flat array; `diagnostics_for`
-     * returns just one file's rows so 07-03 can dispatch one notification
-     * per affected URI without partitioning the workspace array on the JS
-     * side.
+     * Where the name under the cursor is defined: `{ uri, range }` rows, empty
+     * when nothing there has a definition.
+     *
+     * `uri` is the key the host opened the buffer under, verbatim — and two of
+     * the three positions goto-def recognises resolve into the shape document,
+     * so a host with one pane has to read it before moving a cursor.
      *
      * # Errors
      *
-     * Returns a JS error if `handle` is unknown, or if serialization fails.
+     * Returns a JS error if the workspace is busy, or if the result fails to
+     * serialize to `JsValue`.
      * @param {FileHandle} handle
+     * @param {number} line
+     * @param {number} character
      * @returns {any}
      */
-    diagnostics_for(handle) {
+    gotoDefinition(handle, line, character) {
         _assertClass(handle, FileHandle);
-        var ptr0 = handle.__destroy_into_raw();
-        const ret = wasm.fossilplayground_diagnostics_for(this.__wbg_ptr, ptr0);
+        const ret = wasm.fossilworkspace_gotoDefinition(this.__wbg_ptr, handle.__wbg_ptr, line, character);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Construct a new playground.
+     * What is under the cursor: `{ markdown, range }`, or `null` when the
+     * cursor is on whitespace, on an expression the checker inferred no type
+     * for, or outside any mapping.
      *
-     * Installs `console_error_panic_hook` (idempotent — RESEARCH.md
-     * Don't-Hand-Roll #8) so any panic inside compiler-core surfaces as a
-     * `console.error` stack trace in the host (browser `DevTools` or Node).
+     * `line` / `character` are LSP — zero-based, and `character` in UTF-16
+     * code units, which is what a JS host counts in anyway. The `range` comes
+     * back in the same units.
+     *
+     * # Errors
+     *
+     * Returns a JS error if the workspace is busy, or if the result fails to
+     * serialize to `JsValue`. An unknown handle is `null`, not an error —
+     * see [`FossilWorkspace::hover_row`].
+     * @param {FileHandle} handle
+     * @param {number} line
+     * @param {number} character
+     * @returns {any}
+     */
+    hover(handle, line, character) {
+        _assertClass(handle, FileHandle);
+        const ret = wasm.fossilworkspace_hover(this.__wbg_ptr, handle.__wbg_ptr, line, character);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The documents the file at `handle` names that nothing has registered:
+     * `{ key, locator }` rows, the locator expanded through the connection map.
+     *
+     * # Errors
+     *
+     * Returns a JS error if `handle` is unknown, if the workspace is busy, or
+     * if serialization fails.
+     * @param {FileHandle} handle
+     * @returns {any}
+     */
+    missingDocuments(handle) {
+        _assertClass(handle, FileHandle);
+        const ret = wasm.fossilworkspace_missingDocuments(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Construct a new workspace.
+     *
+     * Installs `console_error_panic_hook` (idempotent) so any panic inside
+     * compiler-core surfaces as a `console.error` stack trace in the host
+     * (browser `DevTools` or Node).
      */
     constructor() {
-        const ret = wasm.fossilplayground_new();
+        const ret = wasm.fossilworkspace_new();
         this.__wbg_ptr = ret;
-        FossilPlaygroundFinalization.register(this, this.__wbg_ptr, this);
+        FossilWorkspaceFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * Open a file in the workspace. Returns a [`FileHandle`] the JS side
-     * keys subsequent `update_file` / `close_file` / `compile_file` calls
-     * on. `path` is the URI / virtual path the diagnostics carry back to
-     * the LSP client.
+     * keys subsequent `update_file` / `close_file` calls on. `path` is the
+     * URI / virtual path the diagnostics carry back to the LSP client.
      *
      * Mirrors `ty_wasm::Workspace::open_file` (Astral). Interns a fresh
      * [`fossil_base::SourceFile`] under the current Salsa revision.
      *
      * # Errors
      *
-     * Returns a JS error only if the internal counter is exhausted
-     * (`u32::MAX` files — would require a runaway loop in JS, not a normal
-     * failure mode).
+     * Returns a JS error if the workspace is already inside another call —
+     * see the type-level note on [`WasmWorkspace`].
      * @param {string} path
      * @param {string} contents
      * @returns {FileHandle}
@@ -174,91 +287,116 @@ export class FossilPlayground {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(contents, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.fossilplayground_open_file(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.fossilworkspace_open_file(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return FileHandle.__wrap(ret[0]);
     }
+    /**
+     * Register a fetched document's `text` under the `key` `missingDocuments`
+     * reported.
+     *
+     * # Errors
+     *
+     * Returns a JS error if the workspace is busy.
+     * @param {string} key
+     * @param {string} text
+     */
+    registerDocument(key, text) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.fossilworkspace_registerDocument(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Register an [`fossil_descriptors_input::InferredDescriptor`] for a
-     * source binding name BEFORE invoking [`Self::compile`] /
-     * [`Self::compile_file`]. The Rust compiler reads from this registration
-     * during forward type propagation (Phase 3 CORE-05 rewired in plan
-     * 13-02).
-     *
-     * `descriptor_json` is the JSON serialisation of `InferredDescriptor`;
-     * the canonical shape is exposed in `packages/wasm/src/index.ts` as
-     * `InferredDescriptorJson`:
-     *
-     * ```json
-     * {
-     *   "source_name": "users",
-     *   "columns": [
-     *     { "name": "id", "primitive": "Integer" },
-     *     { "name": "name", "primitive": "String" }
-     *   ],
-     *   "content_hash": ""
-     * }
-     * ```
-     *
-     * Called by the browser-side playground orchestration AFTER running
-     * DuckDB-WASM `DESCRIBE read_csv_auto('<resolved-url>')` and BEFORE
-     * invoking `compile()` / `compile_file()`. Keyed by source-binding
-     * name (`"users"` for `users := io.csv("...")`), NOT by URL.
-     *
-     * Idempotent: re-registering with the same `source_name` OVERWRITES the
-     * previous entry — intentional, since the host may re-introspect when
-     * file content changes.
+     * source binding name BEFORE invoking `check`. The Rust compiler reads
+     * from this registration during forward type propagation — the browser has
+     * no filesystem to introspect a CSV from, so the column types must arrive
+     * from the host.
+     *
+     * Registering the same URI twice REPLACES the previous descriptor
+     * — intentional, since the host re-introspects when the source changes.
      *
      * # Errors
      *
      * - Malformed JSON / missing required fields → JS `Error` with the
      *   underlying `serde_json` message.
-     *
-     * Implementation: thin shim over the pure-Rust
-     * [`Self::register_inferred_descriptor_native`] helper.
+     * - The workspace is busy.
      * @param {string} descriptor_json
      */
     registerInferredDescriptor(descriptor_json) {
         const ptr0 = passStringToWasm0(descriptor_json, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.fossilplayground_registerInferredDescriptor(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.fossilworkspace_registerInferredDescriptor(this.__wbg_ptr, ptr0, len0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * Install a user-supplied `ShEx` schema as the active output descriptor.
-     * On parse failure the previously-installed descriptor is RETAINED (no
-     * half-applied state — a broken schema must never wedge the editor;
-     * same contract as `fossil-lsp`'s `load_sibling_shex` in 06-09).
-     *
-     * The schema is parsed via
-     * [`fossil_descriptors_output::ShExDescriptor::from_reader`] (no
-     * network access — Pitfall 1) and wrapped in
-     * [`OutputDescriptorKind::ShEx`]. The resulting `Arc` is swapped into
-     * the [`WasmDb`]'s descriptor slot atomically; future `fossil-ide`
-     * feature calls (hover, completion) reading
-     * [`HirDb::output_descriptor_kind`] see the new schema.
+     * Every classified span of the file: `{ range, kind, modifiers }` rows in
+     * source order, `kind` and `modifiers` by legend NAME. An editor lays these
+     * over its lexical highlighting — see [`ide::SemanticTokenRow`].
      *
      * # Errors
      *
-     * Returns a JS error if the text is not a parseable `ShEx` schema.
-     * @param {string} text
+     * Returns a JS error if the workspace is busy, or if the result fails to
+     * serialize to `JsValue`. An unknown handle is an empty array.
+     * @param {FileHandle} handle
+     * @returns {any}
      */
-    set_target_shex(text) {
-        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.fossilplayground_set_target_shex(this.__wbg_ptr, ptr0, len0);
+    semanticTokens(handle) {
+        _assertClass(handle, FileHandle);
+        const ret = wasm.fossilworkspace_semanticTokens(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Replace the connection map `@name/…` expands against, as
+     * `Host.connections()` answers it.
+     *
+     * # Errors
+     *
+     * Returns a JS error if `connections` is not a string-to-string record, or
+     * if the workspace is busy.
+     * @param {any} connections
+     */
+    setConnections(connections) {
+        const ret = wasm.fossilworkspace_setConnections(this.__wbg_ptr, connections);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * The data sources the file at `handle` reads — see
+     * [`fossil_lineage::program_sources`].
+     *
+     * # Errors
+     *
+     * Returns a JS error if `handle` is unknown, if the workspace is busy, or
+     * if serialization fails.
+     * @param {FileHandle} handle
+     * @returns {any}
+     */
+    sources(handle) {
+        _assertClass(handle, FileHandle);
+        const ret = wasm.fossilworkspace_sources(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply an edit to an open file. Mutates the SAME `SourceFile` via the
      * Salsa [`salsa::Setter`] (`set_text`) — this BUMPS THE REVISION, the
-     * real cancellation trigger (ADR-0022): any in-flight analysis from the
+     * real cancellation trigger: any in-flight analysis from the
      * previous keystroke observes the new revision at its next cooperative
      * checkpoint. NO new `SourceFile` is interned — the Salsa input
      * identity stays stable across the file's lifetime, so memoised
@@ -267,42 +405,59 @@ export class FossilPlayground {
      *
      * # Errors
      *
-     * Returns a JS error if `handle` was never opened or was already closed.
+     * Returns a JS error if `handle` was never opened or was already closed,
+     * or if the workspace is already inside another call — see the type-level
+     * note on [`WasmWorkspace`]. **Neither leaves the workspace unusable**,
+     * which is the whole reason this method takes `&self`.
      * @param {FileHandle} handle
      * @param {string} contents
      */
     update_file(handle, contents) {
         _assertClass(handle, FileHandle);
-        var ptr0 = handle.__destroy_into_raw();
-        const ptr1 = passStringToWasm0(contents, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.fossilplayground_update_file(this.__wbg_ptr, ptr0, ptr1, len1);
+        const ptr0 = passStringToWasm0(contents, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.fossilworkspace_update_file(this.__wbg_ptr, handle.__wbg_ptr, ptr0, len0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
 }
-if (Symbol.dispose) FossilPlayground.prototype[Symbol.dispose] = FossilPlayground.prototype.free;
+if (Symbol.dispose) FossilWorkspace.prototype[Symbol.dispose] = FossilWorkspace.prototype.free;
 
 /**
- * `JS`-facing re-export of the Phase-6 06-07 semantic-token legend.
- *
- * Returns `{ tokenTypes: string[], tokenModifiers: string[] }` — the exact
- * LSP `SemanticTokensLegend` shape. `CodeMirror` (plan 08-08 +
- * `packages/codemirror-fossil/src/tags.ts`) uses this to translate
- * LSP `semanticTokens/full` response indices into highlight tag names.
- *
- * Delegates to [`fossil_ide::semantic_legend`] (the 06-07 authoritative
- * definition) — NO duplicate legend definition lives here.
+ * The providers this host installs (`io.csv`, `io.rdf`, `io.shex`, …) as a JS
+ * array of `{ name, extensions, kind }`. Pure projection of the provider
+ * registry — no parsing, no db. `kind` is read off each row's capabilities, so
+ * the two shape-document rows come back as `Schema`.
  *
  * # Errors
+ * Returns a JS error only if the result fails to serialize to `JsValue`.
+ * @returns {any}
+ */
+export function providers() {
+    const ret = wasm.providers();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Parse `program` and return its external references — every data URI +
+ * `schema =` argument, each tagged with its `@conn` alias (`null` for a direct
+ * path) and role (`Data` / `Schema`) — as a JS array of
+ * `{ connection, path, role }`. Parse-only; the host resolves `@conn` →
+ * `{base}/path` itself (its data-plane job, kept out of fossil's semantics).
  *
- * Returns a JS error only if `serde_wasm_bindgen` fails (impossible in
- * practice for the legend shape).
+ * # Errors
+ * Returns a JS error only if the result fails to serialize to `JsValue`.
+ * @param {string} program
  * @returns {any}
  */
-export function semantic_legend() {
-    const ret = wasm.semantic_legend();
+export function refs(program) {
+    const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.refs(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -310,28 +465,37 @@ export function semantic_legend() {
 }
 
 /**
- * Worker entrypoint. Idempotent in spirit — calling twice replaces the
- * previous `onmessage` handler (the leaked Closure from the first call
- * stays alive but is no longer referenced by the global scope).
+ * The name of every [`TokenRow::kind`], indexed BY that kind.
+ *
+ * `token_kinds()[row.kind]` is the variant name — `"Comment"`, `"KwFrom"`,
+ * `"String"`. A host maps names to highlight categories and never writes a
+ * discriminant down, which is the only version of this contract that survives
+ * a reorder of the lexer.
  *
- * Must be called from a `DedicatedWorker` global scope; returns a JS error
- * otherwise (e.g. if called from the main thread).
+ * Semantic tokens make the same move one step further: `semanticTokens()`
+ * sends the legend's names themselves, so no index crosses at all.
+ *
+ * A kind past the end of the array is a variant appended by a newer compiler
+ * than the host was built against. That is BACKWARDS-COMPATIBLE by
+ * construction: the host sees `undefined` and styles the span as plain text.
  *
  * # Errors
  *
- * Returns a JS error when not running inside a `DedicatedWorker` scope.
+ * Returns a JS error only if `serde_wasm_bindgen` fails to serialise a
+ * `Vec<&str>` (impossible in practice).
+ * @returns {any}
  */
-export function start_lsp_worker() {
-    const ret = wasm.start_lsp_worker();
-    if (ret[1]) {
-        throw takeFromExternrefTable0(ret[0]);
+export function tokenKinds() {
+    const ret = wasm.tokenKinds();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
  * `JS`-facing tokenize. Returns the same row stream as [`tokenize_native`],
- * serialised via `serde_wasm_bindgen`. Consumed by
- * `@fossil-lang/codemirror-fossil`'s `StreamParser` (plan 08-08).
+ * serialised via `serde_wasm_bindgen`.
  *
  * # Errors
  *
@@ -358,19 +522,6 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_String_8564e559799eccda: function(arg0, arg1) {
-            const ret = String(arg1);
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_bigint_get_as_i64_3af6d4ca77193a4b: function(arg0, arg1) {
-            const v = arg1;
-            const ret = typeof(v) === 'bigint' ? v : undefined;
-            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-        },
         __wbg___wbindgen_boolean_get_c3dd5c39f1b5a12b: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
@@ -383,14 +534,6 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_in_2617fa76397620d3: function(arg0, arg1) {
-            const ret = arg0 in arg1;
-            return ret;
-        },
-        __wbg___wbindgen_is_bigint_d6a8167cac401b95: function(arg0) {
-            const ret = typeof(arg0) === 'bigint';
-            return ret;
-        },
         __wbg___wbindgen_is_function_2f0fd7ceb86e64c5: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
@@ -408,10 +551,6 @@ function __wbg_get_imports() {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_eq_403eaa3610500a25: function(arg0, arg1) {
-            const ret = arg0 === arg1;
-            return ret;
-        },
         __wbg___wbindgen_jsval_loose_eq_1978f1e77b4bce62: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
@@ -437,10 +576,6 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_data_4a14fad4c5f216c4: function(arg0) {
-            const ret = arg0.data;
-            return ret;
-        },
         __wbg_done_b1afd6201ac045e0: function(arg0) {
             const ret = arg0.done;
             return ret;
@@ -460,6 +595,13 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free_command_export(deferred0_0, deferred0_1, 1);
             }
         },
+        __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_get_41476db20fef99a8: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
         __wbg_get_652f640b3b0b6e3e: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -472,10 +614,6 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
-            const ret = arg0[arg1];
-            return ret;
-        },
         __wbg_instanceof_ArrayBuffer_eab9f28fbec23477: function(arg0) {
             let result;
             try {
@@ -486,20 +624,10 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_DedicatedWorkerGlobalScope_32441a4d2ca5f2c4: function(arg0) {
+        __wbg_instanceof_Error_5e21755e9d9cbee5: function(arg0) {
             let result;
             try {
-                result = arg0 instanceof DedicatedWorkerGlobalScope;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
-            return ret;
-        },
-        __wbg_instanceof_Map_10d4edf60fcf9327: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof Map;
+                result = arg0 instanceof Error;
             } catch (_) {
                 result = false;
             }
@@ -516,14 +644,6 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_c6c6ef8308995bcf: function(arg0) {
-            const ret = Array.isArray(arg0);
-            return ret;
-        },
-        __wbg_isSafeInteger_3c56c421a5b4cce4: function(arg0) {
-            const ret = Number.isSafeInteger(arg0);
-            return ret;
-        },
         __wbg_iterator_9d68985a1d096fc2: function() {
             const ret = Symbol.iterator;
             return ret;
@@ -536,6 +656,14 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_message_d5628ca19de920d3: function(arg0) {
+            const ret = arg0.message;
+            return ret;
+        },
+        __wbg_name_bf92195f4668ab6e: function(arg0) {
+            const ret = arg0.name;
+            return ret;
+        },
         __wbg_new_227d7c05414eb861: function() {
             const ret = new Error();
             return ret;
@@ -548,14 +676,14 @@ function __wbg_get_imports() {
             const ret = new Array();
             return ret;
         },
-        __wbg_new_46ae4e4ff2a07a64: function() {
-            const ret = new Map();
-            return ret;
-        },
         __wbg_new_8454eee672b2ba6e: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
+        __wbg_new_c9ea13ea803a692e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_next_261c3c48c6e309a5: function(arg0) {
             const ret = arg0.next;
             return ret;
@@ -564,24 +692,25 @@ function __wbg_get_imports() {
             const ret = arg0.next();
             return ret;
         }, arguments); },
-        __wbg_postMessage_ead2ef5ee8c7a94e: function() { return handleError(function (arg0, arg1) {
-            arg0.postMessage(arg1);
+        __wbg_parse_342d5616e14beccc: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
         }, arguments); },
         __wbg_prototypesetcall_fd4050e806e1d519: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_set_5337f8ac82364a3f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_set_82f7a370f604db70: function(arg0, arg1, arg2) {
-            const ret = arg0.set(arg1, arg2);
-            return ret;
-        },
         __wbg_set_f614f6a0608d1d1d: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
-        __wbg_set_onmessage_2686976b9bf47e87: function(arg0, arg1) {
-            arg0.onmessage = arg1;
+        __wbg_set_name_76644e7964825fa3: function(arg0, arg1, arg2) {
+            arg0.name = getStringFromWasm0(arg1, arg2);
         },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
@@ -590,51 +719,20 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_static_accessor_GLOBAL_THIS_1c7f1bd6c6941fdb: function() {
-            const ret = typeof globalThis === 'undefined' ? null : globalThis;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_static_accessor_GLOBAL_e039bc914f83e74e: function() {
-            const ret = typeof global === 'undefined' ? null : global;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_static_accessor_SELF_8bf8c48c28420ad5: function() {
-            const ret = typeof self === 'undefined' ? null : self;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_static_accessor_WINDOW_6aeee9b51652ee0f: function() {
-            const ret = typeof window === 'undefined' ? null : window;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
         __wbg_value_f852716acdeb3e82: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 9, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000002: function(arg0) {
+        __wbindgen_cast_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
-            // Cast intrinsic for `I64 -> Externref`.
-            const ret = arg0;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000005: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return ret;
-        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -651,16 +749,12 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40(arg0, arg1, arg2);
-}
-
 const FileHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_filehandle_free(ptr, 1));
-const FossilPlaygroundFinalization = (typeof FinalizationRegistry === 'undefined')
+const FossilWorkspaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_fossilplayground_free(ptr, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_fossilworkspace_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc_command_export();
@@ -674,10 +768,6 @@ function _assertClass(instance, klass) {
     }
 }
 
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure_command_export(state.a, state.b));
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -781,34 +871,6 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function makeMutClosure(arg0, arg1, f) {
-    const state = { a: arg0, b: arg1, cnt: 1 };
-    const real = (...args) => {
-
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            state.a = a;
-            real._wbg_cb_unref();
-        }
-    };
-    real._wbg_cb_unref = () => {
-        if (--state.cnt === 0) {
-            wasm.__wbindgen_destroy_closure_command_export(state.a, state.b);
-            state.a = 0;
-            CLOSURE_DTORS.unregister(state);
-        }
-    };
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);