@dialecte/core 0.7.0 → 0.8.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"creation-refusal.d.ts","sourceRoot":"","sources":["../../../src/store/engine/creation-refusal.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC3C,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B,GAAG,IAAI,CAOP"}

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

@@ -0,0 +1,18 @@
+/**
+ * An engine asked for a project of another dialecte, or of another version of it - what a spawner's address
+ * pointing at another worker gives: refused `PROJECT_DIALECTE_MISMATCH` or `PROJECT_DIALECTE_VERSION_MISMATCH`,
+ * naming both. The engine refuses itself before it takes any lock or file; the realm refuses an engine that
+ * answers otherwise than it asked (ending it, as a failed open). A destroy names no version.
+ */
+export declare function refuseAnotherDialecte(params: {
+    project: string;
+    engine: {
+        dialecteId: string;
+        dialecteVersion: string;
+    };
+    asked: {
+        dialecteId: string;
+        dialecteVersion?: string;
+    };
+}): void;
+//# sourceMappingURL=dialecte-refusal.d.ts.map

package/dist/store/engine/dialecte-refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialecte-refusal.d.ts","sourceRoot":"","sources":["../../../src/store/engine/dialecte-refusal.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE,CAAA;IACvD,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACvD,GAAG,IAAI,CAmBP"}

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

