@dialecte/core 0.7.0 → 0.8.0

package/dist/store/apply-record-patch.d.ts

@@ -0,0 +1,13 @@
+import { AnyRawRecord, RecordPatch } from '../types';
+/**
+ * A record with a bulk-write patch applied, the record given left unchanged: each field the patch
+ * gives replaces the record's (a field given as `undefined` is not given); attributes merge by name
+ * (a held one replaced in place, a new one appended), then `removeAttributes` drops the names
+ * listed; children merge by id the same way. A field the record type does not have is dropped, as a
+ * store keeps it. Every store applies a patch through this.
+ */
+export declare function applyRecordPatch(params: {
+    record: AnyRawRecord;
+    patch: RecordPatch;
+}): AnyRawRecord;
+//# sourceMappingURL=apply-record-patch.d.ts.map

package/dist/store/apply-record-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-record-patch.d.ts","sourceRoot":"","sources":["../../src/store/apply-record-patch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAExD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACxC,MAAM,EAAE,YAAY,CAAA;IACpB,KAAK,EAAE,WAAW,CAAA;CAClB,GAAG,YAAY,CAsBf"}

package/dist/store/closing-connections.d.ts

@@ -0,0 +1,7 @@
+import { ClosingConnections } from './closing-connections.types';
+/**
+ * The connections of each name closed while operations of theirs still run, in this realm: a closed
+ * connection counts open no more, and a destroy of the name lets its running operations complete first.
+ */
+export declare function createClosingConnections(): ClosingConnections;
+//# sourceMappingURL=closing-connections.d.ts.map

package/dist/store/closing-connections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closing-connections.d.ts","sourceRoot":"","sources":["../../src/store/closing-connections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAErE;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAoB7D"}

package/dist/store/closing-connections.types.d.ts

@@ -0,0 +1,13 @@
+/** The connections of each project name closed while operations of theirs still run, in this realm. */
+export type ClosingConnections = {
+    /** A connection of the name closed: its running operations settle with `until`. */
+    markClosing: (params: {
+        name: string;
+        until: Promise<unknown>;
+    }) => void;
+    /** Settles once no connection of the name closed with operations running has any left. */
+    settled: (params: {
+        name: string;
+    }) => Promise<void>;
+};
+//# sourceMappingURL=closing-connections.types.d.ts.map

package/dist/store/closing-connections.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closing-connections.types.d.ts","sourceRoot":"","sources":["../../src/store/closing-connections.types.ts"],"names":[],"mappings":"AAAA,uGAAuG;AACvG,MAAM,MAAM,kBAAkB,GAAG;IAChC,mFAAmF;IACnF,WAAW,EAAE,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,KAAK,IAAI,CAAA;IACxE,0FAA0F;IAC1F,OAAO,EAAE,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACpD,CAAA"}

package/dist/store/commit-progress.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A commit's progress as every store tells it, once its records are written: after its creates, its
+ * updates and its deletes, each time out of all of them. The listener is never awaited; its failure
+ * is reported on the console, once for the commit, the commit stands whole.
+ */
+export declare function tellCommitProgress(params: {
+    onProgress: ((current: number, total: number) => unknown) | undefined;
+    parts: readonly number[];
+}): void;
+//# sourceMappingURL=commit-progress.d.ts.map

package/dist/store/commit-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-progress.d.ts","sourceRoot":"","sources":["../../src/store/commit-progress.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAA;IACrE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CACxB,GAAG,IAAI,CAiBP"}

package/dist/store/compare-by-id.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Id order, as an IndexedDB key range answers: strings compared by UTF-16 code unit, not by locale.
+ * Every list read of a store answers in this order.
+ */
+export declare function compareById(left: {
+    id: string;
+}, right: {
+    id: string;
+}): number;
+//# sourceMappingURL=compare-by-id.d.ts.map

package/dist/store/compare-by-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-by-id.d.ts","sourceRoot":"","sources":["../../src/store/compare-by-id.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAG/E"}

package/dist/store/document-path.constants.d.ts

