@dialecte/core 0.6.4 → 0.8.0

package/dist/store/sqlite/engine/records.d.ts

@@ -0,0 +1,117 @@
+import { RecordReadsById } from './engine.types';
+import { AnyRawRecord, RecordPatch } from '../../../types';
+import { Database, Sqlite3Static, SqlValue } from '@sqlite.org/sqlite-wasm';
+export declare function readRecord(params: {
+    db: Database;
+    table: string;
+    id: string;
+}): AnyRawRecord | undefined;
+/**
+ * Every record of the table, in id order: read in table order (a plain scan), sorted here - SQLite
+ * compares by code point, the port by UTF-16 code unit.
+ */
+export declare function readAllRecords(params: {
+    db: Database;
+    table: string;
+}): AnyRawRecord[];
+export declare function readRecordsByTag(params: {
+    db: Database;
+    table: string;
+    tagName: string;
+}): AnyRawRecord[];
+/** The records of these ids the table holds, by id: one statement for all of them. */
+export declare function readRecordsById(params: {
+    db: Database;
+    table: string;
+    ids: readonly string[];
+}): Map<string, AnyRawRecord>;
+/**
+ * Reads by id on one table through one prepared statement, for a caller that reads many times (an
+ * export): `read` answers the records of the ids the table holds, `finalize` releases the statement.
+ */
+export declare function prepareReadsById(params: {
+    db: Database;
+    table: string;
+}): RecordReadsById;
+/** The ids among these the table holds: one statement, no record read. */
+export declare function readHeldIds(params: {
+    db: Database;
+    table: string;
+    ids: readonly string[];
+}): Set<string>;
+export declare function countRecords(params: {
+    db: Database;
+    table: string;
+}): number;
+/**
+ * A create of an id the table holds, or that the write gives twice, refuses the write
+ * (`STORE_DUPLICATE_ID`): the held ids are looked up in one statement.
+ */
+export declare function refuseTakenIds(params: {
+    db: Database;
+    table: string;
+    documentId: string;
+    creates: AnyRawRecord[];
+}): void;
+/**
+ * Ids to create refused (`STORE_DUPLICATE_ID`) when one is held already or given twice among them;
+ * answers the set of the ids given.
+ */
+export declare function refuseDuplicateIds(params: {
+    documentId: string;
+    ids: readonly string[];
+    heldIds: ReadonlySet<string>;
+}): Set<string>;
+/**
+ * A unique id index that could not be built for ids the table holds twice: refused
+ * `STORE_DUPLICATE_ID`, naming them (up to `DUPLICATE_IDS_REPORTED`, read on this failure only).
+ * Any other failure is left as it is.
+ */
+export declare function refuseRepeatedIds(params: {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    table: string;
+    documentId: string;
+    thrown: unknown;
+}): void;
+/**
+ * The patches of a write that apply - those of the records the table holds (one statement per batch
+ * of ids) - checked as one list, as every store checks them: a value that is not JSON refuses the
+ * write with `STORE_VALUE_NOT_JSON`, its place counted among them. A patch of a record the table does
+ * not hold is not checked: it is skipped.
+ */
+export declare function checkApplyingPatches(params: {
+    db: Database;
+    table: string;
+    patches: readonly RecordPatch[];
+}): void;
+/**
+ * The patches of the records `held` checked as one list: a value that is not JSON refuses, its place
+ * counted among them. Answers them: the write applies those and no other, as one write would.
+ */
+export declare function checkHeldPatches(params: {
+    patches: readonly RecordPatch[];
+    held: ReadonlySet<string>;
+}): RecordPatch[];
+/**
+ * Apply bulk-write patches already checked (`checkApplyingPatches`), in the caller's transaction, in
+ * the order given: per batch of ids the records are read in one statement, the patches of the records
+ * held applied (`applyRecordPatch`, a record patched twice in turn), encoded and written back in one
+ * statement, one row per record. A patch of a record the table does not hold is skipped.
+ */
+export declare function patchRecords(params: {
+    db: Database;
+    table: string;
+    patches: RecordPatch[];
+}): void;
+/** Delete the records of these ids, in the caller's transaction; answers how many were held. */
+export declare function deleteRecords(params: {
+    db: Database;
+    table: string;
+    ids: readonly string[];
+}): number;
+/** A record from its row, the columns in the order of `RECORD_COLUMNS`. */
+export declare function recordOf(params: {
+    row: SqlValue[];
+}): AnyRawRecord;
+//# sourceMappingURL=records.d.ts.map

