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

package/README.md

@@ -3,16 +3,20 @@
 JS/TS wrapper around the `fossil-wasm` Rust crate's wasm-bindgen artefacts. Provides:
 
 - `initFossilWasm({ wasmUrl })` — consumer-controlled `.wasm` URL loader (memoised).
-- `tokenize(text)` — calls the Rust lexer, returns `TokenRow[]` (ADR-0030).
-- `semanticLegend()` — returns the LSP semantic-tokens legend (Phase 6 plan 06-07).
-- `FossilPlayground` — the Workspace API class (ADR-0024) for LSP + compile.
+- `tokenize(text)` — calls the Rust lexer, returns `TokenRow[]`. The Rust lexer
+  is the only lexer: no host reimplements one and drifts from the grammar.
+- `semanticLegend()` — returns the LSP semantic-tokens legend.
+- `FossilPlayground` — the Workspace API class for LSP + compile. `fossil-lsp`
+  itself is native-only (stdio over crossbeam), so the browser gets this
+  equivalent dispatch surface over the same `fossil-ide` functions.
 
 ## Why explicit `init({ wasmUrl })` and not auto-load?
 
 We use `wasm-bindgen --target web` (NOT `--target bundler`). This means consumers
 control the `.wasm` URL resolution — works in Vite, Next.js, Webpack, Rspack, or