@@ -0,0 +1,20 @@
+/** What a document's path puts between its folders and its file name. */
+export declare const DOCUMENT_PATH_SEPARATOR = "/";
+/** The longest folder or file name of a path, in UTF-8 bytes: what APFS, ext4 and NTFS take. */
+export declare const DOCUMENT_PATH_SEGMENT_MAX_BYTES = 255;
+/** The longest path, in UTF-8 bytes: macOS's `PATH_MAX`, the tightest of the desktop systems an archive is extracted on. */
+export declare const DOCUMENT_PATH_MAX_BYTES = 1024;
+/**
+ * The characters a path never holds, all invisible or breaking a line in a tree: controls (Cc: U+0000-U+001F,
+ * U+007F-U+009F), formats (Cf: bidi overrides and isolates, zero-width characters, the byte order mark) and line or
+ * paragraph separators (Zl, Zp). A right-to-left override would show `north\u202Edcs.xml` as `northlmx.scd`.
+ */
+export declare const DOCUMENT_PATH_INVISIBLE_CHARACTER: RegExp;
+/**
+ * The fields of a document's registry entry an update may change; any other key handed is ignored. Not its `status`:
+ * only its import marks a document ready (`ImportTarget.markReady`).
+ */
+export declare const DOCUMENT_UPDATE_FIELDS: readonly ["name", "path", "metadata"];
+/** The extension every dialecte reads, besides the ones its config lists: a dialecte's own extension is still XML. */
+export declare const ALWAYS_READ_EXTENSION = ".xml";
+//# sourceMappingURL=document-path.constants.d.ts.map

package/dist/store/document-path.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-path.constants.d.ts","sourceRoot":"","sources":["../../src/store/document-path.constants.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C,gGAAgG;AAChG,eAAO,MAAM,+BAA+B,MAAM,CAAA;AAElD,4HAA4H;AAC5H,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,QAAgC,CAAA;AAE9E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,uCAAwC,CAAA;AAE3E,sHAAsH;AACtH,eAAO,MAAM,qBAAqB,SAAS,CAAA"}

package/dist/store/document-path.d.ts

@@ -0,0 +1,75 @@
+import { DocumentPathParts, PathHolderCandidate } from './document-path.types';
+import { DocumentRecord, DocumentUpdates } from '../project/types';
+/**
+ * A document's path read apart into its folders and its file name. A path is relative and written one way only:
+ * segments joined by `/`, none empty, none `.` or `..`, no backslash, no invisible format, separator or control
+ * character, well-formed and in Unicode NFC, each segment at most 255 UTF-8 bytes and the whole at most 1024.
+ * Nothing is rewritten: a path breaking a rule is refused with `DOCUMENT_PATH_INVALID`, `detail` naming the rule,
+ * `meta.path` the path as given.
+ *
+ * @intent validate a document path, split a document path into folders and file name
+ */
+export declare function parseDocumentPath(params: {
+    path: string;
+}): DocumentPathParts;
+/**
+ * The extensions a document's config reads: the ones it lists, in their order, then `ALWAYS_READ_EXTENSION` (`.xml`)
+ * unless one of them is exactly it (a listed `.XML` matches no lower-cased file name, so `.xml` is still added). The
+ * first one is the extension core gives a document nothing names one for: the first listed, `.xml` for an empty list.
+ */
+export declare function readableExtensionsOf(params: {
+    extensions: readonly string[];
+}): readonly string[];
+/**
+ * The name and the extension of a path's file name, split at its last dot: for a document that has no extension
+ * yet (an import, a new document). A path breaking a rule, a file name without a name and an extension by that rule
+ * (`README`, `north.`, `.scd`), or - when `extensions` are given - one whose extension is not among them (compared as a
+ * file's name is: lower-cased), is refused with `DOCUMENT_PATH_INVALID`.
+ */
+export declare function splitFileName(params: {
+    path: string;
+    extensions?: readonly string[];
+}): Pick<DocumentRecord, 'name' | 'extension'>;
+/**
+ * Check the path a document is registered with: a valid path ending with the document's file name, its `name` then
+ * its own `extension` (`name` non-empty); none passes. Refused with `DOCUMENT_PATH_INVALID`.
+ */
+export declare function assertDocumentPath(params: {
+    document: Pick<DocumentRecord, 'name' | 'extension' | 'path'>;
+}): void;
+/**
+ * A document with the updates applied, its file name and its path kept one fact: a `path` moves and renames it (its
+ * `name` follows the file name, which must end with the document's own `extension`); a `name` on a document with a
+ * path rewrites the file name in it, the folders kept; both given must agree; a field given as `undefined` is left
+ * as it was, a key beyond `DOCUMENT_UPDATE_FIELDS` ignored. Refused with `DOCUMENT_PATH_INVALID` when the result breaks a rule; the document given is left as it
+ * was. Whether the place is free is the store's to check (`assertDocumentPlace`).
+ *
+ * @intent rename or move a document by its path, apply document updates in a custom store
+ */
+export declare function applyDocumentUpdates(params: {
+    document: DocumentRecord;
+    updates: DocumentUpdates;
+}): DocumentRecord;
+/**
+ * Check a document to register against the registered ones: its path valid and ending with its file name
+ * (`DOCUMENT_PATH_INVALID`), then its place free (`DOCUMENT_PATH_TAKEN`). A document without a path passes.
+ *
+ * @intent check a document path is valid and free before registering it, register documents in a custom store
+ */
+export declare function assertDocumentPlace(params: {
+    document: Pick<DocumentRecord, 'id' | 'name' | 'extension' | 'path'>;
+    documents: PathHolderCandidate[];
+}): void;
+/**
+ * The document whose path clashes with `path`, the document `documentId` excepted: one at that very place, or one
+ * whose path is a folder of the other's - a file system holds no file and folder of one name. Paths compare exactly;
+ * a document without a path holds no place. None when the place is free.
+ *
+ * @intent find which document holds a path, check whether a file or folder path is free
+ */
+export declare function pathHolderOf(params: {
+    path: string;
+    documents: PathHolderCandidate[];
+    documentId?: string;
+}): string | undefined;
+//# sourceMappingURL=document-path.d.ts.map

