@fireproof/core 0.18.0 → 0.19.0-dev-use-fix

package/index.d.cts

@@ -0,0 +1,1012 @@
+import { Result, Logger, ResolveOnce, EnvImpl } from '@adviser/cement';
+export { Logger } from '@adviser/cement';
+import { EventLink } from '@web3-storage/pail/clock/api';
+import { Operation } from '@web3-storage/pail/crdt/api';
+import { Version, Block, Link } from 'multiformats';
+import { ToString } from '@ipld/dag-json';
+import { CarReader } from '@ipld/car';
+import { MemoryBlockstore } from '@web3-storage/pail/block';
+import { BlockFetcher as BlockFetcher$1 } from '@web3-storage/pail/api';
+import { ProllyNode as ProllyNode$1 } from 'prolly-trees/db-index';
+import { EventBlock } from '@web3-storage/pail/clock';
+import { PathLike, MakeDirectoryOptions, Stats, ObjectEncodingOptions, Dirent } from 'node:fs';
+import { RunResult } from 'better-sqlite3';
+
+interface GatewayOpts {
+    readonly gateway: Gateway;
+}
+declare class NotFoundError extends Error {
+    readonly code = "ENOENT";
+}
+declare function isNotFoundError(e: Error | Result<unknown> | unknown): e is NotFoundError;
+type GetResult = Result<Uint8Array, NotFoundError | Error>;
+type VoidResult = Result<void>;
+interface Gateway {
+    buildUrl(baseUrl: URL, key: string): Promise<Result<URL>>;
+    start(baseUrl: URL): Promise<VoidResult>;
+    close(baseUrl: URL): Promise<VoidResult>;
+    destroy(baseUrl: URL): Promise<VoidResult>;
+    put(url: URL, body: Uint8Array): Promise<VoidResult>;
+    get(url: URL): Promise<GetResult>;
+    delete(url: URL): Promise<VoidResult>;
+}
+
+type BlockFetcher = BlockFetcher$1;
+declare class CarTransaction extends MemoryBlockstore implements CarMakeable {
+    readonly parent: BaseBlockstore;
+    constructor(parent: BaseBlockstore, opts?: {
+        add: boolean;
+    });
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block<T, C, A, V> | undefined>;
+    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
+}
+declare class BaseBlockstore implements BlockFetcher {
+    readonly transactions: Set<CarTransaction>;
+    readonly ebOpts: BlockstoreRuntime;
+    readonly loader?: Loader;
+    readonly name?: string;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    readonly logger: Logger;
+    constructor(ebOpts?: BlockstoreOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block<T, C, A, V> | undefined>;
+    put(cid: AnyAnyLink, block: Uint8Array): Promise<void>;
+    lastTxMeta?: unknown;
+    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, _opts?: {}): Promise<TransactionWrapper<M>>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class EncryptedBlockstore extends BaseBlockstore {
+    readonly name: string;
+    readonly loader: Loader;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    compacting: boolean;
+    readonly logger: Logger;
+    constructor(ebOpts: BlockstoreOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block<T, C, A, V> | undefined>;
+    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, opts?: {
+        noLoader: boolean;
+    }): Promise<TransactionWrapper<M>>;
+    getFile(car: AnyLink, cid: AnyLink, isPublic?: boolean): Promise<Uint8Array>;
+    compact(): Promise<void>;
+    defaultCompact(blocks: CompactionFetcher, logger: Logger): Promise<TransactionMeta>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class CompactionFetcher implements BlockFetcher {
+    blockstore: EncryptedBlockstore;
+    loggedBlocks: CarTransaction;
+    constructor(blocks: EncryptedBlockstore);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block<T, C, A, V> | undefined>;
+}
+type CompactFn = (blocks: CompactionFetcher) => Promise<TransactionMeta>;
+interface BlockstoreOpts {
+    readonly logger?: Logger;
+    readonly applyMeta?: (meta: TransactionMeta, snap?: boolean) => Promise<void>;
+    readonly compact?: CompactFn;
+    readonly autoCompact?: number;
+    readonly crypto?: CryptoOpts;
+    readonly store?: StoreOpts;
+    readonly public?: boolean;
+    readonly meta?: DbMeta;
+    readonly name?: string;
+    readonly threshold?: number;
+}
+interface BlockstoreRuntime {
+    readonly logger: Logger;
+    readonly applyMeta: (meta: TransactionMeta, snap?: boolean) => Promise<void>;
+    readonly compact: CompactFn;
+    readonly autoCompact: number;
+    readonly crypto: CryptoOpts;
+    readonly store: StoreOpts;
+    readonly storeRuntime: StoreRuntime;
+    readonly public: boolean;
+    readonly meta?: DbMeta;
+    readonly name?: string;
+    readonly threshold: number;
+}
+
+type QueueFunction = () => Promise<void>;
+declare class CommitQueue<T = void> {
+    readonly queue: QueueFunction[];
+    processing: boolean;
+    enqueue(fn: () => Promise<T>): Promise<T>;
+    processNext(): void;
+}
+
+type AbstractRemoteMetaStore = MetaStore & {
+    handleByteHeads(byteHeads: Uint8Array[], branch?: string): Promise<DbMeta[]>;
+};
+declare abstract class Loadable {
+    name: string;
+    abstract readonly logger: Logger;
+    abstract readonly ebOpts: BlockstoreRuntime;
+    remoteCarStore?: DataStore;
+    abstract carStore(): Promise<DataStore>;
+    carLog: CarLog;
+    remoteMetaStore?: AbstractRemoteMetaStore;
+    remoteFileStore?: DataStore;
+    abstract ready(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract fileStore(): Promise<DataStore>;
+    abstract remoteWAL(): Promise<RemoteWAL>;
+    abstract handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
+}
+declare class Loader implements Loadable {
+    readonly name: string;
+    readonly ebOpts: BlockstoreRuntime;
+    readonly commitQueue: CommitQueue<CarGroup>;
+    readonly isCompacting = false;
+    readonly carReaders: Map<string, Promise<CarReader>>;
+    readonly seenCompacted: Set<string>;
+    readonly processedCars: Set<string>;
+    carLog: CarLog;
+    key?: string;
+    keyId?: string;
+    remoteMetaStore?: AbstractRemoteMetaStore;
+    remoteCarStore?: DataStore;
+    remoteFileStore?: DataStore;
+    private getBlockCache;
+    private seenMeta;
+    private writeLimit;
+    carStore(): Promise<DataStore>;
+    fileStore(): Promise<DataStore>;
+    remoteWAL(): Promise<RemoteWAL>;
+    metaStore(): Promise<MetaStore>;
+    readonly onceReady: ResolveOnce<void, void>;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    readonly logger: Logger;
+    constructor(name: string, ebOpts: BlockstoreOpts);
+    handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
+    mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
+    protected ingestKeyFromMeta(meta: DbMeta): Promise<void>;
+    loadCarHeaderFromMeta<T>({ cars: cids }: DbMeta): Promise<CarHeader<T>>;
+    _getKey(): Promise<string | undefined>;
+    commitFiles(t: CarTransaction, done: TransactionMeta, opts?: CommitOpts): Promise<CarGroup>;
+    _commitInternalFiles(t: CarTransaction, done: TransactionMeta, opts?: CommitOpts): Promise<CarGroup>;
+    loadFileCar(cid: AnyLink, isPublic?: boolean): Promise<CarReader>;
+    commit<T = TransactionMeta>(t: CarTransaction, done: T, opts?: CommitOpts): Promise<CarGroup>;
+    cacheTransaction(t: CarTransaction): Promise<void>;
+    cacheCarReader(carCidStr: string, reader: CarReader): Promise<void>;
+    _commitInternal<T>(t: CarTransaction, done: T, opts?: CommitOpts): Promise<CarGroup>;
+    prepareCarFilesFiles(roots: AnyLink[], t: CarTransaction, isPublic: boolean): Promise<{
+        cid: AnyLink;
+        bytes: Uint8Array;
+    }[]>;
+    prepareCarFiles(rootBlock: AnyBlock, t: CarTransaction, isPublic: boolean): Promise<{
+        cid: AnyLink;
+        bytes: Uint8Array;
+    }[]>;
+    private createCarFile;
+    protected makeFileCarHeader(result: FileTransactionMeta): TransactionMeta;
+    updateCarLog<T>(cids: CarGroup, fp: CarHeader<T>, compact: boolean): Promise<void>;
+    removeCidsForCompact(cid: AnyLink): Promise<void>;
+    entries(cache?: boolean): AsyncIterableIterator<AnyBlock>;
+    getBlock(cid: AnyLink): Promise<AnyBlock | Falsy>;
+    protected makeCarHeader<T>(meta: T, cars: CarLog, compact?: boolean): CarHeader<T>;
+    loadCar(cid: AnyLink): Promise<CarReader>;
+    protected storesLoadCar(cid: AnyLink, local: DataStore, remote?: DataStore, publicFiles?: boolean): Promise<CarReader>;
+    protected ensureDecryptedReader(reader: CarReader): Promise<CarReader>;
+    protected setKey(key: string): Promise<void>;
+    protected getMoreReaders(cids: AnyLink[]): Promise<void>;
+}
+
+declare abstract class VersionedStore {
+    readonly name: string;
+    readonly url: URL;
+    readonly logger: Logger;
+    constructor(name: string, url: URL, logger: Logger);
+    readonly _onStarted: (() => void)[];
+    onStarted(fn: () => void): void;
+    abstract start(): Promise<Result<void>>;
+    readonly _onClosed: (() => void)[];
+    onClosed(fn: () => void): void;
+    abstract close(): Promise<Result<void>>;
+}
+declare class MetaStore extends VersionedStore {
+    readonly tag: string;
+    readonly gateway: Gateway;
+    constructor(name: string, url: URL, logger: Logger, gateway: Gateway);
+    makeHeader({ cars, key }: DbMeta): ToString<DbMeta>;
+    parseHeader(headerData: ToString<DbMeta>): DbMeta;
+    start(): Promise<Result<void>>;
+    load(branch?: string): Promise<DbMeta[] | Falsy>;
+    save(meta: DbMeta, branch?: string): Promise<void>;
+    close(): Promise<Result<void>>;
+    destroy(): Promise<Result<void>>;
+}
+interface DataSaveOpts {
+    readonly public: boolean;
+}
+declare class DataStore extends VersionedStore {
+    readonly tag: string;
+    readonly gateway: Gateway;
+    constructor(name: string, url: URL, logger: Logger, gateway: Gateway);
+    start(): Promise<Result<void>>;
+    load(cid: AnyLink): Promise<AnyBlock>;
+    save(car: AnyBlock, opts?: DataSaveOpts): Promise<void>;
+    remove(cid: AnyLink): Promise<Result<void>>;
+    close(): Promise<Result<void>>;
+    destroy(): Promise<Result<void>>;
+}
+interface WALState {
+    operations: DbMeta[];
+    noLoaderOps: DbMeta[];
+    fileOperations: {
+        readonly cid: AnyLink;
+        readonly public: boolean;
+    }[];
+}
+declare class RemoteWAL extends VersionedStore {
+    readonly tag: string;
+    readonly loader: Loadable;
+    readonly _ready: ResolveOnce<void, void>;
+    private ready;
+    walState: WALState;
+    readonly processing: Promise<void> | undefined;
+    readonly processQueue: CommitQueue<void>;
+    readonly gateway: Gateway;
+    constructor(loader: Loadable, url: URL, logger: Logger, gateway: Gateway);
+    enqueue(dbMeta: DbMeta, opts: CommitOpts): Promise<void>;
+    enqueueFile(fileCid: AnyLink, publicFile?: boolean): Promise<void>;
+    _process(): Promise<void>;
+    _doProcess(): Promise<void>;
+    start(): Promise<VoidResult>;
+    load(): Promise<WALState | Falsy>;
+    save(state: WALState): Promise<void>;
+    close(): Promise<Result<undefined, Error>>;
+    destroy(): Promise<VoidResult>;
+}
+
+type AnyLink = Link<unknown, number, number, Version>;
+type CarGroup = AnyLink[];
+type CarLog = CarGroup[];
+type AnyAnyLink = Link<unknown, number, number, Version>;
+interface AnyBlock {
+    readonly cid: Link<unknown, number, number, Version>;
+    readonly bytes: Uint8Array;
+}
+interface CarMakeable {
+    entries(): Iterable<AnyBlock>;
+    get(cid: AnyLink): Promise<AnyBlock | undefined>;
+}
+interface CarHeader<T> {
+    readonly cars: CarLog;
+    readonly compact: CarLog;
+    readonly meta: T;
+}
+interface TransactionWrapper<M extends TransactionMeta> {
+    meta: M;
+    cars?: CarGroup;
+    t: CarTransaction;
+}
+type TransactionMeta = unknown;
+interface CryptoOpts {
+    readonly importKey: typeof crypto.subtle.importKey;
+    readonly decrypt: (algo: {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    }, key: CryptoKey, data: Uint8Array) => Promise<ArrayBuffer>;
+    readonly encrypt: (algo: {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    }, key: CryptoKey, data: Uint8Array) => Promise<ArrayBuffer>;
+    readonly digestSHA256: (data: Uint8Array) => Promise<ArrayBuffer>;
+    readonly randomBytes: (size: number) => Uint8Array;
+}
+interface BlobLike {
+    stream: () => ReadableStream;
+}
+interface StoreFactory {
+    makeMetaStore?: (loader: Loadable) => Promise<MetaStore>;
+    makeDataStore?: (loader: Loadable) => Promise<DataStore>;
+    makeRemoteWAL?: (loader: Loadable) => Promise<RemoteWAL>;
+    encodeFile?: (blob: BlobLike) => Promise<{
+        cid: AnyLink;
+        blocks: AnyBlock[];
+    }>;
+    decodeFile?: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<File>;
+}
+interface StoreOpts extends StoreFactory {
+    readonly isIndex?: string;
+    readonly stores?: {
+        readonly base?: string | URL;
+        readonly meta?: string | URL;
+        readonly data?: string | URL;
+        readonly index?: string | URL;
+        readonly remoteWAL?: string | URL;
+    };
+}
+interface TestStore {
+    get(url: URL, key: string): Promise<Uint8Array>;
+}
+interface StoreRuntime {
+    makeMetaStore(loader: Loadable): Promise<MetaStore>;
+    makeDataStore(loader: Loadable): Promise<DataStore>;
+    makeRemoteWAL(loader: Loadable): Promise<RemoteWAL>;
+    encodeFile(blob: BlobLike): Promise<{
+        cid: AnyLink;
+        blocks: AnyBlock[];
+    }>;
+    decodeFile(blocks: unknown, cid: AnyLink, meta: DocFileMeta): Promise<File>;
+}
+interface CommitOpts {
+    readonly noLoader?: boolean;
+    readonly compact?: boolean;
+    readonly public?: boolean;
+}
+interface DbMeta {
+    readonly cars: CarGroup;
+    key?: string;
+}
+interface UploadMetaFnParams {
+    readonly name: string;
+    readonly branch: string;
+}
+type FnParamTypes = "data" | "file";
+interface UploadDataFnParams {
+    readonly type: FnParamTypes;
+    readonly name: string;
+    readonly car: string;
+    readonly size: string;
+}
+interface DownloadDataFnParams {
+    readonly type: FnParamTypes;
+    readonly name: string;
+    readonly car: string;
+}
+interface DownloadMetaFnParams {
+    readonly name: string;
+    readonly branch: string;
+}
+interface Connection {
+    readonly loader?: Loadable;
+    readonly loaded: Promise<void>;
+    connectMeta({ loader }: {
+        loader?: Loadable;
+    }): void;
+    connectStorage({ loader }: {
+        loader?: Loadable;
+    }): void;
+    metaUpload(bytes: Uint8Array, params: UploadMetaFnParams): Promise<Uint8Array[] | Falsy>;
+    dataUpload(bytes: Uint8Array, params: UploadDataFnParams, opts?: {
+        public?: boolean;
+    }): Promise<void>;
+    metaDownload(params: DownloadMetaFnParams): Promise<Uint8Array[] | Falsy>;
+    dataDownload(params: DownloadDataFnParams): Promise<Uint8Array | Falsy>;
+}
+
+declare class TaskManager {
+    private readonly eventsWeHandled;
+    private readonly loader;
+    private queue;
+    private isProcessing;
+    readonly logger: Logger;
+    constructor(loader: Loader);
+    handleEvent(eventBlock: DbMetaEventBlock): Promise<void>;
+    private processQueue;
+}
+
+type CarClockHead = Link<DbMetaEventBlock, number, number, Version>[];
+interface Connectable {
+    readonly blockstore: {
+        readonly loader?: Loader;
+        readonly ebOpts: BlockstoreOpts;
+    };
+    readonly name?: string;
+}
+declare abstract class ConnectionBase implements Connection {
+    readonly eventBlocks: MemoryBlockstore;
+    parents: CarClockHead;
+    loader?: Loadable;
+    taskManager?: TaskManager;
+    loaded: Promise<void>;
+    abstract metaUpload(bytes: Uint8Array, params: UploadMetaFnParams): Promise<Uint8Array[] | Falsy>;
+    abstract dataUpload(bytes: Uint8Array, params: UploadDataFnParams, opts?: {
+        public?: boolean;
+    }): Promise<void>;
+    abstract metaDownload(params: DownloadMetaFnParams): Promise<Uint8Array[] | Falsy>;
+    abstract dataDownload(params: DownloadDataFnParams): Promise<Uint8Array | Falsy>;
+    readonly logger: Logger;
+    constructor(logger: Logger);
+    refresh(): Promise<void>;
+    connect({ loader }: {
+        loader?: Loader;
+    }): void;
+    connectMeta({ loader }: {
+        loader?: Loader;
+    }): void;
+    onConnect(): Promise<void>;
+    connectStorage({ loader }: {
+        loader?: Loader;
+    }): void;
+    createEventBlock(bytes: Uint8Array): Promise<DbMetaEventBlock>;
+    decodeEventBlock(bytes: Uint8Array): Promise<DbMetaEventBlock>;
+}
+type DbMetaEventBlock = EventBlock<{
+    dbMeta: Uint8Array;
+}>;
+
+declare class ConnectREST extends ConnectionBase {
+    readonly baseUrl: URL;
+    constructor(base: string, logger: Logger);
+    dataUpload(bytes: Uint8Array, params: UploadDataFnParams): Promise<void>;
+    dataDownload(params: DownloadDataFnParams): Promise<Uint8Array | undefined>;
+    metaUpload(bytes: Uint8Array, params: UploadMetaFnParams): Promise<undefined>;
+    metaDownload(params: DownloadMetaFnParams): Promise<never[]>;
+}
+
+declare function toURL(pathOrUrl: string | URL, isIndex?: string): URL;
+interface StoreFactoryItem {
+    readonly protocol: string;
+    readonly overrideBaseURL?: string;
+    readonly data: (logger: Logger) => Promise<Gateway>;
+    readonly meta: (logger: Logger) => Promise<Gateway>;
+    readonly wal: (logger: Logger) => Promise<Gateway>;
+    readonly test: (logger: Logger) => Promise<TestStore>;
+}
+declare function registerStoreProtocol(item: StoreFactoryItem): () => void;
+declare function testStoreFactory(url: URL, ilogger?: Logger): Promise<TestStore>;
+declare function toStoreRuntime(opts: StoreOpts, ilogger: Logger): StoreRuntime;
+
+declare function parseCarFile<T>(reader: CarReader, logger: Logger): Promise<CarHeader<T>>;
+
+type index$3_AnyAnyLink = AnyAnyLink;
+type index$3_AnyBlock = AnyBlock;
+type index$3_AnyLink = AnyLink;
+type index$3_BaseBlockstore = BaseBlockstore;
+declare const index$3_BaseBlockstore: typeof BaseBlockstore;
+type index$3_BlobLike = BlobLike;
+type index$3_BlockFetcher = BlockFetcher;
+type index$3_CarClockHead = CarClockHead;
+type index$3_CarGroup = CarGroup;
+type index$3_CarTransaction = CarTransaction;
+declare const index$3_CarTransaction: typeof CarTransaction;
+type index$3_CommitOpts = CommitOpts;
+type index$3_CompactionFetcher = CompactionFetcher;
+declare const index$3_CompactionFetcher: typeof CompactionFetcher;
+type index$3_ConnectREST = ConnectREST;
+declare const index$3_ConnectREST: typeof ConnectREST;
+type index$3_Connectable = Connectable;
+type index$3_Connection = Connection;
+type index$3_ConnectionBase = ConnectionBase;
+declare const index$3_ConnectionBase: typeof ConnectionBase;
+type index$3_CryptoOpts = CryptoOpts;
+type index$3_DataSaveOpts = DataSaveOpts;
+type index$3_DataStore = DataStore;
+declare const index$3_DataStore: typeof DataStore;
+type index$3_DbMeta = DbMeta;
+type index$3_DbMetaEventBlock = DbMetaEventBlock;
+type index$3_DownloadDataFnParams = DownloadDataFnParams;
+type index$3_DownloadMetaFnParams = DownloadMetaFnParams;
+type index$3_EncryptedBlockstore = EncryptedBlockstore;
+declare const index$3_EncryptedBlockstore: typeof EncryptedBlockstore;
+type index$3_Gateway = Gateway;
+type index$3_GatewayOpts = GatewayOpts;
+type index$3_GetResult = GetResult;
+type index$3_Loadable = Loadable;
+declare const index$3_Loadable: typeof Loadable;
+type index$3_Loader = Loader;
+declare const index$3_Loader: typeof Loader;
+type index$3_MetaStore = MetaStore;
+declare const index$3_MetaStore: typeof MetaStore;
+type index$3_NotFoundError = NotFoundError;
+declare const index$3_NotFoundError: typeof NotFoundError;
+type index$3_RemoteWAL = RemoteWAL;
+declare const index$3_RemoteWAL: typeof RemoteWAL;
+type index$3_StoreFactory = StoreFactory;
+type index$3_StoreFactoryItem = StoreFactoryItem;
+type index$3_StoreOpts = StoreOpts;
+type index$3_StoreRuntime = StoreRuntime;
+type index$3_TestStore = TestStore;
+type index$3_TransactionMeta = TransactionMeta;
+type index$3_UploadDataFnParams = UploadDataFnParams;
+type index$3_UploadMetaFnParams = UploadMetaFnParams;
+type index$3_VoidResult = VoidResult;
+type index$3_WALState = WALState;
+declare const index$3_isNotFoundError: typeof isNotFoundError;
+declare const index$3_parseCarFile: typeof parseCarFile;
+declare const index$3_registerStoreProtocol: typeof registerStoreProtocol;
+declare const index$3_testStoreFactory: typeof testStoreFactory;
+declare const index$3_toStoreRuntime: typeof toStoreRuntime;
+declare const index$3_toURL: typeof toURL;
+declare namespace index$3 {
+  export { type index$3_AnyAnyLink as AnyAnyLink, type index$3_AnyBlock as AnyBlock, type index$3_AnyLink as AnyLink, index$3_BaseBlockstore as BaseBlockstore, type index$3_BlobLike as BlobLike, type index$3_BlockFetcher as BlockFetcher, type index$3_CarClockHead as CarClockHead, type index$3_CarGroup as CarGroup, index$3_CarTransaction as CarTransaction, type index$3_CommitOpts as CommitOpts, index$3_CompactionFetcher as CompactionFetcher, index$3_ConnectREST as ConnectREST, type index$3_Connectable as Connectable, type index$3_Connection as Connection, index$3_ConnectionBase as ConnectionBase, type index$3_CryptoOpts as CryptoOpts, type index$3_DataSaveOpts as DataSaveOpts, index$3_DataStore as DataStore, type index$3_DbMeta as DbMeta, type index$3_DbMetaEventBlock as DbMetaEventBlock, type index$3_DownloadDataFnParams as DownloadDataFnParams, type index$3_DownloadMetaFnParams as DownloadMetaFnParams, index$3_EncryptedBlockstore as EncryptedBlockstore, type index$3_Gateway as Gateway, type index$3_GatewayOpts as GatewayOpts, type index$3_GetResult as GetResult, index$3_Loadable as Loadable, index$3_Loader as Loader, index$3_MetaStore as MetaStore, index$3_NotFoundError as NotFoundError, index$3_RemoteWAL as RemoteWAL, type index$3_StoreFactory as StoreFactory, type index$3_StoreFactoryItem as StoreFactoryItem, type index$3_StoreOpts as StoreOpts, type index$3_StoreRuntime as StoreRuntime, type index$3_TestStore as TestStore, type index$3_TransactionMeta as TransactionMeta, type index$3_UploadDataFnParams as UploadDataFnParams, type index$3_UploadMetaFnParams as UploadMetaFnParams, type index$3_VoidResult as VoidResult, type index$3_WALState as WALState, index$3_isNotFoundError as isNotFoundError, index$3_parseCarFile as parseCarFile, index$3_registerStoreProtocol as registerStoreProtocol, index$3_testStoreFactory as testStoreFactory, index$3_toStoreRuntime as toStoreRuntime, index$3_toURL as toURL };
+}
+
+type Falsy = false | null | undefined;
+declare function isFalsy(value: unknown): value is Falsy;
+declare function throwFalsy<T>(value: T | Falsy): T;
+declare function falsyToUndef<T>(value: T | Falsy): T | undefined;
+interface ConfigOpts {
+    readonly public?: boolean;
+    readonly meta?: DbMeta;
+    readonly persistIndexes?: boolean;
+    readonly autoCompact?: number;
+    readonly crypto?: CryptoOpts;
+    readonly store?: StoreOpts;
+    readonly threshold?: number;
+    readonly logger?: Logger;
+}
+type ClockLink = EventLink<Operation>;
+type ClockHead = ClockLink[];
+type DocFragment = Uint8Array | string | number | boolean | null | AnyLink | DocFragment[] | object;
+type DocLiteral = string | number | boolean | Uint8Array | unknown;
+type DocObject = NonNullable<unknown>;
+type DocTypes = DocObject;
+type DocRecord<T extends DocObject> = T;
+type UnknownDoc = DocRecord<never>;
+type DocFiles = Record<string, DocFileMeta | File>;
+interface DocBase {
+    readonly _id: string;
+    readonly _files?: DocFiles;
+    readonly _publicFiles?: DocFiles;
+    readonly _deleted?: boolean;
+}
+type DocWithId<T extends DocTypes> = DocBase & T;
+type DocSet<T extends DocTypes> = Partial<DocBase> & T;
+interface DocFileMeta {
+    readonly type: string;
+    readonly size: number;
+    readonly cid: AnyLink;
+    readonly car?: AnyLink;
+    url?: string;
+    file?: () => Promise<File>;
+}
+interface DocUpdate<T extends DocTypes> {
+    readonly id: string;
+    readonly value?: DocSet<T>;
+    readonly del?: boolean;
+    readonly clock?: ClockLink;
+}
+interface DocValue<T extends DocTypes> {
+    readonly doc: DocWithId<T>;
+    readonly del: boolean;
+    readonly cid: AnyLink;
+}
+type KeyLiteral = string | number | boolean;
+type IndexKeyType = KeyLiteral | KeyLiteral[];
+type IndexKey<K extends IndexKeyType> = [K, string];
+interface IndexUpdate<K extends IndexKeyType> {
+    readonly key: IndexKey<K>;
+    readonly value?: DocFragment;
+    readonly del?: boolean;
+}
+interface IndexUpdateString {
+    readonly key: string;
+    readonly value?: DocFragment;
+    readonly del?: boolean;
+}
+interface IndexRow<K extends IndexKeyType, T extends DocObject, R extends DocFragment> {
+    readonly id: string;
+    readonly key: K;
+    readonly value: R;
+    readonly doc?: DocWithId<T>;
+}
+interface IndexRows<K extends IndexKeyType, T extends DocObject, R extends DocFragment = T> {
+    readonly rows: IndexRow<K, T, R>[];
+}
+interface CRDTMeta {
+    readonly head: ClockHead;
+}
+interface IndexTransactionMeta {
+    readonly indexes: Record<string, IdxMeta>;
+}
+interface FileTransactionMeta {
+    readonly files?: AnyLink[];
+}
+type MetaType$1 = CRDTMeta | IndexTransactionMeta | FileTransactionMeta;
+interface IdxMeta {
+    readonly byId: AnyLink;
+    readonly byKey: AnyLink;
+    readonly map: string;
+    readonly name: string;
+    readonly head: ClockHead;
+}
+interface IdxMetaMap {
+    readonly indexes?: Map<string, IdxMeta>;
+}
+interface QueryOpts<K extends IndexKeyType> {
+    readonly descending?: boolean;
+    readonly limit?: number;
+    includeDocs?: boolean;
+    readonly range?: [IndexKeyType, IndexKeyType];
+    readonly key?: DocFragment;
+    readonly keys?: DocFragment[];
+    prefix?: IndexKeyType;
+}
+type EmitFn = (k: IndexKeyType, v?: DocFragment) => void;
+type MapFn<T extends DocTypes> = (doc: DocWithId<T>, emit: EmitFn) => DocFragment | unknown;
+interface ChangesOptions {
+    readonly dirty?: boolean;
+    readonly limit?: number;
+}
+interface ChangesResponseRow<T extends DocTypes> {
+    readonly key: string;
+    readonly value: DocWithId<T>;
+    readonly clock?: ClockLink;
+}
+interface ChangesResponse<T extends DocTypes> {
+    readonly clock: ClockHead;
+    readonly rows: ChangesResponseRow<T>[];
+}
+interface DbResponse {
+    readonly id: string;
+    readonly clock: ClockHead;
+}
+type UpdateListenerFn<T extends DocTypes> = (docs: DocWithId<T>[]) => Promise<void> | void;
+type NoUpdateListenerFn = () => Promise<void> | void;
+type ListenerFn<T extends DocTypes> = UpdateListenerFn<T> | NoUpdateListenerFn;
+
+interface WriteQueue<T extends DocTypes> {
+    push(task: DocUpdate<T>): Promise<MetaType$1>;
+}
+
+declare class IndexTree<K extends IndexKeyType, R extends DocFragment> {
+    cid?: AnyLink;
+    root?: ProllyNode<K, R>;
+}
+interface ProllyIndexRow<K extends IndexKeyType, T extends DocFragment> {
+    readonly id: string;
+    readonly key: IndexKey<K>;
+    readonly value: T;
+}
+interface ProllyNode<K extends IndexKeyType, T extends DocFragment> extends ProllyNode$1 {
+    getAllEntries(): PromiseLike<{
+        [x: string]: unknown;
+        result: ProllyIndexRow<K, T>[];
+    }>;
+    getMany<KI extends IndexKeyType>(removeIds: KI[]): Promise<{
+        result: IndexKey<K>[];
+    }>;
+    range(a: string, b: string): Promise<{
+        result: ProllyIndexRow<K, T>[];
+    }>;
+    get(key: string): Promise<{
+        result: ProllyIndexRow<K, T>[];
+    }>;
+    bulk(bulk: (IndexUpdate<K> | IndexUpdateString)[]): PromiseLike<{
+        readonly root?: ProllyNode<K, T>;
+        readonly blocks: Block[];
+    }>;
+    readonly address: Promise<Link>;
+    readonly distance: number;
+    compare: (a: unknown, b: unknown) => number;
+    readonly cache: unknown;
+    readonly block: Promise<Block>;
+}
+
+declare function index$2<K extends IndexKeyType = string, T extends DocTypes = NonNullable<unknown>, R extends DocFragment = T>({ _crdt }: {
+    _crdt: CRDT<T> | CRDT<NonNullable<unknown>>;
+}, name: string, mapFn?: MapFn<T>, meta?: IdxMeta): Index<K, T, R>;
+declare class Index<K extends IndexKeyType, T extends DocTypes, R extends DocFragment = T> {
+    readonly blockstore: BaseBlockstore;
+    readonly crdt: CRDT<T>;
+    name: string;
+    mapFn?: MapFn<T>;
+    mapFnString: string;
+    byKey: IndexTree<K, R>;
+    byId: IndexTree<K, R>;
+    indexHead?: ClockHead;
+    includeDocsDefault: boolean;
+    initError?: Error;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    readonly logger: Logger;
+    constructor(crdt: CRDT<T> | CRDT<NonNullable<unknown>>, name: string, mapFn?: MapFn<T>, meta?: IdxMeta);
+    applyMapFn(name: string, mapFn?: MapFn<T>, meta?: IdxMeta): void;
+    query(opts?: QueryOpts<K>): Promise<IndexRows<K, T, R>>;
+    _resetIndex(): void;
+    _hydrateIndex(): Promise<void>;
+    _updateIndex(): Promise<IndexTransactionMeta>;
+}
+
+interface ApplyHeadTask<T extends DocTypes> {
+    readonly newHead: ClockHead;
+    readonly prevHead: ClockHead;
+    readonly updates?: DocUpdate<T>[];
+}
+interface ApplyHeadQueue<T extends DocTypes> {
+    push(task: ApplyHeadTask<T>): AsyncGenerator<{
+        readonly updates: DocUpdate<T>[];
+        readonly all: boolean;
+    }, void, unknown>;
+    size(): number;
+}
+
+declare class CRDTClock<T extends DocTypes> {
+    head: ClockHead;
+    readonly zoomers: Set<() => void>;
+    readonly watchers: Set<(updates: DocUpdate<T>[]) => void>;
+    readonly emptyWatchers: Set<() => void>;
+    readonly blockstore: BaseBlockstore;
+    readonly applyHeadQueue: ApplyHeadQueue<T>;
+    readonly _ready: ResolveOnce<void, void>;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    readonly logger: Logger;
+    constructor(blockstore: BaseBlockstore);
+    setHead(head: ClockHead): void;
+    applyHead(newHead: ClockHead, prevHead: ClockHead, updates?: DocUpdate<T>[]): Promise<void>;
+    processUpdates(updatesAcc: DocUpdate<T>[], all: boolean, prevHead: ClockHead): Promise<void>;
+    notifyWatchers(updates: DocUpdate<T>[]): void;
+    onTick(fn: (updates: DocUpdate<T>[]) => void): void;
+    onTock(fn: () => void): void;
+    onZoom(fn: () => void): void;
+    int_applyHead(newHead: ClockHead, prevHead: ClockHead, localUpdates: boolean): Promise<void>;
+}
+
+declare class CRDT<T extends DocTypes> {
+    readonly name?: string;
+    readonly opts: ConfigOpts;
+    readonly onceReady: ResolveOnce<void, void>;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    readonly blockstore: BaseBlockstore;
+    readonly indexBlockstore: BaseBlockstore;
+    readonly indexers: Map<string, Index<IndexKeyType, {}, {}>>;
+    readonly clock: CRDTClock<T>;
+    readonly logger: Logger;
+    constructor(name?: string, opts?: ConfigOpts);
+    bulk(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
+    allDocs(): Promise<{
+        result: DocUpdate<T>[];
+        head: ClockHead;
+    }>;
+    vis(): Promise<string>;
+    getBlock(cidString: string): Promise<Block>;
+    get(key: string): Promise<DocValue<T> | Falsy>;
+    changes(since?: ClockHead, opts?: ChangesOptions): Promise<{
+        result: DocUpdate<T>[];
+        head: ClockHead;
+    }>;
+    compact(): Promise<void>;
+}
+
+declare class Database<DT extends DocTypes = NonNullable<unknown>> implements Connectable {
+    static databases: Map<string, Database<{}>>;
+    readonly name?: string;
+    readonly opts: ConfigOpts;
+    _listening: boolean;
+    readonly _listeners: Set<ListenerFn<DT>>;
+    readonly _noupdate_listeners: Set<ListenerFn<DT>>;
+    readonly _crdt: CRDT<DT>;
+    readonly _writeQueue: WriteQueue<DT>;
+    readonly blockstore: BaseBlockstore;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    readonly _ready: ResolveOnce<void, void>;
+    ready(): Promise<void>;
+    readonly logger: Logger;
+    constructor(name?: string, opts?: ConfigOpts);
+    get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
+    put<T extends DocTypes>(doc: DocSet<T>): Promise<DbResponse>;
+    del(id: string): Promise<DbResponse>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse<T>>;
+    allDocs<T extends DocTypes>(): Promise<{
+        rows: {
+            key: string;
+            value: DocWithId<T>;
+        }[];
+        clock: ClockHead;
+    }>;
+    allDocuments<T extends DocTypes>(): Promise<{
+        rows: {
+            key: string;
+            value: DocWithId<T>;
+        }[];
+        clock: ClockHead;
+    }>;
+    subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
+    query<K extends IndexKeyType, T extends DocTypes, R extends DocFragment = T>(field: string | MapFn<T>, opts?: QueryOpts<K>): Promise<IndexRows<K, T, R>>;
+    compact(): Promise<void>;
+    _notify(updates: DocUpdate<NonNullable<unknown>>[]): Promise<void>;
+    _no_update_notify(): Promise<void>;
+}
+declare function fireproof(name: string, opts?: ConfigOpts): Database;
+
+interface NodeMap {
+    state: "seeded" | "browser" | "node";
+    join: (...args: string[]) => string;
+    dirname: (path: string) => string;
+    homedir: () => string;
+    fileURLToPath: (url: string | URL) => string;
+    mkdir: (path: PathLike, options?: {
+        recursive: boolean;
+    }) => Promise<string | undefined>;
+    readdir: (path: PathLike, options?: unknown) => Promise<unknown[]>;
+    rm: (path: PathLike, options?: MakeDirectoryOptions & {
+        recursive: boolean;
+    }) => Promise<void>;
+    copyFile: (source: PathLike, destination: PathLike) => Promise<void>;
+    readfile: (path: PathLike, options?: {
+        encoding: BufferEncoding;
+        flag?: string;
+    }) => Promise<string>;
+    stat: (path: PathLike) => Promise<Stats>;
+    unlink: (path: PathLike) => Promise<void>;
+    writefile: (path: PathLike, data: Uint8Array | string) => Promise<void>;
+}
+declare function join(...paths: string[]): string;
+declare class sysContainer {
+    freight: NodeMap;
+    readonly id: string;
+    start(): Promise<void>;
+    readdir(path: PathLike, options?: (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean;
+    }) | BufferEncoding | null | undefined): Promise<string[]>;
+    readdirent(path: PathLike, options: (ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean;
+    }) | BufferEncoding | null | undefined): Promise<Dirent[]>;
+    readfile(path: PathLike, options?: {
+        encoding: BufferEncoding;
+        flag?: string;
+    }): Promise<Buffer>;
+    mkdir(path: PathLike, options: {
+        recursive: boolean;
+    }): Promise<string | undefined>;
+    rm(path: PathLike, options: MakeDirectoryOptions & {
+        recursive: boolean;
+    }): Promise<void>;
+    unlink(path: PathLike): Promise<void>;
+    writefile(path: PathLike, data: Uint8Array | string): Promise<void>;
+    copyFile(source: PathLike, destination: PathLike): Promise<void>;
+    stat(path: PathLike): Promise<Stats>;
+    fileURLToPath(url: string | URL): string;
+    dirname(path: string): string;
+    join(...args: string[]): string;
+    homedir: () => string;
+    logSeeded(method: string): void;
+    readonly env: EnvImpl;
+}
+declare const SysContainer: sysContainer;
+
+declare function dataDir(name?: string, base?: string | URL): string;
+
+interface LoggerOpts {
+    readonly logger?: Logger;
+}
+declare function ensureLogger(optsOrLogger: Partial<LoggerOpts> | Logger, componentName: string, ctx?: Record<string, unknown>): Logger;
+type Joiner = (...toJoin: string[]) => string;
+declare function getStore(url: URL, logger: Logger, joiner: Joiner): string;
+declare function getKey(url: URL, logger: Logger): string;
+declare function getName(url: URL, logger: Logger): string;
+declare function exception2Result<T = void>(fn: () => Promise<T>): Promise<Result<T>>;
+declare function exceptionWrapper<T, E extends Error>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>>;
+
+declare function getPath(url: URL, logger: Logger): Promise<string>;
+declare function getFileName(url: URL, key: string, logger: Logger): string;
+declare function ensureIndexName(url: URL, name: string): string;
+
+interface DBConnection {
+    connect(): Promise<void>;
+    readonly opts: SQLOpts;
+}
+interface SQLStore<IType, KType, OType = IType[]> {
+    readonly dbConn: DBConnection;
+    start(url: URL): Promise<void>;
+    insert(url: URL, ose: IType): Promise<RunResult>;
+    select(url: URL, car: KType): Promise<OType>;
+    delete(url: URL, car: KType): Promise<RunResult>;
+    close(url: URL): Promise<Result<void>>;
+    destroy(url: URL): Promise<Result<void>>;
+}
+interface SQLTableNames {
+    readonly data: string;
+    readonly meta: string;
+    readonly wal: string;
+}
+declare const DefaultSQLTableNames: SQLTableNames;
+interface SQLOpts {
+    readonly url: URL;
+    readonly sqlFlavor: "sqlite" | "mysql" | "postgres";
+    readonly tableNames: SQLTableNames;
+    readonly logger: Logger;
+    readonly textEncoder: TextEncoder;
+    readonly textDecoder: TextDecoder;
+}
+interface WalKey {
+    readonly name: string;
+    readonly branch: string;
+}
+interface WalRecord extends WalKey {
+    readonly state: Uint8Array;
+    readonly updated_at: Date;
+}
+type WalSQLStore = SQLStore<WalRecord, WalKey>;
+interface MetaType {
+    readonly name: string;
+    readonly branch: string;
+    readonly meta: Uint8Array;
+}
+interface MetaRecordKey {
+    readonly name: string;
+    readonly branch: string;
+}
+interface MetaRecord extends MetaRecordKey {
+    readonly meta: Uint8Array;
+    readonly updated_at: Date;
+}
+type MetaSQLStore = SQLStore<MetaRecord, MetaRecordKey>;
+interface DataRecord {
+    readonly name: string;
+    readonly car: string;
+    readonly data: Uint8Array;
+    readonly updated_at: Date;
+}
+type DataSQLStore = SQLStore<DataRecord, string>;
+
+declare function ensureSQLOpts(url: URL, opts: Partial<SQLOpts>, componentName: string, ctx?: Record<string, unknown>): SQLOpts;
+
+type index$1_DBConnection = DBConnection;
+type index$1_DataRecord = DataRecord;
+type index$1_DataSQLStore = DataSQLStore;
+declare const index$1_DefaultSQLTableNames: typeof DefaultSQLTableNames;
+type index$1_MetaRecord = MetaRecord;
+type index$1_MetaRecordKey = MetaRecordKey;
+type index$1_MetaSQLStore = MetaSQLStore;
+type index$1_MetaType = MetaType;
+type index$1_SQLOpts = SQLOpts;
+type index$1_SQLStore<IType, KType, OType = IType[]> = SQLStore<IType, KType, OType>;
+type index$1_SQLTableNames = SQLTableNames;
+type index$1_WalKey = WalKey;
+type index$1_WalRecord = WalRecord;
+type index$1_WalSQLStore = WalSQLStore;
+declare const index$1_ensureSQLOpts: typeof ensureSQLOpts;
+declare namespace index$1 {
+  export { type index$1_DBConnection as DBConnection, type index$1_DataRecord as DataRecord, type index$1_DataSQLStore as DataSQLStore, index$1_DefaultSQLTableNames as DefaultSQLTableNames, type index$1_MetaRecord as MetaRecord, type index$1_MetaRecordKey as MetaRecordKey, type index$1_MetaSQLStore as MetaSQLStore, type index$1_MetaType as MetaType, type index$1_SQLOpts as SQLOpts, type index$1_SQLStore as SQLStore, type index$1_SQLTableNames as SQLTableNames, type index$1_WalKey as WalKey, type index$1_WalRecord as WalRecord, type index$1_WalSQLStore as WalSQLStore, index$1_ensureSQLOpts as ensureSQLOpts };
+}
+
+declare function toCryptoOpts(cryptoOpts?: Partial<CryptoOpts>): CryptoOpts;
+
+declare const crypto$1_toCryptoOpts: typeof toCryptoOpts;
+declare namespace crypto$1 {
+  export { crypto$1_toCryptoOpts as toCryptoOpts };
+}
+
+declare function encodeFile(blob: BlobLike): Promise<{
+    cid: AnyLink;
+    blocks: AnyBlock[];
+}>;
+declare function decodeFile(blocks: unknown, cid: AnyLink, meta: DocFileMeta): Promise<File>;
+
+declare const files_decodeFile: typeof decodeFile;
+declare const files_encodeFile: typeof encodeFile;
+declare namespace files {
+  export { files_decodeFile as decodeFile, files_encodeFile as encodeFile };
+}
+
+declare const FILESTORE_VERSION = "v0.19-file";
+
+declare const INDEXDB_VERSION = "v0.19-indexdb";
+
+declare const SQLITE_VERSION = "v0.19-sqlite";
+
+declare const index_FILESTORE_VERSION: typeof FILESTORE_VERSION;
+declare const index_INDEXDB_VERSION: typeof INDEXDB_VERSION;
+type index_NodeMap = NodeMap;
+declare const index_SQLITE_VERSION: typeof SQLITE_VERSION;
+declare const index_SysContainer: typeof SysContainer;
+declare const index_dataDir: typeof dataDir;
+declare const index_ensureIndexName: typeof ensureIndexName;
+declare const index_files: typeof files;
+declare const index_getFileName: typeof getFileName;
+declare const index_getPath: typeof getPath;
+declare const index_join: typeof join;
+declare namespace index {
+  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, type index_NodeMap as NodeMap, index_SQLITE_VERSION as SQLITE_VERSION, index_SysContainer as SysContainer, crypto$1 as crypto, index_dataDir as dataDir, index_ensureIndexName as ensureIndexName, index_files as files, index_getFileName as getFileName, index_getPath as getPath, index_join as join, index$1 as sql };
+}
+
+declare const PACKAGE_VERSION: string;
+
+export { CRDT, type CRDTMeta, type ChangesOptions, type ChangesResponse, type ChangesResponseRow, type ClockHead, type ClockLink, type ConfigOpts, Database, type DbResponse, type DocBase, type DocFileMeta, type DocFiles, type DocFragment, type DocLiteral, type DocObject, type DocRecord, type DocSet, type DocTypes, type DocUpdate, type DocValue, type DocWithId, type Falsy, type FileTransactionMeta, type IdxMeta, type IdxMetaMap, Index, type IndexKey, type IndexKeyType, type IndexRow, type IndexRows, type IndexTransactionMeta, type IndexUpdate, type IndexUpdateString, type Joiner, type KeyLiteral, type ListenerFn, type LoggerOpts, type MapFn, type MetaType$1 as MetaType, type NoUpdateListenerFn, PACKAGE_VERSION, type QueryOpts, type UnknownDoc, type UpdateListenerFn, index$3 as blockstore, index$3 as bs, ensureLogger, exception2Result, exceptionWrapper, falsyToUndef, fireproof, getKey, getName, getStore, index$2 as index, isFalsy, index as rt, index as runtime, throwFalsy };
+declare module '@fireproof/core'