@fireproof/core 0.19.121 → 0.20.0-dev-preview-05

package/index.d.cts

@@ -1,15 +1,14 @@
-import { Future, Logger, ResolveOnce, URI, Result, ResolveSeq, CoerceURI, CryptoRuntime, CTCryptoKey, EnvFactoryOpts, Env, runtimeFn } from '@adviser/cement';
-export { Logger, Result } from '@adviser/cement';
+import { Logger, Future, ResolveOnce, URI, Result, ResolveSeq, CoerceURI, CryptoRuntime, CTCryptoKey, EnvFactoryOpts, Env, runtimeFn } from '@adviser/cement';
 import { EventLink } from '@fireproof/vendor/@web3-storage/pail/clock/api';
 import { Operation } from '@fireproof/vendor/@web3-storage/pail/crdt/api';
-import { ByteView, ArrayBufferView, Version, Block as Block$1, Link, CID, BlockView, MultihashHasher } from 'multiformats';
+import { ByteView, ArrayBufferView, Version, Block as Block$1, CID, Link, BlockView, MultihashHasher } from 'multiformats';
 import { MemoryBlockstore } from '@fireproof/vendor/@web3-storage/pail/block';
 import { BlockFetcher as BlockFetcher$1 } from '@fireproof/vendor/@web3-storage/pail/api';
-import { CarReader } from '@fireproof/vendor/@ipld/car/reader';
 import { EventBlock } from '@fireproof/vendor/@web3-storage/pail/clock';
-import { PathLike, MakeDirectoryOptions, Stats } from 'fs';
+import { CarReader } from '@fireproof/vendor/@ipld/car';
 import { ProllyNode as ProllyNode$1 } from 'prolly-trees/db-index';
 import { SuperThis as SuperThis$1 } from '@fireproof/core';
