@dialecte/core 0.6.4 → 0.8.0

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

@@ -0,0 +1,361 @@
+import { EngineApi, EngineCommitParams, EngineExportParams, EngineImportParams } from '../../engine/engine.types';
+import { HISTORY_ENTRY_STATE, HISTORY_PART, RECORD_INDEXES } from './engine.constants';
+import { DialecteErrorKey } from '../../../errors';
+import { Perf } from '../../../perf';
+import { StoreRuntime } from '../../../project/io/store-runtime.types';
+import { DocumentStatus } from '../../../project/types';
+import { ExportControl, ExportFileResult, ImportControl, ImportFileResult, ImportPhase, ImportProgress } from '../../store.types';
+import { AnyRawRecord } from '../../../types';
+import { Database, SqlValue, Sqlite3Static } from '@sqlite.org/sqlite-wasm';
+/** How a page cache follows the device's memory: `mibPerGiB` per GiB, held between a floor and a ceiling. */
+export type DeviceCacheRule = {
+    mibPerGiB: number;
+    floorMiB: number;
+    ceilingMiB: number;
+};
+/** What an engine may be told at start; a field left out takes its default. */
+export type SqliteEngineOptions = {
+    /** The rule the steady cache and the import cache follow from the device's memory. */
+    cacheRule: DeviceCacheRule;
+    /**
+     * A steady cache of this many MiB, instead of the one the rule gives. Not a memory cap: an import
+     * raises the cache to the rule's size while it runs.
+     */
+    steadyCacheMiB?: number;
+    /** How long an import writes in one transaction before it commits and lets other calls run. */
+    importWindowMs: number;
+    /** How long the free pages are given back before the queued calls run. */
+    reclaimSliceMs: number;
+    /** How many free pages one reclaim statement gives back. */
+    reclaimPagesPerStatement: number;
+};
+/** A reclaim of the file's free pages on the engine's connection. */
+export type ReclaimParams = {
+    db: Database;
+    /** Commit the running import's window before a statement writes (as before any foreign write). */
+    settle: () => void;
+    /** Whether the engine was closed meanwhile: the reclaim stops there. */
+    isClosed: () => boolean;
+    pagesPerStatement: number;
+    sliceMs: number;
+    /** Called after each statement: the engine is alive, whoever waits on it. */
+    onStep?: () => void;
+    /**
+     * The end of the work the reclaim gives way to, when some runs (an import): no statement until it has ended.
+     * Without it, the reclaim goes on in steps whatever runs.
+     */
+    giveWayTo?: () => Promise<void> | undefined;
+};
+export type OpenSqliteEngineParams = {
+    sqlite3: Sqlite3Static;
+    /** The project's database, open: the engine is its only user from now on. */
+    db: Database;
+    /** The dialecte the project belongs to, kept in a new file. */
+    dialecteId: string;
+    /**
+     * The creation id the opener knows of the project (a view coming back): a new file, or one of another id,
+     * is refused `PROJECT_DESTROYED_WHILE_AWAY`, nothing written - the project was destroyed meanwhile.
+     */
+    expectedCreationId?: string;
+    /** The project's name, said in the engine's refusals. */
+    name: string;
+    /** What the engine imports with: without it, an import is refused (`IMPORT_FAILED`). */
+    runtime?: StoreRuntime;
+    options?: Partial<SqliteEngineOptions>;
+    /**
+     * Refuse an import, before it registers anything, when the file system cannot take `bytes` more
+     * (`STORE_QUOTA_EXCEEDED`); none: the file is in memory.
+     */
+    ensureImportSpace?: (params: {
+        bytes: number;
+    }) => Promise<void>;
+    /**
+     * Called as an import or an export moves on (each batch) and at each step of giving free pages back:
+     * the engine is alive, whoever waits on it.
+     */
+    onWork?: () => void;
+    /**
+     * Runs one statement that may last long in a single step, with no progress-handler call inside it
+     * (an index build's sort, a table dropped): whoever waits on the engine is told so around it.
+     */
+    onLongStatement?: LongStatementRunner;
+    /**
+     * Says whether a write that failed with an I/O error did because the origin's storage is full: the
+     * `STORE_QUOTA_EXCEEDED` refusal to answer instead, or none (the file system knows, not SQLite).
+     */
+    explainIoFailure?: (params: {
+        thrown: unknown;
+    }) => Promise<Error | undefined>;
+    /**
+     * Called once the engine broke: an import left its connection inside a transaction it could neither roll back
+     * nor commit (a lost handle, no memory). The engine is closed by then, every call refused `STORE_ENGINE_LOST`
+     * (`host-gone`); its host lets it go and starts the next engine on the file, which removes what the import left.
+     */
+    onBroken?: () => void;
+};
+/** Runs a statement that may last long as one step of SQLite, telling who waits on the engine around it. */
+export type LongStatementRunner = <GenericResult>(params: {
+    work: () => GenericResult;
+}) => GenericResult;
+/** An export as the engine runs it: the client that asked for it owns it. */
+export type SqliteEngineExportParams = EngineExportParams & {
+    clientId: string;
+};
+/** A commit on the engine's file; `settle` commits the running import's window first. */
+export type CommitRecordsParams = EngineCommitParams & {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    settle: () => void;
+};
+/** An undo or a redo on the engine's file; `settle` commits the running import's window first. */
+export type HistoryStepParams = {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    documentId: string;
+    direction: HistoryDirection;
+    settle: () => void;
+};
+/** An import as the engine runs it: the client that asked for it owns it. */
+export type SqliteEngineImportParams = EngineImportParams & {
+    clientId: string;
+};
+/** One project's database behind the store port: the single writer of its file, serving every client. */
+export type SqliteEngine = Omit<EngineApi, 'importFile' | 'exportFile'> & {
+    /** An import owned by the client that asked for it; one import runs at a time, the others wait their turn. */
+    importFile: (params: SqliteEngineImportParams, onProgress?: ImportControl['onProgress']) => Promise<ImportFileResult>;
+    /** Abort every import the client owns, running or waiting: its connection is gone. */
+    abortImportsOf: (params: {
+        clientId: string;
+    }) => void;
+    /** An export owned by the client that asked for it; an id that runs already is refused (`ASSERTION_FAILED`). */
+    exportFile: (params: SqliteEngineExportParams, onProgress?: ExportControl['onProgress']) => Promise<ExportFileResult>;
+    /** Abort every export the client owns: its connection is gone. */
+    abortExportsOf: (params: {
+        clientId: string;
+    }) => void;
+    /** The id the project's file was created with: another one after the project was destroyed and made again. */
+    creationId: string;
+    /** The engine as that client reaches it: its imports owned by it, nothing more than the port. */
+    clientView: (params: {
+        clientId: string;
+    }) => EngineApi;
+    /**
+     * Abort every import and every export, then close the database; the engine refuses every call after
+     * (`STORE_CLOSED`).
+     */
+    close: () => void;
+};
+/** One import in the queue: its owner, its id, the controller that aborts it. */
+export type ImportQueueEntry = {
+    writeId: string;
+    clientId: string;
+    controller: AbortController;
+    /** Whether its turn has come (it runs, or it was aborted while it waited). */
+    hasTurn: boolean;
+    /** Whether it registered its document: its registry row says what became of it. */
+    registered: boolean;
+    /** Gives it its turn. */
+    start: () => void;
+};
+/** The imports of an engine, one running at a time, the others waiting their turn in order. */
+export type ImportQueue = {
+    /** Run `work` once every import before it is done; `work` is given the import's abort signal. */
+    run: <GenericResult>(params: {
+        writeId: string;
+        clientId: string;
+        work: (signal: AbortSignal) => Promise<GenericResult>;
+    }) => Promise<GenericResult>;
+    abort: (params: {
+        writeId: string;
+    }) => void;
+    abortOwnedBy: (params: {
+        clientId: string;
+    }) => void;
+    abortAll: () => void;
+    /**
+     * Whether an import of that id has no registry row yet though it runs or will - waiting its turn, or
+     * running before its document is registered (while its space is checked): its row cannot say.
+     */
+    awaitsRow: (params: {
+        writeId: string;
+    }) => boolean;
+    /** The import of that id registered its document: from now on its registry row says what became of it. */
+    markRegistered: (params: {
+        writeId: string;
+    }) => void;
+    /** Whether an import of that id runs or waits its turn: one that ended, however, is no longer in the queue. */
+    runs: (params: {
+        writeId: string;
+    }) => boolean;
+};
+/** An index of a record table. */
+export type RecordIndex = keyof typeof RECORD_INDEXES;
+/** A registered document's row number and its record table. */
+export type DocumentTable = {
+    seq: number;
+    table: string;
+};
+/** A part of a history entry: what a commit created, each updated record before and after it, what it deleted. */
+export type HistoryPart = keyof typeof HISTORY_PART;
+/** Where a history entry stands. */
+export type HistoryEntryState = keyof typeof HISTORY_ENTRY_STATE;
+/** Which way an entry is applied: as committed (a commit, a redo), or reverted (an undo). */
+export type HistoryDirection = 'forward' | 'back';
+/** A history entry, by its row id. */
+export type HistoryEntryRef = {
+    id: number;
+};
+/** A registered document's row number, its status, its record table and its history-rows table. */
+export type DocumentTables = {
+    seq: number;
+    status: DocumentStatus;
+    records: string;
+    history: string;
+};
+/** One bind for the row sink: records already checked, into the document's table, timed on the import's perf. */
+export type RecordSinkParams = {
+    db: Database;
+    table: string;
+    records: AnyRawRecord[];
+    perf: Perf;
+};
+/** What an import's window transactions run with. */
+export type ImportWindowParams = {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    perf: Perf;
+    /** How long one window transaction writes before it commits. */
+    windowMs: number;
+    /** The page cache while the import runs, and the one the engine keeps otherwise. */
+    importCacheMiB: number;
+    steadyCacheMiB: number;
+};
+/** Where an import's window stands. */
+export type ImportWindowState = {
+    /** When the open transaction began; none open when undefined. */
+    openedAt: number | undefined;
+    /** Whether the connection runs with synchronous off. */
+    synchronousOff: boolean;
+    /** Whether the import cache is raised. */
+    cacheRaised: boolean;
+    /** The failure of a commit that lost the window's records, refused at the import's next window. */
+    lost: Error | undefined;
+};
+/**
+ * The transactions an import writes in: time-capped, synchronous off, the import cache held from the
+ * first write to the end; every other write of the engine runs between two of them, durable.
+ */
+export type ImportWindow = {
+    /** Run `work` in the open transaction, opened first when none is. */
+    write: <GenericResult>(work: () => GenericResult) => GenericResult;
+    /** Commit the open transaction once it has written for the window's time; answers whether it did. */
+    commitIfDue: () => boolean;
+    /** Run `work` alone in a transaction of its own (an index build: one long statement). */
+    alone: <GenericResult>(work: () => GenericResult) => GenericResult;
+    /** Commit what is open and make the connection durable for another connection's write; the import cache stays. */
+    settle: () => void;
+    /** Commit what is open and give the connection back its durable settings: the import is complete. */
+    finish: () => void;
+    /** Roll back what is open and give the connection back its durable settings; nothing to do on a closed database. */
+    end: () => void;
+};
+/** The import an engine runs, by its window and its end: none between two imports. */
+export type RunningImport = {
+    window: ImportWindow | undefined;
+    /** Settled once the import has ended, however it did. */
+    ended: Promise<void> | undefined;
+};
+/** What an import's target writes with: the engine's connection and state, and the import's own perf, abort and file. */
+export type ImportTargetParams = {
+    sqlite3: Sqlite3Static;
+    db: Database;
+    perf: Perf;
+    signal: AbortSignal;
+    file: File;
+    /** The engine's record count per document, kept in step by the import's writes. */
+    counts: Map<string, number>;
+    /** The engine's removal of a document (table, row, free pages in steps): what a failed import leaves goes. */
+    removeDocument: (params: {
+        documentId: string;
+    }) => Promise<void>;
+    /** The import's transactions. */
+    window: ImportWindow;
+    /** How long the import works before the engine's queue gets a turn (its window's time). */
+    windowMs: number;
+    /** Tell the caller what the import does now (`indexing` around an index build). */
+    tellPhase: (params: {
+        phase: ImportPhase;
+    }) => void;
+    /** Runs an index build: one long statement. */
+    onLongStatement: LongStatementRunner;
+    /** Told once the import's document is registered (its registry row exists). */
+    onRegistered: () => void;
+    /** Whether the file gives its own record ids (they may repeat); generated ids never do. */
+    customIds: boolean;
+};
+/** The import's progress as the engine relays it: the parser's told on, the last one kept to tell a phase with. */
+export type ImportProgressRelay = {
+    onProgress: (progress: ImportProgress) => void;
+    tellPhase: (params: {
+        phase: ImportPhase;
+    }) => void;
+};
+/** What an import's target knows of its document: the one it registered (with its table) and the indexes built on it. */
+/** A document's registry row as an import checks it is still its own. */
+export type RegistryRowState = {
+    seq: number;
+    status: DocumentStatus;
+    writeId: string | undefined;
+    createdAt: number;
+};
+export type ImportTargetState = {
+    /** The document this import registered: its table, and what tells its row from one registered since under its id. */
+    registered: (DocumentTable & {
+        documentId: string;
+        writeId: string | undefined;
+        createdAt: number;
+    }) | undefined;
+    built: Set<RecordIndex>;
+    /**
+     * The ids stored so far when the file gives its own ids, until the id index exists: a repeated
+     * one is refused at its batch. About 100 bytes an id (0.4 GB for 4 million records): only test
+     * setups give their own ids.
+     */
+    givenIds: Set<string> | undefined;
+};
+/** Reads by id on one table through one prepared statement. */
+export type RecordReadsById = {
+    read: (ids: readonly string[]) => Map<string, AnyRawRecord>;
+    finalize: () => void;
+};
+/** The statement an export reads its document's records through, with what it was prepared for. */
+export type ExportReads = {
+    current: {
+        documentId: string;
+        removals: number;
+        statement: RecordReadsById;
+    } | undefined;
+};
+/** An export the engine runs: its owner, its abort, the statement it reads through. */
+export type RunningExport = {
+    clientId: string;
+    controller: AbortController;
+    reads: ExportReads;
+};
+/** Columns of one value on every row an insert writes, before the record's own. */
+export type LeadColumns = {
+    columns: string[];
+    values: SqlValue[];
+};
+/** Records encoded as rows of a document table: JSON arrays of up to `ROWS_PER_BIND` rows each. */
+export type EncodedRows = {
+    payloads: string[];
+};
+/** The store errors an engine throws a failure of SQLite as, one per kind of operation. */
+export type StoreFailureKey = Extract<DialecteErrorKey, 'STORE_CONNECTION_FAILED' | 'STORE_READ_FAILED' | 'STORE_COMMIT_FAILED' | 'STORE_BULK_ADD_FAILED' | 'STORE_BULK_UPDATE_FAILED' | 'STORE_DELETE_FAILED'>;
+/** A row of a project file's `_meta` table. */
+export type MetaRow = {
+    key: string;
+    value: string;
+};
+//# sourceMappingURL=engine.types.d.ts.map

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

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

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