@@ -0,0 +1,163 @@
+import { ChangeLogEntry, ExportFileParams, ExportFileResult, ImportFileParams, ImportFileResult, Store, StoreNotice, WriteOutcome } from '../store.types';
+import { EngineStoreParams } from './engine-store.types';
+import { DocumentRecord, DocumentUpdates } from '../../project/types';
+import { AnyRawRecord, BlobAttachment, BlobRecord, RecordPatch } from '../../types';
+/**
+ * EngineStore - the store port over a project's engine (the SQLite one today), reached through a link: the engine
+ * holds the data and answers every connection of the project alike (one state per name). This
+ * adapter keeps what is per connection: `close()` refuses the operations started after it with
+ * `STORE_CLOSED` and releases the link once the running ones complete; `open()` connects again.
+ */
+export declare class EngineStore implements Store {
+    readonly name: string;
+    private readonly connector;
+    private link;
+    private connecting;
+    /** Set by `close()`, cleared by `open()`: a closed store refuses every operation started after it. */
+    private closed;
+    /** This store's own destroy while it runs: an operation started meanwhile connects once it has ended. */
+    private destroying;
+    /** How many times `close()` was called: an `open()` refuses when one came after it was called. */
+    private closings;
+    /** The last release of the link: what a `close()` waits for. */
+    private linkReleased;
+    /** The operations running: `close()` releases the link, `open()` and `destroy()` go on, once none is left. */
+    private readonly operations;
+    /** What `subscribe` was given: told every change of the project, through each link this store makes. */
+    private readonly listeners;
+    /** The current link's notices let go: called when the link is released, or nobody listens any more. */
+    private stopNotices;
+    /** The link whose notices this store hears now. */
+    private listenedLink;
+    /**
+     * The writes of this store refused `STORE_ENGINE_LOST`, by id: one that lands later is announced as another
+     * connection's, so whoever listens folds it in. Forgotten once told, once its outcome answers settled (`applied`,
+     * `not-applied`), at a resync (the engine gone tells nothing more) and once the link is released.
+     */
+    private readonly lostWrites;
+    constructor(params: EngineStoreParams);
+    /** Connect to the project's engine (started when none runs: a file of another layout is refused there). */
+    open(): Promise<void>;
+    /**
+     * Refuse every operation started from now on until opened again; the link goes once the running ones
+     * end - a destroy of the name in the realm waits for them, as for its own - and the close is settled once
+     * the link is released: its engine's lock let go, or the hub told it left.
+     */
+    close(): Promise<void>;
+    /**
+     * Delete the project, once the operations running complete - its own, and those of a store of the name
+     * closed with operations running - every store of the name then reads empty; refused
+     * `PROJECT_OPEN_ELSEWHERE` while another connection has it open.
+     */
+    destroy(): Promise<void>;
+    private destroyOnceIdle;
+    /**
+     * Every change of the project, this store's own and its other connections', told once each (its own before the
+     * call that made it settles); a write of its own that was refused `STORE_ENGINE_LOST` and landed later is told
+     * as another's. `resync` once the store reached another engine. Kept across `close()` and `open()`.
+     */
+    subscribe(listener: (notice: StoreNotice) => void): () => void;
+    /** The link's notices told to this store's listeners, once (a link listened to follows its next engine). */
+    private listenToLink;
+    private stopListeningToLink;
+    /** Nothing to bring in sync: the engine answers every connection from one state. */
+    reconcile(): Promise<void>;
+    /** A document is readable once registered, as on every store. */
+    isDocumentReadable(documentId: string): Promise<boolean>;
+    registerDocument(file: DocumentRecord): Promise<void>;
+    getDocument(documentId: string): Promise<DocumentRecord | undefined>;
+    getDocuments(): Promise<DocumentRecord[]>;
+    updateDocument(documentId: string, updates: DocumentUpdates): Promise<void>;
+    removeDocument(documentId: string): Promise<void>;
+    get(id: string, documentId: string): Promise<AnyRawRecord | undefined>;
+    getByDocumentId(documentId: string): Promise<AnyRawRecord[]>;
+    count(documentId: string): Promise<number>;
+    getByTagNameInDocument(tagName: string, documentId: string): Promise<AnyRawRecord[]>;
+    getMany(ids: string[], documentId: string): Promise<(AnyRawRecord | undefined)[]>;
+    /**
+     * The import runs in the engine; its progress listener stays here (the engine's ticks come back on
+     * the call's port, before its answer) and its abort crosses as a call of its own, by `writeId`: made only once the import was asked for, so the engine
+     * knows it (a signal already aborted is told at once), and the engine answers in every store's
+     * order (a store with no dialecte refuses first).
+     */
+    importFile(params: ImportFileParams): Promise<ImportFileResult>;
+    /**
+     * The export runs in the engine; its progress listener stays here (the engine's ticks come back on
+     * the call's port, before its answer) and its abort crosses as a call of its own, by an id of this call. The engine may finish before that call reaches
+     * it: an export its caller aborted before the answer is `EXPORT_ABORTED` all the same (an export
+     * leaves nothing behind); an error the engine answered stays.
+     */
+    exportFile(params: ExportFileParams): Promise<ExportFileResult>;
+    getWriteOutcome(params: {
+        writeId: string;
+    }): Promise<WriteOutcome>;
+    bulkWrite(documentId: string, ops: {
+        creates?: AnyRawRecord[];
+        updates?: RecordPatch[];
+        deletes?: string[];
+    }): Promise<void>;
+    /** The commit runs in the engine; its progress listener stays here, its ticks heard before the answer. */
+    commit(params: {
+        documentId: string;
+        writeId?: string;
+        creates: AnyRawRecord[];
+        updates: AnyRawRecord[];
+        deletes: string[];
+        onProgress: (current: number, total: number) => void;
+    }): Promise<void>;
+    undo(documentId: string): Promise<void>;
+    redo(documentId: string): Promise<void>;
+    getHistoryStatus(documentId: string): Promise<{
+        canUndo: boolean;
+        canRedo: boolean;
+    }>;
+    getChangeLog(documentId: string): Promise<ChangeLogEntry[]>;
+    /** No database object crosses the port: the engine owns it. */
+    getDatabaseInstance(): unknown;
+    addBlob(entry: BlobRecord, data: Blob): Promise<void>;
+    getBlob(blobId: string): Promise<{
+        entry: BlobRecord;
+        data: Blob;
+    } | undefined>;
+    getBlobsByDocument(documentId: string): Promise<BlobRecord[]>;
+    getBlobsByRecord(documentId: string, recordRef: string): Promise<BlobRecord[]>;
+    getStandaloneBlobs(): Promise<BlobRecord[]>;
+    attachBlob(blobId: string, ref: BlobAttachment): Promise<void>;
+    detachBlob(blobId: string, ref: {
+        documentId: string;
+        recordRef: string;
+    }): Promise<void>;
+    removeBlob(blobId: string): Promise<void>;
+    /**
+     * A call of the engine's `member` as one operation of the port; a read (the wire table says which,
+     * for the member this calls) whose engine ended with its host is made once more on the link's next
+     * engine. Its arguments are the member's own, forwarded as they are (not one params object).
+     */
+    private call;
+    /**
+     * One operation of the port: refused once the store is closed; counted while it runs, so a
+     * `close()` meanwhile lets it complete and releases the link after it. `readRetried`: refused
+     * because its engine ended with its host, it is made once more, on the link's next engine. Never
+     * on `realm-dropped` (or `no-heartbeat`): a dropped view reaches no engine until its page binds it
+     * again, every call refused alike meanwhile, and a silent engine may still be running.
+     */
+    private operation;
+    /**
+     * A change the engine announced, as this store tells it: its own when its link made it - but for a write of its own
+     * refused lost, told once as another's (its caller saw it fail), its id forgotten then.
+     */
+    private changeOf;
+    /** A write refused `STORE_ENGINE_LOST` (its id on the refusal): its change, if it lands, is told as another's. */
+    private noteLostWrite;
+    /** Counted while it runs; the last one to end on a closed store releases the link. */
+    private tracked;
+    /** The engine through this store's link, connected on the first operation (once, however many run). */
+    private currentEngine;
+    /** A failed connection is forgotten: the next operation tries again. */
+    private connectOnce;
+    /** A link's notice told to every listener; one that throws stops no other. */
+    private tellListeners;
+    /** Called with no operation running, so no connection is under way; settled once the link counts no more. */
+    private releaseLink;
+}
+//# sourceMappingURL=engine-store.d.ts.map

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

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

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