package/dist/store/document-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-path.d.ts","sourceRoot":"","sources":["../../src/store/document-path.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtE;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,iBAAiB,CAO7E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,MAAM,EAAE,CAIjG;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,CAAC,CAc7C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAC1C,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC,CAAA;CAC7D,GAAG,IAAI,CAgBP;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC5C,QAAQ,EAAE,cAAc,CAAA;IACxB,OAAO,EAAE,eAAe,CAAA;CACxB,GAAG,cAAc,CA8BjB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC3C,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC,CAAA;IACpE,SAAS,EAAE,mBAAmB,EAAE,CAAA;CAChC,GAAG,IAAI,CAOP;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,mBAAmB,EAAE,CAAA;IAChC,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,MAAM,GAAG,SAAS,CASrB"}

package/dist/store/document-path.types.d.ts

@@ -0,0 +1,11 @@
+/** A document's path read apart: the folders it sits in, outermost first, then its file name. */
+export type DocumentPathParts = {
+    folders: string[];
+    fileName: string;
+};
+/** A registered document as the clash check reads it: its id and, when it has one, its path. */
+export type PathHolderCandidate = {
+    id: string;
+    path?: string;
+};
+//# sourceMappingURL=document-path.types.d.ts.map

package/dist/store/document-path.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-path.types.d.ts","sourceRoot":"","sources":["../../src/store/document-path.types.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,MAAM,MAAM,iBAAiB,GAAG;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,gGAAgG;AAChG,MAAM,MAAM,mBAAmB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,CAAA"}

package/dist/store/engine/client/check-engine-wire.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An engine of another library version speaks another wire: refused `STORE_PROTOCOL_MISMATCH`, naming
+ * both versions (its caller ends it, as a failed open).
+ */
+export declare function refuseAnotherWire(params: {
+    found: number;
+}): void;
+//# sourceMappingURL=check-engine-wire.d.ts.map

package/dist/store/engine/client/check-engine-wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-engine-wire.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/check-engine-wire.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAOjE"}

package/dist/store/engine/client/client.constants.d.ts