@@ -0,0 +1,114 @@
+import { EncodedRows, HistoryDirection, HistoryEntryRef, HistoryEntryState, HistoryPart } from './engine.types';
+import { ChangeLogEntry } from '../../store.types';
+import { Database } from '@sqlite.org/sqlite-wasm';
+/**
+ * The history of a document on the file: one `_changeLog` row per commit, and the records it touched
+ * whole in the document's history-rows table, one row per record and part, in the order given. The
+ * entries applied are the first ones in sequence; an undo leaves its entry undone until a redo applies
+ * it again or a commit discards it. Every write runs in the caller's transaction.
+ */
+/**
+ * A new entry, applied, after the document's last: the entries undone before it are discarded first
+ * - their rows gone, their place freed, their write ids kept. Answers the entry.
+ */
+export declare function recordEntry(params: {
+    db: Database;
+    documentId: string;
+    table: string;
+    writeId: string;
+}): HistoryEntryRef;
+/**
+ * The records of these ids the document holds, copied whole into the entry's part, in the order of
+ * the ids (an id it does not hold is left out).
+ */
+export declare function copySnapshots(params: {
+    db: Database;
+    records: string;
+    table: string;
+    entry: HistoryEntryRef;
+    part: HistoryPart;
+    ids: readonly string[];
+}): void;
+/** Records encoded for the row sink, written as the entry's part in the order given. */
+export declare function appendSnapshots(params: {
+    db: Database;
+    table: string;
+    entry: HistoryEntryRef;
+    part: HistoryPart;
+    rows: EncodedRows;
+}): void;
+/**
+ * Apply an entry to the document's records: `forward` (a redo) writes its creates and its updates as
+ * they were after it, then deletes what it deleted; `back` (an undo), in reverse, writes back what it
+ * deleted, then its updates as they were before it, then deletes its creates. Answers how many records
+ * the document gained (negative when it lost some).
+ */
+export declare function applyEntry(params: {
+    db: Database;
+    records: string;
+    table: string;
+    entry: HistoryEntryRef;
+    direction: HistoryDirection;
+}): number;
+/**
+ * The rows of the part written over the records of their ids, whatever the document holds there, in
+ * the order the entry keeps (the last of two updates of a record stands); answers how many of them the
+ * document did not hold.
+ */
+export declare function writePartRecords(params: {
+    db: Database;
+    records: string;
+    table: string;
+    entry: HistoryEntryRef;
+    part: HistoryPart;
+}): number;
+/** The records of the ids the part holds deleted; answers how many there were. */
+export declare function deletePartRecords(params: {
+    db: Database;
+    records: string;
+    table: string;
+    entry: HistoryEntryRef;
+    part: HistoryPart;
+}): number;
+/** The entry an undo of the document reverts: its last applied one; none at the start of its history. */
+export declare function entryToUndo(params: {
+    db: Database;
+    documentId: string;
+}): HistoryEntryRef | undefined;
+/** The entry a redo of the document applies again: its first undone one; none at the end of its history. */
+export declare function entryToRedo(params: {
+    db: Database;
+    documentId: string;
+}): HistoryEntryRef | undefined;
+/** Move the entry to applied (a redo) or undone (an undo). */
+export declare function setEntryState(params: {
+    db: Database;
+    entry: HistoryEntryRef;
+    state: HistoryEntryState;
+}): void;
+/** Whether the document has a commit to undo and one to redo. */
+export declare function readHistoryStatus(params: {
+    db: Database;
+    documentId: string;
+}): {
+    canUndo: boolean;
+    canRedo: boolean;
+};
+/** The document's entries in sequence order (a discarded one is not), each with its records whole, read in two statements. */
+export declare function readChangeLog(params: {
+    db: Database;
+    documentId: string;
+    table: string;
+}): ChangeLogEntry[];
+/** Whether a history entry of any document carries the id, discarded or not: its commit is applied. */
+export declare function hasCommitOf(params: {
+    db: Database;
+    writeId: string;
+}): boolean;
+/** A document's history gone, in the caller's transaction: its history-rows table and its entries. */
+export declare function deleteHistoryOf(params: {
+    db: Database;
+    documentId: string;
+    table: string;
+}): void;
+//# sourceMappingURL=history.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import { ImportQueue } from './engine.types';
+/**
+ * The imports of an engine: one runs at a time (an import changes the connection's pragmas), the
+ * others wait their turn in the order they came. Each is owned by the client that asked for it.
+ */
+export declare function createImportQueue(): ImportQueue;
+//# sourceMappingURL=import-queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import-queue.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/import-queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,gBAAgB,CAAA;AAEnE;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,CA0B/C"}

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