@@ -0,0 +1,53 @@
+import { EngineApi } from './engine.types';
+import { EngineEventSignal } from './host/host.types';
+/** What a link tells its store: a change the engine announced, or that changes may have been missed. */
+export type LinkNotice = {
+    type: 'event';
+    signal: EngineEventSignal;
+} | {
+    type: 'resync';
+};
+/** One connection of a store to its project's engine. */
+export type EngineLink = {
+    /** The engine serving the project now: a later call may answer another one, started since. */
+    engine: () => Promise<EngineApi>;
+    /** The connection's id: the changes its calls make are announced tagged with it. */
+    connectionId: string;
+    /**
+     * `listener` told every change the engine announces, and `resync` once the connection reached another engine
+     * (a link with a listener follows the next engine of its project without waiting for a call). Answers the
+     * unsubscribe.
+     */
+    onNotice: (listener: (notice: LinkNotice) => void) => () => void;
+    /**
+     * Release the connection; the engine closes once no connection is left. Settled once the connection counts
+     * no more for a destroy anywhere (its engine's lock let go, the hub told). Idempotent; the released
+     * connection reaches no engine after (`STORE_CLOSED`).
+     */
+    close: () => Promise<void>;
+};
+/** What a connector's destroy is handed: the destroying store's own connection, when it has one. */
+export type EngineDestroyParams = {
+    own?: OwnEngineLink;
+};
+/** The destroying store's own connection: `letGo` releases it, the store forgetting it, once the destroy goes ahead. */
+export type OwnEngineLink = {
+    link: EngineLink;
+    letGo: () => Promise<void>;
+};
+/** How a store reaches its project's engine, and how the project is deleted. */
+export type EngineConnector = {
+    connect: () => Promise<EngineLink>;
+    /**
+     * Delete the project's file, its engine closed first; the next connection starts on a new file. `own`,
+     * the destroying store's own connection, does not count against it, and is let go only once the destroy
+     * goes ahead: refused, it is kept as it was.
+     */
+    destroy: (params?: EngineDestroyParams) => Promise<void>;
+};
+export type EngineStoreParams = {
+    /** The project's name. */
+    name: string;
+    connector: EngineConnector;
+};
+//# sourceMappingURL=engine-store.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-store.types.d.ts","sourceRoot":"","sources":["../../../src/store/engine/engine-store.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAE1D,wGAAwG;AACxG,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE1F,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG;IACxB,8FAA8F;IAC9F,MAAM,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,CAAA;IAChC,oFAAoF;IACpF,YAAY,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;IAChE;;;;OAIG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B,CAAA;AAED,oGAAoG;AACpG,MAAM,MAAM,mBAAmB,GAAG;IAAE,GAAG,CAAC,EAAE,aAAa,CAAA;CAAE,CAAA;AAEzD,wHAAwH;AACxH,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAA;AAE5E,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG;IAC7B,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAA;IAClC;;;;OAIG;IACH,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACxD,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC/B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,eAAe,CAAA;CAC1B,CAAA"}

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