@@ -0,0 +1,30 @@
+import { EngineLostReason } from './client.types';
+/** One engine's attempt to open its project (the engine lock, then its own setup: SQLite probes and installs its pool). */
+export declare const ENGINE_OPEN_BUDGET_MS = 10000;
+/**
+ * The longest a realm waits for its engine's answer to an open, the hub's client as a realm running the
+ * engine itself: a slow worker start (seconds under load), the engine's own budget for its lock and its
+ * pool, then its database opened and the imports a dead view left removed. An engine silent past it is
+ * ended, the open refused `PROJECT_ENGINE_UNAVAILABLE`.
+ */
+export declare const ENGINE_OPEN_WINDOW_MS = 30000;
+/** How long a realm waits for its engine to close before it ends the worker anyway. */
+export declare const ENGINE_CLOSE_BUDGET_MS = 2000;
+/**
+ * How long an engine a listening connection followed (no call of its own) must run before its end is followed too;
+ * doubled at each such follow up to `ENGINE_FOLLOW_REARM_MAX_MS`, back to this at a call of its own: an engine that
+ * does not last is not started again and again for a listener.
+ */
+export declare const ENGINE_FOLLOW_REARM_FIRST_MS = 1000;
+export declare const ENGINE_FOLLOW_REARM_MAX_MS = 30000;
+/**
+ * A client takes its engine for lost after this long with no message while a call waits: the engine
+ * beats every second while it works (inside its longest steps too), and says `busy` before dialecte
+ * code that may run longer.
+ */
+export declare const ENGINE_HEARTBEAT_TIMEOUT_MS = 10000;
+/** What the work asked of an engine the realm ends answers once its budget passed with no answer: the engine is deaf. */
+export declare const UNANSWERED = "unanswered";
+/** What a call refused `STORE_ENGINE_LOST` says, for each reason its engine was lost. */
+export declare const ENGINE_LOST_DETAILS: Record<EngineLostReason, string>;
+//# sourceMappingURL=client.constants.d.ts.map

package/dist/store/engine/client/client.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.constants.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/client.constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEtD,2HAA2H;AAC3H,eAAO,MAAM,qBAAqB,QAAS,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAS,CAAA;AAE3C,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,OAAQ,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,OAAQ,CAAA;AACjD,eAAO,MAAM,0BAA0B,QAAS,CAAA;AAEhD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAA;AAEjD,yHAAyH;AACzH,eAAO,MAAM,UAAU,eAAe,CAAA;AAEtC,yFAAyF;AACzF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAKhE,CAAA"}

package/dist/store/engine/client/client.types.d.ts

