@fireproof/core 0.20.0-dev-preview-40 → 0.20.0-dev-preview-50

package/index.d.ts

@@ -1,36 +1,13 @@
-import { Logger, Future, Result, ResolveOnce, URI, ResolveSeq, CoerceURI, CryptoRuntime, CTCryptoKey, EnvFactoryOpts, Env, runtimeFn } from '@adviser/cement';
+import { Logger, Future, Result, ResolveOnce, URI, ResolveSeq, CoerceURI, CryptoRuntime, CTCryptoKey, LRUSet, 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, UnknownLink, CID, Link, BlockView, MultihashHasher } from 'multiformats';
+import { Version, Block as Block$1, UnknownLink, CID, ByteView, ArrayBufferView, Link, MultihashHasher, BlockView } from 'multiformats';
 import { BlockFetcher as BlockFetcher$1 } from '@fireproof/vendor/@web3-storage/pail/api';
 import { EventBlock } from '@fireproof/vendor/@web3-storage/pail/clock';
-import { CarReader } from '@ipld/car';
 import { ProllyNode as ProllyNode$1 } from 'prolly-trees/db-index';
-import { CarReader as CarReader$1 } from '@ipld/car/reader';
 import { SuperThis as SuperThis$1 } from '@fireproof/core';
 import { Block as Block$2 } from 'multiformats/block';
 