@@ -0,0 +1,14 @@
+/** The prefix of an engine's Web Lock (`engineLockNameOf`): one engine at a time holds a project's files. */
+export declare const ENGINE_LOCK_PREFIX = "dialecte:engine:";
+/** What the engine posts on a client port outside the calls' answers (no `id`: Comlink passes it by). */
+export declare const ENGINE_SIGNAL: {
+    /** The engine works. */
+    readonly heartbeat: "heartbeat";
+    /** The engine runs dialecte code that may take long with nothing to tell: wait for its next message. */
+    readonly busy: "busy";
+    /** A tick of a call's progress, for the listener the client registered under its `progressId`. */
+    readonly progress: "progress";
+    /** A change of the project, posted on every client's port: who made it, and how (`EngineEventSignal`). */
+    readonly event: "event";
+};
+//# sourceMappingURL=engine.constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine.constants.d.ts","sourceRoot":"","sources":["../../../src/store/engine/engine.constants.ts"],"names":[],"mappings":"AAAA,6GAA6G;AAC7G,eAAO,MAAM,kBAAkB,qBAAqB,CAAA;AAEpD,yGAAyG;AACzG,eAAO,MAAM,aAAa;IACzB,wBAAwB;;IAExB,wGAAwG;;IAExG,kGAAkG;;IAElG,0GAA0G;;CAEjG,CAAA"}

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