-plain `new URL(...)` in a Web Worker context. See `08-RESEARCH.md` Pitfall 1
-(this monorepo's phase-8 research) for why `--target bundler` was rejected.
+plain `new URL(...)` in a Web Worker context. `--target bundler` was rejected
+because its output assumes the consumer's bundler resolves `.wasm` ESM imports,
+which a republished library cannot assume of a host's Vite/Next/Webpack config.
 
 ## Consumer patterns
 
@@ -23,7 +27,7 @@ import { initFossilWasm, tokenize } from '@fossil-lang/wasm';
 import wasmUrl from '@fossil-lang/wasm/pkg/fossil_wasm_bg.wasm?url';
 
 await initFossilWasm({ wasmUrl });
-const tokens = tokenize('prefix ex: <https://example.org/>');
+const tokens = tokenize('User := io.csv("data/people.csv")');
 ```
 
 ### Next.js host (in a Client Component)
@@ -63,8 +67,6 @@ Optionally `wasm-opt` (binaryen) for size reduction.
 
 ## Source of truth
 
-- Rust crate: `crates/fossil-wasm/`
-- tokenize ADR: `decisions/0030-wasm-exported-tokenizer.md`
-- Workspace API ADR: `decisions/0024-fossil-wasm-workspace-api.md`
-- Distribution pattern: `decisions/0028-playground-as-react-library.md`
-  (this package is one of the six in the `@fossil-lang/*` family)
+- Rust crate: `crates/fossil-wasm/` — everything here is a wrapper over its
+  wasm-bindgen exports, and nothing in this package reimplements it.
+- The grammar the tokenizer follows: `grammar.bnf` at the repo root.

package/dist/client.d.ts

@@ -0,0 +1,199 @@
+/**
+ * The wasm-bindgen-backed runtime surface (lexer, LSP worker, Workspace API) of
+ * @fossil-lang/wasm.
+ *
+ * Kept in its OWN module (NOT the package entry) so the wasm-bindgen glue
+ * (`../pkg/fossil_wasm.js`) is imported only from leaf modules — `load.ts` (for
+ * `init`) and here. Under a bundler with `"sideEffects": false`, importing the
+ * stateful glue from the entry chunk can duplicate it: `init()` then populates
+ * the `wasm` binding in one instance while these functions read `undefined` from
+ * another (→ `Cannot read properties of undefined (reading '__wbindgen_malloc…')`,
+ * seen when the codemirror tokenizer calls `tokenize` on the main thread).
+ * Mirrors `@fossil-lang/corpus`'s `client.ts` split, the known-good shape.
+ */
+import { FileHandle as RawFileHandle } from '../pkg/fossil_wasm.js';
+import type { TokenRow, TokenKindLegend, SemanticTokensLegend } from '@fossil-lang/types';
+import type { CheckRow, CompletionRow, DefinitionRow, HoverRow, InferredDescriptorJson, SourceRefInfo, ProviderInfo } from './index.js';
+/**
+ * Install the LSP-over-postMessage dispatcher on the current Worker scope.
+ *
+ * `fossil-wasm` IS the LSP server-side in the browser: `fossil-lsp` is
+ * native-only (it speaks stdio over crossbeam and does not compile to
+ * `wasm32`), so the Worker gets an equivalent 16-route dispatch loop over the
+ * same `fossil-ide` free functions. The Rust function (re-exported from
+ * `crates/fossil-wasm/src/lsp_worker.rs`) installs `self.onmessage` on the
+ * Worker scope and owns LSP JSON-RPC dispatch from that point forward.
+ *
+ * MUST be called inside a Web Worker scope, AFTER {@link initFossilWasm} has
+ * resolved. Calling it on the main thread is a no-op (the dispatcher needs
+ * `DedicatedWorkerGlobalScope.onmessage`).
+ */
+export declare function start_lsp_worker(): void;
+/**
+ * Opaque file-handle returned by {@link FossilPlayground.openFile}. Pass it
+ * back into the matching `updateFile` / `closeFile` / `diagnosticsFor`
+ * calls. JS code cannot construct one directly (the wasm-bindgen class has a
+ * private constructor) — handles are minted only by `openFile` on the Rust
+ * side, where they index a `HashMap<FileHandle, SourceFile>` keyed by a `u32`.
+ */
+export type FileHandle = RawFileHandle;
+/**
+ * Tokenize a Fossil source string. Returns the byte-range tokens from the
+ * canonical Rust lexer (`fossil_syntax::lexer::raw_lex`) — the single grammar
+ * source of truth, so no editor ever reimplements the lexer in TS and drifts.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved; otherwise the
+ * underlying wasm-bindgen function throws (the wasm module is not yet
+ * instantiated).
+ */
+export declare function tokenize(text: string): TokenRow[];
+/**
+ * The legend for {@link TokenRow.kind}: every lexer variant NAME, indexed by the
+ * discriminant a row carries. `tokenKinds()[row.kind]` is `"Comment"`,
+ * `"KwFrom"`, `"String"`, …
+ *
+ * **This is the contract, and the numbers are not.** `kind` is a variant
+ * discriminant of `fossil_syntax::lexer::Token`, so any reorder of that enum
+ * remaps every value with nothing going red. The predecessor of this package
+ * hard-coded the table (`enum FossilKind { Whitespace = 0, … }`) under a comment
+ * saying it had to be updated in lockstep; it was wrong in nine places by the
+ * time it was deleted. Keying on the name is what makes a reorder a non-event.
+ *
+ * An index past the end of the legend is a variant appended by a compiler newer
+ * than this host: `undefined`, and a host styles it as plain text.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export declare function tokenKinds(): TokenKindLegend;
+/**
+ * Returns the LSP `SemanticTokensLegend` (token types + modifiers list) the
+ * editor uses to map LSP `semanticTokens/full` response indices to highlight
+ * categories. Re-export of `fossil_ide::semantic_legend` over the wasm-bindgen
+ * boundary — NO duplicate legend definition lives here.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export declare function semanticLegend(): SemanticTokensLegend;
+/**
+ * Parse a Fossil program and return its external references — the typed lineage
+ * (every data URI + `schema =` argument, each tagged with its `@conn` alias and
+ * role). keasy's client-compute job runner reads this to derive a job's
+ * connections WITHOUT subprocessing `fossil` / a server round-trip. Identical
+ * shape to the native `fossil refs` (the SAME `fossil_lineage::SourceRefInfo`
+ * struct), so the browser and the CLI never diverge.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export declare function refs(program: string): SourceRefInfo[];
+/**
+ * List the data-source providers fossil supports (`io.csv`, `io.rdf`, …) — the
+ * provider name, the extensions it reads, and how it can be used. Identical
+ * shape to the native `fossil providers`.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export declare function providers(): ProviderInfo[];
+/**
+ * Workspace API class. Thin TS wrapper around the wasm-bindgen
+ * `FossilPlayground` that exposes camelCase method names for JS idiom + better
+ * TS inference (the raw bindings use snake_case from the Rust impl block).
+ *
+ * One instance per browser tab / Node process — the instance owns the Salsa
+ * store + `Arc<OutputDescriptorKind>` for the schema slot.
+ *
+ * NOTE: {@link FileHandle} is opaque — JS cannot construct one. Callers receive
+ * a handle from `openFile` and pass it back to subsequent operations.
+ */
+export declare class FossilPlayground {
+    private _inner;
+    constructor();
+    /**
+     * Free the underlying WASM-side Salsa store. Call when the playground is no
+     * longer needed (e.g. component unmount).
+     */
+    free(): void;
+    /**
+     * Open a file in the workspace. Returns the {@link FileHandle} subsequent
+     * `updateFile` / `closeFile` / `diagnosticsFor` calls key on.
+     */
+    openFile(path: string, contents: string): FileHandle;
+    /**
+     * Apply an edit to an open file. Mutates the SAME `SourceFile` via the Salsa
+     * `Setter` (`set_text`) — bumps the revision for incremental
+     * invalidation rather than a full recompute, and that revision bump is also
+     * what cancels any analysis still running on an older snapshot.
+     */
+    updateFile(handle: FileHandle, contents: string): void;
+    /**
+     * Close a file in the workspace. Strict: closing an unknown / already-closed
+     * handle throws so JS-side bugs surface loudly.
+     */
+    closeFile(handle: FileHandle): void;
+    /**
+     * Workspace-wide diagnostic drain. Runs `parse → def_map → typecheck_mapping`
+     * across every open file and returns a flat array of {@link CheckRow}.
+     */
+    check(): CheckRow[];
+    /**
+     * Per-file diagnostic drain — the accessor the LSP Worker uses for its
+     * per-file `publishDiagnostics` notifications.
+     */
+    diagnosticsFor(handle: FileHandle): CheckRow[];
+    /**
+     * What is under the cursor — `{ markdown, range }`, or `null` when nothing
+     * there has a type.
+     *
+     * `line` / `character` are LSP: zero-based, `character` in UTF-16 code units.
+     * A CodeMirror or Monaco host already counts in those units, so a document
+     * offset converts with `doc.lineAt(pos)` and no byte arithmetic — unlike
+     * {@link tokenize}, whose offsets ARE bytes.
+     *
+     * ## Push the buffer before you ask
+     *
+     * This reads the text of the last {@link updateFile}. Hover fires on
+     * mouse-move and the checker is debounced, so a hover mid-debounce answers
+     * about text one keystroke old and its range lands one keystroke wrong. The
+     * three read-only methods take a SHARED borrow on the Rust side and cannot
+     * poison the workspace the way a re-entered `updateFile` once could — see the
+     * `ide` module in `crates/fossil-wasm` — but staleness is not a borrow
+     * problem and nothing here can fix it for you.
+     */
+    hover(handle: FileHandle, line: number, character: number): HoverRow | null;
+    /**
+     * The completion candidates at a position, 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 at all.
+     *
+     * `kind` is the LSP `CompletionItemKind` **by name** (`"function"`,
+     * `"field"`) rather than by number. The numbers never cross this boundary —
+     * `packages/codemirror-fossil`'s deleted predecessor is what happens when
+     * they do.
+     *
+     * The same staleness note as {@link hover} applies, and harder: completion
+     * fires on nearly every keystroke.
+     */
+    completions(handle: FileHandle, line: number, character: number): CompletionRow[];
+    /**
+     * Where the name under the cursor is defined. Empty when nothing there has a
+     * definition.
+     *
+     * `uri` is the key the buffer was opened under, verbatim — and two of the
+     * four positions this recognises resolve into the **shape document**, so a
+     * host with a single editor pane has to read `uri` before it moves a cursor.
+     */
+    gotoDefinition(handle: FileHandle, line: number, character: number): DefinitionRow[];
+    /**
+     * Register an {@link InferredDescriptorJson} under the source URI the program
+     * wrote, BEFORE invoking {@link check}. The Rust compiler reads from this
+     * during forward type propagation.
+     *
+     * The compiler never introspects a source itself: it performs no network or
+     * file IO — that would break the WASM gate and Salsa's determinism alike —
+     * so a host that wants column types must run the `DESCRIBE` and push the
+     * result in here.
+     *
+     * @throws Error if the descriptor JSON fails to deserialise on the Rust side.
+     */
+    registerInferredDescriptor(descriptor: InferredDescriptorJson): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAEL,UAAU,IAAI,aAAa,EAO5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1F,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,aAAa,EACb,QAAQ,EACR,sBAAsB,EACtB,aAAa,EACb,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;AAEvC;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAMjD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,IAAI,eAAe,CAE5C;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,CAErD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,YAAY,EAAE,CAE1C;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAsB;;IAMpC;;;OAGG;IACH,IAAI,IAAI,IAAI;IAIZ;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU;IAIpD;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAItD;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAInC;;;OAGG;IACH,KAAK,IAAI,QAAQ,EAAE;IAInB;;;OAGG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,EAAE;IAI9C;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IAM3E;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE;IAIjF;;;;;;;OAOG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE;IAIpF;;;;;;;;;;;OAWG;IACH,0BAA0B,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;CAKrE"}

package/dist/client.js

@@ -0,0 +1,231 @@
+/**
+ * The wasm-bindgen-backed runtime surface (lexer, LSP worker, Workspace API) of
+ * @fossil-lang/wasm.
+ *
+ * Kept in its OWN module (NOT the package entry) so the wasm-bindgen glue
+ * (`../pkg/fossil_wasm.js`) is imported only from leaf modules — `load.ts` (for
+ * `init`) and here. Under a bundler with `"sideEffects": false`, importing the
+ * stateful glue from the entry chunk can duplicate it: `init()` then populates
+ * the `wasm` binding in one instance while these functions read `undefined` from
+ * another (→ `Cannot read properties of undefined (reading '__wbindgen_malloc…')`,
+ * seen when the codemirror tokenizer calls `tokenize` on the main thread).
+ * Mirrors `@fossil-lang/corpus`'s `client.ts` split, the known-good shape.
+ */
+import { FossilPlayground as RawFossilPlayground, FileHandle as RawFileHandle, tokenize as rawTokenize, semantic_legend as rawSemanticLegend, tokenKinds as rawTokenKinds, start_lsp_worker as rawStartLspWorker, refs as rawRefs, providers as rawProviders, } from '../pkg/fossil_wasm.js';
+/**
+ * Install the LSP-over-postMessage dispatcher on the current Worker scope.
+ *
+ * `fossil-wasm` IS the LSP server-side in the browser: `fossil-lsp` is
+ * native-only (it speaks stdio over crossbeam and does not compile to
+ * `wasm32`), so the Worker gets an equivalent 16-route dispatch loop over the
+ * same `fossil-ide` free functions. The Rust function (re-exported from
+ * `crates/fossil-wasm/src/lsp_worker.rs`) installs `self.onmessage` on the
+ * Worker scope and owns LSP JSON-RPC dispatch from that point forward.
+ *
+ * MUST be called inside a Web Worker scope, AFTER {@link initFossilWasm} has
+ * resolved. Calling it on the main thread is a no-op (the dispatcher needs
+ * `DedicatedWorkerGlobalScope.onmessage`).
+ */
+export function start_lsp_worker() {
+    rawStartLspWorker();
+}
+/**
+ * Tokenize a Fossil source string. Returns the byte-range tokens from the
+ * canonical Rust lexer (`fossil_syntax::lexer::raw_lex`) — the single grammar
+ * source of truth, so no editor ever reimplements the lexer in TS and drifts.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved; otherwise the
+ * underlying wasm-bindgen function throws (the wasm module is not yet
+ * instantiated).
+ */
+export function tokenize(text) {
+    // The wasm-bindgen wrapper returns a `JsValue` typed as `any`; the Rust side
+    // (crates/fossil-wasm/src/tokenize.rs) serializes `Vec<TokenRow>` via
+    // `serde_wasm_bindgen::to_value`, so the shape matches `{ kind, start, end }`
+    // exactly. Cast is safe because the Rust ↔ JS contract is enforced upstream.
+    return rawTokenize(text);
+}
+/**
+ * The legend for {@link TokenRow.kind}: every lexer variant NAME, indexed by the
+ * discriminant a row carries. `tokenKinds()[row.kind]` is `"Comment"`,
+ * `"KwFrom"`, `"String"`, …
+ *
+ * **This is the contract, and the numbers are not.** `kind` is a variant
+ * discriminant of `fossil_syntax::lexer::Token`, so any reorder of that enum
+ * remaps every value with nothing going red. The predecessor of this package
+ * hard-coded the table (`enum FossilKind { Whitespace = 0, … }`) under a comment
+ * saying it had to be updated in lockstep; it was wrong in nine places by the
+ * time it was deleted. Keying on the name is what makes a reorder a non-event.
+ *
+ * An index past the end of the legend is a variant appended by a compiler newer
+ * than this host: `undefined`, and a host styles it as plain text.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export function tokenKinds() {
+    return rawTokenKinds();
+}
+/**
+ * Returns the LSP `SemanticTokensLegend` (token types + modifiers list) the
+ * editor uses to map LSP `semanticTokens/full` response indices to highlight
+ * categories. Re-export of `fossil_ide::semantic_legend` over the wasm-bindgen
+ * boundary — NO duplicate legend definition lives here.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export function semanticLegend() {
+    return rawSemanticLegend();
+}
+/**
+ * Parse a Fossil program and return its external references — the typed lineage
+ * (every data URI + `schema =` argument, each tagged with its `@conn` alias and
+ * role). keasy's client-compute job runner reads this to derive a job's
+ * connections WITHOUT subprocessing `fossil` / a server round-trip. Identical
+ * shape to the native `fossil refs` (the SAME `fossil_lineage::SourceRefInfo`
+ * struct), so the browser and the CLI never diverge.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export function refs(program) {
+    return rawRefs(program);
+}
+/**
+ * List the data-source providers fossil supports (`io.csv`, `io.rdf`, …) — the
+ * provider name, the extensions it reads, and how it can be used. Identical
+ * shape to the native `fossil providers`.
+ *
+ * MUST be called after {@link initFossilWasm} has resolved.
+ */
+export function providers() {
+    return rawProviders();
+}
+/**
+ * Workspace API class. Thin TS wrapper around the wasm-bindgen
+ * `FossilPlayground` that exposes camelCase method names for JS idiom + better
+ * TS inference (the raw bindings use snake_case from the Rust impl block).
+ *
+ * One instance per browser tab / Node process — the instance owns the Salsa
+ * store + `Arc<OutputDescriptorKind>` for the schema slot.
+ *
+ * NOTE: {@link FileHandle} is opaque — JS cannot construct one. Callers receive
+ * a handle from `openFile` and pass it back to subsequent operations.
+ */
+export class FossilPlayground {
+    _inner;
+    constructor() {
+        this._inner = new RawFossilPlayground();
+    }
+    /**
+     * Free the underlying WASM-side Salsa store. Call when the playground is no
+     * longer needed (e.g. component unmount).
+     */
+    free() {
+        this._inner.free();
+    }
+    /**
+     * Open a file in the workspace. Returns the {@link FileHandle} subsequent
+     * `updateFile` / `closeFile` / `diagnosticsFor` calls key on.
+     */
+    openFile(path, contents) {
+        return this._inner.open_file(path, contents);
+    }
+    /**
+     * Apply an edit to an open file. Mutates the SAME `SourceFile` via the Salsa
+     * `Setter` (`set_text`) — bumps the revision for incremental
+     * invalidation rather than a full recompute, and that revision bump is also
+     * what cancels any analysis still running on an older snapshot.
+     */
+    updateFile(handle, contents) {
+        this._inner.update_file(handle, contents);
+    }
+    /**
+     * Close a file in the workspace. Strict: closing an unknown / already-closed
+     * handle throws so JS-side bugs surface loudly.
+     */
+    closeFile(handle) {
+        this._inner.close_file(handle);
+    }
+    /**
+     * Workspace-wide diagnostic drain. Runs `parse → def_map → typecheck_mapping`
+     * across every open file and returns a flat array of {@link CheckRow}.
+     */
+    check() {
+        return this._inner.check();
+    }
+    /**
+     * Per-file diagnostic drain — the accessor the LSP Worker uses for its
+     * per-file `publishDiagnostics` notifications.
+     */
+    diagnosticsFor(handle) {
+        return this._inner.diagnostics_for(handle);
+    }
+    /**
+     * What is under the cursor — `{ markdown, range }`, or `null` when nothing
+     * there has a type.
+     *
+     * `line` / `character` are LSP: zero-based, `character` in UTF-16 code units.
+     * A CodeMirror or Monaco host already counts in those units, so a document
+     * offset converts with `doc.lineAt(pos)` and no byte arithmetic — unlike
+     * {@link tokenize}, whose offsets ARE bytes.
+     *
+     * ## Push the buffer before you ask
+     *
+     * This reads the text of the last {@link updateFile}. Hover fires on
+     * mouse-move and the checker is debounced, so a hover mid-debounce answers
+     * about text one keystroke old and its range lands one keystroke wrong. The
+     * three read-only methods take a SHARED borrow on the Rust side and cannot
+     * poison the workspace the way a re-entered `updateFile` once could — see the
+     * `ide` module in `crates/fossil-wasm` — but staleness is not a borrow
+     * problem and nothing here can fix it for you.
+     */
+    hover(handle, line, character) {
+        // `serde_wasm_bindgen` writes `None` as `undefined`; a host reading this
+        // should have one falsy answer to check, not two.
+        return this._inner.hover(handle, line, character) ?? null;
+    }
+    /**
+     * The completion candidates at a position, 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 at all.
+     *
+     * `kind` is the LSP `CompletionItemKind` **by name** (`"function"`,
+     * `"field"`) rather than by number. The numbers never cross this boundary —
+     * `packages/codemirror-fossil`'s deleted predecessor is what happens when
+     * they do.
+     *
+     * The same staleness note as {@link hover} applies, and harder: completion
+     * fires on nearly every keystroke.
+     */
+    completions(handle, line, character) {
+        return this._inner.completions(handle, line, character);
+    }
+    /**
+     * Where the name under the cursor is defined. Empty when nothing there has a
+     * definition.
+     *
+     * `uri` is the key the buffer was opened under, verbatim — and two of the
+     * four positions this recognises resolve into the **shape document**, so a
+     * host with a single editor pane has to read `uri` before it moves a cursor.
+     */
+    gotoDefinition(handle, line, character) {
+        return this._inner.gotoDefinition(handle, line, character);
+    }
+    /**
+     * Register an {@link InferredDescriptorJson} under the source URI the program
+     * wrote, BEFORE invoking {@link check}. The Rust compiler reads from this
+     * during forward type propagation.
+     *
+     * The compiler never introspects a source itself: it performs no network or
+     * file IO — that would break the WASM gate and Salsa's determinism alike —
+     * so a host that wants column types must run the `DESCRIBE` and push the
+     * result in here.
+     *
+     * @throws Error if the descriptor JSON fails to deserialise on the Rust side.
+     */
+    registerInferredDescriptor(descriptor) {
+        // The wasm-bindgen wrapper accepts a JSON string; serialise here so callers
+        // pass a typed object.
+        this._inner.registerInferredDescriptor(JSON.stringify(descriptor));
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}