@fossil-lang/wasm 0.3.0-alpha.1 → 0.3.0-alpha.3

package/dist/client.d.ts

@@ -0,0 +1,141 @@
+/**
+ * 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/graph`'s `client.ts` split, the known-good shape.
+ */
+import { FileHandle as RawFileHandle } from '../pkg/fossil_wasm.js';
+import type { TokenRow, SemanticTokensLegend } from '@fossil-lang/types';
+import type { CheckRow, StdlibClass, InferredDescriptorJson, SourceRefInfo, ProviderInfo } from './index.js';
+/**
+ * Install the LSP-over-postMessage dispatcher on the current Worker scope.
+ *
+ * Per ADR-0024 (`fossil-wasm` IS the LSP server-side) + Phase 7 plan 07-03
+ * (the 16-route dispatch loop). 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`) — single grammar
+ * source of truth per ADR-0030.
+ *
+ * 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[];
+/**
+ * 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_run_status::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 (ADR-0024). 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;
+    /**
+     * Return the stdlib classification manifest (STDL-07). The playground reads
+     * this once at startup to render `native_udf_only` functions as disabled.
+     */
+    classification(): StdlibClass[];
+    /**
+     * 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 (ADR-0022) for incremental
+     * invalidation rather than a full recompute.
+     */
+    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[];
+    /**
+     * Install a user-supplied ShEx schema as the active output descriptor. On
+     * parse failure the previously-installed descriptor is RETAINED.
+     */
+    setTargetShex(text: string): void;
+    /**
+     * Register an {@link InferredDescriptorJson} for a source binding name BEFORE
+     * invoking {@link check}. The Rust compiler reads from this during forward
+     * type propagation.
+     *
+     * @throws Error if the descriptor JSON fails to deserialise on the Rust side.
+     * @see ADR-0037
+     */
+    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,EAM5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,sBAAsB,EACtB,aAAa,EACb,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;GAWG;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;;;;;;;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,cAAc,IAAI,WAAW,EAAE;IAI/B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU;IAIpD;;;;OAIG;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;;;OAGG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIjC;;;;;;;OAOG;IACH,0BAA0B,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;CAKrE"}

package/dist/client.js