@@ -0,0 +1,165 @@
+import { ENGINE_SIGNAL } from './engine.constants';
+import { ThrownData } from './wire/wire.types';
+import { ExportControl, ExportFileOptions, ExportFileResult, ImportControl, ImportFileOptions, ImportFileResult, Store } from '../store.types';
+import { AnyRawRecord } from '../../types';
+/**
+ * How the engine takes its project's lock: wait for it within the open budget (a successor of an
+ * engine that ended, through the hub), or take it only if free (direct mode: a holder is another
+ * realm's engine).
+ */
+export type EngineLockMode = 'wait' | 'if-available';
+/**
+ * What an engine is opened with: what every engine is told, and `settings`, what its kind of engine
+ * needs besides (the SQLite engine: the consumer's wasm file and its options), passed through as is.
+ */
+export type EngineOpenParams<GenericSettings = unknown> = {
+    project: string;
+    /**
+     * The dialecte and its version the realm expects the engine to run: an engine of another one refuses the
+     * open (`PROJECT_DIALECTE_MISMATCH`, `PROJECT_DIALECTE_VERSION_MISMATCH`) before it takes any lock or file.
+     */
+    dialecteId: string;
+    dialecteVersion: string;
+    /**
+     * The creation id of the project the realm's view had open, when it comes back to it (a resume, an engine
+     * started again): none there, or another, is refused `PROJECT_DESTROYED_WHILE_AWAY`, nothing written.
+     */
+    expectedCreationId?: string;
+    lock: EngineLockMode;
+    /**
+     * How long the engine may take to take its project: the lock, then its own checks of the files (SQLite
+     * probes its pool), from one deadline. The rest of the open (the database, the start's cleanup) is bounded
+     * by the realm's open window (`ENGINE_OPEN_WINDOW_MS`).
+     */
+    budgetMs: number;
+    /** Measure the import's and the export's stages (`dev.perf`). */
+    perf: boolean;
+    /** How often the engine beats while it works (`ENGINE_HEARTBEAT_INTERVAL_MS` when absent). */
+    heartbeatIntervalMs?: number;
+    settings: GenericSettings;
+};
+/** A control message a realm sends its engine worker; each is answered once by its `requestId`. */
+export type EngineControlRequest<GenericSettings = unknown> = ({
+    type: 'open';
+    requestId: number;
+} & EngineOpenParams<GenericSettings>) | {
+    type: 'adopt-client';
+    requestId: number;
+    clientId: string;
+    port: MessagePort;
+} | {
+    type: 'client-gone';
+    requestId: number;
+    clientId: string;
+} | {
+    type: 'close';
+    requestId: number;
+} | {
+    type: 'destroy';
+    requestId: number;
+    project: string;
+    /** The dialecte whose project it is: an engine of another one refuses (`PROJECT_DIALECTE_MISMATCH`), nothing removed. */
+    dialecteId: string;
+    /**
+     * Direct mode takes the lock only if free (a holder is another realm's engine); through the hub
+     * the destroy waits for it (the engine the hub just released may hold it a moment).
+     */
+    lock: EngineLockMode;
+    budgetMs: number;
+};
+/** The engine worker's answer to a control message. */
+export type EngineControlAnswer = {
+    type: 'opened';
+    requestId: number;
+    dialecteId: string;
+    dialecteVersion: string;
+    /** The id the project's file was created with (another one once the project is destroyed and made again). */
+    creationId: string;
+    /** The wire the engine speaks (`ENGINE_WIRE_PROTOCOL` of its copy of the library). */
+    wireProtocol: number;
+    /** Whether the engine took its files back in this worker (closed then opened again) rather than set them up. */
+    resumed: boolean;
+} | {
+    type: 'adopted';
+    requestId: number;
+} | {
+    type: 'released';
+    requestId: number;
+} | {
+    type: 'closed';
+    requestId: number;
+} | {
+    type: 'destroyed';
+    requestId: number;
+} | {
+    type: 'failed';
+    requestId: number;
+    thrown: ThrownData;
+};
+/** A sign of the engine's life its worker posts to the realm running it, beside the control answers. */
+export type EngineLifeSignal = {
+    type: (typeof ENGINE_SIGNAL)['heartbeat'] | (typeof ENGINE_SIGNAL)['busy'];
+};
+/** `Omit` applied to each member of a union. */
+export type DistributiveOmit<GenericUnion, GenericKey extends PropertyKey> = GenericUnion extends unknown ? Omit<GenericUnion, GenericKey> : never;
+/** The port members an engine serves, with the port's own signatures. */
+export type EngineMember = 'registerDocument' | 'getDocument' | 'getDocuments' | 'updateDocument' | 'removeDocument' | 'get' | 'getByDocumentId' | 'count' | 'getByTagNameInDocument' | 'getMany' | 'bulkWrite' | 'getWriteOutcome' | 'undo' | 'redo' | 'getHistoryStatus' | 'getChangeLog';
+/** A file to import, as a client hands it to the engine: plain data, the progress listener apart. */
+export type EngineImportParams = {
+    file: File;
+    options?: ImportFileOptions;
+    /** The caller's id for this import, kept on the document's registry row. */
+    writeId: string;
+};
+/** An export as a client asks the engine for it: plain data, the progress listener apart. */
+export type EngineExportParams = {
+    documentId: string;
+    options?: ExportFileOptions;
+    /** The caller's id for this export, by which it is aborted; one export of an id runs at a time. */
+    exportId: string;
+};
+/** A commit as a client hands it to the engine: plain data, the progress listener apart. */
+export type EngineCommitParams = {
+    documentId: string;
+    /** The caller's id for this commit, kept on its history entry. */
+    writeId: string;
+    creates: AnyRawRecord[];
+    updates: AnyRawRecord[];
+    deletes: string[];
+};
+/** How far a commit is, as the port tells it: the operations written, out of all of them. */
+export type CommitProgressListener = (current: number, total: number) => void;
+/**
+ * The members whose answer says whether they changed anything (`false`: nothing to undo or redo, an unknown
+ * document or blob, an update or a bulk write changing nothing, a blob attached where it is or detached from a record
+ * it is not attached to): the engine announces no change then.
+ */
+export type EngineChangeMember = 'updateDocument' | 'removeDocument' | 'bulkWrite' | 'undo' | 'redo' | 'attachBlob' | 'detachBlob' | 'removeBlob';
+/** Those members as the engine serves them: the port's arguments, an answer saying whether anything changed. */
+export type EngineChangeMembers = {
+    [GenericMember in EngineChangeMember]: (...args: Parameters<Store[GenericMember]>) => Promise<boolean>;
+};
+/**
+ * The port members an engine serves alike to every client, with the port's signatures: registry,
+ * reads, bulk writes, write outcomes, history; and a commit, its progress listener an argument of its own.
+ */
+export type EngineMembers = Omit<Pick<Store, EngineMember> & EngineBlobMembers, EngineChangeMember> & EngineChangeMembers & {
+    commit: (params: EngineCommitParams, onProgress?: CommitProgressListener) => Promise<void>;
+};
+/** The blob members of the port an engine serves, with the port's signatures (a `Blob` crosses a port as it is). */
+export type EngineBlobMember = 'addBlob' | 'getBlob' | 'getBlobsByDocument' | 'getBlobsByRecord' | 'getStandaloneBlobs' | 'attachBlob' | 'detachBlob' | 'removeBlob';
+export type EngineBlobMembers = Pick<Store, EngineBlobMember>;
+/** The store port as one client of an engine reaches it: an import's progress listener is an argument of its own. */
+export type EngineApi = EngineMembers & {
+    importFile: (params: EngineImportParams, onProgress?: ImportControl['onProgress']) => Promise<ImportFileResult>;
+    /** Abort the import of that id: it is refused `IMPORT_ABORTED` and leaves nothing; an id no import runs is ignored. */
+    abortImport: (params: {
+        writeId: string;
+    }) => Promise<void>;
+    exportFile: (params: EngineExportParams, onProgress?: ExportControl['onProgress']) => Promise<ExportFileResult>;
+    /** Abort the export of that id: it is refused `EXPORT_ABORTED`; an id no export runs is ignored. */
+    abortExport: (params: {
+        exportId: string;
+    }) => Promise<void>;
+};
+//# sourceMappingURL=engine.types.d.ts.map

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

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