@@ -0,0 +1,23 @@
+import { ImportProgressRelay, ImportTargetParams } from './engine.types';
+import { ImportControl, ImportTarget } from '../../store.types';
+/**
+ * What one import writes through in the engine (`runImport`'s target). The document's table starts
+ * without indexes (an index kept up by every insert of a large file slows it a lot); the id index is
+ * built at the first update or delete, the remaining ones once the file is stored, before the
+ * document is ready - a document is never ready without them. Reads of a document while it imports
+ * scan its table; nothing reads a document that is not ready.
+ *
+ * Every member checks the import's abort before it touches the database, so an import resumed after
+ * the engine closed stops there. The registry row is read again before each write: a document
+ * removed meanwhile (its number possibly taken by another one) is never written to nor marked ready.
+ */
+export declare function createImportTarget(params: ImportTargetParams): ImportTarget;
+/**
+ * The import's progress relayed to the caller's listener (never awaited, its failure reported once for the import):
+ * the parser's progress told on and kept, so a phase is told with the bytes read so far.
+ */
+export declare function createProgressRelay(params: {
+    file: File;
+    listener: ImportControl['onProgress'];
+}): ImportProgressRelay;
+//# sourceMappingURL=import-target.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import-target.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/import-target.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EACX,mBAAmB,EACnB,kBAAkB,EAIlB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,aAAa,EAAkB,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAItF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CA6E3E;AA+RD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC3C,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CACrC,GAAG,mBAAmB,CAYtB"}

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

