@hydranium/core 1.0.0-next.30 → 1.0.0-next.301

package/README.md

@@ -1,40 +1,19 @@
 # `@hydranium/core`
 
-The framework runtime of [hydranium](../../README.md): the shared Langium
-workspace an adopter's modeling-language server is built from, plus the LSP
-textual head folded in at the `/lsp` subpath. Every adopter server installs it,
-and so does every other head package (`@hydranium/data-server`,
-`@hydranium/glsp-server`).
+The runtime of [Hydranium](https://github.com/eclipse-emfcloud/hydranium): the
+shared Langium workspace your language server is built from, plus the LSP head.
+Every Hydranium server installs it, and `@hydranium/data-server` and
+`@hydranium/glsp-server` build on it.
 
 ## What it gives you
 
-- **A composable services tree.** `createServerSharedModule` and
-  `createServerLanguageModule` supply the shared- and language-tier DI slots;
-  `bootstrapLangium` registers a language on the shared `ServiceRegistry`,
-  asserts the core slots are bound, and eager-constructs the services that must
-  exist before the first build.
-- **Semantics layered onto the AST** that an adopter would otherwise rewrite per
-  language: tiered scoping (`HydraniumScopeProvider`,
-  `ReferenceCandidateProvider`), qualified naming (`NameProvider`), computed and
-  synthetic properties (`AstExtensionService`), AST-integrity rules
-  (`IntegrityRule`, `IntegrityRuleRegistry`), batch build passes
-  (`BuildPhasePassService`), and a CST-residency memory policy
-  (`CstResidencyService`).
-- **A build pipeline you can hook by phase.** `HydraniumDocumentBuilder` and
-  `BuildPipelineIntegration` dispatch work at Langium `DocumentState` phases,
-  while the project tier (`ProjectManager`) discovers and groups documents.
-- **Multi-client document coordination.** `AstDocumentManager`,
-  `HydraniumTextDocuments`, `WritableFileSystemProvider` and `SelfSaveRegistry`
-  generalise the LSP document lifecycle to several co-editing heads, so an edit
-  made on one surface is observable on the others without a head-to-head
-  synchronisation protocol.
-- **The projection the non-LSP heads build on:** `ModelService` (the in-process
-  workspace facade), `TransferEncoder` (AST → transfer model), and the
-  `Serializer` slot.
-- **The LSP head at `./lsp`:** `startLanguageServer`,
-  `createLspServerSharedModule` / `createLspServerLanguageModule`,
-  `HydraniumCompletionProvider`, `HydraniumDocumentUpdateHandler`, and
-  `AbstractHydraniumSemanticTokenProvider`.
+- One call, `createIntegrationServices`, that composes your language's services
+  with Langium's defaults and the framework's.
+- Scoping, naming, validation and build hooks you extend per language, rather
+  than rewrite.
+- One workspace every head works on: an edit made through one head is seen by
+  the others.
+- The LSP head, and launchers that serve another head over stdio or a socket.
 
 ## Install
 
@@ -42,59 +21,70 @@ and so does every other head package (`@hydranium/data-server`,
 npm install @hydranium/core
 ```
 
-Nothing is bundled for you — the peers must be present in the consuming project:
-
-- `@hydranium/protocol` (the wire contract) and `@hydranium/langium` (the pinned
-  Langium re-export). Import Langium through `@hydranium/langium` so the whole
-  workspace resolves one physical copy of it.
-- `vscode-jsonrpc`, `vscode-languageserver`, `vscode-languageserver-protocol`,
-  `vscode-languageserver-textdocument`, `vscode-languageserver-types`.
-- `@playwright/test` — optional, and needed only for `./testing/playwright`.
-
-The single bundled runtime dependency is `diff`. You also need a Langium grammar
-and its generated AST already in place; `hydranium-cli init` scaffolds both.
-
-## Exports
-
-| subpath               | holds                                                                                                                                                                                                       | platform        |
-| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- |
-| `.`                   | The head-neutral framework core: DI modules, AST semantics, build pipeline, model coordination.                                                                                                              | browser-neutral |
-| `./lsp`               | The LSP textual head — `startLanguageServer`, its two DI modules, and the Langium-LSP overrides.                                                                                                             | browser-neutral |
-| `./node`              | Server-only: `DefaultFileSystemProvider` / `NodeFileSystem`, `startStdioServer`, `startSocketServer`, `publishPortOnLspConnection`, and the headless tools `validateWorkspace` / `reflectGrammar` / `lintGrammar`. | Node-only       |
-| `./testing`           | Langium-layer doubles plus `makeTestServices` and `makeFakeDocument`.                                                                                                                                        | browser-neutral |
-| `./testing/node`      | Test support that needs a real filesystem, a stream transport or a child process: scratch workspace, golden corpus, `makeLspHarness`, `startSpawnedServer`.                                                  | Node-only       |
-| `./testing/playwright`| Playwright fixtures for end-to-end profiling and server-log capture.                                                                                                                                        | Node-only       |
-
-The browser-neutral entries are gated in CI (`scripts/check-neutral-bundles.mjs`
-bundles them for the browser and fails on a `node:*` import, including a
-transitive one) — see [what "gated neutral" does and does not promise](../../docs/concepts/browser-hosting.md#a-note-on-what-gated-neutral-does-and-does-not-promise).
-Each subpath also has a `./lib/…` twin, so a consumer on
-`moduleResolution: "Node"` can reach it.
-
-Importing `./node` has two deliberate side effects at module load: it installs
-the `node:fs`-backed log-file sink and the `node:async_hooks`-backed write-lock
-reentrancy check, both of which the neutral tree can only declare.
-
-## Getting oriented
-
-A server composes one shared services tree per process and one language module
-per grammar, then hands that tree to whichever heads it wants to run. The
-worked, compiling version of that composition is in the
-[repository README](../../README.md#compose-a-server--minimal-example); the
-layering behind it is described in
-[`docs/concepts/architecture.md`](../../docs/concepts/architecture.md), and
-[`docs/concepts/head-module-maps.md`](../../docs/concepts/head-module-maps.md) is
-the module-by-module map of this package. The class-role naming, the `./node`
-boundary and the registration-contribution pattern the services follow are in
-[`docs/contributing/conventions.md`](../../docs/contributing/conventions.md).
+| Peer                                 | Range         |
+| ------------------------------------ | ------------- |
+| `@hydranium/langium`                 | `^1.0.0-next` |
+| `@hydranium/protocol`                | `^1.0.0-next` |
+| `@playwright/test`                   | `^1.40.0`     |
+| `vscode-jsonrpc`                     | `^9.0.0`      |
+| `vscode-languageserver`              | `~10.0.1`     |
+| `vscode-languageserver-protocol`     | `~3.18.1`     |
+| `vscode-languageserver-textdocument` | `^1.0.12`     |
+| `vscode-languageserver-types`        | `^3.17.5`     |
+
+Import Langium through `@hydranium/langium`, so your project uses the same copy
+as the framework. `@playwright/test` is optional; only `./testing/playwright`
+needs it.
+
+## Wiring
+
+`hydranium-cli init` scaffolds a starter grammar and all of this wiring.
+
+1. Compose the services with `createIntegrationServices`, passing
+   `createLspServerSharedModule` and `createLspServerLanguageModule` as the
+   extra modules. Your language module binds a `Serializer`.
+2. Create the LSP connection with `withHydraniumLspFeatures`, and start it with
+   `startLanguageServer` from `./lsp`, not Langium's: it fails the start when
+   the LSP shared module is missing.
+3. Start other heads on the same shared services, with `startSocketServer` and
+   `publishPortOnLspConnection` beside the LSP head, or `startStdioServer`
+   alone.
+4. In a web worker, answer the page's bootstrap with `hostHeadsInWorker` from
+   `./browser`: it awaits what you prepared, such as `persistentFileSystem`,
+   then calls your `start`, which starts the LSP head on its port with
+   `startLanguageServerInWorker` and the other heads with their own starters.
+   It posts the ready message once every head is up, runs the validating
+   build and reports a failed start, build or rejection to the page;
+   `reportWorkerError` reports a failure of your own.
+
+See *Compose a server by hand* and *Add a validation check* in
+[Adopting Hydranium](https://github.com/eclipse-emfcloud/hydranium/blob/main/docs/ADOPTING.md).
+
+## Entry points
+
+| Subpath                | Use it for                                                                   | Runs in         |
+| ---------------------- | ---------------------------------------------------------------------------- | --------------- |
+| `.`                    | Composing services and extending the language's semantics                    | browser-neutral |
+| `./lsp`                | The LSP head and its modules                                                 | browser-neutral |
+| `./browser`            | Hosting the heads in a web worker, and the IndexedDB store behind them       | browser-only    |
+| `./node`               | The Node filesystem, the stdio and socket launchers, the headless tools      | Node-only       |
+| `./messages`           | Validation messages with stable codes, and the codes this package raises     | browser-neutral |
+| `./testing`            | Parsing and service doubles for unit tests                                   | browser-neutral |
+| `./testing/node`       | Scratch workspaces, the LSP harness, a spawned server                        | Node-only       |
+| `./testing/playwright` | Playwright fixtures that capture the server log                              | Node-only       |
+
+The subpaths need a TypeScript `moduleResolution` that reads `exports`
+(`NodeNext` or `Bundler`); see *Requirements* in
+[Adopting Hydranium](https://github.com/eclipse-emfcloud/hydranium/blob/main/docs/ADOPTING.md).
 
 ## Status
 
-Alpha — pre-v0, not yet published. The API is not stable and may change without a
-deprecation cycle. See the [repository README](../../README.md) for the current
-status and known limitations.
+Alpha: every release is a prerelease that may break the API, so pin an exact
+version. Guides and known limitations:
+[Adopting Hydranium](https://github.com/eclipse-emfcloud/hydranium/blob/main/docs/ADOPTING.md).
 
 ## License
 
-`MIT` — see this package's [`LICENSE`](./LICENSE). Third-party notices for the
-repository are recorded in [`NOTICE.md`](../../NOTICE.md).
+`MIT` — see this package's [`LICENSE`](./LICENSE), and the repository
+[`NOTICE.md`](https://github.com/eclipse-emfcloud/hydranium/blob/main/NOTICE.md)
+for third-party notices.

package/lib/browser/host-heads-in-worker.d.ts

@@ -0,0 +1,58 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type HeadPorts } from '@hydranium/protocol';
+import type { ServerSharedServicesMinimal } from '../langium/shared-services.js';
+/**
+ * Report a failure to the page on the worker global, the channel no head is
+ * allowed to bind, which is what keeps it free for this. A report under
+ * {@link WORKER_BOOTSTRAP_PHASE} ends the page's heads; any other phase is
+ * shown there and the heads stay. The stack goes with it: a worker has no log
+ * anyone reads, so the page is the one place the stack can be seen.
+ */
+export declare function reportWorkerError(phase: string, error: unknown): void;
+/** What the host's `start` hands back: the shared tier, and the readiness of any head that reports it later. */
+export interface StartedHeads {
+    readonly shared: ServerSharedServicesMinimal;
+    /**
+     * The `started` promise of every head that reports a failed start through
+     * one rather than by throwing, such as the GLSP head's. The ready message
+     * waits for them, and a rejection is a failed bootstrap.
+     */
+    readonly started?: ReadonlyArray<Promise<unknown>>;
+}
+/**
+ * Answer the page's bootstrap by starting the heads on its ports, once per
+ * worker, and tell the page when they are up and when something fails.
+ *
+ * `start` is synchronous by type, and that is the ordering contract: every
+ * head's transport starts its port as it is built but drops what arrives
+ * before the head listens, so an `await` between building a head and
+ * listening loses the page's first request with no error. Everything
+ * asynchronous, the filesystem's restore above all, is `prepared`, which is
+ * awaited before `start` is called. It may be a plain value where nothing has
+ * to be awaited.
+ *
+ * Once `start` has returned and every `started` it handed back has resolved,
+ * the ready message goes out, so a page never hears of heads that failed to
+ * come up, and an uncaught error from then on is a report rather than the end
+ * of the heads. Then every document is built with validation once the
+ * workspace has initialised: Langium's initial build validates nothing, so a
+ * page that only opens its ports would see a server that indexed the
+ * workspace and says nothing. An initial build that a write during startup
+ * cancelled is built the same, since every document exists by then.
+ *
+ * Call it once: a second call answers the same bootstrap with a second set of
+ * heads on the same ports and reports every rejection twice. The worker's
+ * `unhandledrejection` listener is this function's; it drops Langium's
+ * `OperationCancelled` marker, which a build preempted by a write rejects
+ * with, as the Node host does. An uncaught throw needs no listener, since it
+ * reaches the page as the `Worker`'s own `error` event.
+ */
+export declare function hostHeadsInWorker<TPrepared>(prepared: TPrepared | PromiseLike<TPrepared>, start: (ports: HeadPorts, prepared: TPrepared) => ServerSharedServicesMinimal | StartedHeads): void;
+//# sourceMappingURL=host-heads-in-worker.d.ts.map

package/lib/browser/host-heads-in-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-heads-in-worker.d.ts","sourceRoot":"","sources":["../../src/browser/host-heads-in-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAMJ,KAAK,SAAS,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAGjF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAGrE;AAED,gHAAgH;AAChH,MAAM,WAAW,YAAY;IAC1B,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;CACrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EACxC,QAAQ,EAAE,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC,EAC5C,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,KAAK,2BAA2B,GAAG,YAAY,GAC5F,IAAI,CAiDN"}

package/lib/browser/host-heads-in-worker.js

@@ -0,0 +1,113 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { describeErrorWithStack, isWorkerBootstrapMessage, WORKER_BOOTSTRAP_PHASE, WORKER_ERROR_MESSAGE_TYPE, WORKER_READY_MESSAGE_TYPE } from '@hydranium/protocol';
+import { isOperationCancelled } from '@hydranium/langium';
+import { isConnectionGoneError } from '../util/connection-liveness.js';
+/**
+ * Report a failure to the page on the worker global, the channel no head is
+ * allowed to bind, which is what keeps it free for this. A report under
+ * {@link WORKER_BOOTSTRAP_PHASE} ends the page's heads; any other phase is
+ * shown there and the heads stay. The stack goes with it: a worker has no log
+ * anyone reads, so the page is the one place the stack can be seen.
+ */
+export function reportWorkerError(phase, error) {
+    const report = { type: WORKER_ERROR_MESSAGE_TYPE, phase, message: describeErrorWithStack(error) };
+    postMessage(report);
+}
+/**
+ * Answer the page's bootstrap by starting the heads on its ports, once per
+ * worker, and tell the page when they are up and when something fails.
+ *
+ * `start` is synchronous by type, and that is the ordering contract: every
+ * head's transport starts its port as it is built but drops what arrives
+ * before the head listens, so an `await` between building a head and
+ * listening loses the page's first request with no error. Everything
+ * asynchronous, the filesystem's restore above all, is `prepared`, which is
+ * awaited before `start` is called. It may be a plain value where nothing has
+ * to be awaited.
+ *
+ * Once `start` has returned and every `started` it handed back has resolved,
+ * the ready message goes out, so a page never hears of heads that failed to
+ * come up, and an uncaught error from then on is a report rather than the end
+ * of the heads. Then every document is built with validation once the
+ * workspace has initialised: Langium's initial build validates nothing, so a
+ * page that only opens its ports would see a server that indexed the
+ * workspace and says nothing. An initial build that a write during startup
+ * cancelled is built the same, since every document exists by then.
+ *
+ * Call it once: a second call answers the same bootstrap with a second set of
+ * heads on the same ports and reports every rejection twice. The worker's
+ * `unhandledrejection` listener is this function's; it drops Langium's
+ * `OperationCancelled` marker, which a build preempted by a write rejects
+ * with, as the Node host does. An uncaught throw needs no listener, since it
+ * reaches the page as the `Worker`'s own `error` event.
+ */
+export function hostHeadsInWorker(prepared, start) {
+    const preparation = Promise.resolve(prepared);
+    // Handled here, so a restore that fails before the bootstrap arrives reaches
+    // the page once, under the bootstrap phase, and not first as an unhandled
+    // rejection.
+    preparation.catch(() => undefined);
+    // Rejections only, and not the ones the framework's own handlers already
+    // settle: a rejected LSP handler is caught by the connection, and a failed
+    // workspace walk rejects `workspaceInitialized`, which is reported below.
+    addEventListener('unhandledrejection', event => {
+        if (isOperationCancelled(event.reason)) {
+            // Dropped from the console too, as a Node listener's presence drops
+            // it there; a reported rejection keeps its console entry, the one
+            // place its stack stays navigable.
+            event.preventDefault();
+        }
+        else {
+            reportWorkerError('unhandled rejection', event.reason);
+        }
+    });
+    // One bootstrap per worker: the heads are composed against a single shared
+    // Langium tree, so a second would build a second tree over the same seed and
+    // hand out sessions that silently disagree about the workspace.
+    let bootstrapped = false;
+    // The bare global rather than `self.addEventListener`: only the former is
+    // typed against the dedicated worker's event map, where `message` carries a
+    // `MessageEvent`.
+    addEventListener('message', event => {
+        if (bootstrapped || !isWorkerBootstrapMessage(event.data)) {
+            return;
+        }
+        bootstrapped = true;
+        // `.catch` rather than try/catch: a rejected restore, a `start` that
+        // throws and a head whose `started` rejects arrive by the same route, and
+        // all have to reach the page.
+        onBootstrap(event.data.ports).catch((error) => reportWorkerError(WORKER_BOOTSTRAP_PHASE, error));
+    });
+    async function onBootstrap(ports) {
+        const value = await preparation;
+        const result = start(ports, value);
+        const { shared, started } = 'shared' in result ? result : { shared: result, started: undefined };
+        // Safe to await now: every head listens already, so nothing is lost.
+        await Promise.all(started ?? []);
+        const ready = { type: WORKER_READY_MESSAGE_TYPE };
+        postMessage(ready);
+        validateWorkspace(shared).catch((error) => reportWorkerError('workspace validation', error));
+    }
+}
+/**
+ * The trailing validating build, after `workspaceInitialized`: building before
+ * it would validate a partial document set. A cancelled or connection-gone
+ * initial build is routine, so it is built through; any other failure is the
+ * caller's to report.
+ */
+async function validateWorkspace(shared) {
+    await shared.workspace.WorkspaceManager.workspaceInitialized.catch((error) => {
+        if (!isOperationCancelled(error) && !isConnectionGoneError(error)) {
+            throw error;
+        }
+    });
+    await shared.workspace.DocumentBuilder.build(shared.workspace.LangiumDocuments.all.toArray(), { validation: true });
+}
+//# sourceMappingURL=host-heads-in-worker.js.map

package/lib/browser/host-heads-in-worker.js.map

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

package/lib/browser/index.d.ts

@@ -0,0 +1,12 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+export * from './host-heads-in-worker.js';
+export * from './indexeddb-file-system-store.js';
+export * from './start-language-server-in-worker.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAOlF,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC"}

package/lib/browser/index.js

@@ -0,0 +1,17 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+// Worker-only entry (`@hydranium/core/browser`). Compiled as its own project
+// against `lib.webworker`, so a worker global such as `indexedDB` or
+// `postMessage` resolves here and nowhere else in the package: the portable
+// `.` barrel must stay free of DOM and worker globals, since it also loads in a
+// plain Node consumer.
+export * from './host-heads-in-worker.js';
+export * from './indexeddb-file-system-store.js';
+export * from './start-language-server-in-worker.js';
+//# sourceMappingURL=index.js.map

package/lib/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,6EAA6E;AAC7E,qEAAqE;AACrE,4EAA4E;AAC5E,gFAAgF;AAChF,uBAAuB;AACvB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC"}

package/lib/browser/indexeddb-file-system-store.d.ts

@@ -0,0 +1,82 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import type { FileSystemSeed } from '../langium/workspace/in-memory-file-system-provider.js';
+import type { FileSystemStore } from '../langium/workspace/persistent-file-system-provider.js';
+/**
+ * A {@link FileSystemStore} in `IndexedDB`, so an edit survives a reload.
+ *
+ * # Why IndexedDB and not OPFS
+ *
+ * OPFS is the tempting answer, because `createSyncAccessHandle` gives
+ * SYNCHRONOUS file reads in a worker, which is what Langium's
+ * `FileSystemProvider` needs. It buys nothing here: directory enumeration
+ * (`FileSystemDirectoryHandle.entries()`) is async-only, so a directory index
+ * still has to live in memory, and once it does the file reads are being served
+ * from memory too. IndexedDB is the smaller dependency for the same shape.
+ *
+ * # It holds the DELTA, not the workspace
+ *
+ * Only what has been written lands here, and `PersistentFileSystemProvider` lays
+ * it over the host's seed. So a fixture edited in the host's bundle still
+ * reaches a returning visitor, and this database stays a few kilobytes rather
+ * than a copy of the workspace.
+ *
+ * # A failure is loud, deliberately
+ *
+ * Nothing here degrades to non-persistent operation. A refused open, a blocked
+ * upgrade or an aborted transaction, which is what a quota overrun looks like,
+ * rejects the call, which fails the worker's bootstrap or the save that asked.
+ * The alternative, carrying on without a store, would report a saved workspace
+ * and lose it on the next load. An origin EVICTED between visits is not a
+ * failure this class can see: its database opens empty, which is a first visit,
+ * and the provider is correct in that state. Evicted mid-session, the next
+ * transaction rejects like any other failure.
+ *
+ * # The database is origin-scoped
+ *
+ * Every page on the origin shares a database of the same name, and the user
+ * agent may evict it. The name is the one per-app value and is REQUIRED for
+ * that reason: a default would let two apps on one origin overwrite each
+ * other's edits with nothing reporting it.
+ */
+export declare class IndexedDbFileSystemStore implements FileSystemStore {
+    protected readonly databaseName: string;
+    /**
+     * Opened once and shared, and NOT kept when it fails: a refused or blocked
+     * open rejects the call that needed it and the next call opens again, so a
+     * cause that has cleared, such as the other tab closing, does not fail every
+     * later save with the first error.
+     */
+    protected connection?: Promise<IDBDatabase>;
+    constructor(databaseName: string);
+    load(): Promise<FileSystemSeed>;
+    write(path: string, content: string): Promise<void>;
+    remove(path: string): Promise<void>;
+    /**
+     * Drop everything, returning the next load to the seed.
+     *
+     * The escape hatch a persistent host needs and a seeded one does not: a saved
+     * document that no longer parses is otherwise restored on every load, and
+     * clearing site data is the only other way out. Not on {@link FileSystemStore},
+     * which the provider never clears.
+     */
+    clear(): Promise<void>;
+    /**
+     * Run one write transaction and settle on its COMPLETION.
+     *
+     * Not on the request's `success`: a request can succeed inside a transaction
+     * that then aborts, which is exactly what a quota overrun looks like, so
+     * resolving early would report a save the database never kept.
+     */
+    protected mutate(operation: string, act: (files: IDBObjectStore) => void): Promise<void>;
+    protected open(): Promise<IDBDatabase>;
+    protected openDatabase(): Promise<IDBDatabase>;
+    protected failure(transaction: IDBTransaction, operation: string): Error;
+}
+//# sourceMappingURL=indexeddb-file-system-store.d.ts.map

package/lib/browser/indexeddb-file-system-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexeddb-file-system-store.d.ts","sourceRoot":"","sources":["../../src/browser/indexeddb-file-system-store.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wDAAwD,CAAC;AAC7F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yDAAyD,CAAC;AAW/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,wBAAyB,YAAW,eAAe;IASjD,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM;IARnD;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAE5C,YAA+B,YAAY,EAAE,MAAM,EAAI;IAEjD,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,CA2BpC;IAEK,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExD;IAEK,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExC;IAED;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAED;;;;;;OAMG;IACH,UAAgB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ7F;IAED,SAAS,CAAC,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,CAMrC;IAED,SAAS,CAAC,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC,CAwC7C;IAED,SAAS,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAKvE;CACH"}