@@ -0,0 +1,167 @@
+/**
+ * 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/graph`'s `client.ts` split, the known-good shape.
+ */
+import { FossilPlayground as RawFossilPlayground, FileHandle as RawFileHandle, tokenize as rawTokenize, semantic_legend as rawSemanticLegend, 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.
+ *
+ * Per ADR-0024 (`fossil-wasm` IS the LSP server-side) + Phase 7 plan 07-03
+ * (the 16-route dispatch loop). 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`) — single grammar
+ * source of truth per ADR-0030.
+ *
+ * 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);
+}
+/**
+ * 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_run_status::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 (ADR-0024). 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();
+    }
+    /**
+     * Return the stdlib classification manifest (STDL-07). The playground reads
+     * this once at startup to render `native_udf_only` functions as disabled.
+     */
+    classification() {
+        return this._inner.classification();
+    }
+    /**
+     * 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 (ADR-0022) for incremental
+     * invalidation rather than a full recompute.
+     */
+    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);
+    }
+    /**
+     * Install a user-supplied ShEx schema as the active output descriptor. On
+     * parse failure the previously-installed descriptor is RETAINED.
+     */
+    setTargetShex(text) {
+        this._inner.set_target_shex(text);
+    }
+    /**
+     * Register an {@link InferredDescriptorJson} for a source binding name BEFORE
+     * invoking {@link check}. The Rust compiler reads from this during forward
+     * type propagation.
+     *
+     * @throws Error if the descriptor JSON fails to deserialise on the Rust side.
+     * @see ADR-0037
+     */
+    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":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,gBAAgB,IAAI,mBAAmB,EACvC,UAAU,IAAI,aAAa,EAC3B,QAAQ,IAAI,WAAW,EACvB,eAAe,IAAI,iBAAiB,EACpC,gBAAgB,IAAI,iBAAiB,EACrC,IAAI,IAAI,OAAO,EACf,SAAS,IAAI,YAAY,GAC1B,MAAM,uBAAuB,CAAC;AAU/B;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB;IAC9B,iBAAiB,EAAE,CAAC;AACtB,CAAC;AAWD;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,6EAA6E;IAC7E,sEAAsE;IACtE,8EAA8E;IAC9E,6EAA6E;IAC7E,OAAO,WAAW,CAAC,IAAI,CAAe,CAAC;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO,iBAAiB,EAA0B,CAAC;AACrD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,IAAI,CAAC,OAAe;IAClC,OAAO,OAAO,CAAC,OAAO,CAAoB,CAAC;AAC7C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,YAAY,EAAoB,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,gBAAgB;IACnB,MAAM,CAAsB;IAEpC;QACE,IAAI,CAAC,MAAM,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,IAAI;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,EAAmB,CAAC;IACvD,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,IAAY,EAAE,QAAgB;QACrC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,MAAkB,EAAE,QAAgB;QAC7C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,MAAkB;QAC1B,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAgB,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,MAAkB;QAC/B,OAAO,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAe,CAAC;IAC3D,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,IAAY;QACxB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;OAOG;IACH,0BAA0B,CAAC,UAAkC;QAC3D,4EAA4E;QAC5E,uBAAuB;QACvB,IAAI,CAAC,MAAM,CAAC,0BAA0B,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IACrE,CAAC;CACF"}

package/dist/index.d.ts

@@ -15,59 +15,28 @@
  *   await initFossilWasm({ wasmUrl });
  *   const tokens = tokenize('prefix ex: <https://example.org/>');
  */
-import { FileHandle as RawFileHandle } from '../pkg/fossil_wasm.js';
-import type { TokenRow, SemanticTokensLegend } from '@fossil-lang/types';
 export { initFossilWasm } from './load.js';
 export type { InitFossilWasmOpts } from './load.js';
-/**
- * Install the LSP-over-postMessage dispatcher on the current Worker scope.
- *
- * Per ADR-0024 (`fossil-wasm` IS the LSP server-side) + Phase 7 plan 07-03
- * (the 16-route dispatch loop). 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 —
- * including per-file `textDocument/publishDiagnostics` drains (B3 fix from
- * 07-03), `textDocument/semanticTokens/full` (06-07), hover, completion,
- * definition, references, rename, formatting, code actions, document
- * symbols, signature help.
- *
- * 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`).
- *
- * Consumed by `@fossil-lang/playground`'s `src/workers/lsp.worker.ts` —
- * the React component's LSP Worker entry boots the WASM module then calls
- * this function once.
- */
-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) — that is intentional per ADR-0024:
- * handles are minted only by `openFile` on the Rust side, where they index a
- * `HashMap<FileHandle, SourceFile>` keyed by a `u32` newtype.
- */
-export type FileHandle = RawFileHandle;
-/**
- * Tokenize a Fossil source string. Returns the byte-range tokens from the
- * canonical Rust lexer (`fossil_syntax::lexer::raw_lex`) — single grammar
- * source of truth per ADR-0030.
- *
- * 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[];
-/**
- * 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` (Phase-6 06-07) over
- * the wasm-bindgen boundary — NO duplicate legend definition lives here.
- *
- * MUST be called after {@link initFossilWasm} has resolved.
- */
-export declare function semanticLegend(): SemanticTokensLegend;
+export { start_lsp_worker, tokenize, semanticLegend, FossilPlayground, refs, providers, } from './client.js';
+export type { FileHandle } from './client.js';
+/** One external reference a program makes — the typed lineage returned by
+ *  {@link refs}. Mirrors `fossil_run_status::SourceRefInfo` (the SAME struct the
+ *  native `fossil refs` emits). `connection` is the `@conn` alias the reference
+ *  targets, or `null` for a direct URL/path; `role` is where it appears in the
+ *  source constructor. The host resolves `@conn` → `{base}/path` itself. */
+export interface SourceRefInfo {
+    connection: string | null;
+    path: string;
+    role: 'data' | 'schema';
+}
+/** One data-source provider returned by {@link providers}. Mirrors
+ *  `fossil_run_status::ProviderInfo`: the short name (`csv`, `rdf`, …), the file
+ *  extensions it reads (no leading dot), and how it can be used. */
+export interface ProviderInfo {
+    name: string;
+    extensions: string[];
+    kind: 'schema' | 'data' | 'both';
+}
 /** Diagnostic row returned by {@link FossilPlayground.check} and
  *  {@link FossilPlayground.diagnosticsFor} — mirrors `fossil-wasm`'s
  *  `CheckRow` JSON shape (the LSP `Diagnostic` projected through
@@ -136,111 +105,5 @@ export interface InferredDescriptorJson {
      */
     content_hash: string;
 }