package/dist/store/engine/host/engine-wire.d.ts

@@ -0,0 +1,19 @@
+import { EngineApi } from '../engine.types';
+import { Heartbeat, ServedClient, StoreEvents } from './host.types';
+/**
+ * Serve one client's port: one member, `call`, every call of the engine through it - a member outside
+ * the wire table refused, the values the client sent as stand-ins rebuilt, each progress tick posted on
+ * the same port without waiting (a dead port never holds the engine; one port, so every tick reaches
+ * the caller before the answer), a success announced to every client before the answer (tagged with the
+ * connection the call names, else this port's client), the answer an envelope: what the engine answered,
+ * or what it threw as data.
+ */
+export declare function serveClient(params: {
+    port: MessagePort;
+    clientId: string;
+    view: EngineApi;
+    events: StoreEvents;
+    /** The engine's sign of life on its ports: told busy around an answer it cannot beat inside. */
+    heartbeat: Heartbeat;
+}): ServedClient;
+//# sourceMappingURL=engine-wire.d.ts.map

package/dist/store/engine/host/engine-wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-wire.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/host/engine-wire.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAkB,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAExF;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IACnC,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,SAAS,CAAA;IACf,MAAM,EAAE,WAAW,CAAA;IACnB,gGAAgG;IAChG,SAAS,EAAE,SAAS,CAAA;CACpB,GAAG,YAAY,CA+Bf"}