@@ -0,0 +1,200 @@
+import { LinkNotice } from '../engine-store.types';
+import { DistributiveOmit, EngineApi, EngineControlAnswer, EngineControlRequest } from '../engine.types';
+import { EngineEventSignal } from '../host/host.types';
+/** The engine as one client reaches it through its port. */
+export type EngineClient = {
+    /** The engine's members, each call made for the port's own client. */
+    api: EngineApi;
+    /** The engine's members, each call made for that connection of the page (several share one port through the hub). */
+    connection: (params: {
+        connectionId: string;
+    }) => EngineApi;
+    /** `listener` told each change the engine announces on this port; answers the unsubscribe. */
+    onEvent: (listener: (signal: EngineEventSignal) => void) => () => void;
+    /** Refuse every call in flight `STORE_ENGINE_LOST` for that reason; the port stays. */
+    lose: (params: {
+        reason: EngineLostReason;
+    }) => void;
+    /** Release the port: the client reaches the engine no more; a call still waiting is refused `STORE_CLOSED`. */
+    close: (params: {
+        storeName: string;
+    }) => void;
+};
+/**
+ * Why an engine is lost: the view hosting it ended (its lock released), it sent nothing for too long
+ * while a call waited (busy beyond reach, paused, frozen), or the hub dropped this view with the page
+ * that bound it (it reaches the engine again once bound again).
+ */
+export type EngineLostReason = 'host-gone' | 'no-heartbeat' | 'realm-dropped';
+/** A call waiting for the engine's answer: refused at once if the engine is lost. */
+export type CallInFlight = {
+    writeId: string | undefined;
+    /** An export's id: a lost export is told to stop (its result would reach no one). */
+    exportId: string | undefined;
+    reject: (thrown: unknown) => void;
+    /** Refused lost already: its answer, if it ever comes, is dropped. */
+    lost: boolean;
+};
+export type WorkerConnectorParams<GenericSettings> = {
+    /** The project's name. */
+    name: string;
+    /**
+     * The dialecte of the project and the version the realm runs: with the name, what the project is - two
+     * dialectes' projects of one name never meet; an engine of another one is refused.
+     */
+    dialecteId: string;
+    dialecteVersion: string;
+    /** The address of the dialecte's engine worker (its `?worker&url` export). */
+    engineUrl: string;
+    /** Measure the import's and the export's stages in the engine (`dev.perf`). */
+    perf?: boolean;
+    /**
+     * The realm's budget for the project's engine (`ENGINE_OPEN_BUDGET_MS` when absent): how long its
+     * open may take in all (its lock and its own setup); how long the worker a destroy runs through has
+     * to delete the project, with the close budget besides to answer before it counts as deaf and is
+     * ended (`PROJECT_DESTROY_FAILED`); and how long the realm waits for the lock of a worker it ended
+     * deaf to close or to destroy before the next engine of the name starts, or the destroy runs.
+     */
+    openBudgetMs?: number;
+    /**
+     * How long the realm waits for its engine's answer to an open (`ENGINE_OPEN_WINDOW_MS` when absent; never
+     * less than `openBudgetMs` and the close budget): past it the worker is ended and the open refused
+     * `PROJECT_ENGINE_UNAVAILABLE`.
+     */
+    openWindowMs?: number;
+    /**
+     * How the engine and its clients tell a busy engine from a lost one (the defaults when absent): an engine
+     * silent for `heartbeatTimeoutMs` while a call waits, or while it adopts a new connection, is lost.
+     */
+    liveness?: {
+        heartbeatTimeoutMs?: number;
+        heartbeatIntervalMs?: number;
+    };
+    /** What the engine's kind needs to open, handed to it as is (`EngineOpenParams.settings`). */
+    settings: GenericSettings;
+};
+/** A control request sent, waiting for its answer: the answer's type it expects, how it settles. */
+export type PendingControlRequest = {
+    expect: string;
+    resolve: (answer: EngineControlAnswer) => void;
+    reject: (thrown: unknown) => void;
+};
+/** The engine worker a realm runs for one project in direct mode, and the connections it serves. */
+export type RealmEngine = {
+    worker: Worker;
+    /** Counts the engines of the name in this realm: a connection adopted by another one adopts again. */
+    generation: number;
+    /** Settles once the engine opened (or failed to). */
+    opened: Promise<void>;
+    control: EngineControl;
+    links: Set<WorkerLinkState>;
+    /** Set once the realm ends it, or sees it gone: it serves nothing more. */
+    ended: boolean;
+    /** The page's request of the engine lock, granted once the worker no longer holds it (it is gone). */
+    watch: {
+        controller: AbortController;
+        settled: Promise<void>;
+    } | undefined;
+    /** The id its project's file was created with, once it opened. */
+    creationId: string | undefined;
+};
+/**
+ * A worker the realm ends: `ended` answers the work asked of it; `released` settles once the next engine of the
+ * name may start (its lock let go, or waited for within the budget its answer gave it).
+ */
+export type EngineEnding = {
+    ended: Promise<unknown>;
+    released: Promise<void>;
+};
+/** A destroy through a fresh worker: `done` answers it, `released` as for any worker the realm ends. */
+export type FreshWorkerDestroy = {
+    done: Promise<void>;
+    released: Promise<void>;
+};
+/** One connection of the realm to its engine worker: its client, and the engine that adopted it. */
+export type WorkerLinkState = {
+    clientId: string;
+    released: boolean;
+    /** What the connection's store listens with: each change of its engine, and each resync. */
+    listeners: Set<(notice: LinkNotice) => void>;
+    /** Reach the project's engine now (an idle connection with a listener follows the next engine of its project). */
+    follow: () => void;
+    /** Whether `follow` may start an engine: again after each call of the connection's own. */
+    mayFollow: boolean;
+    /** When the engine `follow` reached was reached: its end is followed once it ran `followRearmMs`. */
+    followedAt: number | undefined;
+    /** How long a followed engine must run before its end is followed too (doubled at each follow). */
+    followRearmMs: number;
+    /** The client the engine of that generation adopted for the connection (being adopted while pending). */
+    adoption: {
+        generation: number;
+        client: Promise<EngineClient>;
+    } | undefined;
+    /**
+     * The creation id of the project the connection first reached: an engine started later for it (the one
+     * before ended) must open that project, else the connection is refused `PROJECT_DESTROYED_WHILE_AWAY`.
+     */
+    creationId: string | undefined;
+    /** Its project destroyed while it was away (`PROJECT_DESTROYED_WHILE_AWAY`): every later call refused with it. */
+    refusal: unknown;
+    /** Its release under way or done, once closed: a later close settles with it. */
+    releasing: Promise<void> | undefined;
+};
+/** The control messages of one engine worker, each answered by its request id. */
+export type EngineControl = {
+    request: <GenericType extends EngineControlAnswer['type']>(params: {
+        message: DistributiveOmit<EngineControlRequest, 'requestId'>;
+        expect: GenericType;
+        transfer?: Transferable[];
+    }) => Promise<Extract<EngineControlAnswer, {
+        type: GenericType;
+    }>>;
+    /**
+     * The engine opened: from now on an uncaught error in its worker (a dialecte hook's timer) is no
+     * failure of the engine; before, it refuses every request waiting (`PROJECT_ENGINE_UNAVAILABLE`).
+     */
+    opened: () => void;
+    /** The worker ended or lost: every request waiting, and every one made later, refused with `error`. */
+    end: (params: {
+        error: unknown;
+    }) => void;
+    /** Watch the engine's silence on this channel (`answeredOrSilent`), until stopped. */
+    watchSilence: (params: {
+        budgetMs: number;
+    }) => SilenceWatch;
+};
+/** An engine's silence watched: `silent` settles once it has said nothing for the budget while not busy. */
+export type SilenceWatch = {
+    silent: Promise<void>;
+    stop: () => void;
+};
+/** How a client watches its engine's silence while calls wait. */
+export type HeartbeatWatch = {
+    /** The silence counts from now (a call starts while none waited, the page resumed). */
+    restart: () => void;
+    stop: () => void;
+};
+/** The progress listeners of a client's calls in flight, each under the id its call sends the engine. */
+export type ProgressListeners = {
+    /** Keep the listener of a call; answers the id the call sends. */
+    add: (params: {
+        listener: (...progress: unknown[]) => unknown;
+    }) => number;
+    /** The call answered: its listener let go. */
+    remove: (params: {
+        progressId: number | undefined;
+    }) => void;
+    /** The engine lost: every listener let go (their calls are refused). */
+    clear: () => void;
+    /** The client closed: nothing heard any more. */
+    stop: () => void;
+};
+/** The listeners of the changes an engine announces on a client's port. */
+export type EventListeners = {
+    /** Answers the unsubscribe. */
+    add: (params: {
+        listener: (signal: EngineEventSignal) => void;
+    }) => () => void;
+    stop: () => void;
+};
+//# sourceMappingURL=client.types.d.ts.map