-interface BlockEncoder<Code extends number, T> {
-    name: string;
-    code: Code;
-    encode(data: T): ByteView<T> | PromiseLike<ByteView<T>>;
-}
-interface BlockDecoder<Code extends number, T> {
-    code: Code;
-    decode(bytes: ByteView<T> | ArrayBufferView<T>): T | PromiseLike<T>;
-}
-interface BlockCodec<Code extends number, T> extends BlockEncoder<Code, T>, BlockDecoder<Code, T> {
-}
-
-declare const codecInterface_ArrayBufferView: typeof ArrayBufferView;
-type codecInterface_BlockCodec<Code extends number, T> = BlockCodec<Code, T>;
-type codecInterface_BlockDecoder<Code extends number, T> = BlockDecoder<Code, T>;
-type codecInterface_BlockEncoder<Code extends number, T> = BlockEncoder<Code, T>;
-declare const codecInterface_ByteView: typeof ByteView;
-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;
@@ -44,6 +21,7 @@ declare class CarTransactionImpl implements CarMakeable, CarTransaction {
     superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
     put(cid: AnyLink, block: Uint8Array): Promise<void>;
     putSync(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
+    unshift(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
     entries(): AsyncIterableIterator<AnyBlock>;
 }
 declare class BaseBlockstoreImpl implements BlockFetcher {
@@ -201,14 +179,19 @@ 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_KeysItem as KeysItem, type keyBag_V1StorageKeyItem as V1StorageKeyItem, type keyBag_V2StorageKeyItem as V2StorageKeyItem, keyBag_defaultKeyBagOpts as defaultKeyBagOpts, keyBag_defaultKeyBagUrl as defaultKeyBagUrl, keyBag_getKeyBag as getKeyBag, keyBag_keysByFingerprint as keysByFingerprint, keyBag_registerKeyBagProviderFactory as registerKeyBagProviderFactory, keyBag_toKeyWithFingerPrint as toKeyWithFingerPrint };
 }
 
+interface TaskManagerParams {
+    readonly removeAfter: number;
+    readonly retryTimeout: number;
+}
 declare class TaskManager {
     private readonly eventsWeHandled;
     private queue;
     private isProcessing;
     readonly logger: Logger;
-    readonly callback: (dbMeta: DbMeta) => Promise<void>;
-    constructor(sthis: SuperThis, callback: (dbMeta: DbMeta) => Promise<void>);
-    handleEvent(cid: CarClockLink, parents: CarClockHead, dbMeta: DbMeta): Promise<void>;
+    readonly params: TaskManagerParams;
+    readonly callback: (dbMeta: DbMeta, store: ActiveStore) => Promise<void>;
+    constructor(sthis: SuperThis, callback: (dbMeta: DbMeta, store: ActiveStore) => Promise<void>, params: TaskManagerParams);
+    handleEvent(cid: CarClockLink, parents: CarClockHead, dbMeta: DbMeta, store: ActiveStore): Promise<void>;
     private processQueue;
 }
 
@@ -218,7 +201,8 @@ declare function ensureSuperLog(sthis: SuperThis, componentName: string, ctx?: R
 declare function ensureLogger(sthis: SuperThis, componentName: string, ctx?: Record<string, unknown>): Logger;
 type Joiner = (...toJoin: string[]) => string;
 interface Store {
-    readonly store: StoreType;
+    readonly pathPart: "data" | "wal" | "meta";
+    readonly fromUrl: StoreType;
     readonly name: string;
 }
 declare function getStore(url: URI, sthis: SuperThis, joiner: Joiner): Store;
@@ -235,6 +219,11 @@ declare function toSortedArray(set?: Record<string, unknown>): Record<string, un
 declare function coerceIntoUint8(raw: ToUInt8): Result<Uint8Array>;
 declare function coercePromiseIntoUint8(raw: PromiseToUInt8): Promise<Result<Uint8Array>>;
 declare function makeName(fnString: string): string;
+declare function storeType2DataMetaWal(store: StoreType): "data" | "wal" | "meta";
+declare function ensureURIDefaults(sthis: SuperThis, name: string, curi: CoerceURI | undefined, uri: URI, store: StoreType, ctx?: Partial<{
+    readonly idx: boolean;
+    readonly file: boolean;
+}>): URI;
 
 declare const FPEnvelopeTypes: {
     readonly CAR: "car";
@@ -390,9 +379,56 @@ declare class Context {
     delete(key: string): void;
 }
 
+interface BlockEncoder<Code extends number, T> {
+    readonly name: string;
+    readonly code: Code;
+    bytesToHash?(data: T): ByteView<unknown>;
+    encode(data: T): ByteView<T>;
+}
+interface AsyncBlockEncoder<Code extends number, T> {
+    readonly name: string;
+    readonly code: Code;
+    bytesToHash?(data: T): Promise<ByteView<unknown>>;
+    encode(data: T): PromiseLike<ByteView<T>>;
+}
+interface BlockDecoder<Code extends number, T> {
+    readonly code: Code;
+    valueToHashBytes?(value: T): ByteView<unknown>;
+    decode(bytes: ByteView<unknown>): T;
+}
+interface AsyncBlockDecoder<Code extends number, T> {
+    readonly code: Code;
+    valueToHashBytes?(value: T): Promise<ByteView<unknown>>;
+    decode(bytes: ByteView<unknown>): PromiseLike<T>;
+}
+interface BlockCodec<Code extends number, E, D> extends BlockEncoder<Code, E>, BlockDecoder<Code, D> {
+}
+interface AsyncBlockCodec<Code extends number, E, D> extends AsyncBlockEncoder<Code, E>, AsyncBlockDecoder<Code, D> {
+}
+
+declare const codecInterface_ArrayBufferView: typeof ArrayBufferView;
+type codecInterface_AsyncBlockCodec<Code extends number, E, D> = AsyncBlockCodec<Code, E, D>;
+type codecInterface_AsyncBlockDecoder<Code extends number, T> = AsyncBlockDecoder<Code, T>;
+type codecInterface_AsyncBlockEncoder<Code extends number, T> = AsyncBlockEncoder<Code, T>;
+type codecInterface_BlockCodec<Code extends number, E, D> = BlockCodec<Code, E, D>;
+type codecInterface_BlockDecoder<Code extends number, T> = BlockDecoder<Code, T>;
+type codecInterface_BlockEncoder<Code extends number, T> = BlockEncoder<Code, T>;
+declare const codecInterface_ByteView: typeof ByteView;
+declare namespace codecInterface {
+  export { codecInterface_ArrayBufferView as ArrayBufferView, type codecInterface_AsyncBlockCodec as AsyncBlockCodec, type codecInterface_AsyncBlockDecoder as AsyncBlockDecoder, type codecInterface_AsyncBlockEncoder as AsyncBlockEncoder, type codecInterface_BlockCodec as BlockCodec, type codecInterface_BlockDecoder as BlockDecoder, type codecInterface_BlockEncoder as BlockEncoder, codecInterface_ByteView as ByteView };
+}
+
 type AnyLink = Link<unknown, number, number, Version>;
 type CarGroup = AnyLink[];
-type CarLog = CarGroup[];
+type FroozenCarLog = CarGroup[];
+declare class CarLog {
+    readonly _logs: CarGroup[];
+    get length(): number;
+    last(): AnyLink[];
+    xunshift(logs: CarGroup): void;
+    update(logs: FroozenCarLog): void;
+    asArray(): FroozenCarLog;
+}
 type AnyAnyLink = Link<unknown, number, number, Version>;
 type AnyLinkFn = (cid: AnyLink) => Promise<AnyBlock | undefined>;
 interface AnyBlock {
@@ -433,8 +469,8 @@ interface CarMakeable {
     get(cid: AnyLink): Promise<AnyBlock | undefined>;
 }
 interface CarHeader<T> {
-    readonly cars: CarLog;
-    readonly compact: CarLog;
+    readonly cars: FroozenCarLog;
+    readonly compact: FroozenCarLog;
     readonly meta: T;
 }
 interface TransactionWrapper<M extends TransactionMeta> {
@@ -481,7 +517,7 @@ interface CryptoAction {
         iv: Uint8Array;
         tagLength: number;
     };
-    codec(iv?: Uint8Array, codecOpts?: Partial<CodecOpts>): BlockCodec<number, Uint8Array>;
+    codec(iv?: Uint8Array, codecOpts?: Partial<CodecOpts>): AsyncBlockCodec<24, Uint8Array, IvKeyIdData>;
     _decrypt(data: IvAndKeyAndBytes): Promise<Uint8Array>;
     _encrypt(data: BytesAndKeyWithIv): Promise<Uint8Array>;
 }
@@ -489,9 +525,6 @@ interface BlobLike {
     stream: () => ReadableStream;
 }
 interface StoreFactory {
-    makeMetaStore?: (loader: Loadable) => Promise<MetaStore>;
-    makeDataStore?: (loader: Loadable) => Promise<DataStore>;
-    makeWALStore?: (loader: Loadable) => Promise<WALStore>;
     encodeFile?: (blob: BlobLike) => Promise<{
         cid: AnyLink;
         blocks: AnyBlock[];
@@ -500,7 +533,8 @@ interface StoreFactory {
 }
 interface StoreUrls {
     readonly meta: CoerceURI;
-    readonly data: CoerceURI;
+    readonly car: CoerceURI;
+    readonly file: CoerceURI;
     readonly wal: CoerceURI;
 }
 interface StoreEnDeFile {
@@ -517,7 +551,7 @@ interface StoreUrlsOpts {
 }
 interface StoreURIs {
     readonly meta: URI;
-    readonly data: URI;
+    readonly car: URI;
     readonly file: URI;
     readonly wal: URI;
 }
@@ -525,15 +559,16 @@ interface StoreURIRuntime {
     readonly data: StoreURIs;
     readonly idx: StoreURIs;
 }
-interface StoreFactoryItem {
+interface UrlAndInterceptor {
     readonly url: URI;
     readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+}
+interface StoreFactoryItem {
+    readonly byStore: GatewayUrls;
     readonly loader: Loadable;
 }
 interface StoreRuntime {
-    makeMetaStore(sfi: StoreFactoryItem): Promise<MetaStore>;
-    makeDataStore(sfi: StoreFactoryItem): Promise<DataStore>;
-    makeWALStore(sfi: StoreFactoryItem): Promise<WALStore>;
+    makeStores(sfi: StoreFactoryItem): Promise<DataAndMetaAndWalStore>;
     encodeFile(blob: BlobLike): Promise<{
         cid: AnyLink;
         blocks: AnyBlock[];
@@ -544,6 +579,19 @@ interface CommitOpts {
     readonly noLoader?: boolean;
     readonly compact?: boolean;
 }
+interface WriteableDataAndMetaStore {
+    file: FileStore;
+    car: CarStore;
+    meta: MetaStore;
+}
+type DataAndMetaStore = Readonly<WriteableDataAndMetaStore>;
+interface WriteableDataAndMetaAndWalStore extends WriteableDataAndMetaStore {
+    wal?: WALStore;
+}
+type DataAndMetaAndWalStore = Readonly<WriteableDataAndMetaAndWalStore>;
+type LocalDataAndMetaAndWalStore = Readonly<Omit<WriteableDataAndMetaAndWalStore, "wal">> & {
+    readonly wal: WALStore;
+};
 interface DbMeta {
     readonly cars: CarGroup;
 }
@@ -562,14 +610,13 @@ interface Connection {
 interface BaseStore {
     readonly storeType: StoreType;
     readonly realGateway: SerdeGateway;
+    readonly logger: Logger;
     url(): URI;
-    onStarted(fn: () => void): void;
-    onClosed(fn: () => void): void;
     keyedCrypto(): Promise<CryptoAction>;
     close(): Promise<Result<void>>;
     destroy(): Promise<Result<void>>;
     readonly ready?: () => Promise<void>;
-    start(): Promise<Result<URI>>;
+    start(dam: DataAndMetaStore): Promise<Result<URI>>;
 }
 interface DbMetaEvent {
     readonly eventCid: CarClockLink;
@@ -586,8 +633,14 @@ interface MetaStore extends BaseStore {
 interface DataSaveOpts {
     readonly public: boolean;
 }
-interface DataStore extends BaseStore {
-    readonly storeType: "data";
+interface CarStore extends BaseStore {
+    readonly storeType: "car";
+    load(cid: AnyLink): Promise<AnyBlock>;
+    save(car: AnyBlock, opts?: DataSaveOpts): Promise<void>;
+    remove(cid: AnyLink): Promise<Result<void>>;
+}
+interface FileStore extends BaseStore {
+    readonly storeType: "file";
     load(cid: AnyLink): Promise<AnyBlock>;
     save(car: AnyBlock, opts?: DataSaveOpts): Promise<void>;
     remove(cid: AnyLink): Promise<Result<void>>;
@@ -634,6 +687,7 @@ interface BlockstoreParams {
     readonly keyBag: KeyBagRuntime;
     readonly storeUrls: StoreURIs;
     readonly storeRuntime: StoreRuntime;
+    readonly taskManager: TaskManagerParams;
 }
 type BlockstoreOpts = Partial<BlockstoreParams> & {
     readonly keyBag: KeyBagRuntime;
@@ -650,30 +704,102 @@ interface BlockstoreRuntime {
     readonly keyBag: KeyBagRuntime;
     readonly storeUrls: StoreURIs;
     readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly taskManager: TaskManagerParams;
     readonly meta?: DbMeta;
     readonly threshold: number;
 }
+type LocalActiveStore = Omit<ActiveStore, "active"> & {
+    readonly active: LocalDataAndMetaAndWalStore;
+};
+interface AttachedStores {
+    local(): LocalActiveStore;
+    forRemotes(actionFn: (store: ActiveStore) => Promise<unknown>): Promise<void>;
+    remotes(): ActiveStore[];
+    activate(store: DataAndMetaStore | CoerceURI): ActiveStore;
+    attach(attached: Attachable): Promise<Attached>;
+    detach(): Promise<void>;
+}
+interface BaseAttachedStores {
+    local(): BaseStore;
+    remotes(): BaseStore[];
+}
+interface CarAttachedStores extends BaseAttachedStores {
+    local(): CarStore;
+    remotes(): CarStore[];
+}
+declare abstract class BaseActiveStore {
+    abstract readonly ref: ActiveStore;
+    abstract readonly active: BaseStore;
+    abstract local(): BaseStore;
+    abstract remotes(): BaseStore[];
+    protected abstract readonly xattached: BaseAttachedStores;
+}
+interface FileAttachedStores extends BaseAttachedStores {
+    local(): FileStore;
+    remotes(): FileStore[];
+}
+declare abstract class CarActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: CarAttachedStores;
+    abstract local(): CarStore;
+    abstract remotes(): CarStore[];
+}
+declare abstract class FileActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: FileAttachedStores;
+    abstract local(): FileStore;
+    abstract remotes(): FileStore[];
+}
+type CIDActiveStore = CarActiveStore | FileActiveStore;
+interface MetaAttachedStores extends BaseAttachedStores {
+    local(): MetaStore;
+    remotes(): MetaStore[];
+}
+declare abstract class MetaActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: MetaAttachedStores;
+    abstract local(): MetaStore;
+    abstract remotes(): MetaStore[];
+}
+interface WALAttachedStores extends BaseAttachedStores {
+    local(): WALStore;
+    remotes(): WALStore[];
+}
+declare abstract class WALActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: WALAttachedStores;
+    abstract local(): WALStore;
+    abstract remotes(): WALStore[];
+}
+interface ActiveStore {
+    readonly active: DataAndMetaAndWalStore;
+    baseStores(): BaseStore[];
+    carStore(): CarActiveStore;
+    fileStore(): FileActiveStore;
+    metaStore(): MetaActiveStore;
+    walStore(): WALActiveStore;
+    local(): LocalActiveStore;
+    remotes(): ActiveStore[];
+    readonly xattached: AttachedStores;
+}
+interface CarCacheItem {
+    readonly type: "car" | "block";
+    readonly cid: AnyLink;
+    readonly blocks: AnyBlock[];
+    readonly roots: CID[];
+}
 interface Loadable {
     readonly sthis: SuperThis;
     readonly ebOpts: BlockstoreRuntime;
-    carLog: CarLog;
-    remoteMetaStore?: MetaStore;
-    remoteFileStore?: DataStore;
-    remoteCarStore?: DataStore;
+    readonly carLog: CarLog;
+    readonly attachedStores: AttachedStores;
+    attach(attached: Attachable): Promise<Attached>;
     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>;
+    handleDbMetasFromStore(metas: DbMeta[], store: ActiveStore): 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>;
+    getBlock(cid: AnyLink, store: ActiveStore): Promise<AnyBlock | Falsy>;
+    loadFileCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
+    loadCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
     commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
     entries(cache?: boolean): AsyncIterableIterator<AnyBlock>;
 }
@@ -755,80 +881,73 @@ declare function registerStoreProtocol(item: SerdeOrGatewayFactoryItem): () => v
 declare function getGatewayFactoryItem(protocol: string): SerdeGatewayFactoryItem | undefined;
 declare function defaultGatewayFactoryItem(): SerdeGatewayFactoryItem;
 
+declare function createAttachedStores(urlOrGup: CoerceURI | GatewayUrlsParam, arOrLoadable: AttachedStores | Loadable, name?: string): Promise<Attached>;
+declare class AttachedRemotesImpl implements AttachedStores {
+    private readonly _remotes;
+    readonly loadable: Loadable;
+    _local?: Attached;
+    constructor(loadable: Loadable);
+    forRemotes(action: (store: ActiveStore) => Promise<unknown>): Promise<void>;
+    remotes(): ActiveStore[];
+    local(): LocalActiveStore;
+    activate(store: DataAndMetaStore | CoerceURI): ActiveStore;
+    detach(): Promise<void>;
+    attach(attached: Attachable): Promise<Attached>;
+}
+
 declare class Loader implements Loadable {
     readonly ebOpts: BlockstoreRuntime;
+    readonly logger: Logger;
     readonly commitQueue: CommitQueue<CarGroup>;
-    readonly isCompacting = false;
-    readonly carReaders: Map<string, Promise<CarReader$1>>;
-    readonly seenCompacted: Set<string>;
-    readonly processedCars: Set<string>;
+    isCompacting: boolean;
+    private readonly cidCache;
+    private readonly maxConcurrentCarReader;
+    private readonly maxConcurrentWrite;
+    readonly seenCompacted: LRUSet<string>;
     readonly sthis: SuperThis;
     readonly taskManager: TaskManager;
-    carLog: CarLog;
-    remoteMetaStore?: MetaStore;
-    remoteCarStore?: DataStore;
-    remoteFileStore?: DataStore;
-    private getBlockCache;
+    readonly carLog: CarLog;
+    readonly attachedStores: AttachedStores;
+    attach(attached: Attachable): Promise<Attached>;
     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;
     constructor(sthis: SuperThis, ebOpts: BlockstoreOpts);
-    handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
-    mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
-    loadCarHeaderFromMeta<T>({ cars: cids }: DbMeta): Promise<CarHeader<T>>;
+    handleDbMetasFromStore(metas: DbMeta[], activeStore: ActiveStore): Promise<void>;
+    mergeDbMetaIntoClock(meta: DbMeta, activeStore: ActiveStore): Promise<void>;
+    loadCarHeaderFromMeta<T>(dbm: DbMeta, astore: ActiveStore): Promise<CarHeader<T>>;
     commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
-    loadFileCar(cid: AnyLink): Promise<CarReader$1>;
+    loadFileCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
     commit<T = TransactionMeta>(t: CarTransaction, done: T, opts?: CommitOpts): Promise<CarGroup>;
-    updateCarLog<T>(cids: CarGroup, fp: CarHeader<T>, compact: boolean): Promise<void>;
+    updateCarLog<T>(cids: CarGroup, cHeader: 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>;
+    removeCidsForCompact(cid: AnyLink, store: ActiveStore): Promise<void>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+    getBlock(cid: AnyLink, store: ActiveStore): Promise<AnyBlock | Falsy>;
+    loadCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
+    private makeDecoderAndCarReader;
+    protected storesLoadCar(carCid: AnyLink, store: CIDActiveStore): Promise<CarCacheItem>;
+    protected getMoreReaders(cids: AnyLink[], store: ActiveStore): Promise<void>;
 }
 
-declare function parseCarFile<T>(reader: CarReader$1, logger: Logger): Promise<CarHeader<T>>;
-
-declare abstract class ConnectionBase implements Connection {
-    private loader?;
-    taskManager?: TaskManager;
-    readonly context: Context;
-    readonly url: URI;
-    readonly logger: Logger;
-    constructor(url: URI, logger: Logger);
-    private readonly _loaded;
-    private _metaIsLoading;
-    loaded(): Future<void>;
-    refresh(): Promise<void>;
-    connect(refl: RefLoadable | RefBlockstore): Promise<void>;
-    connectMeta(refl: RefLoadable | RefBlockstore): Promise<void>;
-    abstract onConnect(): Promise<void>;
-    connectStorage(refl: RefLoadable | RefBlockstore): Promise<void>;
-}
+declare function parseCarFile<T>(reader: CarCacheItem, logger: Logger): Promise<CarHeader<T>>;
 
+type index$5_ActiveStore = ActiveStore;
 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_AttachedRemotesImpl = AttachedRemotesImpl;
+declare const index$5_AttachedRemotesImpl: typeof AttachedRemotesImpl;
+type index$5_AttachedStores = AttachedStores;
+type index$5_BaseActiveStore = BaseActiveStore;
+declare const index$5_BaseActiveStore: typeof BaseActiveStore;
+type index$5_BaseAttachedStores = BaseAttachedStores;
 type index$5_BaseBlockstoreImpl = BaseBlockstoreImpl;
 declare const index$5_BaseBlockstoreImpl: typeof BaseBlockstoreImpl;
 type index$5_BaseStore = BaseStore;
@@ -838,14 +957,21 @@ type index$5_BlockstoreOpts = BlockstoreOpts;
 type index$5_BlockstoreParams = BlockstoreParams;
 type index$5_BlockstoreRuntime = BlockstoreRuntime;
 type index$5_BytesAndKeyWithIv = BytesAndKeyWithIv;
+type index$5_CIDActiveStore = CIDActiveStore;
 type index$5_CIDBlock = CIDBlock;
 declare const index$5_Car2FPMsg: typeof Car2FPMsg;
+type index$5_CarActiveStore = CarActiveStore;
+declare const index$5_CarActiveStore: typeof CarActiveStore;
+type index$5_CarAttachedStores = CarAttachedStores;
+type index$5_CarCacheItem = CarCacheItem;
 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;
+declare const index$5_CarLog: typeof CarLog;
 type index$5_CarMakeable = CarMakeable;
+type index$5_CarStore = CarStore;
 type index$5_CarTransactionImpl = CarTransactionImpl;
 declare const index$5_CarTransactionImpl: typeof CarTransactionImpl;
 type index$5_CarTransactionOpts = CarTransactionOpts;
@@ -856,11 +982,10 @@ 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_CryptoAction = CryptoAction;
+type index$5_DataAndMetaAndWalStore = DataAndMetaAndWalStore;
+type index$5_DataAndMetaStore = DataAndMetaStore;
 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;
@@ -879,6 +1004,11 @@ declare const index$5_FPEnvelopeTypes: typeof FPEnvelopeTypes;
 type index$5_FPEnvelopeWAL = FPEnvelopeWAL;
 type index$5_FPWALCarsOps = FPWALCarsOps;
 declare const index$5_File2FPMsg: typeof File2FPMsg;
+type index$5_FileActiveStore = FileActiveStore;
+declare const index$5_FileActiveStore: typeof FileActiveStore;
+type index$5_FileAttachedStores = FileAttachedStores;
+type index$5_FileStore = FileStore;
+type index$5_FroozenCarLog = FroozenCarLog;
 type index$5_Gateway = Gateway;
 type index$5_GatewayOpts = GatewayOpts;
 type index$5_GetResult = GetResult;
@@ -894,6 +1024,11 @@ 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_LocalActiveStore = LocalActiveStore;
+type index$5_LocalDataAndMetaAndWalStore = LocalDataAndMetaAndWalStore;
+type index$5_MetaActiveStore = MetaActiveStore;
+declare const index$5_MetaActiveStore: typeof MetaActiveStore;
+type index$5_MetaAttachedStores = MetaAttachedStores;
 type index$5_MetaStore = MetaStore;
 type index$5_PassThroughGateway = PassThroughGateway;
 declare const index$5_PassThroughGateway: typeof PassThroughGateway;
@@ -932,12 +1067,22 @@ type index$5_StoreURIRuntime = StoreURIRuntime;
 type index$5_StoreURIs = StoreURIs;
 type index$5_StoreUrls = StoreUrls;
 type index$5_StoreUrlsOpts = StoreUrlsOpts;
+type index$5_TaskManager = TaskManager;
+declare const index$5_TaskManager: typeof TaskManager;
+type index$5_TaskManagerParams = TaskManagerParams;
 type index$5_TransactionMeta = TransactionMeta;
 type index$5_TransactionWrapper<M extends TransactionMeta> = TransactionWrapper<M>;
 type index$5_UnsubscribeResult = UnsubscribeResult;
+type index$5_UrlAndInterceptor = UrlAndInterceptor;
 type index$5_VoidResult = VoidResult;
+type index$5_WALActiveStore = WALActiveStore;
+declare const index$5_WALActiveStore: typeof WALActiveStore;
+type index$5_WALAttachedStores = WALAttachedStores;
 type index$5_WALState = WALState;
 type index$5_WALStore = WALStore;
+type index$5_WriteableDataAndMetaAndWalStore = WriteableDataAndMetaAndWalStore;
+type index$5_WriteableDataAndMetaStore = WriteableDataAndMetaStore;
+declare const index$5_createAttachedStores: typeof createAttachedStores;
 declare const index$5_createDbMetaEvent: typeof createDbMetaEvent;
 declare const index$5_defaultGatewayFactoryItem: typeof defaultGatewayFactoryItem;
 declare const index$5_ensureStoreEnDeFile: typeof ensureStoreEnDeFile;
@@ -949,7 +1094,7 @@ 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_BaseBlockstoreImpl as BaseBlockstoreImpl, 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_BytesAndKeyWithIv as BytesAndKeyWithIv, 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_CarTransactionImpl as CarTransactionImpl, type index$5_CarTransactionOpts as CarTransactionOpts, 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_CryptoAction as CryptoAction, 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, type index$5_FPEnvelopeType as FPEnvelopeType, index$5_FPEnvelopeTypes as FPEnvelopeTypes, 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_IvAndKeyAndBytes as IvAndKeyAndBytes, type index$5_IvKeyIdData as IvKeyIdData, type index$5_KeyMaterial as KeyMaterial, type index$5_KeyUpsertResult as KeyUpsertResult, type index$5_KeyWithFingerPrint as KeyWithFingerPrint, type index$5_KeysByFingerprint as KeysByFingerprint, 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_SerdeGatewayCtx as SerdeGatewayCtx, 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 };
+  export { type index$5_ActiveStore as ActiveStore, 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_AttachedRemotesImpl as AttachedRemotesImpl, type index$5_AttachedStores as AttachedStores, index$5_BaseActiveStore as BaseActiveStore, type index$5_BaseAttachedStores as BaseAttachedStores, index$5_BaseBlockstoreImpl as BaseBlockstoreImpl, 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_BytesAndKeyWithIv as BytesAndKeyWithIv, type index$5_CIDActiveStore as CIDActiveStore, type index$5_CIDBlock as CIDBlock, index$5_Car2FPMsg as Car2FPMsg, index$5_CarActiveStore as CarActiveStore, type index$5_CarAttachedStores as CarAttachedStores, type index$5_CarCacheItem as CarCacheItem, type index$5_CarClockHead as CarClockHead, type index$5_CarClockLink as CarClockLink, type index$5_CarGroup as CarGroup, type index$5_CarHeader as CarHeader, index$5_CarLog as CarLog, type index$5_CarMakeable as CarMakeable, type index$5_CarStore as CarStore, index$5_CarTransactionImpl as CarTransactionImpl, type index$5_CarTransactionOpts as CarTransactionOpts, 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, type index$5_CryptoAction as CryptoAction, type index$5_DataAndMetaAndWalStore as DataAndMetaAndWalStore, type index$5_DataAndMetaStore as DataAndMetaStore, type index$5_DataSaveOpts as DataSaveOpts, 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, type index$5_FPEnvelopeType as FPEnvelopeType, index$5_FPEnvelopeTypes as FPEnvelopeTypes, type index$5_FPEnvelopeWAL as FPEnvelopeWAL, type index$5_FPWALCarsOps as FPWALCarsOps, index$5_File2FPMsg as File2FPMsg, index$5_FileActiveStore as FileActiveStore, type index$5_FileAttachedStores as FileAttachedStores, type index$5_FileStore as FileStore, type index$5_FroozenCarLog as FroozenCarLog, 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_IvAndKeyAndBytes as IvAndKeyAndBytes, type index$5_IvKeyIdData as IvKeyIdData, type index$5_KeyMaterial as KeyMaterial, type index$5_KeyUpsertResult as KeyUpsertResult, type index$5_KeyWithFingerPrint as KeyWithFingerPrint, type index$5_KeysByFingerprint as KeysByFingerprint, type index$5_LoadHandler as LoadHandler, type index$5_Loadable as Loadable, index$5_Loader as Loader, type index$5_LocalActiveStore as LocalActiveStore, type index$5_LocalDataAndMetaAndWalStore as LocalDataAndMetaAndWalStore, index$5_MetaActiveStore as MetaActiveStore, type index$5_MetaAttachedStores as MetaAttachedStores, 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_SerdeGatewayCtx as SerdeGatewayCtx, 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, index$5_TaskManager as TaskManager, type index$5_TaskManagerParams as TaskManagerParams, type index$5_TransactionMeta as TransactionMeta, type index$5_TransactionWrapper as TransactionWrapper, type index$5_UnsubscribeResult as UnsubscribeResult, type index$5_UrlAndInterceptor as UrlAndInterceptor, type index$5_VoidResult as VoidResult, index$5_WALActiveStore as WALActiveStore, type index$5_WALAttachedStores as WALAttachedStores, type index$5_WALState as WALState, type index$5_WALStore as WALStore, type index$5_WriteableDataAndMetaAndWalStore as WriteableDataAndMetaAndWalStore, type index$5_WriteableDataAndMetaStore as WriteableDataAndMetaStore, index$5_createAttachedStores as createAttachedStores, 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 };
 }
 
 interface WriteQueueParams {
@@ -1034,11 +1179,16 @@ declare const PARAM: {
     FRAG_HEAD: string;
     EXTRACTKEY: string;
     SELF_REFLECT: string;
+    CAR_PARALLEL: string;
+    CAR_CACHE_SIZE: string;
+    CAR_COMPACT_CACHE_SIZE: string;
+    CAR_META_CACHE_SIZE: string;
+    GENESIS_CID: string;
 };
 type PARAMS = (typeof PARAM)[keyof typeof PARAM];
 declare function throwFalsy<T>(value: T | Falsy): T;
 declare function falsyToUndef<T>(value: T | Falsy): T | undefined;
-type StoreType = "data" | "wal" | "meta";
+type StoreType = "car" | "file" | "wal" | "meta";
 interface FPStats {
     isFile(): boolean;
     isDirectory(): boolean;
@@ -1268,6 +1418,7 @@ interface CarTransaction {
     readonly parent: BaseBlockstore;
     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>;
+    unshift(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
     putSync(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
     put(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): Promise<void>;
     entries(): AsyncIterableIterator<AnyBlock>;
@@ -1331,6 +1482,40 @@ interface ReadyCloseDestroy {
     destroy(): Promise<void>;
     ready(): Promise<void>;
 }
+interface CoerceURIandInterceptor {
+    readonly url: CoerceURI;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+}
+interface GatewayUrlsParam {
+    readonly car: CoerceURIandInterceptor;
+    readonly file: CoerceURIandInterceptor;
+    readonly meta: CoerceURIandInterceptor;
+    readonly wal?: CoerceURIandInterceptor;
+}
+interface GatewayUrls {
+    readonly car: UrlAndInterceptor;
+    readonly file: UrlAndInterceptor;
+    readonly meta: UrlAndInterceptor;
+    readonly wal?: UrlAndInterceptor;
+}
+interface Attachable {
+    readonly name: string;
+    prepare(): Promise<GatewayUrlsParam>;
+}
+declare class DataAndMetaAndWalAndBaseStore implements DataAndMetaAndWalStore {
+    readonly wal?: WALStore | undefined;
+    readonly file: FileStore;
+    readonly car: CarStore;
+    readonly meta: MetaStore;
+    readonly baseStores: BaseStore[];
+    constructor(dam: DataAndMetaAndWalStore);
+}
+interface Attached {
+    readonly gatewayUrls: GatewayUrls;
+    readonly stores: DataAndMetaAndWalAndBaseStore;
+    detach(): Promise<void>;
+    status(): "attached" | "loading" | "loaded" | "error" | "detached" | "syncing" | "idle";
+}
 interface Database extends ReadyCloseDestroy, HasLogger, HasSuperThis {
     readonly ledger: Ledger;
     readonly logger: Logger;
@@ -1338,6 +1523,7 @@ interface Database extends ReadyCloseDestroy, HasLogger, HasSuperThis {
     readonly id: string;
     readonly name: string;
     onClosed(fn: () => void): void;
+    attach(a: Attachable): Promise<Attached>;
     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>;
@@ -1378,6 +1564,7 @@ interface Ledger extends HasCRDT {
     readonly name: string;
     readonly context: Context;
     onClosed(fn: () => void): () => void;
+    attach(a: Attachable): Promise<Attached>;
     close(): Promise<void>;
     destroy(): Promise<void>;
     ready(): Promise<void>;
@@ -1392,6 +1579,7 @@ declare class LedgerShell implements Ledger {
     readonly writeQueue: WriteQueue<DocUpdate<DocTypes>>;
     readonly name: string;
     constructor(ref: LedgerImpl);
+    attach(a: Attachable): Promise<Attached>;
     get opts(): LedgerOpts;
     get context(): Context;
     get id(): string;
@@ -1426,6 +1614,7 @@ declare class LedgerImpl implements Ledger {
     readonly sthis: SuperThis;
     readonly id: string;
     constructor(sthis: SuperThis, opts: LedgerOpts);
+    attach(a: Attachable): Promise<Attached>;
     subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
     private _notify;
     private _no_update_notify;
@@ -1444,6 +1633,7 @@ declare class DatabaseImpl implements Database {
     readonly sthis: SuperThis;
     readonly id: string;
     constructor(ledger: Ledger);
+    attach(a: Attachable): Promise<Attached>;
     get name(): string;
     get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
     put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
@@ -1474,6 +1664,7 @@ declare class CRDTImpl implements CRDT {
     readonly crdt: CRDT;
     constructor(sthis: SuperThis, opts: LedgerOpts);
     bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
+    _bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
     readonly onceReady: ResolveOnce<void>;
     ready(): Promise<void>;
     close(): Promise<void>;
@@ -1507,15 +1698,17 @@ declare namespace files {
   export { files_decodeFile as decodeFile, files_encodeFile as encodeFile };
 }
 
-declare class BlockIvKeyIdCodec implements BlockCodec<0x300539, Uint8Array> {
-    readonly code = 3147065;
+declare class BlockIvKeyIdCodec implements AsyncBlockCodec<24, Uint8Array, IvKeyIdData> {
+    readonly code = 24;
     readonly name = "Fireproof@encrypted-block:aes-gcm";
     readonly ko: CryptoAction;
     readonly iv?: Uint8Array;
     readonly opts: Partial<CodecOpts>;
     constructor(ko: CryptoAction, iv?: Uint8Array, opts?: CodecOpts);
+    valueToHashBytes(value: IvKeyIdData): Promise<ByteView<unknown>>;
+    bytesToHash(data: Uint8Array): Promise<ByteView<unknown>>;
     encode(data: Uint8Array): Promise<Uint8Array>;
-    decode(abytes: Uint8Array | ArrayBuffer): Promise<Uint8Array>;
+    decode(abytes: Uint8Array | ArrayBuffer): Promise<IvKeyIdData>;
 }
 declare function keyedCryptoFactory(url: URI, kb: KeyBag, sthis: SuperThis): Promise<CryptoAction>;
 
@@ -1528,17 +1721,27 @@ declare namespace keyedCrypto {
 
 declare const Block: typeof Block$2;
 interface DecodeInput<T, Code extends number, Alg extends number> {
-    bytes: ByteView<T>;
-    codec: BlockDecoder<Code, T>;
-    hasher: MultihashHasher<Alg>;
+    readonly bytes: ByteView<unknown>;
+    readonly codec: BlockDecoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
 }
-declare function decode<T, Code extends number, Alg extends number>({ bytes, codec, hasher, }: DecodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg>>;
+interface AsyncDecodeInput<T, Code extends number, Alg extends number> {
+    readonly bytes: ByteView<unknown>;
+    readonly codec: AsyncBlockDecoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
+}
+declare function decode<T, Code extends number, Alg extends number>({ bytes, codec, hasher, }: AsyncDecodeInput<T, Code, Alg> | DecodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg>>;
 interface EncodeInput<T, Code extends number, Alg extends number> {
-    value: T;
-    codec: BlockEncoder<Code, T>;
-    hasher: MultihashHasher<Alg>;
+    readonly value: T;
+    readonly codec: BlockEncoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
+}
+interface AsyncEncodeInput<T, Code extends number, Alg extends number> {
+    readonly value: T;
+    readonly codec: AsyncBlockEncoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
 }
-declare function encode<T, Code extends number, Alg extends number>({ value, codec, hasher, }: EncodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg>>;
+declare function encode<T, Code extends number, Alg extends number>({ value, codec, hasher, }: AsyncEncodeInput<T, Code, Alg> | EncodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg>>;
 interface CreateInput<T, Code extends number, Alg extends number, V extends Version> {
     bytes: ByteView<T>;
     cid: Link<T, Code, Alg, V>;
@@ -1559,13 +1762,17 @@ type CreateUnsafeInput<T, Code extends number, Alg extends number, V extends Ver
 };
 declare function createUnsafe<T, Code extends number, Alg extends number, V extends Version>({ bytes, cid, value: maybeValue, codec, }: CreateUnsafeInput<T, Code, Alg, V>): Promise<BlockView<T, Code, Alg, V>>;
 
+type block_AsyncDecodeInput<T, Code extends number, Alg extends number> = AsyncDecodeInput<T, Code, Alg>;
+type block_AsyncEncodeInput<T, Code extends number, Alg extends number> = AsyncEncodeInput<T, Code, Alg>;
 declare const block_Block: typeof Block;
+type block_DecodeInput<T, Code extends number, Alg extends number> = DecodeInput<T, Code, Alg>;
+type block_EncodeInput<T, Code extends number, Alg extends number> = EncodeInput<T, Code, Alg>;
 declare const block_create: typeof create;
 declare const block_createUnsafe: typeof createUnsafe;
 declare const block_decode: typeof decode;
 declare const block_encode: typeof encode;
 declare namespace block {
-  export { block_Block as Block, block_create as create, block_createUnsafe as createUnsafe, block_decode as decode, block_encode as encode };
+  export { type block_AsyncDecodeInput as AsyncDecodeInput, type block_AsyncEncodeInput as AsyncEncodeInput, block_Block as Block, type block_DecodeInput as DecodeInput, type block_EncodeInput as EncodeInput, block_create as create, block_createUnsafe as createUnsafe, block_decode as decode, block_encode as encode };
 }
 
 declare const index$3_block: typeof block;
@@ -1688,5 +1895,5 @@ declare namespace index {
 
 declare const PACKAGE_VERSION: string;
 
-export { type AllDocsQueryOpts, type AllDocsResponse, type BaseBlockstore, type BulkResponse, type CRDT, type CRDTClock, type CRDTEntry, CRDTImpl, type CRDTMeta, type CarTransaction, type ChangesOptions, type ChangesResponse, type ChangesResponseRow, type ClockHead, type ClockLink, type ConfigOpts, type Database, DatabaseImpl, 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 HasLogger, type HasSuperThis, 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 PARAMS, type PathOps, type PromiseToUInt8, type QueryOpts, type ReadyCloseDestroy, type RefLedger, type Store, type StoreType, type SuperThis, type SuperThisOpts, type SysFileSystem, type TextEndeCoder, type ToUInt8, UInt8ArrayEqual, type UnReg, type UnknownDoc, type UpdateListenerFn, type VoidFn, type WriteQueue, 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, isDatabase, isFalsy, isLedger, isNotFoundError, keyConfigOpts, makeName, onSuperThis, index as rt, index as runtime, throwFalsy, toSortedArray, toStoreURIRuntime };
+export { type AllDocsQueryOpts, type AllDocsResponse, type Attachable, type Attached, type BaseBlockstore, type BulkResponse, type CRDT, type CRDTClock, type CRDTEntry, CRDTImpl, type CRDTMeta, type CarTransaction, type ChangesOptions, type ChangesResponse, type ChangesResponseRow, type ClockHead, type ClockLink, type CoerceURIandInterceptor, type ConfigOpts, DataAndMetaAndWalAndBaseStore, type Database, DatabaseImpl, 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 GatewayUrls, type GatewayUrlsParam, type HasCRDT, type HasLogger, type HasSuperThis, 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 PARAMS, type PathOps, type PromiseToUInt8, type QueryOpts, type ReadyCloseDestroy, type RefLedger, type Store, type StoreType, type SuperThis, type SuperThisOpts, type SysFileSystem, type TextEndeCoder, type ToUInt8, UInt8ArrayEqual, type UnReg, type UnknownDoc, type UpdateListenerFn, type VoidFn, type WriteQueue, index$5 as blockstore, index$5 as bs, coerceIntoUint8, coercePromiseIntoUint8, defaultWriteQueueOpts, ensureLogger, ensureSuperLog, ensureSuperThis, ensureURIDefaults, exceptionWrapper, falsyToUndef, fireproof, getKey, getName, getStore, index$4 as index, inplaceFilter, isDatabase, isFalsy, isLedger, isNotFoundError, keyConfigOpts, makeName, onSuperThis, index as rt, index as runtime, storeType2DataMetaWal, throwFalsy, toSortedArray, toStoreURIRuntime };
 declare module '@fireproof/core'