package/dist/store/engine/host/heartbeat.d.ts

@@ -0,0 +1,33 @@
+import { Heartbeat } from './host.types';
+import { AnyDialecteConfig, DialecteHooks } from '../../../types';
+/**
+ * The engine's sign of life, posted on every client port it serves (a call may still sit in the
+ * worker's queue behind the work, unknown to the engine) and to `tellControl`, the realm that runs it
+ * (which waits on it for a new client's adoption): a beat at most every `intervalMs` while it works, a
+ * `busy` before dialecte code that may run long with nothing to tell. Posted from the work itself, never
+ * from a timer: a busy engine is never taken for a lost one.
+ */
+export declare function createHeartbeat(params: {
+    intervalMs: number;
+    tellControl?: (message: {
+        type: string;
+    }) => void;
+}): Heartbeat;
+/**
+ * Work the engine cannot beat inside (one long opcode, a large answer cloned): every client is told the
+ * engine is busy before it, beaten once it is done.
+ */
+export declare function runToldBusy<GenericResult>(params: {
+    heartbeat: Heartbeat;
+    work: () => GenericResult;
+}): GenericResult;
+/**
+ * The dialecte's hooks with their opaque phases told: before the file-wide `beforeImport` and an
+ * import session's `afterImport` - dialecte code that may run for seconds with no statement - every
+ * client is told the engine is busy, then beaten once it is done.
+ */
+export declare function withOpaquePhases(params: {
+    hooks: DialecteHooks<AnyDialecteConfig> | undefined;
+    heartbeat: Heartbeat;
+}): DialecteHooks<AnyDialecteConfig> | undefined;
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/store/engine/host/heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/host/heartbeat.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE/D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CACjD,GAAG,SAAS,CAyCZ;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE;IAClD,SAAS,EAAE,SAAS,CAAA;IACpB,IAAI,EAAE,MAAM,aAAa,CAAA;CACzB,GAAG,aAAa,CAQhB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACxC,KAAK,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAA;IACnD,SAAS,EAAE,SAAS,CAAA;CACpB,GAAG,aAAa,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAmC/C"}

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

@@ -0,0 +1,13 @@
+/** The engine beats at most this often while it works. */
+export declare const ENGINE_HEARTBEAT_INTERVAL_MS = 1000;
+/**
+ * How long a closing engine lets its clients' calls answer before it closes their ports (under the
+ * realm's own close budget).
+ */
+export declare const CLIENT_DRAIN_BUDGET_MS = 1000;
+/**
+ * An answer holding at least this many records is cloned onto the port in one step the engine cannot
+ * beat inside (a whole large document read): its client is told the engine is busy around it.
+ */
+export declare const LARGE_ANSWER_RECORDS = 10000;
+//# sourceMappingURL=host.constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"host.constants.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/host/host.constants.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,eAAO,MAAM,4BAA4B,OAAQ,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,OAAQ,CAAA;AAE3C;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAAS,CAAA"}

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