+import { CarReader as CarReader$1 } from '@fireproof/vendor/@ipld/car/reader';
 import { Block as Block$2 } from 'multiformats/block';
 
 interface BlockEncoder<Code extends number, T> {
@@ -33,6 +32,63 @@ declare namespace codecInterface {
   export { codecInterface_ArrayBufferView as ArrayBufferView, type codecInterface_BlockCodec as BlockCodec, type codecInterface_BlockDecoder as BlockDecoder, type codecInterface_BlockEncoder as BlockEncoder, codecInterface_ByteView as ByteView };
 }
 
+type BlockFetcher = BlockFetcher$1;
+interface CarTransactionOpts {
+    readonly add: boolean;
+    readonly noLoader: boolean;
+}
+interface CarTransactionOpts {
+    readonly add: boolean;
+    readonly noLoader: boolean;
+}
+declare class CarTransaction extends MemoryBlockstore implements CarMakeable {
+    readonly parent: BaseBlockstore;
+    constructor(parent: BaseBlockstore, opts?: CarTransactionOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
+}
+declare class BaseBlockstore implements BlockFetcher {
+    readonly transactions: Set<CarTransaction>;
+    readonly ebOpts: BlockstoreRuntime;
+    readonly sthis: SuperThis;
+    readonly loader: Loadable;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    compact(): Promise<void>;
+    readonly logger: Logger;
+    constructor(ebOpts: BlockstoreOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    put(cid: AnyAnyLink, block: Uint8Array): Promise<void>;
+    lastTxMeta?: unknown;
+    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, _opts?: CarTransactionOpts): Promise<TransactionWrapper<M>>;
+    openTransaction(opts?: CarTransactionOpts): CarTransaction;
+    commitTransaction<M extends TransactionMeta>(t: CarTransaction, done: M, opts: CarTransactionOpts): Promise<TransactionWrapper<M>>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class EncryptedBlockstore extends BaseBlockstore {
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    compacting: boolean;
+    readonly logger: Logger;
+    constructor(sthis: SuperThis, ebOpts: BlockstoreOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block$1<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): Promise<Uint8Array>;
+    compact(): Promise<void>;
+    defaultCompact(blocks: CompactionFetcher, logger: Logger): Promise<TransactionMeta>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class CompactionFetcher implements BlockFetcher {
+    readonly blockstore: EncryptedBlockstore;
+    readonly loggedBlocks: CarTransaction;
+    constructor(blocks: EncryptedBlockstore);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+}
+
 type QueueFunction<T = void> = () => Promise<T>;
 declare class CommitQueue<T = void> {
     readonly queue: QueueFunction<void>[];
@@ -89,6 +145,7 @@ interface KeyBagProviderFactoryItem {
 }
 declare function registerKeyBagProviderFactory(item: KeyBagProviderFactoryItem): void;
 declare function defaultKeyBagUrl(sthis: SuperThis): URI;
+declare function defaultKeyBagOpts(sthis: SuperThis, kbo?: Partial<KeyBagOpts>): KeyBagRuntime;
 declare function getKeyBag(sthis: SuperThis, kbo?: Partial<KeyBagOpts>): Promise<KeyBag>;
 
 type keyBag_KeyBackProviderFactory = KeyBackProviderFactory;
@@ -100,11 +157,12 @@ type keyBag_KeyBagProvider = KeyBagProvider;
 type keyBag_KeyBagProviderFactoryItem = KeyBagProviderFactoryItem;
 type keyBag_KeyBagRuntime = KeyBagRuntime;
 type keyBag_KeyItem = KeyItem;
+declare const keyBag_defaultKeyBagOpts: typeof defaultKeyBagOpts;
 declare const keyBag_defaultKeyBagUrl: typeof defaultKeyBagUrl;
 declare const keyBag_getKeyBag: typeof getKeyBag;
 declare const keyBag_registerKeyBagProviderFactory: typeof registerKeyBagProviderFactory;
 declare namespace keyBag {
-  export { type keyBag_KeyBackProviderFactory as KeyBackProviderFactory, keyBag_KeyBag as KeyBag, type keyBag_KeyBagFile as KeyBagFile, type keyBag_KeyBagOpts as KeyBagOpts, type keyBag_KeyBagProvider as KeyBagProvider, type keyBag_KeyBagProviderFactoryItem as KeyBagProviderFactoryItem, type keyBag_KeyBagRuntime as KeyBagRuntime, type keyBag_KeyItem as KeyItem, keyBag_defaultKeyBagUrl as defaultKeyBagUrl, keyBag_getKeyBag as getKeyBag, keyBag_registerKeyBagProviderFactory as registerKeyBagProviderFactory };
+  export { type keyBag_KeyBackProviderFactory as KeyBackProviderFactory, keyBag_KeyBag as KeyBag, type keyBag_KeyBagFile as KeyBagFile, type keyBag_KeyBagOpts as KeyBagOpts, type keyBag_KeyBagProvider as KeyBagProvider, type keyBag_KeyBagProviderFactoryItem as KeyBagProviderFactoryItem, type keyBag_KeyBagRuntime as KeyBagRuntime, type keyBag_KeyItem as KeyItem, keyBag_defaultKeyBagOpts as defaultKeyBagOpts, keyBag_defaultKeyBagUrl as defaultKeyBagUrl, keyBag_getKeyBag as getKeyBag, keyBag_registerKeyBagProviderFactory as registerKeyBagProviderFactory };
 }
 
 declare class TaskManager {
@@ -114,112 +172,10 @@ declare class TaskManager {
     readonly logger: Logger;
     readonly callback: (dbMeta: DbMeta) => Promise<void>;
     constructor(sthis: SuperThis, callback: (dbMeta: DbMeta) => Promise<void>);
-    handleEvent(cid: CarClockLink, parents: string[], dbMeta: DbMeta): Promise<void>;
+    handleEvent(cid: CarClockLink, parents: CarClockHead, dbMeta: DbMeta): Promise<void>;
     private processQueue;
 }
 
-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>;
-    readonly sthis: SuperThis;
-    readonly taskManager?: TaskManager;
-    carLog: CarLog;
-    remoteMetaStore?: MetaStore;
-    remoteCarStore?: DataStore;
-    remoteFileStore?: DataStore;
-    private getBlockCache;
-    private seenMeta;
-    private writeLimit;
-    keyBag(): Promise<KeyBag>;
-    carStore(): Promise<DataStore>;
-    fileStore(): Promise<DataStore>;
-    WALStore(): Promise<WALStore>;
-    metaStore(): Promise<MetaStore>;
-    readonly onceReady: ResolveOnce<void>;
-    ready(): Promise<void>;
-    close(): Promise<void>;
-    destroy(): Promise<void>;
-    readonly logger: Logger;
-    constructor(name: string, ebOpts: BlockstoreOpts, sthis: SuperThis);
-    handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
-    mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
-    loadCarHeaderFromMeta<T>({ cars: cids }: DbMeta): Promise<CarHeader<T>>;
-    commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
-    loadFileCar(cid: AnyLink): Promise<CarReader>;
-    commit<T = TransactionMeta>(t: CarTransaction, done: T, opts?: CommitOpts): Promise<CarGroup>;
-    updateCarLog<T>(cids: CarGroup, fp: CarHeader<T>, compact: boolean): Promise<void>;
-    cacheTransaction(t: CarTransaction): Promise<void>;
-    cacheCarReader(carCidStr: string, reader: CarReader): Promise<void>;
-    removeCidsForCompact(cid: AnyLink): Promise<void>;
-    entries(cache?: boolean): AsyncIterableIterator<AnyBlock>;
-    getBlock(cid: AnyLink): Promise<AnyBlock | Falsy>;
-    loadCar(cid: AnyLink): Promise<CarReader>;
-    makeDecoderAndCarReader(cid: AnyLink, local: DataStore, remote?: DataStore): Promise<CarReader>;
-    protected storesLoadCar(cid: AnyLink, local: DataStore, remote?: DataStore): Promise<CarReader>;
-    protected getMoreReaders(cids: AnyLink[]): Promise<void>;
-}
-
-type BlockFetcher = BlockFetcher$1;
-interface CarTransactionOpts {
-    readonly add: boolean;
-    readonly noLoader: boolean;
-}
-declare class CarTransaction extends MemoryBlockstore implements CarMakeable {
-    readonly parent: BaseBlockstore;
-    constructor(parent: BaseBlockstore, opts?: CarTransactionOpts);
-    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
-    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
-}
-declare class BaseBlockstore implements BlockFetcher {
-    readonly transactions: Set<CarTransaction>;
-    readonly ebOpts: BlockstoreRuntime;
-    readonly sthis: SuperThis;
-    readonly loader?: Loader;
-    readonly name?: string;
-    ready(): Promise<void>;
-    close(): Promise<void>;
-    destroy(): Promise<void>;
-    compact(): Promise<void>;
-    readonly logger: Logger;
-    constructor(ebOpts?: BlockstoreOpts);
-    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block$1<T, C, A, V> | undefined>;
-    put(cid: AnyAnyLink, block: Uint8Array): Promise<void>;
-    lastTxMeta?: unknown;
-    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, _opts?: CarTransactionOpts): Promise<TransactionWrapper<M>>;
-    openTransaction(opts?: CarTransactionOpts): CarTransaction;
-    commitTransaction<M extends TransactionMeta>(t: CarTransaction, done: M, opts: CarTransactionOpts): 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(sthis: SuperThis, ebOpts: BlockstoreOpts);
-    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block$1<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): Promise<Uint8Array>;
-    compact(): Promise<void>;
-    defaultCompact(blocks: CompactionFetcher, logger: Logger): Promise<TransactionMeta>;
-    entries(): AsyncIterableIterator<AnyBlock>;
-}
-declare class CompactionFetcher implements BlockFetcher {
-    readonly blockstore: EncryptedBlockstore;
-    readonly loggedBlocks: CarTransaction;
-    constructor(blocks: EncryptedBlockstore);
-    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
-}
-
 declare function onSuperThis(fn: (sthis: SuperThis) => void): () => void;
 declare function ensureSuperThis(osthis?: Partial<SuperThisOpts>): SuperThis;
 declare function ensureSuperLog(sthis: SuperThis, componentName: string, ctx?: Record<string, unknown>): SuperThis;
@@ -237,8 +193,107 @@ declare class NotFoundError extends Error {
     readonly code = "ENOENT";
 }
 declare function isNotFoundError(e: Error | Result<unknown> | unknown): e is NotFoundError;
-declare function dataDir(sthis: SuperThis, name?: string, base?: CoerceURI): URI;
 declare function UInt8ArrayEqual(a: Uint8Array, b: Uint8Array): boolean;
+declare function inplaceFilter<T>(i: T[], pred: (i: T, idx: number) => boolean): T[];
+declare function toSortedArray(set?: Record<string, unknown>): Record<string, unknown>[];
+declare function coerceIntoUint8(raw: ToUInt8): Result<Uint8Array>;
+declare function coercePromiseIntoUint8(raw: PromiseToUInt8): Promise<Result<Uint8Array>>;
+
+declare enum FPEnvelopeType {
+    CAR = "car",
+    FILE = "file",
+    META = "meta",
+    WAL = "wal"
+}
+interface FPEnvelope<T> {
+    readonly type: FPEnvelopeType;
+    readonly payload: T;
+}
+interface FPEnvelopeCar extends FPEnvelope<Uint8Array> {
+    readonly type: FPEnvelopeType.CAR;
+}
+interface FPEnvelopeFile extends FPEnvelope<Uint8Array> {
+    readonly type: FPEnvelopeType.FILE;
+}
+interface FPEnvelopeMeta extends FPEnvelope<DbMetaEvent[]> {
+    readonly type: FPEnvelopeType.META;
+}
+interface FPWALCarsOps {
+    readonly cars: CID[];
+}
+interface FPEnvelopeWAL extends FPEnvelope<WALState> {
+    readonly type: FPEnvelopeType.WAL;
+}
+declare function Car2FPMsg(fpcar: Uint8Array): Result<FPEnvelopeCar>;
+declare function File2FPMsg(fpfile: Uint8Array): Result<FPEnvelopeFile>;
+
+interface SerdeGatewayOpts {
+    readonly gateway: SerdeGateway;
+}
+type SerdeGetResult<S> = Result<FPEnvelope<S>, NotFoundError | Error>;
+type VoidResult = Result<void>;
+type UnsubscribeResult = Result<() => void>;
+interface SerdeGateway {
+    buildUrl(sthis: SuperThis, baseUrl: URI, key: string, loader?: Loadable): Promise<Result<URI>>;
+    start(sthis: SuperThis, baseUrl: URI, loader?: Loadable): Promise<Result<URI>>;
+    close(sthis: SuperThis, baseUrl: URI, loader?: Loadable): Promise<VoidResult>;
+    put<T>(sthis: SuperThis, url: URI, body: FPEnvelope<T>, loader?: Loadable): Promise<VoidResult>;
+    get<S>(sthis: SuperThis, url: URI, loader?: Loadable): Promise<SerdeGetResult<S>>;
+    delete(sthis: SuperThis, url: URI, loader?: Loadable): Promise<VoidResult>;
+    subscribe?(sthis: SuperThis, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>, loader?: Loadable): Promise<UnsubscribeResult>;
+    getPlain(sthis: SuperThis, url: URI, key: string, loader?: Loadable): Promise<Result<Uint8Array>>;
+    destroy(sthis: SuperThis, baseUrl: URI, loader?: Loadable): Promise<VoidResult>;
+}
+interface SerdeGatewayReturn<O, T> {
+    readonly op: O;
+    readonly value?: T;
+    readonly stop?: boolean;
+}
+interface SerdeGatewayBuildUrlOp {
+    readonly url: URI;
+    readonly key: string;
+}
+type SerdeGatewayBuildUrlReturn = SerdeGatewayReturn<SerdeGatewayBuildUrlOp, Result<URI>>;
+interface SerdeGatewayStartOp {
+    readonly url: URI;
+}
+type SerdeGatewayStartReturn = SerdeGatewayReturn<SerdeGatewayStartOp, Result<URI>>;
+interface SerdeGatewayCloseOp {
+    readonly url: URI;
+}
+type SerdeGatewayCloseReturn = SerdeGatewayReturn<SerdeGatewayCloseOp, VoidResult>;
+interface SerdeGatewayDestroyOp {
+    readonly url: URI;
+}
+type SerdeGatewayDestroyReturn = SerdeGatewayReturn<SerdeGatewayDestroyOp, VoidResult>;
+interface SerdeGatewayPutOp<T> {
+    readonly url: URI;
+    readonly body: FPEnvelope<T>;
+}
+type SerdeGatewayPutReturn<T> = SerdeGatewayReturn<SerdeGatewayPutOp<T>, VoidResult>;
+interface SerdeGatewayGetOp {
+    readonly url: URI;
+}
+type SerdeGatewayGetReturn<S> = SerdeGatewayReturn<SerdeGatewayGetOp, SerdeGetResult<S>>;
+interface SerdeGatewayDeleteOp {
+    readonly url: URI;
+}
+type SerdeGatewayDeleteReturn = SerdeGatewayReturn<SerdeGatewayDeleteOp, VoidResult>;
+interface SerdeGatewaySubscribeOp {
+    readonly url: URI;
+    readonly callback: (meta: FPEnvelopeMeta) => Promise<void>;
+}
+type SerdeGatewaySubscribeReturn = SerdeGatewayReturn<SerdeGatewaySubscribeOp, UnsubscribeResult>;
+interface SerdeGatewayInterceptor {
+    buildUrl(sthis: SuperThis, baseUrl: URI, key: string, loader: Loadable): Promise<Result<SerdeGatewayBuildUrlReturn>>;
+    start(sthis: SuperThis, baseUrl: URI, loader: Loadable): Promise<Result<SerdeGatewayStartReturn>>;
+    close(sthis: SuperThis, baseUrl: URI, loader: Loadable): Promise<Result<SerdeGatewayCloseReturn>>;
+    delete(sthis: SuperThis, baseUrl: URI, loader: Loadable): Promise<Result<SerdeGatewayDeleteReturn>>;
+    destroy(sthis: SuperThis, baseUrl: URI, loader: Loadable): Promise<Result<SerdeGatewayDestroyReturn>>;
+    put<T>(sthis: SuperThis, url: URI, body: FPEnvelope<T>, loader: Loadable): Promise<Result<SerdeGatewayPutReturn<T>>>;
+    get<S>(sthis: SuperThis, url: URI, loader: Loadable): Promise<Result<SerdeGatewayGetReturn<S>>>;
+    subscribe(sthis: SuperThis, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>, loader: Loadable): Promise<Result<SerdeGatewaySubscribeReturn>>;
+}
 
 type AnyLink = Link<unknown, number, number, Version>;
 type CarGroup = AnyLink[];
@@ -337,20 +392,43 @@ interface StoreFactory {
     }>;
     decodeFile?: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<File>;
 }
-interface StoreOpts extends StoreFactory {
-    readonly isIndex?: string;
-    readonly stores?: {
-        readonly base?: CoerceURI;
-        readonly meta?: CoerceURI;
-        readonly data?: CoerceURI;
-        readonly index?: CoerceURI;
-        readonly wal?: CoerceURI;
-    };
+interface StoreUrls {
+    readonly meta: CoerceURI;
+    readonly data: CoerceURI;
+    readonly wal: CoerceURI;
+}
+interface StoreEnDeFile {
+    readonly encodeFile: (blob: BlobLike) => Promise<{
+        cid: AnyLink;
+        blocks: AnyBlock[];
+    }>;
+    readonly decodeFile: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<File>;
+}
+interface StoreUrlsOpts {
+    readonly base?: CoerceURI;
+    readonly data?: Partial<StoreUrls>;
+    readonly idx?: Partial<StoreUrls>;
+}
+interface StoreURIs {
+    readonly meta: URI;
+    readonly data: URI;
+    readonly file: URI;
+    readonly wal: URI;
+}
+interface StoreURIRuntime {
+    readonly data: StoreURIs;
+    readonly idx: StoreURIs;
+}
+interface StoreFactoryItem {
+    readonly sthis: SuperThis;
+    readonly url: URI;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly loader: Loadable;
 }
 interface StoreRuntime {
-    makeMetaStore(loader: Loadable): Promise<MetaStore>;
-    makeDataStore(loader: Loadable): Promise<DataStore>;
-    makeWALStore(loader: Loadable): Promise<WALStore>;
+    makeMetaStore(sfi: StoreFactoryItem): Promise<MetaStore>;
+    makeDataStore(sfi: StoreFactoryItem): Promise<DataStore>;
+    makeWALStore(sfi: StoreFactoryItem): Promise<WALStore>;
     encodeFile(blob: BlobLike): Promise<{
         cid: AnyLink;
         blocks: AnyBlock[];
@@ -363,24 +441,22 @@ interface CommitOpts {
 }
 interface DbMeta {
     readonly cars: CarGroup;
-    key?: string;
 }
 type LoadHandler = (dbMetas: DbMeta[]) => Promise<void>;
+interface RefLoadable {
+    readonly loader: Loadable;
+}
+interface RefBlockstore {
+    readonly blockstore: RefLoadable;
+}
 interface Connection {
-    readonly loader?: Loadable;
     readonly loaded: Promise<void>;
-    dashboardUrl?: URI;
-    connectMeta_X({ loader }: {
-        loader?: Loadable;
-    }): void;
-    connectStorage_X({ loader }: {
-        loader?: Loadable;
-    }): void;
+    connectStorage(ref: RefLoadable | RefBlockstore): void;
 }
 interface BaseStore {
     readonly storeType: StoreType;
+    readonly realGateway: SerdeGateway;
     url(): URI;
-    readonly name: string;
     onStarted(fn: () => void): void;
     onClosed(fn: () => void): void;
     keyedCrypto(): Promise<KeyedCrypto>;
@@ -389,14 +465,17 @@ interface BaseStore {
     readonly ready?: () => Promise<void>;
     start(): Promise<Result<URI>>;
 }
+interface DbMetaEvent {
+    readonly eventCid: CarClockLink;
+    readonly parents: CarClockHead;
+    readonly dbMeta: DbMeta;
+}
+declare function DbMetaEventEqual(a: DbMetaEvent, b: DbMetaEvent): boolean;
+declare function DbMetaEventsEqual(a: DbMetaEvent[], b: DbMetaEvent[]): boolean;
 interface MetaStore extends BaseStore {
     readonly storeType: "meta";
     load(branch?: string): Promise<DbMeta[] | Falsy>;
     save(meta: DbMeta, branch?: string): Promise<Result<void>>;
-    handleByteHeads(byteHeads: Uint8Array, branch?: string): Promise<{
-        eventCid: CarClockLink;
-        dbMeta: DbMeta;
-    }[]>;
 }
 interface DataSaveOpts {
     readonly public: boolean;
@@ -408,9 +487,9 @@ interface DataStore extends BaseStore {
     remove(cid: AnyLink): Promise<Result<void>>;
 }
 interface WALState {
-    operations: DbMeta[];
-    noLoaderOps: DbMeta[];
-    fileOperations: {
+    readonly operations: DbMeta[];
+    readonly noLoaderOps: DbMeta[];
+    readonly fileOperations: {
         readonly cid: AnyLink;
         readonly public: boolean;
     }[];
@@ -430,253 +509,402 @@ type CompactFetcher = BlockFetcher & {
     readonly loggedBlocks: CarTransaction;
 };
 type CompactFn = (blocks: CompactFetcher) => Promise<TransactionMeta>;
-type BlockstoreOpts = Partial<{
+interface StoreRuntimeUrls {
+    readonly meta: URI;
+    readonly data: URI;
+    readonly wal: URI;
+}
+interface BlockstoreParams {
     readonly logger: Logger;
     readonly applyMeta: (meta: TransactionMeta, snap?: boolean) => Promise<void>;
     readonly compact: CompactFn;
     readonly autoCompact: number;
     readonly crypto: CryptoRuntime;
-    readonly store: StoreOpts;
-    readonly keyBag: KeyBagOpts;
     readonly public: boolean;
     readonly meta: DbMeta;
-    readonly name: string;
     readonly threshold: number;
-}>;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly storeEnDeFile: Partial<StoreEnDeFile>;
+    readonly keyBag: KeyBagRuntime;
+    readonly storeUrls: StoreURIs;
+    readonly storeRuntime: StoreRuntime;
+}
+type BlockstoreOpts = Partial<BlockstoreParams> & {
+    readonly keyBag: KeyBagRuntime;
+    readonly storeUrls: StoreURIs;
+    readonly storeRuntime: StoreRuntime;
+};
 interface BlockstoreRuntime {
     readonly logger: Logger;
     readonly applyMeta: (meta: TransactionMeta, snap?: boolean) => Promise<void>;
     readonly compact: CompactFn;
     readonly autoCompact: number;
     readonly crypto: CryptoRuntime;
-    readonly store: StoreOpts;
     readonly storeRuntime: StoreRuntime;
-    readonly keyBag: Partial<KeyBagOpts>;
+    readonly keyBag: KeyBagRuntime;
+    readonly storeUrls: StoreURIs;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
     readonly meta?: DbMeta;
-    readonly name?: string;
     readonly threshold: number;
 }
 interface Loadable {
-    readonly name: string;
     readonly sthis: SuperThis;
     readonly ebOpts: BlockstoreRuntime;
-    remoteCarStore?: DataStore;
-    carStore(): Promise<DataStore>;
     carLog: CarLog;
     remoteMetaStore?: MetaStore;
     remoteFileStore?: DataStore;
-    taskManager?: TaskManager;
+    remoteCarStore?: DataStore;
+    readonly taskManager: TaskManager;
     ready(): Promise<void>;
     close(): Promise<void>;
+    keyBag(): Promise<KeyBag>;
+    metaStore(): Promise<MetaStore>;
     fileStore(): Promise<DataStore>;
     WALStore(): Promise<WALStore>;
+    carStore(): Promise<DataStore>;
     handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
+    commit<T = TransactionMeta>(t: CarTransaction, done: T, opts: CommitOpts): Promise<CarGroup>;
+    destroy(): Promise<void>;
+    getBlock(cid: AnyLink): Promise<AnyBlock | Falsy>;
+    loadFileCar(cid: AnyLink): Promise<CarReader>;
+    loadCar(cid: AnyLink): Promise<CarReader>;
+    commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
+    entries(cache?: boolean): AsyncIterableIterator<AnyBlock>;
 }
-type DbMetaEventBlock = EventBlock<{
-    dbMeta: Uint8Array;
-}>;
+interface DbMetaBinary {
+    readonly dbMeta: Uint8Array;
+}
+type DbMetaEventBlock = EventBlock<DbMetaBinary>;
 type CarClockLink = Link<DbMetaEventBlock, number, number, Version>;
 type CarClockHead = CarClockLink[];
 
+interface SerdeGatewayInstances {
+    readonly gateway: SerdeGateway;
+}
+interface GatewayReady extends SerdeGatewayInstances {
+    readonly url: URI;
+}
+declare function getStartedGateway(sthis: SuperThis, url: URI): Promise<Result<GatewayReady>>;
+declare function ensureStoreEnDeFile(ende?: Partial<StoreEnDeFile>): StoreEnDeFile;
+declare function toStoreRuntime(sthis: SuperThis, endeOpts?: Partial<StoreEnDeFile>): StoreRuntime;
+
 interface GatewayOpts {
     readonly gateway: Gateway;
 }
 type GetResult = Result<Uint8Array, NotFoundError | Error>;
-type VoidResult = Result<void>;
-interface TestGateway {
-    get(url: URI, key: string): Promise<Uint8Array>;
-}
-type UnsubscribeResult = Result<() => void>;
 interface Gateway {
-    buildUrl(baseUrl: URI, key: string): Promise<Result<URI>>;
-    start(baseUrl: URI): Promise<Result<URI>>;
-    close(baseUrl: URI): Promise<VoidResult>;
-    destroy(baseUrl: URI): Promise<VoidResult>;
-    put(url: URI, body: Uint8Array): Promise<VoidResult>;
-    get(url: URI): Promise<GetResult>;
-    delete(url: URI): Promise<VoidResult>;
-    subscribe?(url: URI, callback: (meta: Uint8Array) => void): Promise<UnsubscribeResult>;
+    buildUrl(baseUrl: URI, key: string, sthis: SuperThis$1): Promise<Result<URI>>;
+    start(baseUrl: URI, sthis: SuperThis$1): Promise<Result<URI>>;
+    close(baseUrl: URI, sthis: SuperThis$1): Promise<VoidResult>;
+    destroy(baseUrl: URI, sthis: SuperThis$1): Promise<VoidResult>;
+    put(url: URI, body: Uint8Array, sthis: SuperThis$1): Promise<VoidResult>;
+    get(url: URI, sthis: SuperThis$1): Promise<GetResult>;
+    delete(url: URI, sthis: SuperThis$1): Promise<VoidResult>;
+    subscribe?(url: URI, callback: (meta: Uint8Array) => void, sthis: SuperThis$1): Promise<UnsubscribeResult>;
+    getPlain(url: URI, key: string, sthis: SuperThis$1): Promise<Result<Uint8Array>>;
+}
+
+declare class PassThroughGateway implements SerdeGatewayInterceptor {
+    buildUrl(sthis: SuperThis, url: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>>;
+    start(sthis: SuperThis, url: URI): Promise<Result<SerdeGatewayStartReturn>>;
+    close(sthis: SuperThis, url: URI): Promise<Result<SerdeGatewayCloseReturn>>;
+    delete(sthis: SuperThis, url: URI): Promise<Result<SerdeGatewayDeleteReturn>>;
+    destroy(sthis: SuperThis, url: URI): Promise<Result<SerdeGatewayDestroyReturn>>;
+    put<T>(sthis: SuperThis, url: URI, body: FPEnvelope<T>): Promise<Result<SerdeGatewayPutReturn<T>>>;
+    get<S>(sthis: SuperThis, url: URI): Promise<Result<SerdeGatewayGetReturn<S>>>;
+    subscribe(sthis: SuperThis, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<SerdeGatewaySubscribeReturn>>;
+}
+declare class InterceptorGateway implements SerdeGateway {
+    readonly innerGW: SerdeGateway;
+    readonly interceptor: SerdeGatewayInterceptor;
+    constructor(sthis: SuperThis, innerGW: SerdeGateway, interceptor: SerdeGatewayInterceptor | undefined);
+    buildUrl(sthis: SuperThis, baseUrl: URI, key: string, loader: Loadable): Promise<Result<URI>>;
+    destroy(sthis: SuperThis, iurl: URI, loader: Loadable): Promise<Result<void>>;
+    start(sthis: SuperThis, url: URI, loader: Loadable): Promise<Result<URI>>;
+    close(sthis: SuperThis, url: URI, loader: Loadable): Promise<VoidResult>;
+    put<T>(sthis: SuperThis, url: URI, fpEnv: FPEnvelope<T>, loader: Loadable): Promise<VoidResult>;
+    get<S>(sthis: SuperThis, url: URI, loader: Loadable): Promise<SerdeGetResult<S>>;
+    subscribe(sthis: SuperThis, url: URI, callback: (msg: FPEnvelopeMeta) => Promise<void>, loader: Loadable): Promise<UnsubscribeResult>;
+    delete(sthis: SuperThis, url: URI, loader: Loadable): Promise<VoidResult>;
+    getPlain(sthis: SuperThis, url: URI, key: string, loader?: Loadable): Promise<Result<Uint8Array>>;
 }
 
-interface GatewayFactoryItem {
+declare function createDbMetaEvent(sthis: SuperThis, dbMeta: DbMeta, parents: CarClockHead): Promise<DbMetaEvent>;
+
+interface SerdeGatewayFactoryItem {
     readonly protocol: string;
-    readonly overrideBaseURL?: string;
-    readonly overrideRegistration?: boolean;
-    readonly gateway: (sthis: SuperThis) => Promise<Gateway>;
-    readonly test: (sthis: SuperThis) => Promise<TestGateway>;
+    readonly isDefault?: boolean;
+    defaultURI(sthis: SuperThis): URI;
+    serdegateway(sthis: SuperThis): Promise<SerdeGateway>;
 }
-interface GatewayReady {
-    readonly gateway: Gateway;
-    readonly test: TestGateway;
-}
-declare function getGatewayFromURL(url: URI, sthis: SuperThis): Promise<GatewayReady | undefined>;
-declare function registerStoreProtocol(item: GatewayFactoryItem): () => void;
-declare function testStoreFactory(url: URI, sthis: SuperThis): Promise<TestGateway>;
-declare function ensureStart<T>(store: T & {
-    start: () => Promise<Result<URI>>;
-}, logger: Logger): Promise<T>;
-declare function toStoreRuntime(opts: StoreOpts, sthis: SuperThis): StoreRuntime;
+declare function getDefaultURI(sthis: SuperThis, protocol?: string): URI;
+interface SerdeOrGatewayFactoryItem {
+    readonly protocol: string;
+    readonly isDefault?: boolean;
+    readonly defaultURI: (sthis: SuperThis) => URI;
+    readonly serdegateway?: (sthis: SuperThis) => Promise<SerdeGateway>;
+    readonly gateway?: (sthis: SuperThis) => Promise<Gateway>;
+}
+declare function registerStoreProtocol(item: SerdeOrGatewayFactoryItem): () => void;
+declare function getGatewayFactoryItem(protocol: string): SerdeGatewayFactoryItem | undefined;
+declare function defaultGatewayFactoryItem(): SerdeGatewayFactoryItem;
 
-declare class FragmentGateway implements Gateway {
+declare class Loader implements Loadable {
+    readonly ebOpts: BlockstoreRuntime;
+    readonly commitQueue: CommitQueue<CarGroup>;
+    readonly isCompacting = false;
+    readonly carReaders: Map<string, Promise<CarReader$1>>;
+    readonly seenCompacted: Set<string>;
+    readonly processedCars: Set<string>;
     readonly sthis: SuperThis;
+    readonly taskManager: TaskManager;
+    carLog: CarLog;
+    remoteMetaStore?: MetaStore;
+    remoteCarStore?: DataStore;
+    remoteFileStore?: DataStore;
+    private getBlockCache;
+    private seenMeta;
+    private writeLimit;
+    private readonly _carStore;
+    carStore(): Promise<DataStore>;
+    private readonly _fileStore;
+    fileStore(): Promise<DataStore>;
+    private readonly _WALStore;
+    WALStore(): Promise<WALStore>;
+    private readonly _metaStore;
+    metaStore(): Promise<MetaStore>;
+    keyBag(): Promise<KeyBag>;
+    private readonly onceReady;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
     readonly logger: Logger;
-    readonly fidLength = 4;
-    readonly innerGW: Gateway;
-    headerSize: number;
-    constructor(sthis: SuperThis, innerGW: Gateway);
-    slicer(url: URI, body: Uint8Array): Promise<VoidResult>[];
-    buildUrl(baseUrl: URI, key: string): Promise<Result<URI>>;
-    destroy(iurl: URI): Promise<Result<void>>;
-    start(url: URI): Promise<Result<URI>>;
-    close(url: URI): Promise<VoidResult>;
-    put(url: URI, body: Uint8Array): Promise<VoidResult>;
-    get(url: URI): Promise<GetResult>;
-    subscribe(url: URI, callback: (msg: Uint8Array) => void): Promise<UnsubscribeResult>;
-    delete(url: URI): Promise<VoidResult>;
+    constructor(sthis: SuperThis, ebOpts: BlockstoreOpts);
+    handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
+    mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
+    loadCarHeaderFromMeta<T>({ cars: cids }: DbMeta): Promise<CarHeader<T>>;
+    commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
+    loadFileCar(cid: AnyLink): Promise<CarReader$1>;
+    commit<T = TransactionMeta>(t: CarTransaction, done: T, opts?: CommitOpts): Promise<CarGroup>;
+    updateCarLog<T>(cids: CarGroup, fp: CarHeader<T>, compact: boolean): Promise<void>;
+    cacheTransaction(t: CarTransaction): Promise<void>;
+    cacheCarReader(carCidStr: string, reader: CarReader$1): Promise<void>;
+    removeCidsForCompact(cid: AnyLink): Promise<void>;
+    entries(cache?: boolean): AsyncIterableIterator<AnyBlock>;
+    getBlock(cid: AnyLink): Promise<AnyBlock | Falsy>;
+    loadCar(cid: AnyLink): Promise<CarReader$1>;
+    makeDecoderAndCarReader(cid: AnyLink, local: DataStore, remote?: DataStore): Promise<CarReader$1>;
+    protected storesLoadCar(cid: AnyLink, local: DataStore, remote?: DataStore): Promise<CarReader$1>;
+    protected getMoreReaders(cids: AnyLink[]): Promise<void>;
 }
 
-interface Connectable {
-    readonly blockstore: {
-        readonly loader?: Loader;
-        readonly ebOpts: BlockstoreRuntime;
-    };
-    readonly name?: string;
-}
+declare function parseCarFile<T>(reader: CarReader$1, logger: Logger): Promise<CarHeader<T>>;
+
 declare abstract class ConnectionBase implements Connection {
-    loader?: Loadable;
+    private loader?;
     taskManager?: TaskManager;
     loaded: Promise<void>;
     readonly url: URI;
     readonly logger: Logger;
     constructor(url: URI, logger: Logger);
     refresh(): Promise<void>;
-    connect_X({ loader }: {
-        readonly loader?: Loadable;
-    }): Promise<void>;
-    connectMeta_X({ loader }: {
-        loader?: Loadable;
-    }): Promise<void>;
+    connect(refl: RefLoadable | RefBlockstore): Promise<void>;
+    connectMeta(refl: RefLoadable | RefBlockstore): Promise<void>;
     abstract onConnect(): Promise<void>;
-    connectStorage_X({ loader }: {
-        loader?: Loadable;
-    }): Promise<void>;
+    connectStorage(refl: RefLoadable | RefBlockstore): Promise<void>;
 }
 
-declare function parseCarFile<T>(reader: CarReader, logger: Logger): Promise<CarHeader<T>>;
-
-declare function setCryptoKeyFromGatewayMetaPayload(uri: URI, sthis: SuperThis, data: Uint8Array): Promise<Result<DbMeta | undefined>>;
-declare function addCryptoKeyToGatewayMetaPayload(uri: URI, sthis: SuperThis, body: Uint8Array): Promise<Result<Uint8Array>>;
-
-type index$3_AnyAnyBlock = AnyAnyBlock;
-type index$3_AnyAnyLink = AnyAnyLink;
-type index$3_AnyBlock = AnyBlock;
-type index$3_AnyDecodedBlock = AnyDecodedBlock;
-type index$3_AnyLink = AnyLink;
-type index$3_AnyLinkFn = AnyLinkFn;
-type index$3_BaseBlockstore = BaseBlockstore;
-declare const index$3_BaseBlockstore: typeof BaseBlockstore;
-type index$3_BaseStore = BaseStore;
-type index$3_BlobLike = BlobLike;
-type index$3_BlockFetcher = BlockFetcher;
-type index$3_BlockstoreOpts = BlockstoreOpts;
-type index$3_BlockstoreRuntime = BlockstoreRuntime;
-type index$3_BytesWithIv = BytesWithIv;
-type index$3_CIDBlock = CIDBlock;
-type index$3_CarClockHead = CarClockHead;
-type index$3_CarClockLink = CarClockLink;
-type index$3_CarGroup = CarGroup;
-type index$3_CarHeader<T> = CarHeader<T>;
-type index$3_CarLog = CarLog;
-type index$3_CarMakeable = CarMakeable;
-type index$3_CarTransaction = CarTransaction;
-declare const index$3_CarTransaction: typeof CarTransaction;
-type index$3_CodecOpts = CodecOpts;
-type index$3_CommitOpts = CommitOpts;
-type index$3_CompactFetcher = CompactFetcher;
-type index$3_CompactFn = CompactFn;
-type index$3_CompactionFetcher = CompactionFetcher;
-declare const index$3_CompactionFetcher: typeof CompactionFetcher;
-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_DataSaveOpts = DataSaveOpts;
-type index$3_DataStore = DataStore;
-type index$3_DbMeta = DbMeta;
-type index$3_DbMetaEventBlock = DbMetaEventBlock;
-type index$3_EncryptedBlock = EncryptedBlock;
-type index$3_EncryptedBlockstore = EncryptedBlockstore;
-declare const index$3_EncryptedBlockstore: typeof EncryptedBlockstore;
-type index$3_FragmentGateway = FragmentGateway;
-declare const index$3_FragmentGateway: typeof FragmentGateway;
-type index$3_Gateway = Gateway;
-type index$3_GatewayFactoryItem = GatewayFactoryItem;
-type index$3_GatewayOpts = GatewayOpts;
-type index$3_GetResult = GetResult;
-type index$3_IvAndBytes = IvAndBytes;
-type index$3_IvKeyIdData = IvKeyIdData;
-type index$3_KeyMaterial = KeyMaterial;
-type index$3_KeyWithFingerExtract = KeyWithFingerExtract;
-type index$3_KeyWithFingerPrint = KeyWithFingerPrint;
-type index$3_KeyedCrypto = KeyedCrypto;
-type index$3_LoadHandler = LoadHandler;
-type index$3_Loadable = Loadable;
-type index$3_Loader = Loader;
-declare const index$3_Loader: typeof Loader;
-type index$3_MetaStore = MetaStore;
-type index$3_StoreFactory = StoreFactory;
-type index$3_StoreOpts = StoreOpts;
-type index$3_StoreRuntime = StoreRuntime;
-type index$3_TestGateway = TestGateway;
-type index$3_TransactionMeta = TransactionMeta;
-type index$3_TransactionWrapper<M extends TransactionMeta> = TransactionWrapper<M>;
-type index$3_UnsubscribeResult = UnsubscribeResult;
-type index$3_VoidResult = VoidResult;
-type index$3_WALState = WALState;
-type index$3_WALStore = WALStore;
-declare const index$3_addCryptoKeyToGatewayMetaPayload: typeof addCryptoKeyToGatewayMetaPayload;
-declare const index$3_ensureStart: typeof ensureStart;
-declare const index$3_getGatewayFromURL: typeof getGatewayFromURL;
-declare const index$3_parseCarFile: typeof parseCarFile;
-declare const index$3_registerStoreProtocol: typeof registerStoreProtocol;
-declare const index$3_setCryptoKeyFromGatewayMetaPayload: typeof setCryptoKeyFromGatewayMetaPayload;
-declare const index$3_testStoreFactory: typeof testStoreFactory;
-declare const index$3_toCIDBlock: typeof toCIDBlock;
-declare const index$3_toStoreRuntime: typeof toStoreRuntime;
-declare namespace index$3 {
-  export { type index$3_AnyAnyBlock as AnyAnyBlock, type index$3_AnyAnyLink as AnyAnyLink, type index$3_AnyBlock as AnyBlock, type index$3_AnyDecodedBlock as AnyDecodedBlock, type index$3_AnyLink as AnyLink, type index$3_AnyLinkFn as AnyLinkFn, index$3_BaseBlockstore as BaseBlockstore, type index$3_BaseStore as BaseStore, type index$3_BlobLike as BlobLike, type index$3_BlockFetcher as BlockFetcher, type index$3_BlockstoreOpts as BlockstoreOpts, type index$3_BlockstoreRuntime as BlockstoreRuntime, type index$3_BytesWithIv as BytesWithIv, type index$3_CIDBlock as CIDBlock, type index$3_CarClockHead as CarClockHead, type index$3_CarClockLink as CarClockLink, type index$3_CarGroup as CarGroup, type index$3_CarHeader as CarHeader, type index$3_CarLog as CarLog, type index$3_CarMakeable as CarMakeable, index$3_CarTransaction as CarTransaction, type index$3_CodecOpts as CodecOpts, type index$3_CommitOpts as CommitOpts, type index$3_CompactFetcher as CompactFetcher, type index$3_CompactFn as CompactFn, index$3_CompactionFetcher as CompactionFetcher, type index$3_Connectable as Connectable, type index$3_Connection as Connection, index$3_ConnectionBase as ConnectionBase, type index$3_DataSaveOpts as DataSaveOpts, type index$3_DataStore as DataStore, type index$3_DbMeta as DbMeta, type index$3_DbMetaEventBlock as DbMetaEventBlock, type index$3_EncryptedBlock as EncryptedBlock, index$3_EncryptedBlockstore as EncryptedBlockstore, index$3_FragmentGateway as FragmentGateway, type index$3_Gateway as Gateway, type index$3_GatewayFactoryItem as GatewayFactoryItem, type index$3_GatewayOpts as GatewayOpts, type index$3_GetResult as GetResult, type index$3_IvAndBytes as IvAndBytes, type index$3_IvKeyIdData as IvKeyIdData, type index$3_KeyMaterial as KeyMaterial, type index$3_KeyWithFingerExtract as KeyWithFingerExtract, type index$3_KeyWithFingerPrint as KeyWithFingerPrint, type index$3_KeyedCrypto as KeyedCrypto, type index$3_LoadHandler as LoadHandler, type index$3_Loadable as Loadable, index$3_Loader as Loader, type index$3_MetaStore as MetaStore, type index$3_StoreFactory as StoreFactory, type index$3_StoreOpts as StoreOpts, type index$3_StoreRuntime as StoreRuntime, type index$3_TestGateway as TestGateway, type index$3_TransactionMeta as TransactionMeta, type index$3_TransactionWrapper as TransactionWrapper, type index$3_UnsubscribeResult as UnsubscribeResult, type index$3_VoidResult as VoidResult, type index$3_WALState as WALState, type index$3_WALStore as WALStore, index$3_addCryptoKeyToGatewayMetaPayload as addCryptoKeyToGatewayMetaPayload, index$3_ensureStart as ensureStart, index$3_getGatewayFromURL as getGatewayFromURL, index$3_parseCarFile as parseCarFile, index$3_registerStoreProtocol as registerStoreProtocol, index$3_setCryptoKeyFromGatewayMetaPayload as setCryptoKeyFromGatewayMetaPayload, index$3_testStoreFactory as testStoreFactory, index$3_toCIDBlock as toCIDBlock, index$3_toStoreRuntime as toStoreRuntime };
+type index$5_AnyAnyBlock = AnyAnyBlock;
+type index$5_AnyAnyLink = AnyAnyLink;
+type index$5_AnyBlock = AnyBlock;
+type index$5_AnyDecodedBlock = AnyDecodedBlock;
+type index$5_AnyLink = AnyLink;
+type index$5_AnyLinkFn = AnyLinkFn;
+type index$5_BaseBlockstore = BaseBlockstore;
+declare const index$5_BaseBlockstore: typeof BaseBlockstore;
+type index$5_BaseStore = BaseStore;
+type index$5_BlobLike = BlobLike;
+type index$5_BlockFetcher = BlockFetcher;
+type index$5_BlockstoreOpts = BlockstoreOpts;
+type index$5_BlockstoreParams = BlockstoreParams;
+type index$5_BlockstoreRuntime = BlockstoreRuntime;
+type index$5_BytesWithIv = BytesWithIv;
+type index$5_CIDBlock = CIDBlock;
+declare const index$5_Car2FPMsg: typeof Car2FPMsg;
+type index$5_CarClockHead = CarClockHead;
+type index$5_CarClockLink = CarClockLink;
+type index$5_CarGroup = CarGroup;
+type index$5_CarHeader<T> = CarHeader<T>;
+type index$5_CarLog = CarLog;
+type index$5_CarMakeable = CarMakeable;
+type index$5_CarTransaction = CarTransaction;
+declare const index$5_CarTransaction: typeof CarTransaction;
+type index$5_CodecOpts = CodecOpts;
+type index$5_CommitOpts = CommitOpts;
+type index$5_CompactFetcher = CompactFetcher;
+type index$5_CompactFn = CompactFn;
+type index$5_CompactionFetcher = CompactionFetcher;
+declare const index$5_CompactionFetcher: typeof CompactionFetcher;
+type index$5_Connection = Connection;
+type index$5_ConnectionBase = ConnectionBase;
+declare const index$5_ConnectionBase: typeof ConnectionBase;
+type index$5_DataSaveOpts = DataSaveOpts;
+type index$5_DataStore = DataStore;
+type index$5_DbMeta = DbMeta;
+type index$5_DbMetaBinary = DbMetaBinary;
+type index$5_DbMetaEvent = DbMetaEvent;
+type index$5_DbMetaEventBlock = DbMetaEventBlock;
+declare const index$5_DbMetaEventEqual: typeof DbMetaEventEqual;
+declare const index$5_DbMetaEventsEqual: typeof DbMetaEventsEqual;
+type index$5_EncryptedBlock = EncryptedBlock;
+type index$5_EncryptedBlockstore = EncryptedBlockstore;
+declare const index$5_EncryptedBlockstore: typeof EncryptedBlockstore;
+type index$5_FPEnvelope<T> = FPEnvelope<T>;
+type index$5_FPEnvelopeCar = FPEnvelopeCar;
+type index$5_FPEnvelopeFile = FPEnvelopeFile;
+type index$5_FPEnvelopeMeta = FPEnvelopeMeta;
+type index$5_FPEnvelopeType = FPEnvelopeType;
+declare const index$5_FPEnvelopeType: typeof FPEnvelopeType;
+type index$5_FPEnvelopeWAL = FPEnvelopeWAL;
+type index$5_FPWALCarsOps = FPWALCarsOps;
+declare const index$5_File2FPMsg: typeof File2FPMsg;
+type index$5_Gateway = Gateway;
+type index$5_GatewayOpts = GatewayOpts;
+type index$5_GetResult = GetResult;
+type index$5_InterceptorGateway = InterceptorGateway;
+declare const index$5_InterceptorGateway: typeof InterceptorGateway;
+type index$5_IvAndBytes = IvAndBytes;
+type index$5_IvKeyIdData = IvKeyIdData;
+type index$5_KeyMaterial = KeyMaterial;
+type index$5_KeyWithFingerExtract = KeyWithFingerExtract;
+type index$5_KeyWithFingerPrint = KeyWithFingerPrint;
+type index$5_KeyedCrypto = KeyedCrypto;
+type index$5_LoadHandler = LoadHandler;
+type index$5_Loadable = Loadable;
+type index$5_Loader = Loader;
+declare const index$5_Loader: typeof Loader;
+type index$5_MetaStore = MetaStore;
+type index$5_PassThroughGateway = PassThroughGateway;
+declare const index$5_PassThroughGateway: typeof PassThroughGateway;
+type index$5_RefBlockstore = RefBlockstore;
+type index$5_RefLoadable = RefLoadable;
+type index$5_SerdeGateway = SerdeGateway;
+type index$5_SerdeGatewayBuildUrlOp = SerdeGatewayBuildUrlOp;
+type index$5_SerdeGatewayBuildUrlReturn = SerdeGatewayBuildUrlReturn;
+type index$5_SerdeGatewayCloseOp = SerdeGatewayCloseOp;
+type index$5_SerdeGatewayCloseReturn = SerdeGatewayCloseReturn;
+type index$5_SerdeGatewayDeleteOp = SerdeGatewayDeleteOp;
+type index$5_SerdeGatewayDeleteReturn = SerdeGatewayDeleteReturn;
+type index$5_SerdeGatewayDestroyOp = SerdeGatewayDestroyOp;
+type index$5_SerdeGatewayDestroyReturn = SerdeGatewayDestroyReturn;
+type index$5_SerdeGatewayFactoryItem = SerdeGatewayFactoryItem;
+type index$5_SerdeGatewayGetOp = SerdeGatewayGetOp;
+type index$5_SerdeGatewayGetReturn<S> = SerdeGatewayGetReturn<S>;
+type index$5_SerdeGatewayInterceptor = SerdeGatewayInterceptor;
+type index$5_SerdeGatewayOpts = SerdeGatewayOpts;
+type index$5_SerdeGatewayPutOp<T> = SerdeGatewayPutOp<T>;
+type index$5_SerdeGatewayPutReturn<T> = SerdeGatewayPutReturn<T>;
+type index$5_SerdeGatewayReturn<O, T> = SerdeGatewayReturn<O, T>;
+type index$5_SerdeGatewayStartOp = SerdeGatewayStartOp;
+type index$5_SerdeGatewayStartReturn = SerdeGatewayStartReturn;
+type index$5_SerdeGatewaySubscribeOp = SerdeGatewaySubscribeOp;
+type index$5_SerdeGatewaySubscribeReturn = SerdeGatewaySubscribeReturn;
+type index$5_SerdeGetResult<S> = SerdeGetResult<S>;
+type index$5_SerdeOrGatewayFactoryItem = SerdeOrGatewayFactoryItem;
+type index$5_StoreEnDeFile = StoreEnDeFile;
+type index$5_StoreFactory = StoreFactory;
+type index$5_StoreFactoryItem = StoreFactoryItem;
+type index$5_StoreRuntime = StoreRuntime;
+type index$5_StoreRuntimeUrls = StoreRuntimeUrls;
+type index$5_StoreURIRuntime = StoreURIRuntime;
+type index$5_StoreURIs = StoreURIs;
+type index$5_StoreUrls = StoreUrls;
+type index$5_StoreUrlsOpts = StoreUrlsOpts;
+type index$5_TransactionMeta = TransactionMeta;
+type index$5_TransactionWrapper<M extends TransactionMeta> = TransactionWrapper<M>;
+type index$5_UnsubscribeResult = UnsubscribeResult;
+type index$5_VoidResult = VoidResult;
+type index$5_WALState = WALState;
+type index$5_WALStore = WALStore;
+declare const index$5_createDbMetaEvent: typeof createDbMetaEvent;
+declare const index$5_defaultGatewayFactoryItem: typeof defaultGatewayFactoryItem;
+declare const index$5_ensureStoreEnDeFile: typeof ensureStoreEnDeFile;
+declare const index$5_getDefaultURI: typeof getDefaultURI;
+declare const index$5_getGatewayFactoryItem: typeof getGatewayFactoryItem;
+declare const index$5_getStartedGateway: typeof getStartedGateway;
+declare const index$5_parseCarFile: typeof parseCarFile;
+declare const index$5_registerStoreProtocol: typeof registerStoreProtocol;
+declare const index$5_toCIDBlock: typeof toCIDBlock;
+declare const index$5_toStoreRuntime: typeof toStoreRuntime;
+declare namespace index$5 {
+  export { type index$5_AnyAnyBlock as AnyAnyBlock, type index$5_AnyAnyLink as AnyAnyLink, type index$5_AnyBlock as AnyBlock, type index$5_AnyDecodedBlock as AnyDecodedBlock, type index$5_AnyLink as AnyLink, type index$5_AnyLinkFn as AnyLinkFn, index$5_BaseBlockstore as BaseBlockstore, type index$5_BaseStore as BaseStore, type index$5_BlobLike as BlobLike, type index$5_BlockFetcher as BlockFetcher, type index$5_BlockstoreOpts as BlockstoreOpts, type index$5_BlockstoreParams as BlockstoreParams, type index$5_BlockstoreRuntime as BlockstoreRuntime, type index$5_BytesWithIv as BytesWithIv, type index$5_CIDBlock as CIDBlock, index$5_Car2FPMsg as Car2FPMsg, type index$5_CarClockHead as CarClockHead, type index$5_CarClockLink as CarClockLink, type index$5_CarGroup as CarGroup, type index$5_CarHeader as CarHeader, type index$5_CarLog as CarLog, type index$5_CarMakeable as CarMakeable, index$5_CarTransaction as CarTransaction, type index$5_CodecOpts as CodecOpts, type index$5_CommitOpts as CommitOpts, type index$5_CompactFetcher as CompactFetcher, type index$5_CompactFn as CompactFn, index$5_CompactionFetcher as CompactionFetcher, type index$5_Connection as Connection, index$5_ConnectionBase as ConnectionBase, type index$5_DataSaveOpts as DataSaveOpts, type index$5_DataStore as DataStore, type index$5_DbMeta as DbMeta, type index$5_DbMetaBinary as DbMetaBinary, type index$5_DbMetaEvent as DbMetaEvent, type index$5_DbMetaEventBlock as DbMetaEventBlock, index$5_DbMetaEventEqual as DbMetaEventEqual, index$5_DbMetaEventsEqual as DbMetaEventsEqual, type index$5_EncryptedBlock as EncryptedBlock, index$5_EncryptedBlockstore as EncryptedBlockstore, type index$5_FPEnvelope as FPEnvelope, type index$5_FPEnvelopeCar as FPEnvelopeCar, type index$5_FPEnvelopeFile as FPEnvelopeFile, type index$5_FPEnvelopeMeta as FPEnvelopeMeta, index$5_FPEnvelopeType as FPEnvelopeType, type index$5_FPEnvelopeWAL as FPEnvelopeWAL, type index$5_FPWALCarsOps as FPWALCarsOps, index$5_File2FPMsg as File2FPMsg, type index$5_Gateway as Gateway, type index$5_GatewayOpts as GatewayOpts, type index$5_GetResult as GetResult, index$5_InterceptorGateway as InterceptorGateway, type index$5_IvAndBytes as IvAndBytes, type index$5_IvKeyIdData as IvKeyIdData, type index$5_KeyMaterial as KeyMaterial, type index$5_KeyWithFingerExtract as KeyWithFingerExtract, type index$5_KeyWithFingerPrint as KeyWithFingerPrint, type index$5_KeyedCrypto as KeyedCrypto, type index$5_LoadHandler as LoadHandler, type index$5_Loadable as Loadable, index$5_Loader as Loader, type index$5_MetaStore as MetaStore, index$5_PassThroughGateway as PassThroughGateway, type index$5_RefBlockstore as RefBlockstore, type index$5_RefLoadable as RefLoadable, type index$5_SerdeGateway as SerdeGateway, type index$5_SerdeGatewayBuildUrlOp as SerdeGatewayBuildUrlOp, type index$5_SerdeGatewayBuildUrlReturn as SerdeGatewayBuildUrlReturn, type index$5_SerdeGatewayCloseOp as SerdeGatewayCloseOp, type index$5_SerdeGatewayCloseReturn as SerdeGatewayCloseReturn, type index$5_SerdeGatewayDeleteOp as SerdeGatewayDeleteOp, type index$5_SerdeGatewayDeleteReturn as SerdeGatewayDeleteReturn, type index$5_SerdeGatewayDestroyOp as SerdeGatewayDestroyOp, type index$5_SerdeGatewayDestroyReturn as SerdeGatewayDestroyReturn, type index$5_SerdeGatewayFactoryItem as SerdeGatewayFactoryItem, type index$5_SerdeGatewayGetOp as SerdeGatewayGetOp, type index$5_SerdeGatewayGetReturn as SerdeGatewayGetReturn, type index$5_SerdeGatewayInterceptor as SerdeGatewayInterceptor, type index$5_SerdeGatewayOpts as SerdeGatewayOpts, type index$5_SerdeGatewayPutOp as SerdeGatewayPutOp, type index$5_SerdeGatewayPutReturn as SerdeGatewayPutReturn, type index$5_SerdeGatewayReturn as SerdeGatewayReturn, type index$5_SerdeGatewayStartOp as SerdeGatewayStartOp, type index$5_SerdeGatewayStartReturn as SerdeGatewayStartReturn, type index$5_SerdeGatewaySubscribeOp as SerdeGatewaySubscribeOp, type index$5_SerdeGatewaySubscribeReturn as SerdeGatewaySubscribeReturn, type index$5_SerdeGetResult as SerdeGetResult, type index$5_SerdeOrGatewayFactoryItem as SerdeOrGatewayFactoryItem, type index$5_StoreEnDeFile as StoreEnDeFile, type index$5_StoreFactory as StoreFactory, type index$5_StoreFactoryItem as StoreFactoryItem, type index$5_StoreRuntime as StoreRuntime, type index$5_StoreRuntimeUrls as StoreRuntimeUrls, type index$5_StoreURIRuntime as StoreURIRuntime, type index$5_StoreURIs as StoreURIs, type index$5_StoreUrls as StoreUrls, type index$5_StoreUrlsOpts as StoreUrlsOpts, type index$5_TransactionMeta as TransactionMeta, type index$5_TransactionWrapper as TransactionWrapper, type index$5_UnsubscribeResult as UnsubscribeResult, type index$5_VoidResult as VoidResult, type index$5_WALState as WALState, type index$5_WALStore as WALStore, index$5_createDbMetaEvent as createDbMetaEvent, index$5_defaultGatewayFactoryItem as defaultGatewayFactoryItem, index$5_ensureStoreEnDeFile as ensureStoreEnDeFile, index$5_getDefaultURI as getDefaultURI, index$5_getGatewayFactoryItem as getGatewayFactoryItem, index$5_getStartedGateway as getStartedGateway, index$5_parseCarFile as parseCarFile, index$5_registerStoreProtocol as registerStoreProtocol, index$5_toCIDBlock as toCIDBlock, index$5_toStoreRuntime as toStoreRuntime };
 }
 
 type Falsy = false | null | undefined;
 declare function isFalsy(value: unknown): value is Falsy;
+declare enum PARAM {
+    SUFFIX = "suffix",
+    URL_GEN = "urlGen",
+    STORE_KEY = "storekey",
+    STORE = "store",
+    KEY = "key",
+    INDEX = "index",
+    NAME = "name",
+    VERSION = "version",
+    RUNTIME = "runtime",
+    FRAG_SIZE = "fragSize",
+    IV_VERIFY = "ivVerify",
+    IV_HASH = "ivHash",
+    FRAG_FID = "fid",
+    FRAG_OFS = "ofs",
+    FRAG_LEN = "len",
+    FRAG_HEAD = "headerSize",
+    EXTRACTKEY = "extractKey"
+}
 declare function throwFalsy<T>(value: T | Falsy): T;
 declare function falsyToUndef<T>(value: T | Falsy): T | undefined;
 type StoreType = "data" | "wal" | "meta";
+interface FPStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    uid: number | Falsy;
+    gid: number | Falsy;
+    size: number | Falsy;
+    atime: Date | Falsy;
+    mtime: Date | Falsy;
+    ctime: Date | Falsy;
+    birthtime: Date | Falsy;
+}
 interface SysFileSystem {
     start(): Promise<SysFileSystem>;
-    mkdir(path: PathLike, options?: {
+    mkdir(path: string, options?: {
         recursive: boolean;
     }): Promise<string | undefined>;
-    readdir(path: PathLike, options?: unknown): Promise<string[]>;
-    rm(path: PathLike, options?: MakeDirectoryOptions & {
+    readdir(path: string): Promise<string[]>;
+    rm(path: string, options?: {
         recursive: boolean;
     }): Promise<void>;
-    copyFile(source: PathLike, destination: PathLike): Promise<void>;
-    readfile(path: PathLike, options?: {
-        encoding: BufferEncoding;
-        flag?: string;
-    }): Promise<Uint8Array>;
-    stat(path: PathLike): Promise<Stats>;
-    unlink(path: PathLike): Promise<void>;
-    writefile(path: PathLike, data: Uint8Array | string): Promise<void>;
+    copyFile(source: string, destination: string): Promise<void>;
+    readfile(path: string): Promise<Uint8Array>;
+    stat(path: string): Promise<FPStats>;
+    unlink(path: string): Promise<void>;
+    writefile(path: string, data: Uint8Array | string): Promise<void>;
 }
 interface PathOps {
     join(...args: string[]): string;
     dirname(path: string): string;
+    basename(path: string): string;
 }
+type ToUInt8 = Uint8Array | Result<Uint8Array>;
+type PromiseToUInt8 = ToUInt8 | Promise<Uint8Array> | Promise<Result<Uint8Array>>;
 interface TextEndeCoder {
     encode(input: string): Uint8Array;
-    decode(input: Uint8Array): string;
+    decode(input: ToUInt8): string;
 }
 interface SuperThisOpts {
     readonly logger: Logger;
@@ -693,12 +921,14 @@ interface SuperThis {
     readonly pathOps: PathOps;
     readonly ctx: Record<string, unknown>;
     readonly txt: TextEndeCoder;
-    nextId(bytes?: number): {
+    timeOrderedNextId(time?: number): {
         str: string;
-        bin: Uint8Array;
+        toString: () => string;
     };
-    timeOrderedNextId(time?: number): {
+    nextId(bytes?: number): {
         str: string;
+        bin: Uint8Array;
+        toString: () => string;
     };
     start(): Promise<void>;
     clone(override: Partial<SuperThisOpts>): SuperThis;
@@ -706,10 +936,13 @@ interface SuperThis {
 interface ConfigOpts extends Partial<SuperThisOpts> {
     readonly public?: boolean;
     readonly meta?: DbMeta;
-    readonly persistIndexes?: boolean;
+    readonly writeQueue?: Partial<WriteQueueParams>;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
     readonly autoCompact?: number;
-    readonly store?: StoreOpts;
+    readonly storeUrls?: StoreUrlsOpts;
+    readonly storeEnDe?: StoreEnDeFile;
     readonly threshold?: number;
+    readonly keyBag?: Partial<KeyBagOpts>;
 }
 type ClockLink = EventLink<Operation>;
 type ClockHead = ClockLink[];
@@ -832,6 +1065,11 @@ interface DocResponse {
     readonly clock: ClockHead;
     readonly name?: string;
 }
+interface BulkResponse {
+    readonly ids: string[];
+    readonly clock: ClockHead;
+    readonly name?: string;
+}
 type UpdateListenerFn<T extends DocTypes> = (docs: DocWithId<T>[]) => Promise<void> | void;
 type NoUpdateListenerFn = () => Promise<void> | void;
 type ListenerFn<T extends DocTypes> = UpdateListenerFn<T> | NoUpdateListenerFn;
@@ -843,7 +1081,13 @@ interface CRDTEntry {
 
 interface WriteQueue<T extends DocTypes> {
     push(task: DocUpdate<T>): Promise<MetaType>;
+    bulk(tasks: DocUpdate<T>[]): Promise<MetaType>;
+    close(): Promise<void>;
+}
+interface WriteQueueParams {
+    readonly chunkSize: number;
 }
+declare function defaultWriteQueueOpts(opts?: Partial<WriteQueueParams>): WriteQueueParams;
 
 declare class IndexTree<K extends IndexKeyType, R extends DocFragment> {
     cid?: AnyLink;
@@ -879,13 +1123,11 @@ interface ProllyNode<K extends IndexKeyType, T extends DocFragment> extends Prol
     readonly block: Promise<Block$1>;
 }
 
-declare function index$2<K extends IndexKeyType = string, T extends DocTypes = NonNullable<unknown>, R extends DocFragment = T>(sthis: SuperThis, { _crdt }: {
-    _crdt: CRDT<T> | CRDT<NonNullable<unknown>>;
-}, name: string, mapFn?: MapFn<T>, meta?: IdxMeta): Index<K, T, R>;
+declare function index$4<K extends IndexKeyType = string, T extends DocTypes = NonNullable<unknown>, R extends DocFragment = T>(refDb: HasCRDT<T>, 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;
+    readonly name: string;
     mapFn?: MapFn<T>;
     mapFnString: string;
     byKey: IndexTree<K, R>;
@@ -894,8 +1136,6 @@ declare class Index<K extends IndexKeyType, T extends DocTypes, R extends DocFra
     includeDocsDefault: boolean;
     initError?: Error;
     ready(): Promise<void>;
-    close(): Promise<void>;
-    destroy(): Promise<void>;
     readonly logger: Logger;
     constructor(sthis: SuperThis, crdt: CRDT<T> | CRDT<NonNullable<unknown>>, name: string, mapFn?: MapFn<T>, meta?: IdxMeta);
     applyMapFn(name: string, mapFn?: MapFn<T>, meta?: IdxMeta): void;
@@ -941,16 +1181,18 @@ declare class CRDTClock<T extends DocTypes> {
     int_applyHead(newHead: ClockHead, prevHead: ClockHead, localUpdates: boolean): Promise<void>;
 }
 
+interface HasCRDT<T extends DocTypes> {
+    readonly crdt: CRDT<T> | CRDT<NonNullable<unknown>>;
+}
 declare class CRDT<T extends DocTypes> {
-    readonly name?: string;
-    readonly opts: ConfigOpts;
+    readonly opts: LedgerOpts;
     readonly blockstore: BaseBlockstore;
     readonly indexBlockstore: BaseBlockstore;
     readonly indexers: Map<string, Index<IndexKeyType, NonNullable<unknown>>>;
     readonly clock: CRDTClock<T>;
     readonly logger: Logger;
     readonly sthis: SuperThis;
-    constructor(sthis: SuperThis, name?: string, opts?: ConfigOpts);
+    constructor(sthis: SuperThis, opts: LedgerOpts);
     bulk(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
     readonly onceReady: ResolveOnce<void>;
     ready(): Promise<void>;
@@ -970,25 +1212,97 @@ declare class CRDT<T extends DocTypes> {
     compact(): Promise<void>;
 }
 
-declare class Database<DT extends DocTypes = NonNullable<unknown>> implements Connectable {
-    static databases: Map<string, Database>;
+declare function keyConfigOpts(sthis: SuperThis, name?: string, opts?: ConfigOpts): string;
+interface LedgerOpts {
     readonly name?: string;
-    readonly opts: ConfigOpts;
+    readonly meta?: DbMeta;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly writeQueue: WriteQueueParams;
+    readonly storeUrls: StoreURIRuntime;
+    readonly storeEnDe: StoreEnDeFile;
+    readonly keyBag: KeyBagRuntime;
+}
+interface Ledger<DT extends DocTypes = NonNullable<unknown>> extends HasCRDT<DT> {
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly id: string;
+    readonly name: string;
+    onClosed(fn: () => void): void;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+    get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
+    put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
+    bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
+    del(id: string): Promise<DocResponse>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse<T>>;
+    allDocs<T extends DocTypes>(opts?: AllDocsQueryOpts): Promise<AllDocsResponse<T>>;
+    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>;
+}
+declare function isLedger<T extends DocTypes = NonNullable<unknown>>(db: unknown): db is Ledger<T>;
+declare function LedgerFactory<T extends DocTypes = NonNullable<unknown>>(name: string | undefined, opts?: ConfigOpts): Ledger<T>;
+declare class LedgerShell<DT extends DocTypes = NonNullable<unknown>> implements Ledger<DT> {
+    readonly ref: LedgerImpl<DT>;
+    constructor(ref: LedgerImpl<DT>);
+    get id(): string;
+    get logger(): Logger;
+    get sthis(): SuperThis;
+    get crdt(): CRDT<DT>;
+    get name(): string;
+    onClosed(fn: () => void): void;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+    get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
+    put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
+    bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
+    del(id: string): Promise<DocResponse>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse<T>>;
+    allDocs<T extends DocTypes>(opts?: AllDocsQueryOpts): Promise<AllDocsResponse<T>>;
+    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>;
+}
+declare class LedgerImpl<DT extends DocTypes = NonNullable<unknown>> implements Ledger<DT> {
+    readonly opts: LedgerOpts;
     _listening: boolean;
     readonly _listeners: Set<ListenerFn<DT>>;
     readonly _noupdate_listeners: Set<ListenerFn<DT>>;
-    readonly _crdt: CRDT<DT>;
+    readonly crdt: CRDT<DT>;
     readonly _writeQueue: WriteQueue<DT>;
-    readonly blockstore: BaseBlockstore;
+    readonly shells: Set<LedgerShell<DT>>;
+    addShell(shell: LedgerShell<DT>): void;
+    readonly _onClosedFns: Set<() => void>;
+    onClosed(fn: () => void): void;
     close(): Promise<void>;
+    shellClose(db: LedgerShell<DT>): Promise<void>;
     destroy(): Promise<void>;
     readonly _ready: ResolveOnce<void>;
     ready(): Promise<void>;
     readonly logger: Logger;
     readonly sthis: SuperThis;
-    constructor(name?: string, opts?: ConfigOpts);
+    readonly id: string;
+    constructor(sthis: SuperThis, opts: LedgerOpts);
+    get name(): string;
     get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
     put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
+    bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
     del(id: string): Promise<DocResponse>;
     changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse<T>>;
     allDocs<T extends DocTypes>(opts?: AllDocsQueryOpts): Promise<AllDocsResponse<T>>;
@@ -1005,7 +1319,8 @@ declare class Database<DT extends DocTypes = NonNullable<unknown>> implements Co
     _notify(updates: DocUpdate<NonNullable<unknown>>[]): Promise<void>;
     _no_update_notify(): Promise<void>;
 }
-declare function fireproof(name: string, opts?: ConfigOpts): Database;
+declare function toStoreURIRuntime(sthis: SuperThis, name?: string, sopts?: StoreUrlsOpts): StoreURIRuntime;
+declare function fireproof(name: string, opts?: ConfigOpts): Ledger;
 
 declare function getPath(url: URI, sthis: SuperThis$1): string;
 declare function getFileName(url: URI, sthis: SuperThis$1): string;
@@ -1083,9 +1398,94 @@ declare namespace block {
   export { block_Block as Block, block_create as create, block_createUnsafe as createUnsafe, block_decode as decode, block_encode as encode };
 }
 
-declare const index$1_block: typeof block;
+declare const index$3_block: typeof block;
+declare namespace index$3 {
+  export { index$3_block as block, codecInterface as codec };
+}
+
+interface SerializedMeta {
+    readonly data: string;
+    readonly parents: string[];
+    readonly cid: string;
+}
+type CAREncodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type FILEEncodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type METAEncodeEnvelope = (sthis: SuperThis, payload: SerializedMeta[]) => Promise<Result<Uint8Array>>;
+type WALEncodeEnvelope = (sthis: SuperThis, payload: SerializedWAL) => Promise<Result<Uint8Array>>;
+interface Encoder {
+    readonly car: CAREncodeEnvelope;
+    readonly file: FILEEncodeEnvelope;
+    readonly meta: METAEncodeEnvelope;
+    readonly wal: WALEncodeEnvelope;
+}
+declare function fpSerialize<T>(sthis: SuperThis, env: FPEnvelope<T>, pencoder?: Partial<Encoder>): Promise<Result<Uint8Array>>;
+type linkOrCid = {
+    "/": string;
+} | string;
+interface SerializedWAL {
+    readonly fileOperations?: {
+        cid: linkOrCid;
+        public: boolean;
+    }[];
+    readonly noLoaderOps?: {
+        cars: linkOrCid[];
+    }[];
+    readonly operations?: {
+        cars: linkOrCid[];
+    }[];
+}
+type CARDecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type FILEDecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type METADecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<SerializedMeta[]>>;
+type WALDecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<SerializedWAL>>;
+interface Decoder {
+    readonly car: CARDecodeEnvelope;
+    readonly file: FILEDecodeEnvelope;
+    readonly meta: METADecodeEnvelope;
+    readonly wal: WALDecodeEnvelope;
+}
+declare function fpDeserialize<S>(sthis: SuperThis, url: URI, intoRaw: PromiseToUInt8, pdecoder?: Partial<Decoder>): Promise<Result<FPEnvelope<S>>>;
+
+interface KeyBagCtx {
+    readonly dirName: string;
+    readonly sysFS: SysFileSystem;
+    readonly fName: string;
+}
+declare class KeyBagProviderFile implements KeyBagProvider {
+    _prepare(id: string): Promise<KeyBagCtx>;
+    private readonly url;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    constructor(url: URI, sthis: SuperThis);
+    get(id: string): Promise<KeyItem | undefined>;
+    set(id: string, item: KeyItem): Promise<void>;
+}
+
+declare function sysFileSystemFactory(uri: URI): Promise<SysFileSystem>;
+
+type index$2_KeyBagProviderFile = KeyBagProviderFile;
+declare const index$2_KeyBagProviderFile: typeof KeyBagProviderFile;
+declare const index$2_sysFileSystemFactory: typeof sysFileSystemFactory;
+declare namespace index$2 {
+  export { index$2_KeyBagProviderFile as KeyBagProviderFile, index$2_sysFileSystemFactory as sysFileSystemFactory };
+}
+
+type index$1_CARDecodeEnvelope = CARDecodeEnvelope;
+type index$1_CAREncodeEnvelope = CAREncodeEnvelope;
+type index$1_Decoder = Decoder;
+type index$1_Encoder = Encoder;
+type index$1_FILEDecodeEnvelope = FILEDecodeEnvelope;
+type index$1_FILEEncodeEnvelope = FILEEncodeEnvelope;
+type index$1_METADecodeEnvelope = METADecodeEnvelope;
+type index$1_METAEncodeEnvelope = METAEncodeEnvelope;
+type index$1_SerializedMeta = SerializedMeta;
+type index$1_SerializedWAL = SerializedWAL;
+type index$1_WALDecodeEnvelope = WALDecodeEnvelope;
+type index$1_WALEncodeEnvelope = WALEncodeEnvelope;
+declare const index$1_fpDeserialize: typeof fpDeserialize;
+declare const index$1_fpSerialize: typeof fpSerialize;
 declare namespace index$1 {
-  export { index$1_block as block, codecInterface as codec };
+  export { type index$1_CARDecodeEnvelope as CARDecodeEnvelope, type index$1_CAREncodeEnvelope as CAREncodeEnvelope, type index$1_Decoder as Decoder, type index$1_Encoder as Encoder, type index$1_FILEDecodeEnvelope as FILEDecodeEnvelope, type index$1_FILEEncodeEnvelope as FILEEncodeEnvelope, type index$1_METADecodeEnvelope as METADecodeEnvelope, type index$1_METAEncodeEnvelope as METAEncodeEnvelope, type index$1_SerializedMeta as SerializedMeta, type index$1_SerializedWAL as SerializedWAL, type index$1_WALDecodeEnvelope as WALDecodeEnvelope, type index$1_WALEncodeEnvelope as WALEncodeEnvelope, index$2 as file, index$1_fpDeserialize as fpDeserialize, index$1_fpSerialize as fpSerialize };
 }
 
 declare const FILESTORE_VERSION = "v0.19-file";
@@ -1094,15 +1494,28 @@ declare const INDEXDB_VERSION = "v0.19-indexdb";
 
 declare const index_FILESTORE_VERSION: typeof FILESTORE_VERSION;
 declare const index_INDEXDB_VERSION: typeof INDEXDB_VERSION;
+type index_KeyBackProviderFactory = KeyBackProviderFactory;
+type index_KeyBag = KeyBag;
+declare const index_KeyBag: typeof KeyBag;
+type index_KeyBagFile = KeyBagFile;
+type index_KeyBagOpts = KeyBagOpts;
+type index_KeyBagProvider = KeyBagProvider;
+type index_KeyBagProviderFactoryItem = KeyBagProviderFactoryItem;
+type index_KeyBagRuntime = KeyBagRuntime;
+type index_KeyItem = KeyItem;
+declare const index_defaultKeyBagOpts: typeof defaultKeyBagOpts;
+declare const index_defaultKeyBagUrl: typeof defaultKeyBagUrl;
 declare const index_files: typeof files;
 declare const index_getFileName: typeof getFileName;
+declare const index_getKeyBag: typeof getKeyBag;
 declare const index_getPath: typeof getPath;
+declare const index_registerKeyBagProviderFactory: typeof registerKeyBagProviderFactory;
 declare const index_runtimeFn: typeof runtimeFn;
 declare namespace index {
-  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, index_files as files, index_getFileName as getFileName, index_getPath as getPath, keyBag as kb, keyedCrypto as kc, index$1 as mf, index_runtimeFn as runtimeFn };
+  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, type index_KeyBackProviderFactory as KeyBackProviderFactory, index_KeyBag as KeyBag, type index_KeyBagFile as KeyBagFile, type index_KeyBagOpts as KeyBagOpts, type index_KeyBagProvider as KeyBagProvider, type index_KeyBagProviderFactoryItem as KeyBagProviderFactoryItem, type index_KeyBagRuntime as KeyBagRuntime, type index_KeyItem as KeyItem, index_defaultKeyBagOpts as defaultKeyBagOpts, index_defaultKeyBagUrl as defaultKeyBagUrl, index_files as files, index_getFileName as getFileName, index_getKeyBag as getKeyBag, index_getPath as getPath, index$1 as gw, keyBag as kb, keyedCrypto as kc, index$3 as mf, index_registerKeyBagProviderFactory as registerKeyBagProviderFactory, index_runtimeFn as runtimeFn };
 }
 
 declare const PACKAGE_VERSION: string;
 
-export { type AllDocsQueryOpts, type AllDocsResponse, CRDT, type CRDTEntry, type CRDTMeta, type ChangesOptions, type ChangesResponse, type ChangesResponseRow, type ClockHead, type ClockLink, type ConfigOpts, type Connectable, Database, type DocBase, type DocFileMeta, type DocFiles, type DocFragment, type DocLiteral, type DocObject, type DocRecord, type DocResponse, 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 MapFn, type MetaType, type NoUpdateListenerFn, NotFoundError, PACKAGE_VERSION, type PathOps, type QueryOpts, type Store, type StoreType, type SuperThis, type SuperThisOpts, type SysFileSystem, type TextEndeCoder, UInt8ArrayEqual, type UnknownDoc, type UpdateListenerFn, index$3 as blockstore, index$3 as bs, dataDir, ensureLogger, ensureSuperLog, ensureSuperThis, exceptionWrapper, falsyToUndef, fireproof, getKey, getName, getStore, index$2 as index, isFalsy, isNotFoundError, onSuperThis, index as rt, index as runtime, throwFalsy };
+export { type AllDocsQueryOpts, type AllDocsResponse, type BulkResponse, CRDT, type CRDTEntry, type CRDTMeta, type ChangesOptions, type ChangesResponse, type ChangesResponseRow, type ClockHead, type ClockLink, type ConfigOpts, type DbMeta, type DocBase, type DocFileMeta, type DocFiles, type DocFragment, type DocLiteral, type DocObject, type DocRecord, type DocResponse, type DocSet, type DocTypes, type DocUpdate, type DocValue, type DocWithId, type FPStats, type Falsy, type FileTransactionMeta, type HasCRDT, type IdxMeta, type IdxMetaMap, Index, type IndexKey, type IndexKeyType, type IndexRow, type IndexRows, type IndexTransactionMeta, type IndexUpdate, type IndexUpdateString, type Joiner, type KeyLiteral, type Ledger, LedgerFactory, type LedgerOpts, LedgerShell, type ListenerFn, type MapFn, type MetaType, type NoUpdateListenerFn, NotFoundError, PACKAGE_VERSION, PARAM, type PathOps, type PromiseToUInt8, type QueryOpts, type Store, type StoreType, type SuperThis, type SuperThisOpts, type SysFileSystem, type TextEndeCoder, type ToUInt8, UInt8ArrayEqual, type UnknownDoc, type UpdateListenerFn, index$5 as blockstore, index$5 as bs, coerceIntoUint8, coercePromiseIntoUint8, defaultWriteQueueOpts, ensureLogger, ensureSuperLog, ensureSuperThis, exceptionWrapper, falsyToUndef, fireproof, getKey, getName, getStore, index$4 as index, inplaceFilter, isFalsy, isLedger, isNotFoundError, keyConfigOpts, onSuperThis, index as rt, index as runtime, throwFalsy, toSortedArray, toStoreURIRuntime };
 declare module '@fireproof/core'