@@ -0,0 +1,23 @@
+import { ImportWindow, ImportWindowParams } from './engine.types';
+/**
+ * The window transactions of one import. Its writes go into a transaction that commits after about
+ * `windowMs` of work, with synchronous off (the rollback journal kept: a failed import rolls back
+ * what is open, then its document is dropped) and the import cache, raised at its first write and
+ * held until it ends (lowering it between two transactions would read the import's pages again).
+ * Commits are tallied as `import::commit`.
+ *
+ * A write of another connection settles the window first: what is open is committed and the
+ * connection is durable again (synchronous full), so that write lands at once, on its own, and stays
+ * whatever becomes of the import; the import opens its next window at its next write. A commit that
+ * fails there loses the window's records: the import is then refused at its next window
+ * (`STORE_COMMIT_FAILED`), never ready without them.
+ */
+export declare function createImportWindow(params: ImportWindowParams): ImportWindow;
+/**
+ * End the window of an import that failed: the connection durable again; a failure of the rollback is
+ * dropped (not thrown, not attached), the import's own failure is the one to report.
+ */
+export declare function endQuietly(params: {
+    window: ImportWindow;
+}): void;
+//# sourceMappingURL=import-window.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import-window.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/import-window.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAqB,MAAM,gBAAgB,CAAA;AAEzF;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CA0E3E;AAyDD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,GAAG,IAAI,CAMjE"}

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

@@ -0,0 +1,13 @@
+import { ReclaimParams } from './engine.types';
+/**
+ * Give the file's free pages back (incremental auto-vacuum) in whole statements of
+ * `pagesPerStatement` pages, letting the queued calls run after every `sliceMs` of them: a large
+ * removal never holds the engine for long. Each statement is a write of its own, made after the
+ * running import's window is settled - or, for a reclaim that gives way (`giveWayTo`), once that import
+ * has ended; the reclaim stops once the freelist is empty or the engine is closed (what is left is given
+ * back by the next removal or start).
+ */
+export declare function reclaimInSteps(params: ReclaimParams): Promise<void>;
+/** How many pages of the file are free. */
+export declare function freePagesOf(params: Pick<ReclaimParams, 'db'>): number;
+//# sourceMappingURL=reclaim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reclaim.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/reclaim.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBzE;AAED,2CAA2C;AAC3C,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,GAAG,MAAM,CAErE"}