package/dist/store/engine/client/client.types.d.ts.map

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

package/dist/store/engine/client/engine-client.d.ts

@@ -0,0 +1,15 @@
+import { EngineClient } from './client.types';
+/**
+ * The engine as one client reaches it through its port: a plain object of the engine's members
+ * (it answers no `then` and no symbol key, so it never looks like a promise), each call crossing as
+ * the wire table says - its JSON values copied as plain data, its progress listener kept here under an
+ * id (the engine posts each tick on this port: every tick is told before the answer), its answer an
+ * envelope: a value, or what the engine threw, rebuilt. The calls in flight are known: once the engine is lost they are refused
+ * `STORE_ENGINE_LOST` (a write with its `writeId`); a write refused so while its engine may still run
+ * it is `running` for `getWriteOutcome` until its answer arrives.
+ */
+export declare function createEngineClient(params: {
+    port: MessagePort;
+    heartbeatTimeoutMs?: number;
+}): EngineClient;
+//# sourceMappingURL=engine-client.d.ts.map

package/dist/store/engine/client/engine-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-client.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/engine-client.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAEX,YAAY,EAIZ,MAAM,gBAAgB,CAAA;AAGvB;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAC1C,IAAI,EAAE,WAAW,CAAA;IACjB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC3B,GAAG,YAAY,CA4If"}

