@minnowdb/core 0.2.1 → 0.4.0

package/dist/testing/index.d.ts

@@ -1,67 +1,85 @@
-import type { BlockStore, BlockWrite, CompactionJobRecord, CompactionJobRecordUpdate, CreateGarbageCollectionJobInput, GarbageCollectionJobRecord, GarbageCollectionStepResult, CommitTransactionInput, LeaseRecord, Manifest, ManifestSummary, PublishManifestInput, CatalogProbe, QueryCatalogState, RowIdRange, RunGarbageCollectionStepInput, SegmentRecord, StoragePage, TableRecord, TempOwnerRecord, TempRunPage, TransactionRecord, TransactionRecordUpdate } from "../storage/index.js";
-export declare const faultPoints: readonly ["beforeBlockWrite", "afterBlockWrite", "beforeBlockRead", "afterBlockRead", "beforeManifestCommit", "afterManifestCommit", "beforeTransactionCommit", "afterTransactionCommit"];
+import type { BlockStore, AdoptAbortedSegmentInput, AbortTransactionIfExpiredInput, CompactionJobRecord, CompactionJobRecordUpdate, CreateGarbageCollectionJobInput, GarbageCollectionJobRecord, GarbageCollectionStepResult, CommitTransactionInput, LeaseRecord, Manifest, ManifestSummary, CatalogProbe, RowIdRange, RenewTransactionInput, RunGarbageCollectionStepInput, RollbackTransactionArtifactsInput, SegmentRecord, StageTransactionArtifactsInput, StoragePage, TableRecord, TempOwnerRecord, TempRunPage, TransactionRecord, TransactionRecordUpdate } from "../storage/index.js";
+export declare const faultPoints: readonly ["beforeBlockWrite", "afterBlockWrite", "beforeBlockRead", "afterBlockRead", "beforeTransactionCommit", "afterTransactionCommit"];
 export type FaultPoint = (typeof faultPoints)[number];
 export type FaultInjector = (point: FaultPoint) => void | Promise<void>;
 export declare class FaultInjectingBlockStore implements BlockStore {
     private readonly inner;
     private readonly inject;
-    /** Present only when the inner store implements it, so callers' fallbacks stay honest. */
-    getQueryCatalogState?: (tableNames: readonly string[]) => Promise<QueryCatalogState>;
-    /** Present only when the inner store implements it, so callers' fallbacks stay honest. */
-    getCatalogProbe?: () => Promise<CatalogProbe>;
     constructor(inner: BlockStore, inject: FaultInjector);
-    addBlock(id: string, bytes: Uint8Array): Promise<void>;
-    addBlocks(blocks: readonly BlockWrite[]): Promise<void>;
+    getCatalogProbe(): Promise<CatalogProbe>;
+    beginTransaction(input: Parameters<BlockStore["beginTransaction"]>[0]): ReturnType<BlockStore["beginTransaction"]>;
     getBlock(id: string): Promise<Uint8Array | undefined>;
     getBlocks(ids: readonly string[]): Promise<Array<Uint8Array | undefined>>;
-    removeBlock(id: string): Promise<void>;
-    listBlockIds(): Promise<string[]>;
-    addTable(record: TableRecord): Promise<void>;
+    readManifestBlock(version: number | null, id: string): Promise<Uint8Array | undefined>;
+    hasManifestBlocks(version: number | null, ids: readonly string[]): Promise<boolean[]>;
+    addTable(record: TableRecord, options?: Parameters<BlockStore["addTable"]>[1]): Promise<void>;
     getTable(id: string): Promise<TableRecord | undefined>;
     getTableByName(name: string): Promise<TableRecord | undefined>;
     listTables(): Promise<TableRecord[]>;
     updateTable(id: string, expectedRevision: number, update: Parameters<BlockStore["updateTable"]>[2]): Promise<TableRecord>;
-    removeTable(id: string, expectedRevision: number): Promise<void>;
-    addSegment(record: SegmentRecord): Promise<void>;
+    removeTable(id: string, expectedRevision: number, options?: Parameters<BlockStore["removeTable"]>[2]): Promise<void>;
+    dropTable(input: Parameters<BlockStore["dropTable"]>[0]): Promise<ManifestSummary>;
+    dropTableColumn(input: Parameters<BlockStore["dropTableColumn"]>[0]): Promise<ManifestSummary>;
     getSegment(id: string): Promise<SegmentRecord | undefined>;
-    listSegments(tableId?: string): Promise<SegmentRecord[]>;
-    removeSegment(id: string): Promise<void>;
+    listSegmentPage(afterId: string | null, limit: number): Promise<StoragePage<SegmentRecord, string>>;
+    listTableSegmentPage(tableId: string, afterId: string | null, limit: number): Promise<StoragePage<SegmentRecord, string>>;
+    removeAbortedSegment(id: string, expectedTransactionId: string): Promise<boolean>;
+    adoptAbortedSegment(input: AdoptAbortedSegmentInput): Promise<TransactionRecord>;
     reserveRowIds(tableId: string, count: number): Promise<RowIdRange>;
     reserveAutoIncrement(tableId: string, columnId: string, count: number, atLeast?: bigint): Promise<RowIdRange>;
     writeFtsBase(tableId: string, columnId: string, input: Parameters<BlockStore["writeFtsBase"]>[2]): Promise<void>;
+    beginFtsBaseBuild(input: Parameters<BlockStore["beginFtsBaseBuild"]>[0]): Promise<void>;
+    renewFtsBaseBuild(input: Parameters<BlockStore["renewFtsBaseBuild"]>[0]): Promise<void>;
+    writeFtsBaseBuildChunk(input: Parameters<BlockStore["writeFtsBaseBuildChunk"]>[0]): Promise<void>;
+    finishFtsBaseBuild(input: Parameters<BlockStore["finishFtsBaseBuild"]>[0]): Promise<void>;
+    abortFtsBaseBuild(input: Parameters<BlockStore["abortFtsBaseBuild"]>[0]): Promise<void>;
+    removeFtsColumn(tableId: string, columnId: string): Promise<void>;
     readFtsCandidates(tableId: string, columnId: string, terms: Parameters<BlockStore["readFtsCandidates"]>[2], upToVersion: number): ReturnType<BlockStore["readFtsCandidates"]>;
+    readFtsPostings(tableId: string, columnId: string, upToVersion: number, maxRowIds?: number, maxRetainedBytes?: number): ReturnType<BlockStore["readFtsPostings"]>;
     getExistingUniqueKeys(tableId: string, keyTokens: readonly string[]): Promise<string[]>;
+    beginUniqueKeyBuild(input: Parameters<BlockStore["beginUniqueKeyBuild"]>[0]): Promise<import("../storage/types.js").UniqueKeyBuildRecord>;
+    getUniqueKeyBuild(buildId: string): Promise<import("../storage/types.js").UniqueKeyBuildRecord | undefined>;
+    renewUniqueKeyBuild(input: Parameters<BlockStore["renewUniqueKeyBuild"]>[0]): Promise<import("../storage/types.js").UniqueKeyBuildRecord>;
+    appendUniqueKeyBuildChunk(input: Parameters<BlockStore["appendUniqueKeyBuildChunk"]>[0]): Promise<import("../storage/types.js").UniqueKeyBuildRecord>;
+    finishUniqueKeyBuild(input: Parameters<BlockStore["finishUniqueKeyBuild"]>[0]): Promise<TableRecord>;
+    abortUniqueKeyBuild(input: Parameters<BlockStore["abortUniqueKeyBuild"]>[0]): Promise<boolean>;
     getCurrentManifestVersion(): Promise<number | null>;
     getCurrentManifest(): Promise<Manifest | undefined>;
     getManifest(version: number): Promise<Manifest | undefined>;
-    listManifests(): Promise<Manifest[]>;
-    listManifestPage(afterVersion: number | null, limit: number): Promise<StoragePage<Manifest, number>>;
-    publishManifest(input: PublishManifestInput): Promise<Manifest>;
+    listManifestBlockPage(input: Parameters<BlockStore["listManifestBlockPage"]>[0]): Promise<import("../storage/types.js").ManifestBlockPage>;
+    listRetiredManifestBlockPage(input: Parameters<BlockStore["listRetiredManifestBlockPage"]>[0]): Promise<import("../storage/types.js").ManifestBlockPage>;
+    listManifestPage(afterVersion: number | null, limit: number): Promise<StoragePage<ManifestSummary, number>>;
     createTransaction(record: TransactionRecord): Promise<void>;
     getTransaction(id: string): Promise<TransactionRecord | undefined>;
     getTransactions(ids: readonly string[]): Promise<Array<TransactionRecord | undefined>>;
-    listTransactions(): Promise<TransactionRecord[]>;
     listTransactionPage(afterId: string | null, limit: number): Promise<StoragePage<TransactionRecord, string>>;
     updateTransaction(id: string, expectedRevision: number, update: TransactionRecordUpdate): Promise<TransactionRecord>;
+    renewTransaction(input: RenewTransactionInput): Promise<boolean>;
+    abortTransactionIfExpired(input: AbortTransactionIfExpiredInput): Promise<TransactionRecord | undefined>;
+    stageTransactionArtifacts(input: StageTransactionArtifactsInput): Promise<TransactionRecord>;
+    rollbackTransactionArtifacts(input: RollbackTransactionArtifactsInput): Promise<TransactionRecord>;
     commitTransaction(input: CommitTransactionInput): Promise<ManifestSummary>;
     createLease(record: LeaseRecord): Promise<void>;
     getLease(id: string): Promise<LeaseRecord | undefined>;
     listLeases(): Promise<LeaseRecord[]>;
-    renewLease(id: string, expectedRevision: number, expiresAt: string): Promise<LeaseRecord>;
+    listExpiredLeasePage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<StoragePage<LeaseRecord, string>>;
+    renewLease(input: Parameters<BlockStore["renewLease"]>[0]): Promise<LeaseRecord>;
     removeLeaseIfExpired(id: string, expectedRevision: number, expiresAtCutoff: string): Promise<boolean>;
-    removeLease(id: string): Promise<void>;
+    removeLease(input: Parameters<BlockStore["removeLease"]>[0]): Promise<boolean>;
     createCompactionJob(record: CompactionJobRecord): Promise<void>;
     getCompactionJob(id: string): Promise<CompactionJobRecord | undefined>;
     listCompactionJobs(tableId?: string): Promise<CompactionJobRecord[]>;
     listCompactionJobPage(afterId: string | null, limit: number): Promise<StoragePage<CompactionJobRecord, string>>;
     updateCompactionJob(id: string, expectedRevision: number, update: CompactionJobRecordUpdate): Promise<CompactionJobRecord>;
     cancelCompactionJob(id: string, expectedRevision: number, cancelledAt: string): Promise<CompactionJobRecord>;
-    removeCompactionJob(id: string): Promise<void>;
+    removeCompactionJob(id: string): Promise<boolean>;
     createGarbageCollectionJob(input: CreateGarbageCollectionJobInput): Promise<GarbageCollectionJobRecord>;
+    updateGarbageCollectionPlanning(input: Parameters<BlockStore["updateGarbageCollectionPlanning"]>[0]): Promise<GarbageCollectionJobRecord>;
     getGarbageCollectionJob(id: string): Promise<GarbageCollectionJobRecord | undefined>;
     listGarbageCollectionJobs(): Promise<GarbageCollectionJobRecord[]>;
+    listGarbageCollectionJobPage(afterId: string | null, limit: number): Promise<StoragePage<GarbageCollectionJobRecord, string>>;
     runGarbageCollectionStep(input: RunGarbageCollectionStepInput): Promise<GarbageCollectionStepResult>;
-    removePrunedManifestRecords(): Promise<number>;
+    removePrunedManifestRecords(maxItems: number): Promise<number>;
     removeGarbageCollectionJob(id: string): Promise<void>;
     putTempRunPage(page: TempRunPage): Promise<void>;
     getTempRunPage(ownerId: string, runId: string, pageIndex: number): Promise<Uint8Array | undefined>;
@@ -69,11 +87,13 @@ export declare class FaultInjectingBlockStore implements BlockStore {
     removeTempOwner(ownerId: string): Promise<void>;
     createTempOwner(record: TempOwnerRecord): Promise<void>;
     getTempOwner(ownerId: string): Promise<TempOwnerRecord | undefined>;
-    renewTempOwner(ownerId: string, expectedRevision: number, expiresAt: string): Promise<TempOwnerRecord>;
+    renewTempOwner(input: Parameters<BlockStore["renewTempOwner"]>[0]): Promise<TempOwnerRecord>;
     removeTempOwnerIfExpired(ownerId: string, expiresAtCutoff: string): Promise<boolean>;
     listTempOwnerIdsPage(afterOwnerId: string | null, limit: number): Promise<StoragePage<string, string>>;
+    listExpiredTempOwnerPage(expiresAtCutoff: string, afterCursor: string | null, limit: number): Promise<StoragePage<string, string>>;
     close(): void;
 }
 export { blockStoreConformanceCases, runBlockStoreConformance, type BlockStoreConformanceCase, type BlockStoreConformanceTarget, } from "./block-store-conformance.js";
-export { MemoryOpfs, type WriteFault } from "./opfs-shim.js";
-//# sourceMappingURL=index.d.ts.map
+export { MemoryOpfs, type TransferLimit, type WriteFault } from "./opfs-shim.js";
+export { DeterministicScheduler, generateSimulationPlan, parseSimulationPlan, runSimulation, scheduledBlockStore, type CollectionPassSummary, type SimulationDelete, type SimulationMutation, type SimulationOptions, type SimulationPlan, type SimulationPut, type SimulationResult, type SimulationStep, type SimulationTraceEvent, } from "./simulator.js";
+export { SqlLogicFailure, SqlLogicParseError, md5Hex, parseSqlLogicTest, parseSqlLogicTestLines, renderSqlLogicValue, runSqlLogicTest, type SqlLogicCondition, type SqlLogicDatabase, type SqlLogicExpectedHash, type SqlLogicExpectedValues, type SqlLogicHalt, type SqlLogicHashThreshold, type SqlLogicLocation, type SqlLogicQuery, type SqlLogicRecord, type SqlLogicRunStatistics, type SqlLogicRunOptions, type SqlLogicSortMode, type SqlLogicStatement, type SqlLogicType, } from "./sqllogictest.js";

package/dist/testing/index.js

@@ -3,39 +3,21 @@ export const faultPoints = [
     "afterBlockWrite",
     "beforeBlockRead",
     "afterBlockRead",
-    "beforeManifestCommit",
-    "afterManifestCommit",
     "beforeTransactionCommit",
     "afterTransactionCommit",
 ];
 export class FaultInjectingBlockStore {
     inner;
     inject;
-    /** Present only when the inner store implements it, so callers' fallbacks stay honest. */
-    getQueryCatalogState;
-    /** Present only when the inner store implements it, so callers' fallbacks stay honest. */
-    getCatalogProbe;
     constructor(inner, inject) {
         this.inner = inner;
         this.inject = inject;
-        const innerCatalogState = inner.getQueryCatalogState?.bind(inner);
-        if (innerCatalogState !== undefined) {
-            this.getQueryCatalogState = (tableNames) => innerCatalogState(tableNames);
-        }
-        const innerCatalogProbe = inner.getCatalogProbe?.bind(inner);
-        if (innerCatalogProbe !== undefined) {
-            this.getCatalogProbe = () => innerCatalogProbe();
-        }
-    }
-    async addBlock(id, bytes) {
-        await this.inject("beforeBlockWrite");
-        await this.inner.addBlock(id, bytes);
-        await this.inject("afterBlockWrite");
     }
-    async addBlocks(blocks) {
-        await this.inject("beforeBlockWrite");
-        await this.inner.addBlocks(blocks);
-        await this.inject("afterBlockWrite");
+    getCatalogProbe() {
+        return this.inner.getCatalogProbe();
+    }
+    beginTransaction(input) {
+        return this.inner.beginTransaction(input);
     }
     async getBlock(id) {
         await this.inject("beforeBlockRead");
@@ -49,14 +31,17 @@ export class FaultInjectingBlockStore {
         await this.inject("afterBlockRead");
         return blocks;
     }
-    removeBlock(id) {
-        return this.inner.removeBlock(id);
+    async readManifestBlock(version, id) {
+        await this.inject("beforeBlockRead");
+        const bytes = await this.inner.readManifestBlock(version, id);
+        await this.inject("afterBlockRead");
+        return bytes;
     }
-    listBlockIds() {
-        return this.inner.listBlockIds();
+    hasManifestBlocks(version, ids) {
+        return this.inner.hasManifestBlocks(version, ids);
     }
-    addTable(record) {
-        return this.inner.addTable(record);
+    addTable(record, options) {
+        return this.inner.addTable(record, options);
     }
     getTable(id) {
         return this.inner.getTable(id);
@@ -70,20 +55,29 @@ export class FaultInjectingBlockStore {
     updateTable(id, expectedRevision, update) {
         return this.inner.updateTable(id, expectedRevision, update);
     }
-    removeTable(id, expectedRevision) {
-        return this.inner.removeTable(id, expectedRevision);
+    removeTable(id, expectedRevision, options) {
+        return this.inner.removeTable(id, expectedRevision, options);
     }
-    addSegment(record) {
-        return this.inner.addSegment(record);
+    dropTable(input) {
+        return this.inner.dropTable(input);
+    }
+    dropTableColumn(input) {
+        return this.inner.dropTableColumn(input);
     }
     getSegment(id) {
         return this.inner.getSegment(id);
     }
-    listSegments(tableId) {
-        return this.inner.listSegments(tableId);
+    listSegmentPage(afterId, limit) {
+        return this.inner.listSegmentPage(afterId, limit);
+    }
+    listTableSegmentPage(tableId, afterId, limit) {
+        return this.inner.listTableSegmentPage(tableId, afterId, limit);
     }
-    removeSegment(id) {
-        return this.inner.removeSegment(id);
+    removeAbortedSegment(id, expectedTransactionId) {
+        return this.inner.removeAbortedSegment(id, expectedTransactionId);
+    }
+    adoptAbortedSegment(input) {
+        return this.inner.adoptAbortedSegment(input);
     }
     reserveRowIds(tableId, count) {
         return this.inner.reserveRowIds(tableId, count);
@@ -94,12 +88,51 @@ export class FaultInjectingBlockStore {
     writeFtsBase(tableId, columnId, input) {
         return this.inner.writeFtsBase(tableId, columnId, input);
     }
+    beginFtsBaseBuild(input) {
+        return this.inner.beginFtsBaseBuild(input);
+    }
+    renewFtsBaseBuild(input) {
+        return this.inner.renewFtsBaseBuild(input);
+    }
+    writeFtsBaseBuildChunk(input) {
+        return this.inner.writeFtsBaseBuildChunk(input);
+    }
+    finishFtsBaseBuild(input) {
+        return this.inner.finishFtsBaseBuild(input);
+    }
+    abortFtsBaseBuild(input) {
+        return this.inner.abortFtsBaseBuild(input);
+    }
+    removeFtsColumn(tableId, columnId) {
+        return this.inner.removeFtsColumn(tableId, columnId);
+    }
     readFtsCandidates(tableId, columnId, terms, upToVersion) {
         return this.inner.readFtsCandidates(tableId, columnId, terms, upToVersion);
     }
+    readFtsPostings(tableId, columnId, upToVersion, maxRowIds, maxRetainedBytes) {
+        return this.inner.readFtsPostings(tableId, columnId, upToVersion, maxRowIds, maxRetainedBytes);
+    }
     getExistingUniqueKeys(tableId, keyTokens) {
         return this.inner.getExistingUniqueKeys(tableId, keyTokens);
     }
+    beginUniqueKeyBuild(input) {
+        return this.inner.beginUniqueKeyBuild(input);
+    }
+    getUniqueKeyBuild(buildId) {
+        return this.inner.getUniqueKeyBuild(buildId);
+    }
+    renewUniqueKeyBuild(input) {
+        return this.inner.renewUniqueKeyBuild(input);
+    }
+    appendUniqueKeyBuildChunk(input) {
+        return this.inner.appendUniqueKeyBuildChunk(input);
+    }
+    finishUniqueKeyBuild(input) {
+        return this.inner.finishUniqueKeyBuild(input);
+    }
+    abortUniqueKeyBuild(input) {
+        return this.inner.abortUniqueKeyBuild(input);
+    }
     getCurrentManifestVersion() {
         return this.inner.getCurrentManifestVersion();
     }
@@ -109,18 +142,15 @@ export class FaultInjectingBlockStore {
     getManifest(version) {
         return this.inner.getManifest(version);
     }
-    listManifests() {
-        return this.inner.listManifests();
+    listManifestBlockPage(input) {
+        return this.inner.listManifestBlockPage(input);
+    }
+    listRetiredManifestBlockPage(input) {
+        return this.inner.listRetiredManifestBlockPage(input);
     }
     listManifestPage(afterVersion, limit) {
         return this.inner.listManifestPage(afterVersion, limit);
     }
-    async publishManifest(input) {
-        await this.inject("beforeManifestCommit");
-        const manifest = await this.inner.publishManifest(input);
-        await this.inject("afterManifestCommit");
-        return manifest;
-    }
     createTransaction(record) {
         return this.inner.createTransaction(record);
     }
@@ -130,15 +160,27 @@ export class FaultInjectingBlockStore {
     getTransactions(ids) {
         return this.inner.getTransactions(ids);
     }
-    listTransactions() {
-        return this.inner.listTransactions();
-    }
     listTransactionPage(afterId, limit) {
         return this.inner.listTransactionPage(afterId, limit);
     }
     updateTransaction(id, expectedRevision, update) {
         return this.inner.updateTransaction(id, expectedRevision, update);
     }
+    renewTransaction(input) {
+        return this.inner.renewTransaction(input);
+    }
+    abortTransactionIfExpired(input) {
+        return this.inner.abortTransactionIfExpired(input);
+    }
+    async stageTransactionArtifacts(input) {
+        await this.inject("beforeBlockWrite");
+        const transaction = await this.inner.stageTransactionArtifacts(input);
+        await this.inject("afterBlockWrite");
+        return transaction;
+    }
+    rollbackTransactionArtifacts(input) {
+        return this.inner.rollbackTransactionArtifacts(input);
+    }
     async commitTransaction(input) {
         await this.inject("beforeTransactionCommit");
         const manifest = await this.inner.commitTransaction(input);
@@ -154,14 +196,17 @@ export class FaultInjectingBlockStore {
     listLeases() {
         return this.inner.listLeases();
     }
-    renewLease(id, expectedRevision, expiresAt) {
-        return this.inner.renewLease(id, expectedRevision, expiresAt);
+    listExpiredLeasePage(expiresAtCutoff, afterCursor, limit) {
+        return this.inner.listExpiredLeasePage(expiresAtCutoff, afterCursor, limit);
+    }
+    renewLease(input) {
+        return this.inner.renewLease(input);
     }
     removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff) {
         return this.inner.removeLeaseIfExpired(id, expectedRevision, expiresAtCutoff);
     }
-    removeLease(id) {
-        return this.inner.removeLease(id);
+    removeLease(input) {
+        return this.inner.removeLease(input);
     }
     createCompactionJob(record) {
         return this.inner.createCompactionJob(record);
@@ -187,17 +232,23 @@ export class FaultInjectingBlockStore {
     createGarbageCollectionJob(input) {
         return this.inner.createGarbageCollectionJob(input);
     }
+    updateGarbageCollectionPlanning(input) {
+        return this.inner.updateGarbageCollectionPlanning(input);
+    }
     getGarbageCollectionJob(id) {
         return this.inner.getGarbageCollectionJob(id);
     }
     listGarbageCollectionJobs() {
         return this.inner.listGarbageCollectionJobs();
     }
+    listGarbageCollectionJobPage(afterId, limit) {
+        return this.inner.listGarbageCollectionJobPage(afterId, limit);
+    }
     runGarbageCollectionStep(input) {
         return this.inner.runGarbageCollectionStep(input);
     }
-    removePrunedManifestRecords() {
-        return this.inner.removePrunedManifestRecords();
+    removePrunedManifestRecords(maxItems) {
+        return this.inner.removePrunedManifestRecords(maxItems);
     }
     removeGarbageCollectionJob(id) {
         return this.inner.removeGarbageCollectionJob(id);
@@ -220,8 +271,8 @@ export class FaultInjectingBlockStore {
     getTempOwner(ownerId) {
         return this.inner.getTempOwner(ownerId);
     }
-    renewTempOwner(ownerId, expectedRevision, expiresAt) {
-        return this.inner.renewTempOwner(ownerId, expectedRevision, expiresAt);
+    renewTempOwner(input) {
+        return this.inner.renewTempOwner(input);
     }
     removeTempOwnerIfExpired(ownerId, expiresAtCutoff) {
         return this.inner.removeTempOwnerIfExpired(ownerId, expiresAtCutoff);
@@ -229,10 +280,14 @@ export class FaultInjectingBlockStore {
     listTempOwnerIdsPage(afterOwnerId, limit) {
         return this.inner.listTempOwnerIdsPage(afterOwnerId, limit);
     }
+    listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit) {
+        return this.inner.listExpiredTempOwnerPage(expiresAtCutoff, afterCursor, limit);
+    }
     close() {
         this.inner.close();
     }
 }
 export { blockStoreConformanceCases, runBlockStoreConformance, } from "./block-store-conformance.js";
 export { MemoryOpfs } from "./opfs-shim.js";
-//# sourceMappingURL=index.js.map
+export { DeterministicScheduler, generateSimulationPlan, parseSimulationPlan, runSimulation, scheduledBlockStore, } from "./simulator.js";
+export { SqlLogicFailure, SqlLogicParseError, md5Hex, parseSqlLogicTest, parseSqlLogicTestLines, renderSqlLogicValue, runSqlLogicTest, } from "./sqllogictest.js";

package/dist/testing/opfs-shim.d.ts

@@ -12,24 +12,34 @@
  *   `InvalidModificationError`, `NoModificationAllowedError`, and injected
  *   `QuotaExceededError`s are actual `DOMException`s, since error identity is part of the
  *   storage contract.
- * - **Injectable write faults.** `setWriteFault` throws from inside sync writes, creates, or
- *   flushes — how the quota and crash suites produce a failure at an exact byte boundary.
+ * - **Injectable write faults and short transfers.** `setWriteFault` throws from inside sync
+ *   writes, creates, or flushes; `setTransferLimit` makes reads or writes return any valid short
+ *   byte count, including zero progress, at deterministic offsets.
  *
  * For applications, `MemoryBlockStore` remains the right store in Node tests. This shim is for
  * adapter authors: it hosts `OpfsBlockStore` (pass `root`) or anything built on the storage
  * toolkit's `SyncFileHandle` surface, in plain vitest, with crashes and quota failures on tap.
  */
 export type WriteFault = (path: string, phase: "create" | "write" | "flush") => void;
+export type DeleteFault = (path: string) => void;
+export type TransferLimit = (path: string, operation: "read" | "write", requestedBytes: number, at: number) => number | undefined;
 export declare class MemoryOpfs {
     #private;
     /** The tree's root, shaped like `navigator.storage.getDirectory()`'s result. */
     get root(): FileSystemDirectoryHandle;
     /** Installs (or clears, with `null`) a fault thrown from inside write paths. */
     setWriteFault(fault: WriteFault | null): void;
+    /** Installs a fault at file/directory removal, for post-commit cleanup tests. */
+    setDeleteFault(fault: DeleteFault | null): void;
+    /** Limits individual sync-handle transfers so tests can deterministically exercise short I/O. */
+    setTransferLimit(limit: TransferLimit | null): void;
     maybeFault(path: string, phase: "create" | "write" | "flush"): void;
+    maybeDeleteFault(path: string): void;
+    limitTransfer(path: string, operation: "read" | "write", requestedBytes: number, at: number): number;
     /** Test-side peek: the file's current bytes, or undefined. Bypasses locks on purpose. */
     readFileBytes(path: string): Uint8Array | undefined;
     /** Test-side poke: writes bytes directly, creating parents. Bypasses locks on purpose. */
     writeFileBytes(path: string, bytes: Uint8Array): void;
+    /** Test-side in-place corruption: existing sync handles observe the changed byte. */
+    corruptFileByte(path: string, offset: number): void;
 }
-//# sourceMappingURL=opfs-shim.d.ts.map

package/dist/testing/opfs-shim.js

@@ -12,8 +12,9 @@
  *   `InvalidModificationError`, `NoModificationAllowedError`, and injected
  *   `QuotaExceededError`s are actual `DOMException`s, since error identity is part of the
  *   storage contract.
- * - **Injectable write faults.** `setWriteFault` throws from inside sync writes, creates, or
- *   flushes — how the quota and crash suites produce a failure at an exact byte boundary.
+ * - **Injectable write faults and short transfers.** `setWriteFault` throws from inside sync
+ *   writes, creates, or flushes; `setTransferLimit` makes reads or writes return any valid short
+ *   byte count, including zero progress, at deterministic offsets.
  *
  * For applications, `MemoryBlockStore` remains the right store in Node tests. This shim is for
  * adapter authors: it hosts `OpfsBlockStore` (pass `root`) or anything built on the storage
@@ -22,6 +23,8 @@
 export class MemoryOpfs {
     #rootNode = { kind: "directory", name: "", children: new Map() };
     #writeFault = null;
+    #deleteFault = null;
+    #transferLimit = null;
     /** The tree's root, shaped like `navigator.storage.getDirectory()`'s result. */
     get root() {
         return new ShimDirectoryHandle(this, this.#rootNode, "");
@@ -30,9 +33,27 @@ export class MemoryOpfs {
     setWriteFault(fault) {
         this.#writeFault = fault;
     }
+    /** Installs a fault at file/directory removal, for post-commit cleanup tests. */
+    setDeleteFault(fault) {
+        this.#deleteFault = fault;
+    }
+    /** Limits individual sync-handle transfers so tests can deterministically exercise short I/O. */
+    setTransferLimit(limit) {
+        this.#transferLimit = limit;
+    }
     maybeFault(path, phase) {
         this.#writeFault?.(path, phase);
     }
+    maybeDeleteFault(path) {
+        this.#deleteFault?.(path);
+    }
+    limitTransfer(path, operation, requestedBytes, at) {
+        const limited = this.#transferLimit?.(path, operation, requestedBytes, at) ?? requestedBytes;
+        if (!Number.isSafeInteger(limited) || limited < 0 || limited > requestedBytes) {
+            throw new RangeError(`Invalid test transfer limit ${String(limited)} for ${String(requestedBytes)} requested bytes`);
+        }
+        return limited;
+    }
     /** Test-side peek: the file's current bytes, or undefined. Bypasses locks on purpose. */
     readFileBytes(path) {
         const node = this.#find(path);
@@ -65,6 +86,16 @@ export class MemoryOpfs {
             lockHolder: existing?.lockHolder ?? null,
         });
     }
+    /** Test-side in-place corruption: existing sync handles observe the changed byte. */
+    corruptFileByte(path, offset) {
+        const node = this.#find(path);
+        if (node?.kind !== "file")
+            throw new Error(`Not a file: ${path}`);
+        if (!Number.isSafeInteger(offset) || offset < 0 || offset >= node.bytes.byteLength) {
+            throw new RangeError(`Invalid corruption offset ${String(offset)} for ${path}`);
+        }
+        node.bytes[offset] = (node.bytes[offset] ?? 0) ^ 0xff;
+    }
     #find(path) {
         let node = this.#rootNode;
         for (const segment of path.split("/").filter((segment) => segment.length > 0)) {
@@ -138,6 +169,7 @@ class ShimDirectoryHandle {
         const existing = this.#node.children.get(name);
         if (existing === undefined)
             throw notFound(name);
+        this.#shim.maybeDeleteFault(this.#childPath(name));
         if (existing.kind === "file") {
             if (existing.lockHolder !== null)
                 throw locked(name);
@@ -251,7 +283,8 @@ class ShimSyncAccessHandle {
         this.#assertOpen();
         const at = options?.at ?? 0;
         const target = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        const source = this.#node.bytes.subarray(at, at + target.byteLength);
+        const limit = this.#shim.limitTransfer(this.#path, "read", target.byteLength, at);
+        const source = this.#node.bytes.subarray(at, at + limit);
         target.set(source);
         return source.byteLength;
     }
@@ -259,9 +292,11 @@ class ShimSyncAccessHandle {
         this.#assertOpen();
         this.#shim.maybeFault(this.#path, "write");
         const at = options?.at ?? 0;
-        const source = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        const requested = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        const limit = this.#shim.limitTransfer(this.#path, "write", requested.byteLength, at);
+        const source = requested.subarray(0, limit);
         const end = at + source.byteLength;
-        if (end > this.#node.bytes.byteLength) {
+        if (source.byteLength > 0 && end > this.#node.bytes.byteLength) {
             const grown = new Uint8Array(end);
             grown.set(this.#node.bytes);
             this.#node.bytes = grown;
@@ -292,4 +327,3 @@ class ShimSyncAccessHandle {
             this.#node.lockHolder = null;
     }
 }
-//# sourceMappingURL=opfs-shim.js.map

package/dist/testing/simulator.d.ts

@@ -0,0 +1,97 @@
+import { type BlockStore } from "../storage/index.js";
+import { type FaultPoint } from "./index.js";
+export interface SimulationPut {
+    readonly kind: "put";
+    readonly client: number;
+    readonly key: number;
+    readonly amount: number;
+}
+export interface SimulationDelete {
+    readonly kind: "delete";
+    readonly client: number;
+    readonly key: number;
+}
+export type SimulationMutation = SimulationPut | SimulationDelete;
+export type SimulationStep = {
+    readonly kind: "concurrent";
+    readonly operations: readonly SimulationMutation[];
+} | {
+    readonly kind: "checkpoint";
+} | {
+    readonly kind: "maintenance";
+} | {
+    readonly kind: "fault";
+    readonly point: FaultPoint;
+    readonly occurrence: number;
+    readonly operation: SimulationMutation;
+};
+export interface SimulationPlan {
+    readonly version: 1;
+    readonly seed: number;
+    readonly clients: number;
+    readonly keySpace: number;
+    readonly steps: readonly SimulationStep[];
+}
+export interface SimulationTraceEvent {
+    readonly sequence: number;
+    readonly operation: string;
+    readonly outcome: "resolved" | "rejected";
+}
+export interface SimulationResult {
+    readonly seed: number;
+    readonly acceptedMutations: number;
+    readonly rejectedConflicts: number;
+    readonly injectedFaults: number;
+    readonly checkpoints: number;
+    readonly maintenanceCompactions: number;
+    readonly compactionStop: string;
+    readonly collectionPasses: number;
+    readonly collectionTail: readonly CollectionPassSummary[];
+    readonly rows: ReadonlyArray<{
+        readonly id: number;
+        readonly client: number;
+        readonly amount: number;
+    }>;
+    readonly blockCount: number;
+    readonly segmentCount: number;
+    readonly transactionCount: number;
+    readonly manifestCount: number;
+    readonly leaseCount: number;
+    readonly storageBytes: number;
+    readonly schedulerHighWater: number;
+    readonly trace: readonly SimulationTraceEvent[];
+    readonly traceDigest: string;
+}
+export interface SimulationOptions {
+    /** Bounded diagnostic tail; old events are evicted as the simulator runs. */
+    readonly traceEvents?: number;
+}
+export interface CollectionPassSummary {
+    readonly prunedManifests: number;
+    readonly retainedManifests: number;
+    readonly reclaimedSegments: number;
+    readonly retainedSegments: number;
+    readonly reclaimedBlocks: number;
+    readonly retainedBlocks: number;
+    readonly reclaimedTransactions: number;
+    readonly retainedTransactions: number;
+}
+/** Chooses every storage completion from a seeded queue and keeps only a bounded trace tail. */
+export declare class DeterministicScheduler {
+    #private;
+    constructor(seed: number, traceLimit?: number);
+    get highWater(): number;
+    get trace(): readonly SimulationTraceEvent[];
+    schedule<T>(label: string, run: () => Promise<T>): Promise<T>;
+    settle<T>(promises: ReadonlyArray<Promise<T>>): Promise<Array<PromiseSettledResult<T>>>;
+}
+/** Wraps every asynchronous BlockStore entry point in the deterministic completion scheduler. */
+export declare function scheduledBlockStore(store: BlockStore, scheduler: DeterministicScheduler): BlockStore;
+export declare function generateSimulationPlan(seed: number, options?: {
+    readonly rounds?: number;
+    readonly clients?: number;
+    readonly keySpace?: number;
+}): SimulationPlan;
+export declare function parseSimulationPlan(source: string): SimulationPlan;
+/** Runs a replayable state-machine plan through production SQL, transactions, and block storage. */
+export declare function runSimulation(plan: SimulationPlan, options?: SimulationOptions): Promise<SimulationResult>;