-/**
- * Workspace API class (ADR-0024). 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. Subsequent
- * `openFile` calls intern fresh `SourceFile` inputs under the same Salsa
- * revision so `updateFile` benefits from incremental memoisation.
- *
- * The Phase 7 LSP Worker (07-03) drives this class via postMessage; the React
- * component in `@fossil-lang/playground` (08-09) does the same via the
- * WorkerTransport adapter.
- *
- * NOTE: {@link FileHandle} is opaque — JS cannot construct one. Callers receive
- * a handle from `openFile` and pass it back to subsequent operations. The Rust
- * side keeps a `HashMap<FileHandle, SourceFile>` indexed by a `u32` newtype;
- * the wasm-bindgen wrapper exposes that as a class with `private constructor()`.
- */
-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). Idempotent in spirit — subsequent
-     * method calls on a freed playground throw.
-     */
-    free(): void;
-    /**
-     * Return the stdlib classification manifest (STDL-07). The playground reads
-     * this once at startup to render `native_udf_only` functions as disabled
-     * with a "native-only — unavailable in the browser" tooltip.
-     */
-    classification(): StdlibClass[];
-    /**
-     * Open a file in the workspace. Returns the {@link FileHandle} subsequent
-     * `updateFile` / `closeFile` / `diagnosticsFor` calls key
-     * on. `path` is the URI / virtual path diagnostics carry back to the LSP
-     * client (e.g. `"file:///tmp/a.fossil"` or `"untitled:Untitled-1"`).
-     *
-     * Mirrors `ty_wasm::Workspace::open_file` (Astral). Interns a fresh
-     * `fossil_base::SourceFile` under the current Salsa revision.
-     */
-    openFile(path: string, contents: string): FileHandle;
-    /**
-     * Apply an edit to an open file. Mutates the SAME `SourceFile` via the
-     * Salsa `Setter` (`set_text`) — this BUMPS THE REVISION (ADR-0022), the
-     * real cancellation trigger. NO new `SourceFile` is interned, so memoised
-     * downstream queries (`def_map`, `typecheck_mapping`) invalidate
-     * incrementally instead of falling off a cliff.
-     */
-    updateFile(handle: FileHandle, contents: string): void;
-    /**
-     * Close a file in the workspace. Strict in signal: closing an unknown /
-     * already-closed handle throws so JS-side bugs surface loudly (mirrors
-     * `ty_wasm`).
-     */
-    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}. The LSP Worker (07-03) republishes these grouped by URI
-     * as `textDocument/publishDiagnostics` notifications.
-     */
-    check(): CheckRow[];
-    /**
-     * Per-file diagnostic drain — the B3 follow-up accessor the LSP Worker uses
-     * for its per-file `publishDiagnostics` notifications. `check()` returns
-     * the workspace-wide flat array; `diagnosticsFor` 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.
-     */
-    diagnosticsFor(handle: FileHandle): CheckRow[];
-    /**
-     * Install a user-supplied ShEx schema as the active output descriptor. On
-     * parse failure the previously-installed descriptor is RETAINED (no
-     * half-applied state — same contract as `fossil-lsp::load_sibling_shex` in
-     * 06-09). Future `fossil-ide` feature calls (hover, completion) reading
-     * `HirDb::output_descriptor_kind` see the new schema atomically.
-     */
-    setTargetShex(text: string): void;
-    /**
-     * Register an {@link InferredDescriptorJson} for a source binding name
-     * BEFORE invoking {@link check}. The Rust compiler reads from this
-     * registration during forward type propagation (Phase 3 CORE-05 rewired in
-     * plan 13-02).
-     *
-     * The browser-side orchestration runs DuckDB-WASM
-     * `DESCRIBE read_csv_auto('<resolved-url>')` for each `io.csv("...")`
-     * reference in the source, canonicalises the columns to the
-     * {@link InferredPrimitive} catalog, and calls this method with the
-     * resulting descriptor before {@link check}. See ADR-0037 for the full
-     * architectural rationale.
-     *
-     * Keyed by source-binding name (e.g. `"users"` for
-     * `users := io.csv("...")`), NOT by URL. Idempotent — re-registering with
-     * the same `source_name` overwrites the previous entry.
-     *
-     * @throws Error if the descriptor JSON fails to deserialise on the Rust
-     *         side (e.g. missing required fields). The error message includes
-     *         the underlying serde_json diagnostic.
-     *
-     * @see ADR-0037 — drop user-facing CSVW; infer via DuckDB DESCRIBE
-     */
-    registerInferredDescriptor(descriptor: InferredDescriptorJson): void;
-}
 export type { TokenRow, SemanticTokensLegend } from '@fossil-lang/types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAEL,UAAU,IAAI,aAAa,EAI5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAEzE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;AAEvC;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAMjD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,CAErD;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE;QACL,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3C,GAAG,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1C,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAAC;CAC5C;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,MAAM,GACN,UAAU,GACV,MAAM,GACN,OAAO,GACP,QAAQ,CAAC;AAEb,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAsB;;IAMpC;;;;OAIG;IACH,IAAI,IAAI,IAAI;IAIZ;;;;OAIG;IACH,cAAc,IAAI,WAAW,EAAE;IAI/B;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU;IAIpD;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAItD;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAInC;;;;;OAKG;IACH,KAAK,IAAI,QAAQ,EAAE;IAInB;;;;;;OAMG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,EAAE;IAI9C;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIjC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAA0B,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;CAKrE;AAKD,YAAY,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,EACL,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,gBAAgB,EAChB,IAAI,EACJ,SAAS,GACV,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;4EAI4E;AAC5E,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;CACzB;AAED;;oEAEoE;AACpE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE;QACL,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3C,GAAG,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1C,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAAC;CAC5C;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,MAAM,GACN,UAAU,GACV,MAAM,GACN,OAAO,GACP,QAAQ,CAAC;AAEb,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAKD,YAAY,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -15,187 +15,12 @@
  *   await initFossilWasm({ wasmUrl });
  *   const tokens = tokenize('prefix ex: <https://example.org/>');
  */