@@ -0,0 +1,65 @@
+import { DistributiveOmit, EngineApi } from '../engine.types';
+import { StoreRuntime } from '../../../project/io/store-runtime.types';
+import { ProjectChannelMessage } from '../../../project/types';
+/** The dialecte an engine serves, as the engine needs it: its identity and how to make its runtime. */
+export type EngineDialecte = {
+    id: string;
+    version: string;
+    /** The configs and a fresh set of the dialecte's hooks, measured when `perf`. */
+    createRuntime: (params: {
+        perf: boolean;
+    }) => StoreRuntime;
+};
+/**
+ * A change of the project as the engine posts it on every client's port: the project event, the connection whose
+ * call made it, and that call's write id (a commit's, an import's) - a write its caller saw lost is its own no more.
+ */
+export type EngineEventSignal = {
+    type: 'event';
+    message: ProjectChannelMessage;
+    connectionId: string;
+    writeId?: string;
+};
+/**
+ * How each member's success is told (its timestamp added when posted): nothing for a member left out, nor when its
+ * answer says it changed nothing (`false`).
+ */
+export type StoreEventOf = Partial<Record<keyof EngineApi, (params: {
+    args: unknown[];
+    value: unknown;
+}) => DistributiveOmit<ProjectChannelMessage, 'timestamp'> | undefined>>;
+/** A member's success as the engine tells it: the call, and the connection it was made for. */
+export type AnnouncedCall = {
+    member: keyof EngineApi;
+    args: unknown[];
+    value: unknown;
+    connectionId: string;
+};
+/** How the engine tells its clients each change. */
+export type StoreEvents = {
+    announce: (params: AnnouncedCall) => void;
+    close: () => void;
+};
+/** The engine's sign of life on the ports it serves. */
+export type Heartbeat = {
+    add: (port: MessagePort) => void;
+    remove: (port: MessagePort) => void;
+    /** A beat, unless one was posted less than the interval ago. */
+    beat: () => void;
+    /** Opaque dialecte code begins: clients wait for the engine's next message, however long. */
+    busy: () => void;
+    /** That opaque code ended: a beat now (a `busy` again while another opaque phase still runs). */
+    idle: () => void;
+};
+/** A client port the engine serves, and when every call it was asked has been answered. */
+export type ServedClient = {
+    port: MessagePort;
+    drained: () => Promise<void>;
+};
+/** A tick of a call's progress, posted on the client's port under the call's progress id. */
+export type ProgressSignal = {
+    type: 'progress';
+    progressId: number;
+    progress: unknown[];
+};
+//# sourceMappingURL=host.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"host.types.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/host/host.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAE5D,uGAAuG;AACvG,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,iFAAiF;IACjF,aAAa,EAAE,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,KAAK,YAAY,CAAA;CAC1D,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,qBAAqB,CAAA;IAC9B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,CACjC,MAAM,CACL,MAAM,SAAS,EACf,CAAC,MAAM,EAAE;IACR,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACd,KAAK,gBAAgB,CAAC,qBAAqB,EAAE,WAAW,CAAC,GAAG,SAAS,CACtE,CACD,CAAA;AAED,+FAA+F;AAC/F,MAAM,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE,MAAM,SAAS,CAAA;IACvB,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,oDAAoD;AACpD,MAAM,MAAM,WAAW,GAAG;IACzB,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAA;IACzC,KAAK,EAAE,MAAM,IAAI,CAAA;CACjB,CAAA;AAED,wDAAwD;AACxD,MAAM,MAAM,SAAS,GAAG;IACvB,GAAG,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAA;IAChC,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAA;IACnC,gEAAgE;IAChE,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,6FAA6F;IAC7F,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,iGAAiG;IACjG,IAAI,EAAE,MAAM,IAAI,CAAA;CAChB,CAAA;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5B,CAAA;AAED,6FAA6F;AAC7F,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAA;CACnB,CAAA"}

package/dist/store/engine/host/store-events.d.ts

@@ -0,0 +1,14 @@
+import { AnnouncedCall, EngineEventSignal, StoreEvents } from './host.types';
+/**
+ * The change a member's success makes, as every client of the engine is told it: the project event (its timestamp
+ * now), the connection the call was made for, and the call's write id; none when it changed nothing.
+ */
+export declare function storeEventOf(params: AnnouncedCall): EngineEventSignal | undefined;
+/**
+ * The engine's announcer: each change posted on every client port it serves now (`ports`), the caller's
+ * included - on the caller's port before its call's answer. A port that cannot take it (closed) is skipped.
+ */
+export declare function createStoreEvents(params: {
+    ports: () => Iterable<MessagePort>;
+}): StoreEvents;
+//# sourceMappingURL=store-events.d.ts.map

package/dist/store/engine/host/store-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-events.d.ts","sourceRoot":"","sources":["../../../../src/store/engine/host/store-events.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAgB,WAAW,EAAE,MAAM,cAAc,CAAA;AAkE/F;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,GAAG,SAAS,CAWjF;AAUD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAA;CAAE,GAAG,WAAW,CAoB7F"}