package/dist/store/sqlite/engine/records.d.ts.map

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

package/dist/store/sqlite/engine/registry.d.ts

@@ -0,0 +1,76 @@
+import { DocumentTable, DocumentTables, RegistryRowState } from './engine.types';
+import { DocumentRecord, DocumentUpdates } from '../../../project/types';
+import { Database } from '@sqlite.org/sqlite-wasm';
+/**
+ * Register a document and create its record table without indexes and its history-rows table, in the
+ * caller's transaction; answers the row's number and the record table. An id already registered is refused with
+ * `STORE_DUPLICATE_ID`, the registered one left as it was, then a value that is not JSON with
+ * `STORE_VALUE_NOT_JSON`, then a path that is not valid or not the document's with `DOCUMENT_PATH_INVALID`, then a
+ * place another document holds with `DOCUMENT_PATH_TAKEN`.
+ */
+export declare function insertDocument(params: {
+    db: Database;
+    document: DocumentRecord;
+}): DocumentTable;
+/** A document's row number, status, write and creation time, read by its id; none when it is not registered. */
+export declare function readDocumentState(params: {
+    db: Database;
+    documentId: string;
+}): RegistryRowState | undefined;
+/**
+ * Mark an imported document ready, in the caller's transaction; answers whether it was there, still
+ * `importing` - a document removed meanwhile is never marked.
+ */
+export declare function markImportReady(params: {
+    db: Database;
+    documentId: string;
+}): boolean;
+export declare function readDocument(params: {
+    db: Database;
+    documentId: string;
+}): DocumentRecord | undefined;
+/** Every registered document, in id order. */
+export declare function readDocuments(params: {
+    db: Database;
+}): DocumentRecord[];
+/**
+ * The name, path and metadata of a registered document, in the caller's transaction: a value that
+ * is not JSON is refused with `STORE_VALUE_NOT_JSON` first; an unknown document is then left alone; then the
+ * path rules (`DOCUMENT_PATH_INVALID`, `DOCUMENT_PATH_TAKEN`), as every store applies them.
+ */
+export declare function updateDocumentRow(params: {
+    db: Database;
+    documentId: string;
+    updates: DocumentUpdates;
+}): boolean;
+/**
+ * A document gone, in the caller's transaction: its record table, its history (its history-rows table
+ * and its entries), the blobs it owns, its registry row. An unknown one is ignored; whether it was there.
+ */
+export declare function deleteDocument(params: {
+    db: Database;
+    documentId: string;
+}): boolean;
+/** The record table of a registered document; none for a document that is not registered. */
+export declare function recordTableOf(params: {
+    db: Database;
+    documentId: string;
+}): string | undefined;
+/** The record and history-rows tables of a registered document; none for a document that is not registered. */
+export declare function documentTablesOf(params: {
+    db: Database;
+    documentId: string;
+}): DocumentTables | undefined;
+/**
+ * Every document left `importing` gone with all it has, in the caller's transaction: no import
+ * outlives its engine, so at an engine start such a document is a leftover (a closed tab, a crash).
+ */
+export declare function deleteUnfinishedImports(params: {
+    db: Database;
+}): void;
+/** The documents written by the write of that id (one at most). */
+export declare function readDocumentsByWriteId(params: {
+    db: Database;
+    writeId: string;
+}): DocumentRecord[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/store/sqlite/engine/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/registry.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACrF,OAAO,KAAK,EAAE,cAAc,EAAkB,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtF,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,yBAAyB,CAAA;AAEjE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAA;CAAE,GAAG,aAAa,CAqBhG;AAED,gHAAgH;AAChH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,QAAQ,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,gBAAgB,GAAG,SAAS,CAc/B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAOrF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE;IACpC,EAAE,EAAE,QAAQ,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,cAAc,GAAG,SAAS,CAO7B;AAED,8CAA8C;AAC9C,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAA;CAAE,GAAG,cAAc,EAAE,CAIxE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,QAAQ,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,eAAe,CAAA;CACxB,GAAG,OAAO,CAeV;AAYD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAMpF;AAED,6FAA6F;AAC7F,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAG9F;AAED,+GAA+G;AAC/G,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACxC,EAAE,EAAE,QAAQ,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,cAAc,GAAG,SAAS,CAK7B;AA8ED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAA;CAAE,GAAG,IAAI,CAQtE;AAED,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC9C,EAAE,EAAE,QAAQ,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CACf,GAAG,cAAc,EAAE,CAOnB"}

package/dist/store/sqlite/engine/schema.d.ts

@@ -0,0 +1,57 @@
+import { RecordIndex } from './engine.types';
+import { Database, Sqlite3Static } from '@sqlite.org/sqlite-wasm';
+/**
+ * The dialecte's mark in a project file's header (`PRAGMA application_id`, a signed 32-bit integer): the
+ * FNV-1a digest of its id, read with the layout version without opening the file. A hint only - two ids may
+ * share a digest; the file's directory and its `_meta` table say the dialecte.
+ */
+export declare function dialecteApplicationId(params: {
+    dialecteId: string;
+}): number;
+/**
+ * Lay out a new file, or check one: the layout version is read from the header, which every layout keeps,
+ * before anything else of the file. A file at another layout - or holding tables with none - is refused with
+ * `PROJECT_LAYOUT_OUTDATED`, one of another dialecte with `PROJECT_DIALECTE_MISMATCH`: nothing of it written.
+ * Answers the file's creation id.
+ */
+export declare function prepareFile(params: {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    /** The project's name, said in a refusal. */
+    project: string;
+    dialecteId: string;
+    /** The creation id the opener knows (a view coming back): a new file or one of another id is refused. */
+    expectedCreationId?: string;
+    steadyCacheMiB: number;
+}): {
+    creationId: string;
+};
+/** A document's record table, without its indexes: a rowid table holding one row per record (its children listed on it). */
+export declare function createRecordTable(params: {
+    db: Database;
+    table: string;
+}): void;
+/**
+ * A document's history-rows table: one row per record of a part of an entry (`HISTORY_PART`), the
+ * record whole in the record table's columns, numbered in the order written; read by entry and part.
+ */
+export declare function createHistoryRowsTable(params: {
+    db: Database;
+    table: string;
+}): void;
+/** One index of a record table, named after the table and the index. */
+export declare function createRecordIndex(params: {
+    db: Database;
+    table: string;
+    index: RecordIndex;
+}): void;
+/** Every index of a record table: the ones a registered document has from the start. */
+export declare function createRecordIndexes(params: {
+    db: Database;
+    table: string;
+}): void;
+/** Columns with their SQL types as the body of a `CREATE TABLE`, in the order given. */
+export declare function columnDefinitions(params: {
+    columns: Record<string, string>;
+}): string;
+//# sourceMappingURL=schema.d.ts.map

package/dist/store/sqlite/engine/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/schema.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAwDtE;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAQ5E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IACnC,OAAO,EAAE,aAAa,CAAA;IACtB,EAAE,EAAE,QAAQ,CAAA;IACZ,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,yGAAyG;IACzG,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,cAAc,EAAE,MAAM,CAAA;CACtB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAwBzB;AA8BD,4HAA4H;AAC5H,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAG/E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAOpF;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,QAAQ,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,WAAW,CAAA;CAClB,GAAG,IAAI,CAIP;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIjF;AAED,wFAAwF;AACxF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,MAAM,CAIrF"}

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

@@ -0,0 +1,14 @@
+import { OpenSqliteEngineParams, SqliteEngine } from './engine.types';
+/**
+ * Start the engine of a project on its database: a new file is laid out, a file of another layout
+ * refused (`PROJECT_LAYOUT_OUTDATED`), every document an import left `importing` removed - its free
+ * pages given back in steps while the engine already serves. The engine owns the database from then
+ * on: a start that fails closes it, so the file stays free.
+ *
+ * Its methods run synchronously on the one connection and never await while a transaction is open,
+ * so no call runs inside another's transaction. A failure of SQLite is thrown as the operation's
+ * store error (`STORE_READ_FAILED`, `STORE_COMMIT_FAILED`, ...), the failure as its cause; a refusal
+ * passes as it is.
+ */
+export declare function openSqliteEngine(params: OpenSqliteEngineParams): SqliteEngine;
+//# sourceMappingURL=sqlite-engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-engine.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/sqlite-engine.ts"],"names":[],"mappings":"AAsEA,OAAO,KAAK,EAIX,sBAAsB,EAItB,YAAY,EAGZ,MAAM,gBAAgB,CAAA;AAWvB;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,YAAY,CAs0B7E"}

package/dist/store/sqlite/engine/transaction.d.ts

@@ -0,0 +1,12 @@
+import { Database, Sqlite3Static } from '@sqlite.org/sqlite-wasm';
+/**
+ * Run `work` in one write transaction: committed when it returns, rolled back when it throws - unless
+ * SQLite has already rolled it back (an I/O, full or out-of-memory error does), so the error thrown
+ * is always the one that failed the work.
+ */
+export declare function inWriteTransaction<GenericResult>(params: {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    work: () => GenericResult;
+}): GenericResult;
+//# sourceMappingURL=transaction.d.ts.map

package/dist/store/sqlite/engine/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAEtE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE;IACzD,OAAO,EAAE,aAAa,CAAA;IACtB,EAAE,EAAE,QAAQ,CAAA;IACZ,IAAI,EAAE,MAAM,aAAa,CAAA;CACzB,GAAG,aAAa,CAWhB"}

package/dist/store/sqlite/list-projects.constants.d.ts

@@ -0,0 +1,12 @@
+/** What a SQLite database file starts with: its magic string, and where its header keeps the layout version. */
+export declare const SQLITE_FILE_HEADER: {
+    readonly magic: "SQLite format 3\0";
+    /** `PRAGMA user_version`: 4 bytes, big-endian. */
+    readonly userVersionOffset: 60;
+    readonly bytes: 100;
+};
+/** How often a pool file the browser refuses to read (its engine writing) is read again before it is listed `unknown`. */
+export declare const LISTING_READ_ATTEMPTS = 3;
+/** The wait between two reads of a pool file the browser refused. */
+export declare const LISTING_READ_RETRY_MS = 50;
+//# sourceMappingURL=list-projects.constants.d.ts.map

package/dist/store/sqlite/list-projects.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-projects.constants.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/list-projects.constants.ts"],"names":[],"mappings":"AAAA,gHAAgH;AAChH,eAAO,MAAM,kBAAkB;;IAE9B,kDAAkD;;;CAGzC,CAAA;AAEV,0HAA0H;AAC1H,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC,qEAAqE;AACrE,eAAO,MAAM,qBAAqB,KAAK,CAAA"}

package/dist/store/sqlite/list-projects.d.ts

@@ -0,0 +1,22 @@
+import { ProjectListing } from './list-projects.types';
+/**
+ * The projects on SQLite storage of this origin - every dialecte's, or `dialecteId`'s - read from the origin's
+ * private file system alone (no engine started, no wasm loaded; a project whose engine runs is read too), sorted by
+ * dialecte and name: each one's state (`current`, `outdated`, `lost`, `new`, `unknown`), the bytes it takes and when
+ * it was last written. Where the browser gives no private file system (Node, a private window) it refuses
+ * `STORE_UNAVAILABLE`.
+ *
+ * @intent list the projects stored in the browser on SQLite storage, find outdated or lost projects on SQLite storage, show how much space each project takes, check whether a project exists on SQLite storage without opening it
+ */
+export declare function listProjects(params?: {
+    dialecteId?: string;
+}): Promise<ProjectListing[]>;
+/**
+ * The projects of the pool directory under `root`, as `listProjects` lists them. A directory removed while the walk
+ * reads it (a project destroyed in another tab) is passed by; a pool whose files the browser refuses is `unknown`.
+ */
+export declare function listProjectsIn(params: {
+    root: FileSystemDirectoryHandle;
+    dialecteId?: string;
+}): Promise<ProjectListing[]>;
+//# sourceMappingURL=list-projects.d.ts.map

package/dist/store/sqlite/list-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-projects.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/list-projects.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAGX,cAAc,EAEd,MAAM,uBAAuB,CAAA;AAE9B;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CACjC,MAAM,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,cAAc,EAAE,CAAC,CAG3B;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE;IAC5C,IAAI,EAAE,yBAAyB,CAAA;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAyB5B"}

package/dist/store/sqlite/list-projects.types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What a project on SQLite storage is to its app, from its files alone: `current` (opened by this version), `outdated`
+ * (stored by another version of the library: destroy it, import its files again), `lost` (its files hold data but its
+ * database is gone: destroy it), `new` (made, never written), `unknown` (its files could not be read now - its engine
+ * writing: list again).
+ */
+export type ProjectListingState = 'current' | 'outdated' | 'lost' | 'new' | 'unknown';
+/** A project on SQLite storage, as `listProjects` lists it. */
+export type ProjectListing = {
+    name: string;
+    /** The dialecte whose project it is: two dialectes' projects of one name are two projects. */
+    dialecteId: string;
+    state: ProjectListingState;
+    /** The bytes its files take. */
+    bytes: number;
+    /** When its files were last written (ms since the epoch). */
+    lastModified: number;
+};
+/** A pool file as listing reads it: its size, when written, its pool header, the start of its data. */
+export type ListedPoolFile = {
+    size: number;
+    lastModified: number;
+    header: Uint8Array;
+    data: Uint8Array;
+};
+/** An entry of a directory listing reads: a directory or a file. */
+export type PoolEntry = FileSystemDirectoryHandle | FileSystemFileHandle;
+//# sourceMappingURL=list-projects.types.d.ts.map

package/dist/store/sqlite/list-projects.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-projects.types.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/list-projects.types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAA;AAErF,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,8FAA8F;IAC9F,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,uGAAuG;AACvG,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,UAAU,CAAA;CAChB,CAAA;AAED,oEAAoE;AACpE,MAAM,MAAM,SAAS,GAAG,yBAAyB,GAAG,oBAAoB,CAAA"}

package/dist/store/sqlite/load-sqlite.d.ts

@@ -0,0 +1,11 @@
+import { Sqlite3Static } from '@sqlite.org/sqlite-wasm';
+/**
+ * The SQLite module of this realm, loaded once: its wasm fetched from `wasmUrl` when given (a page or
+ * an engine worker: the consumer's one wasm file), else found by the package itself (node, and core's
+ * own tests). A later call naming another wasm file is refused (`ASSERTION_FAILED`). The VFSes the
+ * engine never uses are not installed; its text codec is made lossless (`installLosslessText`).
+ */
+export declare function loadSqlite(params?: {
+    wasmUrl?: string;
+}): Promise<Sqlite3Static>;
+//# sourceMappingURL=load-sqlite.d.ts.map

package/dist/store/sqlite/load-sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-sqlite.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/load-sqlite.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAS5D;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAuBpF"}

package/dist/store/sqlite/runtime/close-engine.d.ts

@@ -0,0 +1,18 @@
+import { EngineRuntimeState } from './runtime.types';
+/** Every import and export aborted, the database closed, the pool paused (its files kept), the lock released. */
+export declare function closeEngine(params: {
+    state: EngineRuntimeState;
+}): Promise<void>;
+/**
+ * The engine closed (every import and export aborted), then each client port closed once the calls it
+ * was asked have answered (an aborted import answers `IMPORT_ABORTED`), within `CLIENT_DRAIN_BUDGET_MS`.
+ * The engine and its clients are let go whatever its close does: the worker may open the project again.
+ */
+export declare function endEngineAndClients(params: {
+    state: EngineRuntimeState;
+}): Promise<void>;
+/** The pool paused and the lock released whatever the pause does: the files stay, another engine may open them. */
+export declare function releasePool(params: {
+    state: EngineRuntimeState;
+}): void;
+//# sourceMappingURL=close-engine.d.ts.map

package/dist/store/sqlite/runtime/close-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-engine.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/runtime/close-engine.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEzD,iHAAiH;AACjH,wBAAsB,WAAW,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,kBAAkB,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtF;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,kBAAkB,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAW9F;AA4BD,mHAAmH;AACnH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,kBAAkB,CAAA;CAAE,GAAG,IAAI,CAWvE"}

package/dist/store/sqlite/runtime/install-pool.d.ts

@@ -0,0 +1,94 @@
+import { EngineLockMode } from '../../engine/engine.types';
+import { HeldEngineLock } from './runtime.types';
+import { SAHPoolUtil, Sqlite3Static } from '@sqlite.org/sqlite-wasm';
+/**
+ * The project's pool, opened for this engine within `budgetMs`: first the loaded sqlite-wasm checked to
+ * keep a pool whose install fails (`refuseUnsafeSqlite`), then the origin's private files checked,
+ * the engine lock taken, then - inside one try that releases the lock on any failure - every file of
+ * an existing pool probed (opened and closed again; one another engine still holds is waited for, then
+ * refused PROJECT_ENGINE_BUSY) and refused PROJECT_DATABASE_LOST when it holds data but no database
+ * (`refuseLostDatabase`), then, for a pool that never held pages (none yet, or blank files), the space
+ * a new pool needs checked, and only then the pool
+ * installed - one whose install fails anyway keeps its files (`preserveOnInitFailure`: by default
+ * sqlite-wasm removes the whole pool directory on a failed install), and a later open in this worker
+ * installs it again (`forceReinitIfPreviouslyFailed`: by default the failure is kept and answered again).
+ */
+export declare function openPool(params: {
+    sqlite3: Sqlite3Static;
+    dialecteId: string;
+    project: string;
+    lock: EngineLockMode;
+    budgetMs: number;
+    /** The creation id a view coming back knows: a pool holding no database then means the project was destroyed. */
+    expectedCreationId?: string;
+}): Promise<{
+    pool: SAHPoolUtil;
+    lock: HeldEngineLock;
+}>;
+/**
+ * The pool this worker paused (a close), checked again before it is taken back, the engine lock held:
+ * its files probed and the open refused `PROJECT_DATABASE_LOST` when they hold data but no database
+ * any more - sqlite-wasm reads the headers again as it unpauses and would drop a damaged one.
+ */
+export declare function probePausedPool(params: {
+    dialecteId: string;
+    project: string;
+    /** The open's own deadline, set before it waited for the lock: one budget covers both. */
+    deadline: number;
+    /** The creation id a view coming back knows: a pool holding no database then means the project was destroyed. */
+    expectedCreationId?: string;
+}): Promise<void>;
+/**
+ * The project's pool gone with its directory, the engine lock held meanwhile: removed by sqlite-wasm
+ * when this engine has it installed (`removeVfs`), else straight from the directory; then checked
+ * gone, `PROJECT_DESTROY_FAILED` if not (a file another worker holds stays).
+ */
+export declare function destroyPool(params: {
+    dialecteId: string;
+    project: string;
+    pool: SAHPoolUtil | undefined;
+    /** Until when a file still held (a worker that just ended lets its handles go a little later) is waited for. */
+    deadline: number;
+}): Promise<void>;
+/**
+ * The project's pool directory under the origin's private file system: one directory per dialecte, one per
+ * project in it (`projectKeyOf`). A name or a dialecte id no directory can be named after - empty, `.`, `..` -
+ * is refused `PROJECT_NAME_INVALID`, before any file is touched (every store refuses it as it is built: a guard).
+ */
+export declare function poolDirectoryOf(params: {
+    dialecteId: string;
+    project: string;
+}): string;
+/**
+ * The project's engine lock, held until released: free at once or refused `PROJECT_OPEN_ELSEWHERE`
+ * (`if-available`), or waited for until `deadline` - what the work before the lock spent is not given again;
+ * a deadline passed takes only a lock free at once - else `PROJECT_ENGINE_BUSY` (`wait`).
+ */
+export declare function takeEngineLock(params: {
+    dialecteId: string;
+    project: string;
+    mode: EngineLockMode;
+    /** `performance.now()` time the wait ends (`wait` only). */
+    deadline: number;
+}): Promise<HeldEngineLock>;
+/**
+ * `STORE_QUOTA_EXCEEDED` when the origin has fewer than `bytes` left (a new pool's files, an import's
+ * rows): refused before anything is written. A browser that tells no quota, or refuses to estimate it, is
+ * trusted.
+ */
+export declare function refuseShortSpace(params: {
+    project: string;
+    bytes: number;
+}): Promise<void>;
+/**
+ * A write SQLite reports as an I/O error, explained by the file system: the origin has (nearly) no
+ * storage left → `STORE_QUOTA_EXCEEDED`; anything else is no shortage (none returned). The pool keeps
+ * the file system's own error (`QuotaExceededError`) to itself - SQLite sees an I/O error only - so the
+ * shortage is inferred from the estimate: an I/O error of another cause on a nearly full origin is
+ * answered as a shortage too.
+ */
+export declare function explainOutOfSpace(params: {
+    project: string;
+    thrown: unknown;
+}): Promise<Error | undefined>;
+//# sourceMappingURL=install-pool.d.ts.map

package/dist/store/sqlite/runtime/install-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-pool.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/runtime/install-pool.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,KAAK,EACX,cAAc,EAKd,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAEzE;;;;;;;;;;;GAWG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE;IACtC,OAAO,EAAE,aAAa,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,cAAc,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,iHAAiH;IACjH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC3B,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC,CA8BvD;AAiBD;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC7C,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,0FAA0F;IAC1F,QAAQ,EAAE,MAAM,CAAA;IAChB,iHAAiH;IACjH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC3B,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,WAAW,GAAG,SAAS,CAAA;IAC7B,gHAAgH;IAChH,QAAQ,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAGvF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,cAAc,CAAA;IACpB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,cAAc,CAAC,CAiC1B;AAoID;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAahG;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;CACf,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAe7B"}

package/dist/store/sqlite/runtime/pool-header.d.ts

@@ -0,0 +1,13 @@
+import { PoolContents, PoolFileHead } from './runtime.types';
+/**
+ * What an existing pool holds, from each file's size and header, read before sqlite-wasm installs it: `database` when
+ * a header sqlite-wasm keeps names the project's database; else `blank` when no file holds more than its header (the
+ * pool never held pages: an install or a creation that ended early); else `lost` - a file holds data and none is the
+ * database: sqlite-wasm would drop the damaged header with the pages behind it, and SQLite make a new empty database.
+ */
+export declare function classifyPool(params: {
+    files: PoolFileHead[];
+}): PoolContents;
+/** Whether the pool file's header names the project's database (as sqlite-wasm reads it at install). */
+export declare function namesDatabase(file: PoolFileHead): boolean;
+//# sourceMappingURL=pool-header.d.ts.map

package/dist/store/sqlite/runtime/pool-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-header.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/runtime/pool-header.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEjE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,YAAY,EAAE,CAAA;CAAE,GAAG,YAAY,CAK5E;AAED,wGAAwG;AACxG,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD"}

package/dist/store/sqlite/runtime/progress-beat.d.ts

@@ -0,0 +1,13 @@
+import { Heartbeat } from '../../engine/host/host.types';
+import { Database, Sqlite3Static } from '@sqlite.org/sqlite-wasm';
+/**
+ * Beat from inside SQLite: its progress handler runs every `ops` virtual-machine steps of any
+ * statement (an index build, a long read, a vacuum step), so one long statement keeps its callers.
+ */
+export declare function installProgressBeat(params: {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    heartbeat: Heartbeat;
+    ops: number;
+}): void;
+//# sourceMappingURL=progress-beat.d.ts.map

package/dist/store/sqlite/runtime/progress-beat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-beat.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/runtime/progress-beat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAEtE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC3C,OAAO,EAAE,aAAa,CAAA;IACtB,EAAE,EAAE,QAAQ,CAAA;IACZ,SAAS,EAAE,SAAS,CAAA;IACpB,GAAG,EAAE,MAAM,CAAA;CACX,GAAG,IAAI,CAYP"}

package/dist/store/sqlite/runtime/runtime.constants.d.ts

@@ -0,0 +1,57 @@
+/** The OPFS directory holding every project's pool: a directory per dialecte, one per project in it. */
+export declare const POOL_ROOT_DIRECTORY = "dialecte-projects";
+/** The name the pool's VFS is registered under in its worker (one project per engine worker). */
+export declare const POOL_VFS_NAME = "dialecte-pool";
+/** The project's database inside its pool. */
+export declare const POOL_FILE = "/project.sqlite3";
+/** The files a new pool is given: the database, its journal and the temporary files SQLite opens. */
+export declare const POOL_CAPACITY = 6;
+/**
+ * The oldest SQLite (`sqlite3.version.libVersionNumber`) whose sqlite-wasm keeps a pool's files when its install
+ * fails (`preserveOnInitFailure`, 3.54.1-build1): an older one ignores the option and removes the whole pool.
+ */
+export declare const SAFE_POOL_SQLITE_VERSION = 3054001;
+/**
+ * sqlite-wasm's pool file header (opfs-sahpool; frozen there: a change orphans every pool): the file's path (512
+ * bytes, NUL-ended), its SQLite open flags (4, big-endian, at `flagsOffset`) and their digest (two native 32-bit
+ * words), the file's data from `bytes` on. `headBytes` is what the probe reads of each file: up to the digest's end.
+ */
+export declare const POOL_FILE_HEADER: {
+    readonly bytes: 4096;
+    readonly flagsOffset: 512;
+    readonly digestOffset: 516;
+    readonly digestBytes: 8;
+    readonly headBytes: number;
+};
+/** The SQLite open flags (sqlite3.h) sqlite-wasm's header check reads; `digestV2` marks a header with a digest. */
+export declare const POOL_HEADER_FLAGS: {
+    readonly deleteOnClose: 8;
+    readonly digestV2: 128;
+    /** main database, main journal, super-journal, WAL: the files sqlite-wasm keeps */
+    readonly persistentTypes: number;
+};
+/** The seeds and multipliers of sqlite-wasm's header digest (two 32-bit multiplicative hashes). */
+export declare const POOL_HEADER_DIGEST: {
+    readonly seeds: readonly [3735928559, 1103547991];
+    readonly multipliers: readonly [2654435761, 104729];
+};
+/** The subdirectory where sqlite-wasm keeps a pool's files. */
+export declare const OPAQUE_DIRECTORY = ".opaque";
+/** Waits between two probes of a pool file still held by an engine that ended (the last one repeats). */
+export declare const PROBE_BACKOFF_MS: readonly [25, 50, 100, 200, 400];
+/** The space a new pool needs free: its files' headers and the database's first pages, with room to spare. */
+export declare const NEW_POOL_FREE_BYTES: number;
+/**
+ * SQLite's progress handler runs every this many virtual-machine steps of a statement - its count
+ * starts again with each statement, so it must be small enough that the engine's chunked work (1,000
+ * ids or rows a statement: an import's after-writes, a commit, a large delete) beats too, not only one
+ * long statement; the handler only reads the clock until a beat is due.
+ */
+export declare const PROGRESS_BEAT_OPS = 10000;
+/**
+ * A write the file system failed while the origin has less than this left failed for want of space:
+ * the quota refuses a write larger than what is left - the engine's own writes are pages and windows of
+ * a few MiB, but a file's capacity may grow by a larger step - so the bound leaves room to spare.
+ */
+export declare const OUT_OF_SPACE_BYTES: number;
+//# sourceMappingURL=runtime.constants.d.ts.map

package/dist/store/sqlite/runtime/runtime.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.constants.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/runtime/runtime.constants.ts"],"names":[],"mappings":"AAAA,wGAAwG;AACxG,eAAO,MAAM,mBAAmB,sBAAsB,CAAA;AAEtD,iGAAiG;AACjG,eAAO,MAAM,aAAa,kBAAkB,CAAA;AAE5C,8CAA8C;AAC9C,eAAO,MAAM,SAAS,qBAAqB,CAAA;AAE3C,qGAAqG;AACrG,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B;;;GAGG;AACH,eAAO,MAAM,wBAAwB,UAAY,CAAA;AAOjD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;CAMnB,CAAA;AAEV,mHAAmH;AACnH,eAAO,MAAM,iBAAiB;;;IAG7B,mFAAmF;;CAE1E,CAAA;AAEV,mGAAmG;AACnG,eAAO,MAAM,kBAAkB;;;CAGrB,CAAA;AAEV,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB,YAAY,CAAA;AAEzC,yGAAyG;AACzG,eAAO,MAAM,gBAAgB,kCAAmC,CAAA;AAEhE,8GAA8G;AAC9G,eAAO,MAAM,mBAAmB,QAAc,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAS,CAAA;AAEvC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QAAmB,CAAA"}