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

package/dist/index.d.ts

@@ -1,246 +1,175 @@
 /**
  * @fossil-lang/wasm — JS/TS wrapper around the fossil-wasm wasm-bindgen artifacts.
  *
- * Public API (one of the six @fossil-lang/* packages per ADR-0028):
- * - {@link initFossilWasm} — consumer-controlled .wasm URL loader (memoised).
- * - {@link tokenize} — calls the Rust lexer, returns TokenRow[] (ADR-0030).
- * - {@link semanticLegend} — returns the LSP SemanticTokensLegend (Phase-6 06-07).
- * - {@link FossilPlayground} — Workspace API class (ADR-0024) for the LSP.
+ * Public API (one of the @fossil-lang/* packages; `git ls-files packages` is
+ * the list):
+ * - {@link initFossilWasm} — boots the module; its `.wasm` is a bundler asset. A failed boot is
+ *   forgotten, so the next call tries again.
+ * - {@link tokenize} — calls the Rust lexer, returns TokenRow[].
+ * - {@link tokenKinds} — the legend for TokenRow.kind: variant names by index.
+ * - {@link openProgram} — one program open for an editor: the workspace, the push-before-ask
+ *   discipline and the document resolution a host would otherwise write, shaped to spread into
+ *   `@fossil-lang/codemirror-fossil`'s `fossil()`. What a host with one editor calls.
+ * - {@link FossilWorkspace} — Workspace API class: open / update / close,
+ *   `check`, the three position queries (`hover`, `completions`,
+ *   `gotoDefinition`) and `semanticTokens` an editor draws its IDE surface from, and the documents
+ *   and sources a program reads (`missingDocuments`, `registerDocument`,
+ *   `sources`) that a host resolves through its `Host`.
  *
- * Consumer pattern (wasm-bindgen --target web — RESEARCH.md Pattern 3):
+ * Consumer pattern (wasm-bindgen --target web):
  *
- *   import { initFossilWasm, tokenize } from '@fossil-lang/wasm';
- *   import wasmUrl from '@fossil-lang/wasm/pkg/fossil_wasm_bg.wasm?url';  // Vite
+ *   import { openProgram } from '@fossil-lang/wasm';
+ *   import { fossil } from '@fossil-lang/codemirror-fossil';
  *
- *   await initFossilWasm({ wasmUrl });
- *   const tokens = tokenize('prefix ex: <https://example.org/>');
+ *   const program = await openProgram('job.fossil', { host, text });
+ *   const extensions = fossil({ ...program, onNavigate });
  */