package/dist/store/engine/client/engine-control.d.ts

@@ -0,0 +1,16 @@
+import { UNANSWERED } from './client.constants';
+import { EngineControl } from './client.types';
+/** The control messages of one engine worker: each request answered once, by its id. */
+export declare function createEngineControl(params: {
+    worker: Worker;
+}): EngineControl;
+/**
+ * `work`'s answer, or `UNANSWERED` once the engine has been silent for `budgetMs` while not busy (a busy
+ * engine is never taken for a lost one): what a realm waits a control request with.
+ */
+export declare function answeredOrSilent<GenericAnswer>(params: {
+    control: EngineControl;
+    work: Promise<GenericAnswer>;
+    budgetMs: number;
+}): Promise<GenericAnswer | typeof UNANSWERED>;
+//# sourceMappingURL=engine-control.d.ts.map

package/dist/store/engine/client/engine-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-control.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/engine-control.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAM/C,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,gBAAgB,CAAA;AAExF,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAyE7E;AAgCD;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,MAAM,EAAE;IAC7D,OAAO,EAAE,aAAa,CAAA;IACtB,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC5B,QAAQ,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,aAAa,GAAG,OAAO,UAAU,CAAC,CAW7C"}

package/dist/store/engine/client/heartbeat-watch.d.ts

@@ -0,0 +1,17 @@
+import { HeartbeatWatch } from './client.types';
+/**
+ * The engine's silence while something waits on it (a call on a client port, an adoption on the worker's
+ * control channel): any message from `source` (an answer, a beat) is a sign of life; `busy` holds the clock
+ * from the engine's busy signal to its next heartbeat - `busy` when the watch starts, if the engine said so
+ * last; none for `timeoutMs` while something waits loses the engine - once the messages queued meanwhile
+ * have gone through (a message turn: the page may have stalled, or been frozen with its worker); the
+ * document's `resume` and the page's `pageshow` restart the clock. The clock starts at the first `restart`.
+ */
+export declare function watchHeartbeat(params: {
+    source: EventTarget;
+    timeoutMs: number;
+    waiting: () => number;
+    lose: () => void;
+    busy?: boolean;
+}): HeartbeatWatch;
+//# sourceMappingURL=heartbeat-watch.d.ts.map

package/dist/store/engine/client/heartbeat-watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat-watch.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/heartbeat-watch.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACtC,MAAM,EAAE,WAAW,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,MAAM,CAAA;IACrB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,IAAI,CAAC,EAAE,OAAO,CAAA;CACd,GAAG,cAAc,CA8DjB"}

package/dist/store/engine/client/hub-connector.d.ts

@@ -0,0 +1,11 @@
+import { EngineConnector } from '../engine-store.types';
+import { HubConnectorParams } from './hub-connector.types';
+/**
+ * A project's engine reached through the origin's hub: the hub elects the realm that hosts it and hands
+ * this realm a port to it; a call made before the hub answered waits for its answer. The connection's
+ * engine is the one the realm holds now: after its host is gone, the next one. The project is destroyed
+ * once the hub grants it (no other view uses it), by a fresh worker that waits for the lock of the
+ * engine the hub just released - in this realm, or (`deletesFiles: false`) in a view the hub picks.
+ */
+export declare function createHubConnector(params: HubConnectorParams): EngineConnector;
+//# sourceMappingURL=hub-connector.d.ts.map

package/dist/store/engine/client/hub-connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-connector.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/hub-connector.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAc,MAAM,uBAAuB,CAAA;AAIxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAK/D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,eAAe,CAmE9E"}

package/dist/store/engine/client/hub-connector.types.d.ts