-// '../pkg/fossil_wasm.js' is a wasm-bindgen --target web output emitted by `pnpm run build:wasm`.
-// Gitignored at the repo root (`packages/wasm/pkg/`) but always present at build time. The accompanying
-// .d.ts is consumed via the file's `/* @ts-self-types="./fossil_wasm.d.ts" */` pragma.
-import { FossilPlayground as RawFossilPlayground, FileHandle as RawFileHandle, tokenize as rawTokenize, semantic_legend as rawSemanticLegend, start_lsp_worker as rawStartLspWorker, } from '../pkg/fossil_wasm.js';
+// The wasm-bindgen glue (`../pkg/fossil_wasm.js`) is imported ONLY from leaf
+// modules — `load.ts` (init) and `client.ts` (the lexer / LSP / Workspace API) —
+// never here in the entry. See `client.ts`: importing the stateful glue from the
+// package entry lets a `sideEffects:false` bundler duplicate it, splitting
+// `init()`'s wasm instance from the one the functions use (the crash the
+// codemirror tokenizer hit on the main thread). This entry only re-exports.
 export { initFossilWasm } from './load.js';
-/**
- * Install the LSP-over-postMessage dispatcher on the current Worker scope.
- *
- * Per ADR-0024 (`fossil-wasm` IS the LSP server-side) + Phase 7 plan 07-03
- * (the 16-route dispatch loop). 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 —
- * including per-file `textDocument/publishDiagnostics` drains (B3 fix from
- * 07-03), `textDocument/semanticTokens/full` (06-07), hover, completion,
- * definition, references, rename, formatting, code actions, document
- * symbols, signature help.
- *
- * 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`).
- *
- * Consumed by `@fossil-lang/playground`'s `src/workers/lsp.worker.ts` —
- * the React component's LSP Worker entry boots the WASM module then calls
- * this function once.
- */
-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`) — single grammar
- * source of truth per ADR-0030.
- *
- * 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);
-}
-/**
- * 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` (Phase-6 06-07) over
- * the wasm-bindgen boundary — NO duplicate legend definition lives here.
- *
- * MUST be called after {@link initFossilWasm} has resolved.
- */
-export function semanticLegend() {
-    return rawSemanticLegend();
-}
-/**
- * Workspace API class (ADR-0024). 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. Subsequent
- * `openFile` calls intern fresh `SourceFile` inputs under the same Salsa
- * revision so `updateFile` benefits from incremental memoisation.
- *
- * The Phase 7 LSP Worker (07-03) drives this class via postMessage; the React
- * component in `@fossil-lang/playground` (08-09) does the same via the
- * WorkerTransport adapter.
- *
- * NOTE: {@link FileHandle} is opaque — JS cannot construct one. Callers receive
- * a handle from `openFile` and pass it back to subsequent operations. The Rust
- * side keeps a `HashMap<FileHandle, SourceFile>` indexed by a `u32` newtype;
- * the wasm-bindgen wrapper exposes that as a class with `private constructor()`.
- */
-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). Idempotent in spirit — subsequent
-     * method calls on a freed playground throw.
-     */
-    free() {
-        this._inner.free();
-    }
-    /**
-     * Return the stdlib classification manifest (STDL-07). The playground reads
-     * this once at startup to render `native_udf_only` functions as disabled
-     * with a "native-only — unavailable in the browser" tooltip.
-     */
-    classification() {
-        return this._inner.classification();
-    }
-    /**
-     * Open a file in the workspace. Returns the {@link FileHandle} subsequent
-     * `updateFile` / `closeFile` / `diagnosticsFor` calls key
-     * on. `path` is the URI / virtual path diagnostics carry back to the LSP
-     * client (e.g. `"file:///tmp/a.fossil"` or `"untitled:Untitled-1"`).
-     *
-     * Mirrors `ty_wasm::Workspace::open_file` (Astral). Interns a fresh
-     * `fossil_base::SourceFile` under the current Salsa revision.
-     */
-    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`) — this BUMPS THE REVISION (ADR-0022), the
-     * real cancellation trigger. NO new `SourceFile` is interned, so memoised
-     * downstream queries (`def_map`, `typecheck_mapping`) invalidate
-     * incrementally instead of falling off a cliff.
-     */
-    updateFile(handle, contents) {
-        this._inner.update_file(handle, contents);
-    }
-    /**
-     * Close a file in the workspace. Strict in signal: closing an unknown /
-     * already-closed handle throws so JS-side bugs surface loudly (mirrors
-     * `ty_wasm`).
-     */
-    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}. The LSP Worker (07-03) republishes these grouped by URI
-     * as `textDocument/publishDiagnostics` notifications.
-     */
-    check() {
-        return this._inner.check();
-    }
-    /**
-     * Per-file diagnostic drain — the B3 follow-up accessor the LSP Worker uses
-     * for its per-file `publishDiagnostics` notifications. `check()` returns
-     * the workspace-wide flat array; `diagnosticsFor` 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.
-     */
-    diagnosticsFor(handle) {
-        return this._inner.diagnostics_for(handle);
-    }
-    /**
-     * Install a user-supplied ShEx schema as the active output descriptor. On
-     * parse failure the previously-installed descriptor is RETAINED (no
-     * half-applied state — same contract as `fossil-lsp::load_sibling_shex` in
-     * 06-09). Future `fossil-ide` feature calls (hover, completion) reading
-     * `HirDb::output_descriptor_kind` see the new schema atomically.
-     */
-    setTargetShex(text) {
-        this._inner.set_target_shex(text);
-    }
-    /**
-     * Register an {@link InferredDescriptorJson} for a source binding name
-     * BEFORE invoking {@link check}. The Rust compiler reads from this
-     * registration during forward type propagation (Phase 3 CORE-05 rewired in
-     * plan 13-02).
-     *
-     * The browser-side orchestration runs DuckDB-WASM
-     * `DESCRIBE read_csv_auto('<resolved-url>')` for each `io.csv("...")`
-     * reference in the source, canonicalises the columns to the
-     * {@link InferredPrimitive} catalog, and calls this method with the
-     * resulting descriptor before {@link check}. See ADR-0037 for the full
-     * architectural rationale.
-     *
-     * Keyed by source-binding name (e.g. `"users"` for
-     * `users := io.csv("...")`), NOT by URL. Idempotent — re-registering with
-     * the same `source_name` overwrites the previous entry.
-     *
-     * @throws Error if the descriptor JSON fails to deserialise on the Rust
-     *         side (e.g. missing required fields). The error message includes
-     *         the underlying serde_json diagnostic.
-     *
-     * @see ADR-0037 — drop user-facing CSVW; infer via DuckDB DESCRIBE
-     */
-    registerInferredDescriptor(descriptor) {
-        // The wasm-bindgen wrapper exposes `registerInferredDescriptor(string)` —
-        // it accepts a JSON string. Serialise here so callers pass a typed object.
-        this._inner.registerInferredDescriptor(JSON.stringify(descriptor));
-    }
-}
+export { start_lsp_worker, tokenize, semanticLegend, FossilPlayground, refs, providers, } from './client.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,kGAAkG;AAClG,wGAAwG;AACxG,uFAAuF;AACvF,OAAO,EACL,gBAAgB,IAAI,mBAAmB,EACvC,UAAU,IAAI,aAAa,EAC3B,QAAQ,IAAI,WAAW,EACvB,eAAe,IAAI,iBAAiB,EACpC,gBAAgB,IAAI,iBAAiB,GACtC,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,gBAAgB;IAC9B,iBAAiB,EAAE,CAAC;AACtB,CAAC;AAYD;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,6EAA6E;IAC7E,sEAAsE;IACtE,8EAA8E;IAC9E,6EAA6E;IAC7E,OAAO,WAAW,CAAC,IAAI,CAAe,CAAC;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO,iBAAiB,EAA0B,CAAC;AACrD,CAAC;AA8ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,gBAAgB;IACnB,MAAM,CAAsB;IAEpC;QACE,IAAI,CAAC,MAAM,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,EAAmB,CAAC;IACvD,CAAC;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAY,EAAE,QAAgB;QACrC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,MAAkB,EAAE,QAAgB;QAC7C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,MAAkB;QAC1B,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAgB,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,MAAkB;QAC/B,OAAO,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAe,CAAC;IAC3D,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CAAC,IAAY;QACxB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAA0B,CAAC,UAAkC;QAC3D,0EAA0E;QAC1E,2EAA2E;QAC3E,IAAI,CAAC,MAAM,CAAC,0BAA0B,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IACrE,CAAC;CACF"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,6EAA6E;AAC7E,iFAAiF;AACjF,iFAAiF;AACjF,2EAA2E;AAC3E,yEAAyE;AACzE,4EAA4E;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C,OAAO,EACL,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,gBAAgB,EAChB,IAAI,EACJ,SAAS,GACV,MAAM,aAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fossil-lang/wasm",
-  "version": "0.3.0-alpha.1",
+  "version": "0.3.0-alpha.3",
   "description": "JS/TS wrapper around the fossil-wasm wasm-bindgen artifacts (--target web). Exposes initFossilWasm + tokenize + semanticLegend + FossilPlayground class for downstream @fossil-lang/* packages.",
   "license": "Apache-2.0",
   "repository": {
@@ -33,7 +33,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@fossil-lang/types": "0.3.0-alpha.1"
+    "@fossil-lang/types": "0.3.0-alpha.3"
   },
   "devDependencies": {
     "typescript": "^5.6.0",

package/pkg/fossil_wasm.d.ts

@@ -185,6 +185,28 @@ export class FossilPlayground {
     update_file(handle: FileHandle, contents: string): void;
 }
 
+/**
+ * The data-source providers fossil supports (`io.csv`, `io.rdf`, …) as a JS
+ * array of `{ name, extensions, kind }`. Pure projection of the stdlib source
+ * registry — no parsing, no db.
+ *
+ * # Errors
+ * Returns a JS error only if the result fails to serialize to `JsValue`.
+ */
+export function providers(): any;
+
+/**
+ * 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).
+ *
+ * # Errors
+ * Returns a JS error only if the result fails to serialize to `JsValue`.
+ */
+export function refs(program: string): any;
+
 /**
  * `JS`-facing re-export of the Phase-6 06-07 semantic-token legend.
  *
@@ -249,7 +271,9 @@ export interface InitOutput {
     readonly fossilplayground_diagnostics_for: (a: number, b: number) => [number, number, number];
     readonly fossilplayground_set_target_shex: (a: number, b: number, c: number) => [number, number];
     readonly fossilplayground_registerInferredDescriptor: (a: number, b: number, c: number) => [number, number];
-    readonly wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40: (a: number, b: number, c: any) => void;
+    readonly providers: () => [number, number, number];
+    readonly refs: (a: number, b: number) => [number, number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h6bdcc41945596778: (a: number, b: number, c: any) => void;
     readonly __wbindgen_malloc_command_export: (a: number, b: number) => number;
     readonly __wbindgen_realloc_command_export: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store_command_export: (a: number) => void;

package/pkg/fossil_wasm.js

@@ -284,6 +284,45 @@ export class FossilPlayground {
 }
 if (Symbol.dispose) FossilPlayground.prototype[Symbol.dispose] = FossilPlayground.prototype.free;
 
+/**
+ * The data-source providers fossil supports (`io.csv`, `io.rdf`, …) as a JS
+ * array of `{ name, extensions, kind }`. Pure projection of the stdlib source
+ * registry — no parsing, no db.
+ *
+ * # 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).
+ *
+ * # Errors
+ * Returns a JS error only if the result fails to serialize to `JsValue`.
+ * @param {string} program
+ * @returns {any}
+ */
+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]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * `JS`-facing re-export of the Phase-6 06-07 semantic-token legend.
  *
@@ -612,7 +651,7 @@ function __wbg_get_imports() {
         },
         __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);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h6bdcc41945596778);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -651,8 +690,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h6bdcc41945596778(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h6bdcc41945596778(arg0, arg1, arg2);
 }
 
 const FileHandleFinalization = (typeof FinalizationRegistry === 'undefined')

package/pkg/fossil_wasm_bg.wasm.d.ts

@@ -15,7 +15,9 @@ export const fossilplayground_check: (a: number) => [number, number, number];
 export const fossilplayground_diagnostics_for: (a: number, b: number) => [number, number, number];
 export const fossilplayground_set_target_shex: (a: number, b: number, c: number) => [number, number];
 export const fossilplayground_registerInferredDescriptor: (a: number, b: number, c: number) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h4393dedb0066ad40: (a: number, b: number, c: any) => void;
+export const providers: () => [number, number, number];
+export const refs: (a: number, b: number) => [number, number, number];
+export const wasm_bindgen__convert__closures_____invoke__h6bdcc41945596778: (a: number, b: number, c: any) => void;
 export const __wbindgen_malloc_command_export: (a: number, b: number) => number;
 export const __wbindgen_realloc_command_export: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store_command_export: (a: number) => void;