-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`).
+export type { InitInput } from './load.js';
+export { tokenize, tokenKinds, FossilWorkspace, refs, providers, } from './client.js';
+export type { FileHandle } from './client.js';
+export { openProgram } from './program.js';
+export type { FossilProgram, OpenProgramOptions } from './program.js';
+/** One external reference a program makes — the typed lineage returned by
+ *  {@link refs}. Mirrors `fossil_lineage::SourceRefInfo`. `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_lineage::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';
+}
+/** The rows {@link FossilWorkspace.check} and {@link FossilWorkspace.diagnosticsFor} return —
+ *  defined in `@fossil-lang/types`, beside the `Code` and `ProblemData` that type them. */
+export type { CheckRow, CheckRelated } from '@fossil-lang/types';
+/** An LSP range: zero-based lines, `character` in UTF-16 code units — the units
+ *  a JavaScript string is indexed in, so no byte arithmetic converts it. (The
+ *  lexer's {@link TokenRow} offsets are the other thing: those ARE bytes.) */
+export interface LspRange {
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
+}
+/** What {@link FossilWorkspace.hover} found: the rendered Markdown — a
+ *  ` ```fossil ` fence, the type of what you wrote and where it came from, and
+ *  a second block with the type the target shape demands of that predicate when
+ *  the shape resolves — and the range it applies to. */
+export interface HoverRow {
+    markdown: string;
+    range: LspRange;
+}
+/** One candidate from {@link FossilWorkspace.completions}.
  *
- * 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.
+ *  `kind` is the LSP `CompletionItemKind` **by name**, lowercased —
+ *  `"function"`, `"field"`, `"enum_member"` — and `""` when the item carries
+ *  none. Rust owns that table (`fossil_wasm::ide::kind_name`, total over the
+ *  twenty-five the spec defines) because a table in TypeScript is one nothing
+ *  can check: the deleted predecessor of `@fossil-lang/codemirror-fossil`
+ *  hard-copied the lexer's discriminants and was wrong in nine places by the
+ *  time it went.
  *
- * 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.
+ *  `detail` is the signature, the shape property's IRI, or the source field's
+ *  inferred type — whatever the compiler wrote beside the label; `""` when it
+ *  wrote none. Neither field is optional, on purpose: an absent optional is the
+ *  one shape `serde_json` and `serde_wasm_bindgen` are measured to disagree
+ *  about. */
+export interface CompletionRow {
+    label: string;
+    kind: string;
+    detail: string;
+    /** What picking the row writes: the label's one spelling — the label itself,
+     *  or `"Person.id"` for a column whose name is not an identifier. Never
+     *  empty. */
+    insert: string;
+}
+/** One place {@link FossilWorkspace.gotoDefinition} found a definition.
  *
- * MUST be called after {@link initFossilWasm} has resolved.
- */
-export declare function semanticLegend(): SemanticTokensLegend;
-/** Diagnostic row returned by {@link FossilPlayground.check} and
- *  {@link FossilPlayground.diagnosticsFor} — mirrors `fossil-wasm`'s
- *  `CheckRow` JSON shape (the LSP `Diagnostic` projected through
- *  `fossil_ide::LineIndex` for UTF-16 ranges).
- */
-export interface CheckRow {
+ *  `uri` is the key the buffer was opened under, VERBATIM — matching
+ *  {@link CheckRow.uri}, and not a `file://` URI. Two of the four positions
+ *  goto-def recognises resolve into the shape document, so a target in another
+ *  file is the ordinary case and a host with one editor pane has to read this
+ *  before it moves a cursor. */
+export interface DefinitionRow {
     uri: string;
-    range: {
-        start: {
-            line: number;
-            character: number;
-        };
-        end: {
-            line: number;
-            character: number;
-        };
-    };
-    severity: number;
-    message: string;
+    range: LspRange;
 }
-/** Stdlib classification entry returned by {@link FossilPlayground.classification}.
- *  `wasm_class` indicates whether a stdlib function can execute in-browser
- *  (`"pure_sql"`) or requires the native runtime (`"native_udf_only"`). The
- *  playground reads this once at startup to render `native_udf_only` functions
- *  as disabled (STDL-07 / SC#1 playground half).
- */
-export interface StdlibClass {
-    name: string;
-    wasm_class: 'pure_sql' | 'native_udf_only';
+/** One classified span from {@link FossilWorkspace.semanticTokens} — what the
+ *  compiler knows about a stretch of the program that the lexer cannot: that
+ *  `Person` is a shape, `users` a binding being declared, `@warehouse` a
+ *  connection inside a string.
+ *
+ *  `kind` is the semantic-token type by legend NAME (`"type"`, `"namespace"`,
+ *  `"function"`, `"property"`, `"parameter"`, `"variable"`, `"keyword"`,
+ *  `"string"`, `"number"`, `"operator"`, `"comment"`); `modifiers` likewise
+ *  (`"declaration"`), empty when there are none. Names and not indices, for the
+ *  reason {@link CompletionRow.kind} is one. Rows are in source order and never
+ *  overlap; a range may cross a line. */
+export interface SemanticTokenRow {
+    range: LspRange;
+    kind: string;
+    modifiers: string[];
 }
 /**
- * Canonical primitive names for inferred-descriptor columns. Must match the
- * lookup table in `fossil-hir::infer::primitive_from_name` (ADR-0037). Names
- * map 1:1 to the `Primitive` enum in HIR (Integer, Float, String, Bool, Date,
- * DateTime, Time, GYear, AnyURI).
+ * The primitive lattice, as `fossil-graph-schema` serialises it — the same enum
+ * the checker types against, not a set of names it looks up.
  *
- * Unknown / non-canonical strings are accepted on the wire — the Rust side
- * coerces them to `String` and emits a `D-INFERRED-UNKNOWN-DATATYPE`
- * diagnostic. Hosts SHOULD canonicalise their DuckDB `DESCRIBE` output to
- * these names before registering.
+ * A value outside this union is REJECTED when the descriptor is registered:
+ * `registerInferredDescriptor` returns the serde error naming the offending
+ * value. It is no longer coerced to `string` with a diagnostic three crates
+ * later, so a host that sends a type fossil does not carry finds out at the
+ * call, not in a compile.
  */
-export type InferredPrimitive = 'String' | 'Integer' | 'Float' | 'Bool' | 'Date' | 'DateTime' | 'Time' | 'GYear' | 'AnyURI';
+export type InferredPrimitive = 'string' | 'integer' | 'float' | 'bool' | 'date' | 'date_time' | 'time' | 'g_year' | 'any_uri';
 /** One column from a host-introspected source. */
 export interface InferredColumnJson {
     name: string;
     primitive: InferredPrimitive;
 }
 /**
- * Host-introspected input schema. Produced by the playground's browser-side
- * `DuckDB-WASM` `DESCRIBE read_csv_auto('<url>')` call (see plan 13-04b);
- * consumed by the Rust compiler via
- * {@link FossilPlayground.registerInferredDescriptor}. See ADR-0037 for the
- * full architectural rationale (drop user-facing CSVW; host-side
- * introspection feeds the compiler ahead of `compile()`).
- */
-export interface InferredDescriptorJson {
-    /** Source binding name (e.g. `"users"` for `users := io.csv(...)`). */
-    source_name: string;
-    /** Ordered columns — order is significant for column-position fallback. */
-    columns: InferredColumnJson[];
-    /**
-     * Opaque content-hash. Empty string means "let the Rust side derive a
-     * deterministic hash from the column tuple list" (used for Salsa keying).
-     * Hosts that already maintain a per-file content-hash (e.g. resolver-side)
-     * MAY supply it.
-     */
-    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.
+ * Host-introspected input schema. Produced by a `DESCRIBE SELECT * FROM
+ * <reader>('<url>')` the host runs — `DuckDB-WASM` in a browser — where the
+ * reader is the one the binding's `io.` constructor names: `read_csv_auto`,
+ * `read_json_auto` or `read_parquet`. `@fossil-lang/introspect` is the one home
+ * for that, and picking the reader off the constructor is not a nicety: a
+ * Parquet file read as CSV fails DuckDB's sniffer outright, and a JSON array
+ * read as CSV introspects to a single column named `[`.
  *
- * 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()`.
+ * Consumed by the Rust compiler via
+ * {@link FossilWorkspace.registerInferredDescriptor}. There is no metadata
+ * sidecar for the user to write and keep in sync: the host introspects the
+ * real file and feeds the compiler ahead of `compile()`.
  */
-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[];
+export interface InferredDescriptorJson {
     /**
-     * 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.
+     * The source URI exactly as the program writes it — the string inside
+     * `io.csv("examples/users.csv")`. NOT the binding name, and NOT the URL the
+     * host resolved in order to read the file: the checker only ever sees what
+     * the program says.
      */
-    setTargetShex(text: string): void;
+    uri: string;
+    /** Ordered columns — order is significant for column-position fallback. */
+    columns: InferredColumnJson[];
     /**
-     * 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
+     * Opaque token identifying the state of the source this was read from. The
+     * cache compares it and nothing interprets it: an ETag, a digest, a
+     * `Last-Modified`, whatever the host can get cheaply. Empty means "I cannot
+     * tell", which the cache reads as never-fresh, so that source is
+     * re-introspected on every compile.
      */
-    registerInferredDescriptor(descriptor: InferredDescriptorJson): void;
+    freshness_token: string;
 }
-export type { TokenRow, SemanticTokensLegend } from '@fossil-lang/types';
+export type { TokenRow, Host, MissingDocument, UnreadDocument, DocumentWorkspace, ProgramSource, } 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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAUH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EACL,QAAQ,EACR,UAAU,EACV,eAAe,EACf,IAAI,EACJ,SAAS,GACV,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEtE;;;4EAG4E;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;2FAC2F;AAC3F,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;8EAE8E;AAC9E,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C;AAED;;;wDAGwD;AACxD,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC;CACjB;AAED;;;;;;;;;;;;;;aAca;AACb,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf;;iBAEa;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;gCAMgC;AAChC,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,QAAQ,CAAC;CACjB;AAED;;;;;;;;;;yCAUyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAYD;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,MAAM,GACN,WAAW,GACX,MAAM,GACN,QAAQ,GACR,SAAS,CAAC;AAEd,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B;;;;;;OAMG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAKD,YAAY,EACV,QAAQ,EACR,IAAI,EACJ,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,GACd,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -1,201 +1,30 @@
 /**
  * @fossil-lang/wasm — JS/TS wrapper around the fossil-wasm wasm-bindgen artifacts.
  *
- * Public API (one of the six @fossil-lang/* packages per ADR-0028):
- * - {@link initFossilWasm} — consumer-controlled .wasm URL loader (memoised).
- * - {@link tokenize} — calls the Rust lexer, returns TokenRow[] (ADR-0030).
- * - {@link semanticLegend} — returns the LSP SemanticTokensLegend (Phase-6 06-07).
- * - {@link FossilPlayground} — Workspace API class (ADR-0024) for the LSP.
- *
- * Consumer pattern (wasm-bindgen --target web — RESEARCH.md Pattern 3):
- *
- *   import { initFossilWasm, tokenize } from '@fossil-lang/wasm';
- *   import wasmUrl from '@fossil-lang/wasm/pkg/fossil_wasm_bg.wasm?url';  // Vite
- *
- *   await initFossilWasm({ wasmUrl });
- *   const tokens = tokenize('prefix ex: <https://example.org/>');
+ * Public API (one of the @fossil-lang/* packages; `git ls-files packages` is
+ * the list):
+ * - {@link initFossilWasm} — boots the module; its `.wasm` is a bundler asset. A failed boot is
+ *   forgotten, so the next call tries again.
+ * - {@link tokenize} — calls the Rust lexer, returns TokenRow[].
+ * - {@link tokenKinds} — the legend for TokenRow.kind: variant names by index.
+ * - {@link openProgram} — one program open for an editor: the workspace, the push-before-ask
+ *   discipline and the document resolution a host would otherwise write, shaped to spread into
+ *   `@fossil-lang/codemirror-fossil`'s `fossil()`. What a host with one editor calls.
+ * - {@link FossilWorkspace} — Workspace API class: open / update / close,
+ *   `check`, the three position queries (`hover`, `completions`,
+ *   `gotoDefinition`) and `semanticTokens` an editor draws its IDE surface from, and the documents
+ *   and sources a program reads (`missingDocuments`, `registerDocument`,
+ *   `sources`) that a host resolves through its `Host`.
+ *
+ * Consumer pattern (wasm-bindgen --target web):
+ *
+ *   import { openProgram } from '@fossil-lang/wasm';
+ *   import { fossil } from '@fossil-lang/codemirror-fossil';
+ *
+ *   const program = await openProgram('job.fossil', { host, text });
+ *   const extensions = fossil({ ...program, onNavigate });
  */
-// '../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';
 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 { tokenize, tokenKinds, FossilWorkspace, refs, providers, } from './client.js';
+export { openProgram } from './program.js';
 //# sourceMappingURL=index.js.map