sliftutils 1.2.39 → 1.3.1

package/.claude/settings.local.json

@@ -1,7 +1,11 @@
 {
   "permissions": {
     "allow": [
-      "WebFetch(domain:openrouter.ai)"
+      "WebFetch(domain:openrouter.ai)",
+      "Bash(git pull *)",
+      "Bash(echo \"---EXIT:$?---\")",
+      "Bash(yarn publish *)",
+      "Bash(git push *)"
     ]
   }
 }

package/index.d.ts

@@ -55,6 +55,7 @@ declare module "sliftutils/misc/getSecret" {
         getAllKeys(): string[];
         get(key: string): Promise<string> | undefined;
     };
+    export declare function setSecret(key: string, value: string): void;
 
 }
 
@@ -714,6 +715,7 @@ declare module "sliftutils/render-utils/colors" {
 }
 
 declare module "sliftutils/render-utils/mobxTyped" {
+    export { observable, runInAction, computed, autorun } from "mobx";
     export declare function configureMobxNextFrameScheduler(): void;
 
 }
@@ -760,6 +762,320 @@ declare module "sliftutils/render-utils/observer" {
 
 }
 
+declare module "sliftutils/storage/BulkDatabase2/BulkDatabase2" {
+    import { BulkDatabaseBase } from "./BulkDatabaseBase";
+    export { BulkDatabaseBase, noopReactiveDeps, bulkDatabase2Timing } from "./BulkDatabaseBase";
+    export type { ReactiveDeps, StorageFactory } from "./BulkDatabaseBase";
+    /** Per-column on-disk size info, as reported by getColumnInfo/getReaderInfo. */
+    export type BulkColumnInfo = {
+        column: string;
+        byteSize: number;
+    };
+    /** A snapshot of the collection's shape (no row data), as reported by getReaderInfo. */
+    export type BulkReaderInfo = {
+        rowCount: number;
+        totalBytes: number;
+        keyCount: number;
+        sampleKey: string | undefined;
+        columns: BulkColumnInfo[];
+    };
+    /**
+     * The full public API of BulkDatabase2 (the static `clearCache()` aside). BulkDatabase2 implements
+     * this; an application that just wants to depend on the surface can type against this interface instead
+     * of reading the implementation. `T` is the row type and must have a string `key`.
+     *
+     * Reads resolve every key/column by the latest write-time across all storage tiers. Writes are
+     * column-merges: a write/update only changes the columns it includes; columns it omits keep their
+     * previous value (clear a column by writing it as `undefined`).
+     */
+    export interface IBulkDatabase2<T extends {
+        key: string;
+    }> {
+        /** The collection name (its folder under the storage root). */
+        readonly name: string;
+        /** Write one full row (merging its columns onto any existing row for the key). */
+        write(entry: T): Promise<void>;
+        /** Write many full rows in one batch. */
+        writeBatch(entries: T[]): Promise<void>;
+        /** Update only the given columns of an existing key (key required). Warns and no-ops if the key isn't present. */
+        update(entry: Partial<T> & {
+            key: string;
+        }): Promise<void>;
+        /** Update many keys' partial columns in one batch. */
+        updateBatch(entries: (Partial<T> & {
+            key: string;
+        })[]): Promise<void>;
+        /** Delete a key. */
+        delete(key: string): Promise<void>;
+        /** Delete many keys in one batch. */
+        deleteBatch(keys: string[]): Promise<void>;
+        /** All live keys. */
+        getKeys(): Promise<string[]>;
+        /** One field's value for a key, or undefined if the key/column isn't set or the key is deleted. */
+        getSingleField<Column extends keyof T>(key: string, column: Column): Promise<T[Column] | undefined>;
+        /** A whole column as {key, value} for every live key. */
+        getColumn<Column extends keyof T>(column: Column): Promise<{
+            key: string;
+            value: T[Column];
+        }[]>;
+        /**
+         * Synchronous, reactive read of one field. Returns undefined while the base value is still loading
+         * (and re-renders once it arrives, under a mobx observer); reflects pending writes immediately.
+         */
+        getSingleFieldSync<Column extends keyof T>(key: string, column: Column): T[Column] | undefined;
+        /** Synchronous, reactive read of a whole column. undefined while still loading. */
+        getColumnSync<Column extends keyof T>(column: Column): {
+            key: string;
+            value: T[Column];
+        }[] | undefined;
+        /** The columns present on disk and their byte sizes (no row data read). */
+        getColumnInfo(): Promise<BulkColumnInfo[]>;
+        /** A cheap snapshot of the collection's shape (row/key counts, total bytes, columns) — no row data. */
+        getReaderInfo(): Promise<BulkReaderInfo>;
+        /** Consolidate on-disk files. Optional to call; the database also does this in the background. */
+        compact(): Promise<void>;
+    }
+    export declare class BulkDatabase2<T extends {
+        key: string;
+    }> extends BulkDatabaseBase<T> implements IBulkDatabase2<T> {
+        constructor(name: string);
+    }
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/BulkDatabaseBase" {
+    import type { FileStorage } from "../FileFolderAPI";
+    export declare const bulkDatabase2Timing: {
+        streamSealAgeMs: number;
+        foldDataAgeMs: number;
+        foldTriggerAgeMs: number;
+        foldCheckIntervalMs: number;
+        cleanupAgeMs: number;
+        cleanupIntervalMs: number;
+    };
+    export interface ReactiveDeps {
+        observe(signal: string): void;
+        invalidate(signal: string): void;
+        batch(fn: () => void): void;
+    }
+    export declare const noopReactiveDeps: ReactiveDeps;
+    export type StorageFactory = (path: string) => Promise<FileStorage>;
+    export declare class BulkDatabaseBase<T extends {
+        key: string;
+    }> {
+        readonly name: string;
+        protected deps: ReactiveDeps;
+        private storageFactory;
+        constructor(name: string, deps: ReactiveDeps, storageFactory: StorageFactory);
+        static clearCache(): void;
+        storage: {
+            (): Promise<FileStorage>;
+            reset(): void;
+            set(newValue: Promise<FileStorage>): void;
+        };
+        private overlay;
+        private streamTimes;
+        private streamFileName;
+        private lastCleanup;
+        private lastFoldCheck;
+        private getStreamFileName;
+        private invalidateOverlay;
+        private setOverlayRow;
+        private setOverlayDeleted;
+        private reader;
+        private syncSetup;
+        private localTime;
+        private applyRemote;
+        private resetReader;
+        write(entry: T): Promise<void>;
+        writeBatch(entries: T[]): Promise<void>;
+        delete(key: string): Promise<void>;
+        deleteBatch(keys: string[]): Promise<void>;
+        update(entry: Partial<T> & {
+            key: string;
+        }): Promise<void>;
+        updateBatch(entries: (Partial<T> & {
+            key: string;
+        })[]): Promise<void>;
+        private getValidFiles;
+        private commitManifest;
+        private writeBulkFile;
+        private consolidate;
+        private loadStreamEntries;
+        private orderStreamEntries;
+        private maybeRolloverStream;
+        compact(): Promise<void>;
+        private makeRawGetRange;
+        private loadFileReader;
+        private fileLogicalSize;
+        private handleUnreadableFile;
+        private mergeFilesBase;
+        private mergeFiles;
+        private mergeFilesLocked;
+        private cleanup;
+        private formatInfo;
+        private patchColumn;
+        getSingleField<Column extends keyof T>(key: string, column: Column): Promise<T[Column] | undefined>;
+        getColumn<Column extends keyof T>(column: Column): Promise<{
+            key: string;
+            value: T[Column];
+        }[]>;
+        getKeys(): Promise<string[]>;
+        private baseColumns;
+        private baseColumnsLoading;
+        private baseFields;
+        private baseFieldsLoading;
+        private ensureBaseColumn;
+        private ensureBaseField;
+        getSingleFieldSync<Column extends keyof T>(key: string, column: Column): T[Column] | undefined;
+        getColumnSync<Column extends keyof T>(column: Column): {
+            key: string;
+            value: T[Column];
+        }[] | undefined;
+        getColumnInfo(): Promise<{
+            column: string;
+            byteSize: number;
+        }[]>;
+        getReaderInfo(): Promise<{
+            rowCount: number;
+            totalBytes: number;
+            keyCount: number;
+            sampleKey: string | undefined;
+            columns: {
+                column: string;
+                byteSize: number;
+            }[];
+        }>;
+    }
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/BulkDatabaseFormat" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export declare const KEY_COLUMN = "key";
+    export declare const EMPTY_BUFFER: Buffer;
+    export declare const ABSENT: unique symbol;
+    export declare function buildFileBuffer(rows: Record<string, unknown>[], times: number[]): Buffer[];
+    export type BaseBulkDatabaseReader = {
+        rowCount: number;
+        totalBytes: number;
+        minTime: number;
+        maxTime: number;
+        keys: string[];
+        columns: {
+            column: string;
+            byteSize: number;
+        }[];
+        keyTimes: Map<string, number>;
+        deleteTimes?: Map<string, number>;
+        getColumn: (column: string) => Promise<{
+            key: string;
+            value: unknown;
+            time: number;
+        }[]>;
+        getSingleField: (key: string, column: string) => Promise<{
+            value: unknown;
+            time: number;
+        } | typeof ABSENT>;
+    };
+    export declare function loadBulkDatabase(config: {
+        totalBytes: number;
+        getRange: (start: number, end: number) => Promise<Buffer>;
+    }): Promise<BaseBulkDatabaseReader>;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/blockCache" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export type GetRange = (start: number, end: number) => Promise<Buffer>;
+    export declare function encodeCompressedBlocks(data: Buffer): Buffer;
+    export declare class BlockCache {
+        private blocks;
+        private indexes;
+        clear(): void;
+        private touch;
+        private readIndex;
+        open(fileId: string, fileSize: number, rawGetRange: GetRange): Promise<{
+            uncompressedSize: number;
+            getRange: GetRange;
+        }>;
+        private makeGetRange;
+    }
+    export declare const blockCache: BlockCache;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/manifest" {
+    export declare const MANIFEST_EXTENSION = ".manifest";
+    export type Manifest = {
+        startTime: number;
+        validBulkFiles: string[];
+        ignoredStreamFiles: string[];
+        readFiles: string[];
+    };
+    export declare function isManifestName(name: string): boolean;
+    export declare function manifestFileName(startTime: number, writerId: string, counter: number): string;
+    export declare function parseManifestStartTime(name: string): number | undefined;
+    export declare function chooseManifest(manifests: {
+        name: string;
+        manifest: Manifest;
+    }[]): {
+        name: string;
+        manifest: Manifest;
+    } | undefined;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/mergeLock" {
+    export declare function tryAcquireMergeLock(collection: string, holderId: string): boolean;
+    export declare function releaseMergeLock(collection: string, holderId: string): void;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/streamLog" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { BaseBulkDatabaseReader } from "./BulkDatabaseFormat";
+    export declare const STREAM_EXTENSION = ".stream";
+    export type StreamEntry = {
+        time: number;
+        row?: Record<string, unknown>;
+        deletedKey?: string;
+    };
+    export declare function frameRows(entries: {
+        time: number;
+        row: Record<string, unknown>;
+    }[]): Buffer;
+    export declare function frameDeletes(entries: {
+        time: number;
+        key: string;
+    }[]): Buffer;
+    export declare function parseStream(buffer: Buffer): {
+        entries: StreamEntry[];
+        badBytes: number;
+    };
+    export declare function streamReaderFromEntries(entries: StreamEntry[], totalBytes: number): {
+        reader: BaseBulkDatabaseReader;
+        times: Map<string, number>;
+    };
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/syncClient" {
+    export type RemoteWrite = {
+        key: string;
+        time: number;
+        deleted?: boolean;
+        value?: unknown;
+    };
+    export declare function isSyncSupported(): boolean;
+    export declare function connect(collection: string, onWrite: (write: RemoteWrite) => void): Promise<RemoteWrite[]>;
+    export declare function broadcast(collection: string, write: RemoteWrite): void;
+
+}
+
 declare module "sliftutils/storage/CBORStorage" {
     /// <reference types="node" />
     /// <reference types="node" />
@@ -815,6 +1131,8 @@ declare module "sliftutils/storage/DiskCollection" {
     export declare class DiskCollection<T> implements IStorageSync<T> {
         private collectionName;
         private config?;
+        static getForceNoPrompt(): boolean;
+        static setForceNoPrompt(forceNoPrompt: boolean): void;
         constructor(collectionName: string, config?: {
             writeDelay?: number | undefined;
             cbor?: boolean | undefined;
@@ -984,6 +1302,52 @@ declare module "sliftutils/storage/FileFolderAPI" {
         ]>;
     };
     export declare function setFileAPIKey(key: string): void;
+    export declare class NodeJSFileHandleWrapper implements FileWrapper {
+        private filePath;
+        constructor(filePath: string);
+        getFile(): Promise<{
+            size: number;
+            lastModified: number;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            slice: (start: number, end: number) => {
+                arrayBuffer: () => Promise<ArrayBuffer>;
+            };
+        }>;
+        createWritable(config?: {
+            keepExistingData?: boolean;
+        }): Promise<{
+            seek: (offset: number) => Promise<void>;
+            write: (value: Buffer) => Promise<void>;
+            close: () => Promise<void>;
+        }>;
+    }
+    export declare class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
+        private rootPath;
+        constructor(rootPath: string);
+        removeEntry(key: string, options?: {
+            recursive?: boolean;
+        }): Promise<void>;
+        getFileHandle(key: string, options?: {
+            create?: boolean;
+        }): Promise<FileWrapper>;
+        getDirectoryHandle(key: string, options?: {
+            create?: boolean;
+        }): Promise<DirectoryWrapper>;
+        [Symbol.asyncIterator](): AsyncIterableIterator<[
+            string,
+            {
+                kind: "file";
+                name: string;
+                getFile(): Promise<FileWrapper>;
+            } | {
+                kind: "directory";
+                name: string;
+                getDirectoryHandle(key: string, options?: {
+                    create?: boolean;
+                }): Promise<DirectoryWrapper>;
+            }
+        ]>;
+    }
     export declare const getDirectoryHandle: {
         (): Promise<DirectoryWrapper>;
         reset(): void;
@@ -997,6 +1361,14 @@ declare module "sliftutils/storage/FileFolderAPI" {
         getAllKeys(): string[];
         get(key: string): Promise<FileStorage> | undefined;
     };
+    export declare const getFileStorageNested2: {
+        (key: string): Promise<FileStorage>;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: Promise<FileStorage>): void;
+        getAllKeys(): string[];
+        get(key: string): Promise<FileStorage> | undefined;
+    };
     export declare const getFileStorage: {
         (): Promise<FileStorage>;
         reset(): void;
@@ -1012,6 +1384,8 @@ declare module "sliftutils/storage/FileFolderAPI" {
     export type FileStorage = IStorageRaw & {
         folder: NestedFileStorage;
     };
+    export declare function wrapHandle(handle: DirectoryWrapper): FileStorage;
+    export declare function tryToLoadPointer(pointer: string): Promise<DirectoryWrapper | undefined>;
     export {};
 
 }

package/misc/getSecret.d.ts

@@ -7,3 +7,4 @@ export declare const getSecret: {
     getAllKeys(): string[];
     get(key: string): Promise<string> | undefined;
 };
+export declare function setSecret(key: string, value: string): void;

package/misc/getSecret.ts

@@ -96,3 +96,10 @@ export const getSecret = cache(async function getSecret(key: string): Promise<st
         });
     });
 });