@@ -0,0 +1,25 @@
+import { HubConnection } from '../hub/hub-client.types';
+export type HubConnectorParams = {
+    /** The project's name. */
+    name: string;
+    /** The realm's connection to the hub. */
+    connection: HubConnection;
+    dialecteId: string;
+    /** The version of the dialecte this realm runs: the hub refuses an engine of another one. */
+    dialecteVersion: string;
+    /** The address of the dialecte's engine worker: a fresh one destroys the project. */
+    engineUrl: string;
+    /**
+     * How long the destroy's fresh worker has to delete the project (`ENGINE_OPEN_BUDGET_MS` when absent),
+     * the close budget besides to answer; the hub keeps its own budget for opening engines.
+     */
+    destroyBudgetMs?: number;
+    /** How long a call waits on a silent engine (the default when absent). */
+    heartbeatTimeoutMs?: number;
+    /**
+     * Whether this realm deletes the project's files on a destroy (a fresh worker here; the default). A realm that
+     * cannot store (`false`): the hub has a view that runs an engine of the dialecte delete them.
+     */
+    deletesFiles?: boolean;
+};
+//# sourceMappingURL=hub-connector.types.d.ts.map

package/dist/store/engine/client/hub-connector.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-connector.types.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/hub-connector.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAE5D,MAAM,MAAM,kBAAkB,GAAG;IAChC,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,yCAAyC;IACzC,UAAU,EAAE,aAAa,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,6FAA6F;IAC7F,eAAe,EAAE,MAAM,CAAA;IACvB,qFAAqF;IACrF,SAAS,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA"}

package/dist/store/engine/client/worker-connector.d.ts

@@ -0,0 +1,32 @@
+import { EngineConnector } from '../engine-store.types';
+import { EngineLockMode } from '../engine.types';
+import { WorkerConnectorParams } from './client.types';
+/**
+ * Direct mode: the project's engine runs in a dedicated worker this realm spawns (from the dialecte's
+ * engine address), shared by every connection of the realm to the name, each through a port of its
+ * own. The engine takes the project's lock only if free: another realm holding it refuses with
+ * `PROJECT_OPEN_ELSEWHERE`. The worker is closed and ended with the last connection.
+ */
+export declare function createWorkerConnector<GenericSettings>(params: WorkerConnectorParams<GenericSettings>): EngineConnector;
+/**
+ * Whether this realm runs the project's engine itself (a connection of it open in direct mode): a new connection
+ * of the realm joins that engine, whatever the hub says by then.
+ */
+export declare function runsDirectly(params: {
+    name: string;
+    dialecteId: string;
+}): boolean;
+/**
+ * A worker that opens nothing deletes the project, the lock taken as `lock` says (only if free in
+ * direct mode; waited for through the hub, whose engine just released may hold it a moment); ended
+ * after. It has the open budget to delete and the close budget to answer: one that does not is ended,
+ * and the destroy refused `PROJECT_DESTROY_FAILED` (the project may still be there).
+ */
+export declare function destroyFromFreshWorker(params: {
+    name: string;
+    dialecteId: string;
+    engineUrl: string;
+    budgetMs: number;
+    lock: EngineLockMode;
+}): Promise<void>;
+//# sourceMappingURL=worker-connector.d.ts.map

package/dist/store/engine/client/worker-connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-connector.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/client/worker-connector.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,eAAe,EAAyC,MAAM,uBAAuB,CAAA;AACnG,OAAO,KAAK,EAAa,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChE,OAAO,KAAK,EAMX,qBAAqB,EAErB,MAAM,gBAAgB,CAAA;AAavB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,EACpD,MAAM,EAAE,qBAAqB,CAAC,eAAe,CAAC,GAC5C,eAAe,CAUjB;AA8dD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAElF;AAqBD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,cAAc,CAAA;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB"}

package/dist/store/engine/creation-refusal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A view coming back to its project (`expectedCreationId`) and finding none, or one created since under its name:
+ * the project was destroyed while it was away - refused `PROJECT_DESTROYED_WHILE_AWAY`, nothing written.
+ */
+export declare function refuseOtherCreation(params: {
+    project: string;
+    expectedCreationId: string | undefined;
+    creationId: string | undefined;
+}): void;
+//# sourceMappingURL=creation-refusal.d.ts.map