+
+export function setSecret(key: string, value: string) {
+    if (isNode()) {
+        throw new Error("setSecret is only supported in the browser. We don't want to break the user's file system with setSecret in NodeJS.");
+    }
+    localStorage.setItem(getStorageKey(key), value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.2.39",
+    "version": "1.3.1",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -51,7 +51,7 @@
         "mobx": "^6.13.3",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.1.30",
+        "socket-function": "^1.1.42",
         "typenode": "*",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/render-utils/mobxTyped.d.ts

@@ -1 +1,2 @@
+export { observable, runInAction, computed, autorun } from "mobx";
 export declare function configureMobxNextFrameScheduler(): void;

package/render-utils/mobxTyped.ts

@@ -1,5 +1,9 @@
 import * as mobx from "mobx";
 import { batchFunction } from "socket-function/src/batching";
+
+// Re-export the core mobx primitives so downstream packages (which may have their own duplicate mobx
+// in node_modules) can share THIS mobx instance, otherwise reactivity doesn't cross package boundaries.
+export { observable, runInAction, computed, autorun } from "mobx";
 export function configureMobxNextFrameScheduler() {
     // NOTE: This makes a big difference if we do await calls in a loop which mutates observable state. BUT... we should probably just do those await calls before the loop?
     let batchReactionScheduler = batchFunction({

package/storage/BulkDatabase2/BulkDatabase2.d.ts

@@ -0,0 +1,77 @@
+import { BulkDatabaseBase } from "./BulkDatabaseBase";
+export { BulkDatabaseBase, noopReactiveDeps, bulkDatabase2Timing } from "./BulkDatabaseBase";
+export type { ReactiveDeps, StorageFactory } from "./BulkDatabaseBase";
+/** Per-column on-disk size info, as reported by getColumnInfo/getReaderInfo. */
+export type BulkColumnInfo = {
+    column: string;
+    byteSize: number;
+};
+/** A snapshot of the collection's shape (no row data), as reported by getReaderInfo. */
+export type BulkReaderInfo = {
+    rowCount: number;
+    totalBytes: number;
+    keyCount: number;
+    sampleKey: string | undefined;
+    columns: BulkColumnInfo[];
+};
+/**
+ * The full public API of BulkDatabase2 (the static `clearCache()` aside). BulkDatabase2 implements
+ * this; an application that just wants to depend on the surface can type against this interface instead
+ * of reading the implementation. `T` is the row type and must have a string `key`.
+ *
+ * Reads resolve every key/column by the latest write-time across all storage tiers. Writes are
+ * column-merges: a write/update only changes the columns it includes; columns it omits keep their
+ * previous value (clear a column by writing it as `undefined`).
+ */
+export interface IBulkDatabase2<T extends {
+    key: string;
+}> {
+    /** The collection name (its folder under the storage root). */
+    readonly name: string;
+    /** Write one full row (merging its columns onto any existing row for the key). */
+    write(entry: T): Promise<void>;
+    /** Write many full rows in one batch. */
+    writeBatch(entries: T[]): Promise<void>;
+    /** Update only the given columns of an existing key (key required). Warns and no-ops if the key isn't present. */
+    update(entry: Partial<T> & {
+        key: string;
+    }): Promise<void>;
+    /** Update many keys' partial columns in one batch. */
+    updateBatch(entries: (Partial<T> & {
+        key: string;
+    })[]): Promise<void>;
+    /** Delete a key. */
+    delete(key: string): Promise<void>;
+    /** Delete many keys in one batch. */
+    deleteBatch(keys: string[]): Promise<void>;
+    /** All live keys. */
+    getKeys(): Promise<string[]>;
+    /** One field's value for a key, or undefined if the key/column isn't set or the key is deleted. */
+    getSingleField<Column extends keyof T>(key: string, column: Column): Promise<T[Column] | undefined>;
+    /** A whole column as {key, value} for every live key. */
+    getColumn<Column extends keyof T>(column: Column): Promise<{
+        key: string;
+        value: T[Column];
+    }[]>;
+    /**
+     * Synchronous, reactive read of one field. Returns undefined while the base value is still loading
+     * (and re-renders once it arrives, under a mobx observer); reflects pending writes immediately.
+     */
+    getSingleFieldSync<Column extends keyof T>(key: string, column: Column): T[Column] | undefined;
+    /** Synchronous, reactive read of a whole column. undefined while still loading. */
+    getColumnSync<Column extends keyof T>(column: Column): {
+        key: string;
+        value: T[Column];
+    }[] | undefined;
+    /** The columns present on disk and their byte sizes (no row data read). */
+    getColumnInfo(): Promise<BulkColumnInfo[]>;
+    /** A cheap snapshot of the collection's shape (row/key counts, total bytes, columns) — no row data. */
+    getReaderInfo(): Promise<BulkReaderInfo>;
+    /** Consolidate on-disk files. Optional to call; the database also does this in the background. */
+    compact(): Promise<void>;
+}
+export declare class BulkDatabase2<T extends {
+    key: string;
+}> extends BulkDatabaseBase<T> implements IBulkDatabase2<T> {
+    constructor(name: string);
+}

package/storage/BulkDatabase2/BulkDatabase2.ts

@@ -0,0 +1,103 @@
+import { getFileStorageNested2 } from "../FileFolderAPI";
+import { observable, runInAction } from "../../render-utils/mobxTyped";
+import { BulkDatabaseBase, ReactiveDeps } from "./BulkDatabaseBase";
+
+export { BulkDatabaseBase, noopReactiveDeps, bulkDatabase2Timing } from "./BulkDatabaseBase";
+export type { ReactiveDeps, StorageFactory } from "./BulkDatabaseBase";
+
+/** Per-column on-disk size info, as reported by getColumnInfo/getReaderInfo. */
+export type BulkColumnInfo = { column: string; byteSize: number };
+
+/** A snapshot of the collection's shape (no row data), as reported by getReaderInfo. */
+export type BulkReaderInfo = {
+    rowCount: number;
+    totalBytes: number;
+    keyCount: number;
+    sampleKey: string | undefined;
+    columns: BulkColumnInfo[];
+};
+
+/**
+ * The full public API of BulkDatabase2 (the static `clearCache()` aside). BulkDatabase2 implements
+ * this; an application that just wants to depend on the surface can type against this interface instead
+ * of reading the implementation. `T` is the row type and must have a string `key`.
+ *
+ * Reads resolve every key/column by the latest write-time across all storage tiers. Writes are
+ * column-merges: a write/update only changes the columns it includes; columns it omits keep their
+ * previous value (clear a column by writing it as `undefined`).
+ */
+export interface IBulkDatabase2<T extends { key: string }> {
+    /** The collection name (its folder under the storage root). */
+    readonly name: string;
+
+    /** Write one full row (merging its columns onto any existing row for the key). */
+    write(entry: T): Promise<void>;
+    /** Write many full rows in one batch. */
+    writeBatch(entries: T[]): Promise<void>;
+    /** Update only the given columns of an existing key (key required). Warns and no-ops if the key isn't present. */
+    update(entry: Partial<T> & { key: string }): Promise<void>;
+    /** Update many keys' partial columns in one batch. */
+    updateBatch(entries: (Partial<T> & { key: string })[]): Promise<void>;
+    /** Delete a key. */
+    delete(key: string): Promise<void>;
+    /** Delete many keys in one batch. */
+    deleteBatch(keys: string[]): Promise<void>;
+
+    /** All live keys. */
+    getKeys(): Promise<string[]>;
+    /** One field's value for a key, or undefined if the key/column isn't set or the key is deleted. */
+    getSingleField<Column extends keyof T>(key: string, column: Column): Promise<T[Column] | undefined>;
+    /** A whole column as {key, value} for every live key. */
+    getColumn<Column extends keyof T>(column: Column): Promise<{ key: string; value: T[Column] }[]>;
+
+    /**
+     * Synchronous, reactive read of one field. Returns undefined while the base value is still loading
+     * (and re-renders once it arrives, under a mobx observer); reflects pending writes immediately.
+     */
+    getSingleFieldSync<Column extends keyof T>(key: string, column: Column): T[Column] | undefined;
+    /** Synchronous, reactive read of a whole column. undefined while still loading. */
+    getColumnSync<Column extends keyof T>(column: Column): { key: string; value: T[Column] }[] | undefined;
+
+    /** The columns present on disk and their byte sizes (no row data read). */
+    getColumnInfo(): Promise<BulkColumnInfo[]>;
+    /** A cheap snapshot of the collection's shape (row/key counts, total bytes, columns) — no row data. */
+    getReaderInfo(): Promise<BulkReaderInfo>;
+
+    /** Consolidate on-disk files. Optional to call; the database also does this in the background. */
+    compact(): Promise<void>;
+}
+
+// mobx-backed reactivity: each signal string gets its own observable box. observe() reads it (so an
+// observer/autorun that calls it tracks that box) and invalidate() bumps it (so those reactions re-run).
+// This reproduces the fine-grained per-key + load-version reactivity the class had when it used
+// observable.map/observable.box directly, while keeping all that logic in the mobx-free base.
+class MobxReactiveDeps implements ReactiveDeps {
+    private boxes = new Map<string, { get(): number; set(value: number): void }>();
+    private box(signal: string) {
+        let box = this.boxes.get(signal);
+        if (!box) {
+            box = observable.box(0);
+            this.boxes.set(signal, box);
+        }
+        return box;
+    }
+    observe(signal: string) {
+        this.box(signal).get();
+    }
+    invalidate(signal: string) {
+        let box = this.box(signal);
+        box.set(box.get() + 1);
+    }
+    batch(fn: () => void) {
+        runInAction(fn);
+    }
+}
+
+// Backwards-compatible BulkDatabase2: the mobx-reactive flavor. All behavior lives in BulkDatabaseBase;
+// this just supplies mobx reactivity and the default (getFileStorageNested2) storage backend, so the
+// sync reads (getSingleFieldSync / getColumnSync) stay observable for mobx components.
+export class BulkDatabase2<T extends { key: string }> extends BulkDatabaseBase<T> implements IBulkDatabase2<T> {
+    constructor(name: string) {
+        super(name, new MobxReactiveDeps(), getFileStorageNested2);
+    }
+}