@fireproof/core 0.20.0-dev-preview-54 → 0.20.0-dev-preview-57

package/index.d.cts

@@ -1,4 +1,4 @@
-import { Logger, Future, URI, CryptoRuntime, ResolveOnce, Result, ResolveSeq, CTCryptoKey, CoerceURI, LRUSet, Env, EnvFactoryOpts, runtimeFn } from '@adviser/cement';
+import { Logger, Future, URI, CryptoRuntime, ResolveOnce, Result, ResolveSeq, CTCryptoKey, CoerceURI, Promisable, LRUSet, Env, EnvFactoryOpts, MatchResult, 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 { Version, Block as Block$1, UnknownLink, CID, ByteView, ArrayBufferView, Link, MultihashHasher, BlockView } from 'multiformats';
@@ -6,6 +6,10 @@ import { BlockFetcher as BlockFetcher$1 } from '@fireproof/vendor/@web3-storage/
 import { EventBlock } from '@fireproof/vendor/@web3-storage/pail/clock';
 import { ProllyNode as ProllyNode$1 } from 'prolly-trees/db-index';
 import { Block as Block$2 } from 'multiformats/block';
+import * as jose from 'jose';
+import { JWTPayload, JWTVerifyResult } from 'jose';
+import { GenerateKeyPairOptions } from 'jose/key/generate/keypair';
+import { SuperThis as SuperThis$1 } from '@fireproof/core';
 
 type BlockFetcher = BlockFetcher$1;
 interface CarTransactionOpts {
@@ -806,32 +810,6 @@ 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(ctx: SerdeGatewayCtx, 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>;
-interface Gateway {
-    buildUrl(baseUrl: URI, key: string, sthis: SuperThis): Promise<Result<URI>>;
-    start(baseUrl: URI, sthis: SuperThis): Promise<Result<URI>>;
-    close(baseUrl: URI, sthis: SuperThis): Promise<VoidResult>;
-    destroy(baseUrl: URI, sthis: SuperThis): Promise<VoidResult>;
-    put(url: URI, body: Uint8Array, sthis: SuperThis): Promise<VoidResult>;
-    get(url: URI, sthis: SuperThis): Promise<GetResult>;
-    delete(url: URI, sthis: SuperThis): Promise<VoidResult>;
-    subscribe?(url: URI, callback: (meta: Uint8Array) => void, sthis: SuperThis): Promise<UnsubscribeResult>;
-    getPlain(url: URI, key: string, sthis: SuperThis): Promise<Result<Uint8Array>>;
-}
-
 declare class PassThroughGateway implements SerdeGatewayInterceptor {
     buildUrl(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>>;
     start(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayStartReturn>>;
@@ -857,6 +835,28 @@ declare class InterceptorGateway implements SerdeGateway {
     getPlain(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>>;
 }
 
+declare function getInterceptableGateway(ctx: SerdeGatewayCtx, url: URI, opt: {
+    gatewayInterceptor?: SerdeGatewayInterceptor;
+}): Promise<Result<InterceptorGateway>>;
+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>;
+interface Gateway {
+    buildUrl(baseUrl: URI, key: string, sthis: SuperThis): Promise<Result<URI>>;
+    start(baseUrl: URI, sthis: SuperThis): Promise<Result<URI>>;
+    close(baseUrl: URI, sthis: SuperThis): Promise<VoidResult>;
+    destroy(baseUrl: URI, sthis: SuperThis): Promise<VoidResult>;
+    put(url: URI, body: Uint8Array, sthis: SuperThis): Promise<VoidResult>;
+    get(url: URI, sthis: SuperThis): Promise<GetResult>;
+    delete(url: URI, sthis: SuperThis): Promise<VoidResult>;
+    subscribe?(url: URI, callback: (meta: Uint8Array) => void, sthis: SuperThis): Promise<UnsubscribeResult>;
+    getPlain(url: URI, key: string, sthis: SuperThis): Promise<Result<Uint8Array>>;
+}
+
 declare function createDbMetaEvent(sthis: SuperThis, dbMeta: DbMeta, parents: CarClockHead): Promise<DbMetaEvent>;
 
 interface SerdeGatewayFactoryItem {
@@ -891,6 +891,21 @@ declare class AttachedRemotesImpl implements AttachedStores {
     attach(attached: Attachable): Promise<Attached>;
 }
 
+type URIMapper = (uri: URI) => Promisable<URI>;
+declare class URIInterceptor extends PassThroughGateway {
+    #private;
+    static withMapper(mapper: URIMapper): URIInterceptor;
+    addMapper(mapper: URIMapper): URIInterceptor;
+    buildUrl(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>>;
+    start(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayStartReturn>>;
+    close(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayCloseReturn>>;
+    delete(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDeleteReturn>>;
+    destroy(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDestroyReturn>>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<SerdeGatewayPutReturn<T>>>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayGetReturn<S>>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<SerdeGatewaySubscribeReturn>>;
+}
+
 declare class Loader implements Loadable {
     readonly ebOpts: BlockstoreRuntime;
     readonly logger: Logger;
@@ -931,165 +946,168 @@ declare class Loader implements Loadable {
 
 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;
-type index$5_BlockFetcher = BlockFetcher;
-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;
-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_CryptoAction = CryptoAction;
-type index$5_DataAndMetaAndWalStore = DataAndMetaAndWalStore;
-type index$5_DataAndMetaStore = DataAndMetaStore;
-type index$5_DataSaveOpts = DataSaveOpts;
-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_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;
-type index$5_InterceptorGateway = InterceptorGateway;
-declare const index$5_InterceptorGateway: typeof InterceptorGateway;
-type index$5_IvAndKeyAndBytes = IvAndKeyAndBytes;
-type index$5_IvKeyIdData = IvKeyIdData;
-type index$5_KeyMaterial = KeyMaterial;
-type index$5_KeyUpsertResult = KeyUpsertResult;
-type index$5_KeyWithFingerPrint = KeyWithFingerPrint;
-type index$5_KeysByFingerprint = KeysByFingerprint;
-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;
-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_SerdeGatewayCtx = SerdeGatewayCtx;
-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_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;
-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_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_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 };
+type index$8_ActiveStore = ActiveStore;
+type index$8_AnyAnyBlock = AnyAnyBlock;
+type index$8_AnyAnyLink = AnyAnyLink;
+type index$8_AnyBlock = AnyBlock;
+type index$8_AnyDecodedBlock = AnyDecodedBlock;
+type index$8_AnyLink = AnyLink;
+type index$8_AnyLinkFn = AnyLinkFn;
+type index$8_AttachedRemotesImpl = AttachedRemotesImpl;
+declare const index$8_AttachedRemotesImpl: typeof AttachedRemotesImpl;
+type index$8_AttachedStores = AttachedStores;
+type index$8_BaseActiveStore = BaseActiveStore;
+declare const index$8_BaseActiveStore: typeof BaseActiveStore;
+type index$8_BaseAttachedStores = BaseAttachedStores;
+type index$8_BaseBlockstoreImpl = BaseBlockstoreImpl;
+declare const index$8_BaseBlockstoreImpl: typeof BaseBlockstoreImpl;
+type index$8_BaseStore = BaseStore;
+type index$8_BlockFetcher = BlockFetcher;
+type index$8_BlockstoreOpts = BlockstoreOpts;
+type index$8_BlockstoreParams = BlockstoreParams;
+type index$8_BlockstoreRuntime = BlockstoreRuntime;
+type index$8_BytesAndKeyWithIv = BytesAndKeyWithIv;
+type index$8_CIDActiveStore = CIDActiveStore;
+type index$8_CIDBlock = CIDBlock;
+declare const index$8_Car2FPMsg: typeof Car2FPMsg;
+type index$8_CarActiveStore = CarActiveStore;
+declare const index$8_CarActiveStore: typeof CarActiveStore;
+type index$8_CarAttachedStores = CarAttachedStores;
+type index$8_CarCacheItem = CarCacheItem;
+type index$8_CarClockHead = CarClockHead;
+type index$8_CarClockLink = CarClockLink;
+type index$8_CarGroup = CarGroup;
+type index$8_CarHeader<T> = CarHeader<T>;
+type index$8_CarLog = CarLog;
+declare const index$8_CarLog: typeof CarLog;
+type index$8_CarMakeable = CarMakeable;
+type index$8_CarStore = CarStore;
+type index$8_CarTransactionImpl = CarTransactionImpl;
+declare const index$8_CarTransactionImpl: typeof CarTransactionImpl;
+type index$8_CarTransactionOpts = CarTransactionOpts;
+type index$8_CodecOpts = CodecOpts;
+type index$8_CommitOpts = CommitOpts;
+type index$8_CompactFetcher = CompactFetcher;
+type index$8_CompactFn = CompactFn;
+type index$8_CompactionFetcher = CompactionFetcher;
+declare const index$8_CompactionFetcher: typeof CompactionFetcher;
+type index$8_Connection = Connection;
+type index$8_CryptoAction = CryptoAction;
+type index$8_DataAndMetaAndWalStore = DataAndMetaAndWalStore;
+type index$8_DataAndMetaStore = DataAndMetaStore;
+type index$8_DataSaveOpts = DataSaveOpts;
+type index$8_DbMeta = DbMeta;
+type index$8_DbMetaBinary = DbMetaBinary;
+type index$8_DbMetaEvent = DbMetaEvent;
+type index$8_DbMetaEventBlock = DbMetaEventBlock;
+declare const index$8_DbMetaEventEqual: typeof DbMetaEventEqual;
+declare const index$8_DbMetaEventsEqual: typeof DbMetaEventsEqual;
+type index$8_EncryptedBlock = EncryptedBlock;
+type index$8_EncryptedBlockstore = EncryptedBlockstore;
+declare const index$8_EncryptedBlockstore: typeof EncryptedBlockstore;
+type index$8_FPEnvelope<T> = FPEnvelope<T>;
+type index$8_FPEnvelopeCar = FPEnvelopeCar;
+type index$8_FPEnvelopeFile = FPEnvelopeFile;
+type index$8_FPEnvelopeMeta = FPEnvelopeMeta;
+type index$8_FPEnvelopeType = FPEnvelopeType;
+declare const index$8_FPEnvelopeTypes: typeof FPEnvelopeTypes;
+type index$8_FPEnvelopeWAL = FPEnvelopeWAL;
+type index$8_FPWALCarsOps = FPWALCarsOps;
+declare const index$8_File2FPMsg: typeof File2FPMsg;
+type index$8_FileActiveStore = FileActiveStore;
+declare const index$8_FileActiveStore: typeof FileActiveStore;
+type index$8_FileAttachedStores = FileAttachedStores;
+type index$8_FileStore = FileStore;
+type index$8_FroozenCarLog = FroozenCarLog;
+type index$8_Gateway = Gateway;
+type index$8_GatewayOpts = GatewayOpts;
+type index$8_GetResult = GetResult;
+type index$8_InterceptorGateway = InterceptorGateway;
+declare const index$8_InterceptorGateway: typeof InterceptorGateway;
+type index$8_IvAndKeyAndBytes = IvAndKeyAndBytes;
+type index$8_IvKeyIdData = IvKeyIdData;
+type index$8_KeyMaterial = KeyMaterial;
+type index$8_KeyUpsertResult = KeyUpsertResult;
+type index$8_KeyWithFingerPrint = KeyWithFingerPrint;
+type index$8_KeysByFingerprint = KeysByFingerprint;
+type index$8_LoadHandler = LoadHandler;
+type index$8_Loadable = Loadable;
+type index$8_Loader = Loader;
+declare const index$8_Loader: typeof Loader;
+type index$8_LocalActiveStore = LocalActiveStore;
+type index$8_LocalDataAndMetaAndWalStore = LocalDataAndMetaAndWalStore;
+type index$8_MetaActiveStore = MetaActiveStore;
+declare const index$8_MetaActiveStore: typeof MetaActiveStore;
+type index$8_MetaAttachedStores = MetaAttachedStores;
+type index$8_MetaStore = MetaStore;
+type index$8_PassThroughGateway = PassThroughGateway;
+declare const index$8_PassThroughGateway: typeof PassThroughGateway;
+type index$8_RefBlockstore = RefBlockstore;
+type index$8_RefLoadable = RefLoadable;
+type index$8_SerdeGateway = SerdeGateway;
+type index$8_SerdeGatewayBuildUrlOp = SerdeGatewayBuildUrlOp;
+type index$8_SerdeGatewayBuildUrlReturn = SerdeGatewayBuildUrlReturn;
+type index$8_SerdeGatewayCloseOp = SerdeGatewayCloseOp;
+type index$8_SerdeGatewayCloseReturn = SerdeGatewayCloseReturn;
+type index$8_SerdeGatewayCtx = SerdeGatewayCtx;
+type index$8_SerdeGatewayDeleteOp = SerdeGatewayDeleteOp;
+type index$8_SerdeGatewayDeleteReturn = SerdeGatewayDeleteReturn;
+type index$8_SerdeGatewayDestroyOp = SerdeGatewayDestroyOp;
+type index$8_SerdeGatewayDestroyReturn = SerdeGatewayDestroyReturn;
+type index$8_SerdeGatewayFactoryItem = SerdeGatewayFactoryItem;
+type index$8_SerdeGatewayGetOp = SerdeGatewayGetOp;
+type index$8_SerdeGatewayGetReturn<S> = SerdeGatewayGetReturn<S>;
+type index$8_SerdeGatewayInterceptor = SerdeGatewayInterceptor;
+type index$8_SerdeGatewayOpts = SerdeGatewayOpts;
+type index$8_SerdeGatewayPutOp<T> = SerdeGatewayPutOp<T>;
+type index$8_SerdeGatewayPutReturn<T> = SerdeGatewayPutReturn<T>;
+type index$8_SerdeGatewayReturn<O, T> = SerdeGatewayReturn<O, T>;
+type index$8_SerdeGatewayStartOp = SerdeGatewayStartOp;
+type index$8_SerdeGatewayStartReturn = SerdeGatewayStartReturn;
+type index$8_SerdeGatewaySubscribeOp = SerdeGatewaySubscribeOp;
+type index$8_SerdeGatewaySubscribeReturn = SerdeGatewaySubscribeReturn;
+type index$8_SerdeGetResult<S> = SerdeGetResult<S>;
+type index$8_SerdeOrGatewayFactoryItem = SerdeOrGatewayFactoryItem;
+type index$8_StoreEnDeFile = StoreEnDeFile;
+type index$8_StoreFactory = StoreFactory;
+type index$8_StoreFactoryItem = StoreFactoryItem;
+type index$8_StoreRuntime = StoreRuntime;
+type index$8_StoreRuntimeUrls = StoreRuntimeUrls;
+type index$8_StoreURIRuntime = StoreURIRuntime;
+type index$8_StoreURIs = StoreURIs;
+type index$8_StoreUrls = StoreUrls;
+type index$8_StoreUrlsOpts = StoreUrlsOpts;
+type index$8_TaskManager = TaskManager;
+declare const index$8_TaskManager: typeof TaskManager;
+type index$8_TaskManagerParams = TaskManagerParams;
+type index$8_TransactionMeta = TransactionMeta;
+type index$8_TransactionWrapper<M extends TransactionMeta> = TransactionWrapper<M>;
+type index$8_URIInterceptor = URIInterceptor;
+declare const index$8_URIInterceptor: typeof URIInterceptor;
+type index$8_URIMapper = URIMapper;
+type index$8_UnsubscribeResult = UnsubscribeResult;
+type index$8_UrlAndInterceptor = UrlAndInterceptor;
+type index$8_VoidResult = VoidResult;
+type index$8_WALActiveStore = WALActiveStore;
+declare const index$8_WALActiveStore: typeof WALActiveStore;
+type index$8_WALAttachedStores = WALAttachedStores;
+type index$8_WALState = WALState;
+type index$8_WALStore = WALStore;
+type index$8_WriteableDataAndMetaAndWalStore = WriteableDataAndMetaAndWalStore;
+type index$8_WriteableDataAndMetaStore = WriteableDataAndMetaStore;
+declare const index$8_createAttachedStores: typeof createAttachedStores;
+declare const index$8_createDbMetaEvent: typeof createDbMetaEvent;
+declare const index$8_defaultGatewayFactoryItem: typeof defaultGatewayFactoryItem;
+declare const index$8_ensureStoreEnDeFile: typeof ensureStoreEnDeFile;
+declare const index$8_getDefaultURI: typeof getDefaultURI;
+declare const index$8_getGatewayFactoryItem: typeof getGatewayFactoryItem;
+declare const index$8_getInterceptableGateway: typeof getInterceptableGateway;
+declare const index$8_parseCarFile: typeof parseCarFile;
+declare const index$8_registerStoreProtocol: typeof registerStoreProtocol;
+declare const index$8_toCIDBlock: typeof toCIDBlock;
+declare const index$8_toStoreRuntime: typeof toStoreRuntime;
+declare namespace index$8 {
+  export { type index$8_ActiveStore as ActiveStore, type index$8_AnyAnyBlock as AnyAnyBlock, type index$8_AnyAnyLink as AnyAnyLink, type index$8_AnyBlock as AnyBlock, type index$8_AnyDecodedBlock as AnyDecodedBlock, type index$8_AnyLink as AnyLink, type index$8_AnyLinkFn as AnyLinkFn, index$8_AttachedRemotesImpl as AttachedRemotesImpl, type index$8_AttachedStores as AttachedStores, index$8_BaseActiveStore as BaseActiveStore, type index$8_BaseAttachedStores as BaseAttachedStores, index$8_BaseBlockstoreImpl as BaseBlockstoreImpl, type index$8_BaseStore as BaseStore, type index$8_BlockFetcher as BlockFetcher, type index$8_BlockstoreOpts as BlockstoreOpts, type index$8_BlockstoreParams as BlockstoreParams, type index$8_BlockstoreRuntime as BlockstoreRuntime, type index$8_BytesAndKeyWithIv as BytesAndKeyWithIv, type index$8_CIDActiveStore as CIDActiveStore, type index$8_CIDBlock as CIDBlock, index$8_Car2FPMsg as Car2FPMsg, index$8_CarActiveStore as CarActiveStore, type index$8_CarAttachedStores as CarAttachedStores, type index$8_CarCacheItem as CarCacheItem, type index$8_CarClockHead as CarClockHead, type index$8_CarClockLink as CarClockLink, type index$8_CarGroup as CarGroup, type index$8_CarHeader as CarHeader, index$8_CarLog as CarLog, type index$8_CarMakeable as CarMakeable, type index$8_CarStore as CarStore, index$8_CarTransactionImpl as CarTransactionImpl, type index$8_CarTransactionOpts as CarTransactionOpts, type index$8_CodecOpts as CodecOpts, type index$8_CommitOpts as CommitOpts, type index$8_CompactFetcher as CompactFetcher, type index$8_CompactFn as CompactFn, index$8_CompactionFetcher as CompactionFetcher, type index$8_Connection as Connection, type index$8_CryptoAction as CryptoAction, type index$8_DataAndMetaAndWalStore as DataAndMetaAndWalStore, type index$8_DataAndMetaStore as DataAndMetaStore, type index$8_DataSaveOpts as DataSaveOpts, type index$8_DbMeta as DbMeta, type index$8_DbMetaBinary as DbMetaBinary, type index$8_DbMetaEvent as DbMetaEvent, type index$8_DbMetaEventBlock as DbMetaEventBlock, index$8_DbMetaEventEqual as DbMetaEventEqual, index$8_DbMetaEventsEqual as DbMetaEventsEqual, type index$8_EncryptedBlock as EncryptedBlock, index$8_EncryptedBlockstore as EncryptedBlockstore, type index$8_FPEnvelope as FPEnvelope, type index$8_FPEnvelopeCar as FPEnvelopeCar, type index$8_FPEnvelopeFile as FPEnvelopeFile, type index$8_FPEnvelopeMeta as FPEnvelopeMeta, type index$8_FPEnvelopeType as FPEnvelopeType, index$8_FPEnvelopeTypes as FPEnvelopeTypes, type index$8_FPEnvelopeWAL as FPEnvelopeWAL, type index$8_FPWALCarsOps as FPWALCarsOps, index$8_File2FPMsg as File2FPMsg, index$8_FileActiveStore as FileActiveStore, type index$8_FileAttachedStores as FileAttachedStores, type index$8_FileStore as FileStore, type index$8_FroozenCarLog as FroozenCarLog, type index$8_Gateway as Gateway, type index$8_GatewayOpts as GatewayOpts, type index$8_GetResult as GetResult, index$8_InterceptorGateway as InterceptorGateway, type index$8_IvAndKeyAndBytes as IvAndKeyAndBytes, type index$8_IvKeyIdData as IvKeyIdData, type index$8_KeyMaterial as KeyMaterial, type index$8_KeyUpsertResult as KeyUpsertResult, type index$8_KeyWithFingerPrint as KeyWithFingerPrint, type index$8_KeysByFingerprint as KeysByFingerprint, type index$8_LoadHandler as LoadHandler, type index$8_Loadable as Loadable, index$8_Loader as Loader, type index$8_LocalActiveStore as LocalActiveStore, type index$8_LocalDataAndMetaAndWalStore as LocalDataAndMetaAndWalStore, index$8_MetaActiveStore as MetaActiveStore, type index$8_MetaAttachedStores as MetaAttachedStores, type index$8_MetaStore as MetaStore, index$8_PassThroughGateway as PassThroughGateway, type index$8_RefBlockstore as RefBlockstore, type index$8_RefLoadable as RefLoadable, type index$8_SerdeGateway as SerdeGateway, type index$8_SerdeGatewayBuildUrlOp as SerdeGatewayBuildUrlOp, type index$8_SerdeGatewayBuildUrlReturn as SerdeGatewayBuildUrlReturn, type index$8_SerdeGatewayCloseOp as SerdeGatewayCloseOp, type index$8_SerdeGatewayCloseReturn as SerdeGatewayCloseReturn, type index$8_SerdeGatewayCtx as SerdeGatewayCtx, type index$8_SerdeGatewayDeleteOp as SerdeGatewayDeleteOp, type index$8_SerdeGatewayDeleteReturn as SerdeGatewayDeleteReturn, type index$8_SerdeGatewayDestroyOp as SerdeGatewayDestroyOp, type index$8_SerdeGatewayDestroyReturn as SerdeGatewayDestroyReturn, type index$8_SerdeGatewayFactoryItem as SerdeGatewayFactoryItem, type index$8_SerdeGatewayGetOp as SerdeGatewayGetOp, type index$8_SerdeGatewayGetReturn as SerdeGatewayGetReturn, type index$8_SerdeGatewayInterceptor as SerdeGatewayInterceptor, type index$8_SerdeGatewayOpts as SerdeGatewayOpts, type index$8_SerdeGatewayPutOp as SerdeGatewayPutOp, type index$8_SerdeGatewayPutReturn as SerdeGatewayPutReturn, type index$8_SerdeGatewayReturn as SerdeGatewayReturn, type index$8_SerdeGatewayStartOp as SerdeGatewayStartOp, type index$8_SerdeGatewayStartReturn as SerdeGatewayStartReturn, type index$8_SerdeGatewaySubscribeOp as SerdeGatewaySubscribeOp, type index$8_SerdeGatewaySubscribeReturn as SerdeGatewaySubscribeReturn, type index$8_SerdeGetResult as SerdeGetResult, type index$8_SerdeOrGatewayFactoryItem as SerdeOrGatewayFactoryItem, type index$8_StoreEnDeFile as StoreEnDeFile, type index$8_StoreFactory as StoreFactory, type index$8_StoreFactoryItem as StoreFactoryItem, type index$8_StoreRuntime as StoreRuntime, type index$8_StoreRuntimeUrls as StoreRuntimeUrls, type index$8_StoreURIRuntime as StoreURIRuntime, type index$8_StoreURIs as StoreURIs, type index$8_StoreUrls as StoreUrls, type index$8_StoreUrlsOpts as StoreUrlsOpts, index$8_TaskManager as TaskManager, type index$8_TaskManagerParams as TaskManagerParams, type index$8_TransactionMeta as TransactionMeta, type index$8_TransactionWrapper as TransactionWrapper, index$8_URIInterceptor as URIInterceptor, type index$8_URIMapper as URIMapper, type index$8_UnsubscribeResult as UnsubscribeResult, type index$8_UrlAndInterceptor as UrlAndInterceptor, type index$8_VoidResult as VoidResult, index$8_WALActiveStore as WALActiveStore, type index$8_WALAttachedStores as WALAttachedStores, type index$8_WALState as WALState, type index$8_WALStore as WALStore, type index$8_WriteableDataAndMetaAndWalStore as WriteableDataAndMetaAndWalStore, type index$8_WriteableDataAndMetaStore as WriteableDataAndMetaStore, index$8_createAttachedStores as createAttachedStores, index$8_createDbMetaEvent as createDbMetaEvent, index$8_defaultGatewayFactoryItem as defaultGatewayFactoryItem, index$8_ensureStoreEnDeFile as ensureStoreEnDeFile, index$8_getDefaultURI as getDefaultURI, index$8_getGatewayFactoryItem as getGatewayFactoryItem, index$8_getInterceptableGateway as getInterceptableGateway, index$8_parseCarFile as parseCarFile, index$8_registerStoreProtocol as registerStoreProtocol, index$8_toCIDBlock as toCIDBlock, index$8_toStoreRuntime as toStoreRuntime };
 }
 
 interface WriteQueueParams {
@@ -1131,7 +1149,7 @@ interface ProllyNode<K extends IndexKeyType, T extends DocFragment> extends Prol
     readonly block: Promise<Block$1>;
 }
 
-declare function index$4<K extends IndexKeyType = string, T extends DocTypes = NonNullable<unknown>, R extends DocFragment = T>(refDb: HasLogger & HasSuperThis & (HasCRDT | RefLedger), name: string, mapFn?: MapFn<T>, meta?: IdxMeta): Index<K, T, R>;
+declare function index$7<K extends IndexKeyType = string, T extends DocTypes = NonNullable<unknown>, R extends DocFragment = T>(refDb: HasLogger & HasSuperThis & (HasCRDT | RefLedger), 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;
@@ -1154,6 +1172,7 @@ declare class Index<K extends IndexKeyType, T extends DocTypes, R extends DocFra
 }
 
 type Falsy = false | null | undefined;
+type Unreg = () => void;
 declare function isFalsy(value: unknown): value is Falsy;
 declare const PARAM: {
     SUFFIX: string;
@@ -1400,13 +1419,13 @@ interface CRDTEntry {
     readonly cid: string;
 }
 type VoidFn = () => void;
-type UnReg = () => void;
+type UnReg$1 = () => void;
 interface CRDTClock {
     readonly head: ClockHead;
-    onTock(fn: VoidFn): UnReg;
-    onTick(fn: (updates: DocUpdate<DocTypes>[]) => void): UnReg;
+    onTock(fn: VoidFn): UnReg$1;
+    onTick(fn: (updates: DocUpdate<DocTypes>[]) => void): UnReg$1;
     applyHead(newHead: ClockHead, prevHead: ClockHead, updates?: DocUpdate<DocTypes>[]): Promise<void>;
-    onZoom(fn: VoidFn): UnReg;
+    onZoom(fn: VoidFn): UnReg$1;
     close(): Promise<void>;
     ready(): Promise<void>;
 }
@@ -1524,6 +1543,7 @@ interface Database extends ReadyCloseDestroy, HasLogger, HasSuperThis {
     put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
     bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
     del(id: string): Promise<DocResponse>;
+    remove(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<{
@@ -1635,6 +1655,7 @@ declare class DatabaseImpl implements Database {
     put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
     bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
     del(id: string): Promise<DocResponse>;
+    remove(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<{
@@ -1775,9 +1796,361 @@ declare namespace block {
   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;
-declare namespace index$3 {
-  export { index$3_block as block, codecInterface as codec };
+declare const index$6_block: typeof block;
+declare namespace index$6 {
+  export { index$6_block as block, codecInterface as codec };
+}
+
+interface ReqGetData extends ReqSignedUrl {
+    readonly type: "reqGetData";
+}
+declare function buildReqGetData(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqGetData;
+declare function MsgIsReqGetData(msg: MsgBase): msg is ReqGetData;
+interface ResGetData extends ResSignedUrl {
+    readonly type: "resGetData";
+}
+declare function MsgIsResGetData(msg: MsgBase): msg is ResGetData;
+interface CalculatePreSignedUrl {
+    calculatePreSignedUrl(ctx: MsgTypesCtx, p: PreSignedMsg): Promise<Result<URI>>;
+}
+declare function buildResGetData(msgCtx: MsgTypesCtx, req: MsgWithConnAuth<ReqGetData>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResGetData>>;
+interface ReqPutData extends ReqSignedUrl {
+    readonly type: "reqPutData";
+}
+declare function MsgIsReqPutData(msg: MsgBase): msg is ReqPutData;
+declare function buildReqPutData(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqPutData;
+interface ResPutData extends ResSignedUrl {
+    readonly type: "resPutData";
+}
+declare function MsgIsResPutData(msg: MsgBase): msg is ResPutData;
+declare function buildResPutData(msgCtx: MsgTypesCtx, req: MsgWithConnAuth<ReqPutData>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResPutData>>;
+interface ReqDelData extends ReqSignedUrl {
+    readonly type: "reqDelData";
+}
+declare function MsgIsReqDelData(msg: MsgBase): msg is ReqDelData;
+declare function buildReqDelData(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqDelData;
+interface ResDelData extends ResSignedUrl {
+    readonly type: "resDelData";
+}
+declare function MsgIsResDelData(msg: MsgBase): msg is ResDelData;
+declare function buildResDelData(msgCtx: MsgTypesCtx, req: MsgWithConnAuth<ReqDelData>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResDelData>>;
+
+declare const VERSION = "FP-MSG-1.0";
+interface BaseTokenParam {
+    readonly alg: string;
+    readonly issuer: string;
+    readonly audience: string;
+    readonly validFor: number;
+}
+interface FPCloudClaim extends JWTPayload {
+    readonly userId: string;
+    readonly tenants: {
+        readonly id: string;
+        readonly role: string;
+    }[];
+    readonly ledgers: {
+        readonly id: string;
+        readonly role: string;
+        readonly right: string;
+    }[];
+}
+type TokenForParam = FPCloudClaim & Partial<BaseTokenParam>;
+type MsgWithError<T extends MsgBase> = T | ErrorMsg;
+interface PreSignedMsg extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly methodParams: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+}
+interface RequestOpts {
+    readonly waitFor: (msg: MsgBase) => boolean;
+    readonly pollInterval?: number;
+    readonly timeout?: number;
+}
+interface EnDeCoder {
+    encode<T>(node: T): Uint8Array;
+    decode<T>(data: Uint8Array): T;
+}
+interface WaitForTid {
+    readonly tid: string;
+    readonly future: Future<MsgBase>;
+    readonly timeout?: number;
+    readonly waitFor: (msg: MsgBase) => boolean;
+}
+interface NextId {
+    readonly nextId: SuperThis$1["nextId"];
+}
+interface AuthType {
+    readonly type: "ucan" | "error" | "fp-cloud-jwk" | "fp-cloud";
+}
+declare function isAuthTypeFPCloudJWK(a: AuthType): a is FPJWKCloudAuthType;
+declare function isAuthTypeFPCloud(a: AuthType): a is FPCloudAuthType;
+interface UCanAuth extends AuthType {
+    readonly type: "ucan";
+    readonly params: {
+        readonly tbd: string;
+    };
+}
+interface FPJWKCloudAuthType extends AuthType {
+    readonly type: "fp-cloud-jwk";
+    readonly params: {
+        readonly jwk: string;
+    };
+}
+interface FPCloudAuthType extends AuthType {
+    readonly type: "fp-cloud";
+    readonly params: {
+        readonly claim: TokenForParam;
+        readonly jwk: string;
+    };
+}
+type AuthFactory = (tp?: Partial<TokenForParam>) => Promise<Result<AuthType>>;
+interface TenantLedger {
+    readonly tenant: string;
+    readonly ledger: string;
+}
+declare function keyTenantLedger(t: TenantLedger): string;
+interface QSId {
+    readonly reqId: string;
+    readonly resId: string;
+}
+declare function qsidEqual(a: QSId, b: QSId): boolean;
+declare function qsidKey(qsid: QSId): string;
+interface MsgBase {
+    readonly tid: string;
+    readonly type: string;
+    readonly version: string;
+    readonly auth: AuthType;
+}
+declare function MsgIsTid(msg: MsgBase, tid: string): boolean;
+type MsgWithConn<T extends MsgBase = MsgBase> = T & {
+    readonly conn: QSId;
+};
+type MsgWithConnAuth<T extends MsgBase = MsgBase> = MsgWithConn<T> & {
+    readonly auth: AuthType;
+};
+type MsgWithTenantLedger<T extends MsgWithConnAuth> = T & {
+    readonly tenant: TenantLedger;
+};
+interface ErrorMsg extends MsgBase {
+    readonly type: "error";
+    readonly src: unknown;
+    readonly message: string;
+    readonly body?: string;
+    readonly stack?: string[];
+}
+declare function MsgIsError(rq: MsgBase): rq is ErrorMsg;
+declare function MsgIsQSError(rq: ReqRes<MsgBase, MsgBase>): rq is ReqRes<ErrorMsg, ErrorMsg>;
+type HttpMethods = "GET" | "PUT" | "DELETE";
+type FPStoreTypes = "meta" | "car" | "wal" | "file";
+declare function coerceFPStoreTypes(s?: string): FPStoreTypes;
+type ProtocolCapabilities = "reqRes" | "stream";
+declare function isProtocolCapabilities(s: string): s is ProtocolCapabilities;
+interface Gestalt {
+    readonly storeTypes: FPStoreTypes[];
+    readonly id: string;
+    readonly protocolCapabilities: ProtocolCapabilities[];
+    readonly httpEndpoints: string[];
+    readonly wsEndpoints: string[];
+    readonly encodings: ("JSON" | "CBOR")[];
+    readonly auth: AuthType[];
+    readonly requiresAuth: boolean;
+    readonly data?: {
+        readonly inband: boolean;
+        readonly outband: boolean;
+    };
+    readonly meta?: {
+        readonly inband: true;
+        readonly outband: boolean;
+    };
+    readonly wal?: {
+        readonly inband: boolean;
+        readonly outband: boolean;
+    };
+    readonly reqTypes: string[];
+    readonly resTypes: string[];
+    readonly eventTypes: string[];
+}
+interface MsgerParams {
+    readonly mime: string;
+    readonly auth?: AuthType;
+    readonly hasPersistent?: boolean;
+    readonly protocolCapabilities?: ProtocolCapabilities[];
+    readonly timeout: number;
+}
+type GestaltParam = Partial<Gestalt> & {
+    readonly id: string;
+};
+declare function defaultGestalt(msgP: MsgerParams, gestalt: GestaltParam): Gestalt;
+interface ReqChat extends MsgWithConn {
+    readonly type: "reqChat";
+    readonly message: string;
+    readonly targets: QSId[];
+}
+interface ResChat extends MsgWithConn {
+    readonly type: "resChat";
+    readonly message: string;
+    readonly targets: QSId[];
+}
+declare function buildReqChat(sthis: NextId, auth: AuthType, conn: QSId, message: string, targets?: QSId[]): ReqChat;
+declare function buildResChat(req: ReqChat, conn?: QSId, message?: string, targets?: QSId[], auth?: AuthType): ResChat;
+declare function MsgIsReqChat(msg: MsgBase): msg is ReqChat;
+declare function MsgIsResChat(msg: MsgBase): msg is ResChat;
+interface ReqGestalt extends MsgBase {
+    readonly type: "reqGestalt";
+    readonly gestalt: Gestalt;
+    readonly publish?: boolean;
+}
+declare function MsgIsReqGestalt(msg: MsgBase): msg is ReqGestalt;
+declare function buildReqGestalt(sthis: NextId, auth: AuthType, gestalt: Gestalt, publish?: boolean): ReqGestalt;
+interface ConnInfo {
+    readonly connIds: string[];
+}
+interface ResGestalt extends MsgBase {
+    readonly type: "resGestalt";
+    readonly gestalt: Gestalt;
+}
+declare function buildResGestalt(req: ReqGestalt, gestalt: Gestalt, auth: AuthType): ResGestalt | ErrorMsg;
+declare function MsgIsResGestalt(msg: MsgBase): msg is ResGestalt;
+interface ReqOpenConnection {
+    readonly reqId?: string;
+    readonly resId?: string;
+}
+interface ReqOpenConn {
+    readonly reqId: string;
+    readonly resId?: string;
+}
+interface ReqOpen extends MsgBase {
+    readonly type: "reqOpen";
+    readonly conn: ReqOpenConn;
+}
+declare function buildReqOpen(sthis: NextId, auth: AuthType, conn: ReqOpenConnection): ReqOpen;
+declare function MsgIsReqOpen(imsg: MsgBase): imsg is MsgWithConn<ReqOpen>;
+interface ResOpen extends MsgBase {
+    readonly type: "resOpen";
+    readonly conn: QSId;
+}
+declare function MsgIsWithConn<T extends MsgBase>(msg: T): msg is MsgWithConn<T>;
+declare function MsgIsWithConnAuth<T extends MsgBase>(msg: T): msg is MsgWithConnAuth<T>;
+declare function MsgIsConnected<T extends MsgBase>(msg: T, qsid: QSId): msg is MsgWithConn<T>;
+declare function buildResOpen(sthis: NextId, req: ReqOpen, resStreamId?: string): ResOpen;
+declare function MsgIsResOpen(msg: MsgBase): msg is ResOpen;
+interface ReqClose extends MsgWithConn {
+    readonly type: "reqClose";
+}
+declare function MsgIsReqClose(msg: MsgBase): msg is ReqClose;
+interface ResClose extends MsgWithConn {
+    readonly type: "resClose";
+}
+declare function MsgIsResClose(msg: MsgBase): msg is ResClose;
+declare function buildResClose(req: ReqClose, conn: QSId): ResClose;
+declare function buildReqClose(sthis: NextId, auth: AuthType, conn: QSId): ReqClose;
+interface SignedUrlParam {
+    readonly path?: string;
+    readonly key: string;
+    readonly expires?: number;
+    readonly index?: string;
+}
+interface MethodSignedUrlParam {
+    readonly method: HttpMethods;
+    readonly store: FPStoreTypes;
+}
+interface ReqSignedUrlParam {
+    readonly auth: AuthType;
+    readonly methodParam: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+}
+interface UpdateReqRes<Q extends MsgBase, S extends MsgBase> {
+    req: Q;
+    res: S;
+}
+type ReqRes<Q extends MsgBase, S extends MsgBase> = Readonly<UpdateReqRes<Q, S>>;
+declare function buildErrorMsg(msgCtx: {
+    readonly logger: Logger;
+    readonly sthis: SuperThis$1;
+}, base: Partial<MsgBase & {
+    ref?: unknown;
+}>, error: Error, body?: string, stack?: string[]): ErrorMsg;
+declare function MsgIsTenantLedger<T extends MsgBase>(msg: T): msg is MsgWithTenantLedger<MsgWithConnAuth<T>>;
+interface ReqSignedUrl extends ReqSignedUrlWithoutMethodParams {
+    readonly methodParams: MethodSignedUrlParam;
+}
+interface ReqSignedUrlWithoutMethodParams extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly params: SignedUrlParam;
+}
+interface GwCtx {
+    readonly tid?: string;
+    readonly conn: QSId;
+    readonly tenant: TenantLedger;
+}
+interface GwCtxConn {
+    readonly tid?: string;
+    readonly conn: QSId;
+    readonly tenant: TenantLedger;
+}
+declare function buildReqSignedUrl<T extends ReqSignedUrl>(sthis: NextId, type: string, rparam: ReqSignedUrlParam, gwCtx: GwCtx): T;
+interface ResSignedUrl extends MsgWithTenantLedger<MsgWithConn> {
+    readonly methodParams: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+    readonly signedUrl: string;
+}
+interface ResOptionalSignedUrl extends MsgWithTenantLedger<MsgWithConn> {
+    readonly params: SignedUrlParam;
+    readonly methodParams: MethodSignedUrlParam;
+    readonly signedUrl?: string;
+}
+interface MsgTypesCtx {
+    readonly sthis: SuperThis$1;
+    readonly logger: Logger;
+}
+interface MsgTypesCtxSync {
+    readonly sthis: SuperThis$1;
+    readonly logger: Logger;
+    readonly auth: AuthType;
+}
+declare function resAuth(msg: MsgBase): Promise<AuthType>;
+declare function buildRes<Q extends MsgWithTenantLedger<MsgWithConn<ReqSignedUrlWithoutMethodParams>>, S extends ResSignedUrl>(methodParams: MethodSignedUrlParam, type: string, msgCtx: MsgTypesCtx, req: Q, ctx: CalculatePreSignedUrl): Promise<MsgWithError<S>>;
+
+declare const envKeyDefaults: {
+    SECRET: string;
+    PUBLIC: string;
+};
+interface SessionTokenServiceParam extends Partial<BaseTokenParam> {
+    readonly token: string;
+}
+interface SessionTokenServiceFromEnvParam extends Partial<BaseTokenParam> {
+    readonly privateEnvKey?: string;
+    readonly publicEnvKey?: string;
+}
+declare function jwk2env(jwk: CryptoKey, sthis?: SuperThis): Promise<string>;
+declare function env2jwk(env: string, alg: string, sthis?: SuperThis): Promise<CryptoKey>;
+interface KeysResult {
+    readonly material: CryptoKeyPair;
+    readonly strings: {
+        readonly publicKey: string;
+        readonly privateKey: string;
+    };
+}
+declare class SessionTokenService {
+    #private;
+    static generateKeyPair(alg?: string, options?: GenerateKeyPairOptions, generateKeyPairFN?: (alg: string, options: GenerateKeyPairOptions) => Promise<jose.GenerateKeyPairResult>): Promise<KeysResult>;
+    static createFromEnv(sp?: SessionTokenServiceFromEnvParam, sthis?: SuperThis): Promise<SessionTokenService>;
+    static create(stsparam: SessionTokenServiceParam, sthis?: SuperThis): Promise<SessionTokenService>;
+    private constructor();
+    get validFor(): number;
+    get alg(): string;
+    get isssuer(): string;
+    get audience(): string;
+    validate(token: string): Promise<Result<JWTVerifyResult<FPCloudClaim>>>;
+    tokenFor(p: TokenForParam): Promise<string>;
+}
+
+type index$5_KeysResult = KeysResult;
+type index$5_SessionTokenService = SessionTokenService;
+declare const index$5_SessionTokenService: typeof SessionTokenService;
+declare const index$5_env2jwk: typeof env2jwk;
+declare const index$5_envKeyDefaults: typeof envKeyDefaults;
+declare const index$5_jwk2env: typeof jwk2env;
+declare namespace index$5 {
+  export { type index$5_KeysResult as KeysResult, index$5_SessionTokenService as SessionTokenService, index$5_env2jwk as env2jwk, index$5_envKeyDefaults as envKeyDefaults, index$5_jwk2env as jwk2env };
 }
 
 interface KeyBagCtx {
@@ -1797,11 +2170,11 @@ declare class KeyBagProviderFile implements KeyBagProvider {
 
 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$4_KeyBagProviderFile = KeyBagProviderFile;
+declare const index$4_KeyBagProviderFile: typeof KeyBagProviderFile;
+declare const index$4_sysFileSystemFactory: typeof sysFileSystemFactory;
+declare namespace index$4 {
+  export { index$4_KeyBagProviderFile as KeyBagProviderFile, index$4_sysFileSystemFactory as sysFileSystemFactory };
 }
 
 declare class MemoryGateway implements Gateway {
@@ -1818,10 +2191,133 @@ declare class MemoryGateway implements Gateway {
     getPlain(url: URI, key: string): Promise<Result<Uint8Array>>;
 }
 
-type gateway_MemoryGateway = MemoryGateway;
-declare const gateway_MemoryGateway: typeof MemoryGateway;
+type gateway$1_MemoryGateway = MemoryGateway;
+declare const gateway$1_MemoryGateway: typeof MemoryGateway;
+declare namespace gateway$1 {
+  export { gateway$1_MemoryGateway as MemoryGateway };
+}
+
+declare function selectRandom<T>(arr: T[]): T;
+declare function timeout<T>(ms: number, promise: Promise<T>): Promise<T>;
+type OnMsgFn<T extends MsgBase = MsgBase> = (msg: MsgWithError<T>) => void;
+type UnReg = () => void;
+interface ExchangedGestalt {
+    readonly my: Gestalt;
+    readonly remote: Gestalt;
+}
+type OnErrorFn = (msg: Partial<MsgBase>, err: Error) => Partial<MsgBase>;
+interface ActiveStream<S extends MsgBase, Q extends MsgBase> {
+    readonly id: string;
+    readonly bind: {
+        readonly msg: Q;
+        readonly opts: RequestOpts;
+    };
+    timeout?: unknown;
+    controller?: ReadableStreamDefaultController<MsgWithError<S>>;
+}
+interface MsgRawConnection<T extends MsgBase = MsgBase> {
+    readonly sthis: SuperThis;
+    readonly exchangedGestalt: ExchangedGestalt;
+    readonly activeBinds: Map<string, ActiveStream<T, MsgBase>>;
+    bind<S extends T, Q extends T>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    request<S extends T, Q extends T>(req: Q, opts: RequestOpts): Promise<MsgWithError<S>>;
+    send<S extends T, Q extends T>(msg: Q): Promise<MsgWithError<S>>;
+    start(): Promise<Result<void>>;
+    close(o: T): Promise<Result<void>>;
+    onMsg(msg: OnMsgFn<T>): UnReg;
+}
+declare function jsonEnDe(sthis: SuperThis): EnDeCoder;
+type MsgerParamsWithEnDe = MsgerParams & {
+    readonly ende: EnDeCoder;
+};
+declare function defaultMsgParams(sthis: SuperThis, igs: Partial<MsgerParamsWithEnDe>): MsgerParamsWithEnDe;
+interface OpenParams {
+    readonly timeout: number;
+}
+declare function applyStart(prC: Promise<Result<MsgRawConnection>>): Promise<Result<MsgRawConnection>>;
+declare function authTypeFromUri(logger: Logger, curi: CoerceURI): Promise<Result<FPJWKCloudAuthType>>;
+declare class MsgConnected {
+    static connect(auth: AuthType, mrc: Result<MsgRawConnection> | MsgRawConnection, conn?: Partial<QSId>): Promise<Result<MsgConnected>>;
+    readonly sthis: SuperThis;
+    readonly conn: QSId;
+    readonly raw: MsgRawConnection;
+    readonly exchangedGestalt: ExchangedGestalt;
+    readonly activeBinds: Map<string, ActiveStream<MsgWithConnAuth, MsgBase>>;
+    readonly id: string;
+    private constructor();
+    attachAuth(auth: AuthFactory): MsgConnectedAuth;
+}
+declare class MsgConnectedAuth implements MsgRawConnection<MsgWithConnAuth> {
+    readonly sthis: SuperThis;
+    readonly conn: QSId;
+    readonly raw: MsgRawConnection;
+    readonly exchangedGestalt: ExchangedGestalt;
+    readonly activeBinds: Map<string, ActiveStream<MsgWithConnAuth, MsgBase>>;
+    readonly id: string;
+    readonly authFactory: AuthFactory;
+    constructor(conn: MsgConnected, authFactory: AuthFactory);
+    bind<S extends MsgWithConnAuth, Q extends MsgWithConnAuth>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    authType(): Promise<Result<AuthType>>;
+    msgConnAuth(): Promise<Result<MsgWithConnAuth>>;
+    request<S extends MsgWithConnAuth, Q extends MsgWithConnAuth>(req: Q, opts: RequestOpts): Promise<MsgWithError<S>>;
+    send<S extends MsgWithConnAuth, Q extends MsgWithConnAuth>(msg: Q): Promise<MsgWithError<S>>;
+    start(): Promise<Result<void>>;
+    close(t: MsgWithConnAuth): Promise<Result<void>>;
+    onMsg(msgFn: OnMsgFn<MsgWithConnAuth>): UnReg;
+}
+declare class Msger {
+    static openHttp(sthis: SuperThis, urls: URI[], msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt): Promise<Result<MsgRawConnection>>;
+    static openWS(sthis: SuperThis, url: URI, msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt): Promise<Result<MsgRawConnection>>;
+    static open(sthis: SuperThis, auth: AuthType, curl: CoerceURI, imsgP?: Partial<MsgerParamsWithEnDe>): Promise<Result<MsgRawConnection>>;
+    static connect(sthis: SuperThis, auth: AuthType, curl: CoerceURI, imsgP?: Partial<MsgerParamsWithEnDe>, conn?: Partial<QSId>): Promise<Result<MsgConnected>>;
+    private constructor();
+}
+
+type ConnectedSerdeGatewayCtx = SerdeGatewayCtx & {
+    conn: AuthedConnection;
+};
+interface StoreTypeGateway {
+    get: <S>(ctx: ConnectedSerdeGatewayCtx, url: URI) => Promise<SerdeGetResult<S>>;
+    put: <T>(ctx: ConnectedSerdeGatewayCtx, url: URI, body: FPEnvelope<T>) => Promise<VoidResult>;
+    delete: (ctx: ConnectedSerdeGatewayCtx, url: URI) => Promise<VoidResult>;
+}
+interface ConnectionItem {
+    readonly uri: URI;
+    readonly matchRes: MatchResult;
+    readonly connection: ResolveOnce<Result<MsgConnected>>;
+    readonly trackPuts: Set<string>;
+}
+interface AuthedConnection {
+    readonly conn: Result<MsgConnectedAuth>;
+    readonly citem: ConnectionItem;
+}
+declare class FireproofCloudGateway implements SerdeGateway {
+    #private;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    constructor(sthis: SuperThis);
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    start(ctx: SerdeGatewayCtx, uri: URI): Promise<Result<URI>>;
+    get<S>(ctx: SerdeGatewayCtx, uri: URI): Promise<SerdeGetResult<S>>;
+    put<T>(ctx: SerdeGatewayCtx, uri: URI, body: FPEnvelope<T>): Promise<VoidResult>;
+    delete(ctx: SerdeGatewayCtx, uri: URI): Promise<VoidResult>;
+    close(ctx: SerdeGatewayCtx, uri: URI): Promise<VoidResult>;
+    getCloudConnection(uri: URI): Promise<Result<MsgConnectedAuth>>;
+    getCloudConnectionItem(uri: URI): Promise<AuthedConnection>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<UnsubscribeResult>;
+    destroy(ctx: SerdeGatewayCtx, uri: URI): Promise<VoidResult>;
+    getPlain(): Promise<Result<Uint8Array>>;
+}
+declare function registerFireproofCloudStoreProtocol(protocol?: string): () => void;
+declare function toCloud(url: CoerceURI): Attachable;
+
+type gateway_FireproofCloudGateway = FireproofCloudGateway;
+declare const gateway_FireproofCloudGateway: typeof FireproofCloudGateway;
+type gateway_StoreTypeGateway = StoreTypeGateway;
+declare const gateway_registerFireproofCloudStoreProtocol: typeof registerFireproofCloudStoreProtocol;
+declare const gateway_toCloud: typeof toCloud;
 declare namespace gateway {
-  export { gateway_MemoryGateway as MemoryGateway };
+  export { gateway_FireproofCloudGateway as FireproofCloudGateway, type gateway_StoreTypeGateway as StoreTypeGateway, gateway_registerFireproofCloudStoreProtocol as registerFireproofCloudStoreProtocol, gateway_toCloud as toCloud };
 }
 
 declare class DefSerdeGateway implements SerdeGateway {
@@ -1839,61 +2335,405 @@ declare class DefSerdeGateway implements SerdeGateway {
     getPlain({ loader: { sthis } }: SerdeGatewayCtx, iurl: URI, key: string): Promise<Result<Uint8Array<ArrayBufferLike>, Error>>;
 }
 
-type index$1_CARDecodeEnvelope = CARDecodeEnvelope;
-type index$1_CAREncodeEnvelope = CAREncodeEnvelope;
-type index$1_DefSerdeGateway = DefSerdeGateway;
-declare const index$1_DefSerdeGateway: typeof DefSerdeGateway;
-type index$1_FILEDecodeEnvelope = FILEDecodeEnvelope;
-type index$1_FILEEncodeEnvelope = FILEEncodeEnvelope;
-type index$1_FPDecoder = FPDecoder;
-type index$1_FPEncoder = FPEncoder;
-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_dbMetaEvent2Serialized: typeof dbMetaEvent2Serialized;
-declare const index$1_decode2DbMetaEvents: typeof decode2DbMetaEvents;
-declare const index$1_fpDeserialize: typeof fpDeserialize;
-declare const index$1_fpSerialize: typeof fpSerialize;
-declare namespace index$1 {
-  export { type index$1_CARDecodeEnvelope as CARDecodeEnvelope, type index$1_CAREncodeEnvelope as CAREncodeEnvelope, index$1_DefSerdeGateway as DefSerdeGateway, type index$1_FILEDecodeEnvelope as FILEDecodeEnvelope, type index$1_FILEEncodeEnvelope as FILEEncodeEnvelope, type index$1_FPDecoder as FPDecoder, type index$1_FPEncoder as FPEncoder, 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$1_dbMetaEvent2Serialized as dbMetaEvent2Serialized, index$1_decode2DbMetaEvents as decode2DbMetaEvents, index$2 as file, index$1_fpDeserialize as fpDeserialize, index$1_fpSerialize as fpSerialize, gateway as memory };
+type index$3_CARDecodeEnvelope = CARDecodeEnvelope;
+type index$3_CAREncodeEnvelope = CAREncodeEnvelope;
+type index$3_DefSerdeGateway = DefSerdeGateway;
+declare const index$3_DefSerdeGateway: typeof DefSerdeGateway;
+type index$3_FILEDecodeEnvelope = FILEDecodeEnvelope;
+type index$3_FILEEncodeEnvelope = FILEEncodeEnvelope;
+type index$3_FPDecoder = FPDecoder;
+type index$3_FPEncoder = FPEncoder;
+type index$3_METADecodeEnvelope = METADecodeEnvelope;
+type index$3_METAEncodeEnvelope = METAEncodeEnvelope;
+type index$3_SerializedMeta = SerializedMeta;
+type index$3_SerializedWAL = SerializedWAL;
+type index$3_WALDecodeEnvelope = WALDecodeEnvelope;
+type index$3_WALEncodeEnvelope = WALEncodeEnvelope;
+declare const index$3_dbMetaEvent2Serialized: typeof dbMetaEvent2Serialized;
+declare const index$3_decode2DbMetaEvents: typeof decode2DbMetaEvents;
+declare const index$3_fpDeserialize: typeof fpDeserialize;
+declare const index$3_fpSerialize: typeof fpSerialize;
+declare namespace index$3 {
+  export { type index$3_CARDecodeEnvelope as CARDecodeEnvelope, type index$3_CAREncodeEnvelope as CAREncodeEnvelope, index$3_DefSerdeGateway as DefSerdeGateway, type index$3_FILEDecodeEnvelope as FILEDecodeEnvelope, type index$3_FILEEncodeEnvelope as FILEEncodeEnvelope, type index$3_FPDecoder as FPDecoder, type index$3_FPEncoder as FPEncoder, type index$3_METADecodeEnvelope as METADecodeEnvelope, type index$3_METAEncodeEnvelope as METAEncodeEnvelope, type index$3_SerializedMeta as SerializedMeta, type index$3_SerializedWAL as SerializedWAL, type index$3_WALDecodeEnvelope as WALDecodeEnvelope, type index$3_WALEncodeEnvelope as WALEncodeEnvelope, gateway as cloud, index$3_dbMetaEvent2Serialized as dbMetaEvent2Serialized, index$3_decode2DbMetaEvents as decode2DbMetaEvents, index$4 as file, index$3_fpDeserialize as fpDeserialize, index$3_fpSerialize as fpSerialize, gateway$1 as memory };
+}
+
+type V1SerializedMetaKey = SerializedMeta & {
+    readonly key?: string | string[];
+    readonly keys?: string[];
+};
+interface V2SerializedMetaKey {
+    readonly metas: SerializedMeta[];
+    readonly keys: string[];
+}
+declare function V2SerializedMetaKeyExtractKey(ctx: SerdeGatewayCtx, v2: V2SerializedMetaKey): Promise<Result<SerializedMeta[]>>;
+declare function decodeAsToSerializedMeta(ctx: SerdeGatewayCtx, raw: Uint8Array): Promise<Result<V2SerializedMetaKey>>;
+declare function addKeyToDbMetaDecoder(ctx: SerdeGatewayCtx & {
+    readonly lastDecodedMetas?: V2SerializedMetaKey[];
+}): SerdeGatewayCtx & {
+    lastDecodedMetas: V2SerializedMetaKey[];
+};
+declare function encodeAsV1SerializedMetaKey(ctx: SerdeGatewayCtx, payload: SerializedMeta[]): Promise<Result<V1SerializedMetaKey[]>>;
+declare function encodeAsV2SerializedMetaKey(ctx: SerdeGatewayCtx, payload: SerializedMeta[]): Promise<Result<V2SerializedMetaKey>>;
+declare function addKeyToDbMetaEncoder(ctx: SerdeGatewayCtx, version: "v1" | "v2"): SerdeGatewayCtx;
+declare class AddKeyToDbMetaGateway implements SerdeGateway {
+    private readonly sdGw;
+    readonly version: "v1" | "v2";
+    constructor(gw: Gateway, version: "v1" | "v2");
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    start(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<URI>>;
+    close(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<void, Error>>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<void, Error>>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<FPEnvelope<S>, Error | NotFoundError>>;
+    readonly lastDecodedMetas: V2SerializedMetaKey[];
+    delete(ctx: SerdeGatewayCtx, url: URI, loader?: Loadable): Promise<Result<void, Error>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<() => void, Error>>;
+    getPlain(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>>;
+    destroy(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<void, Error>>;
 }
 
 declare const FILESTORE_VERSION = "v0.19-file";
 
 declare const INDEXEDDB_VERSION = "v0.19-indexeddb";
 
-declare const index_FILESTORE_VERSION: typeof FILESTORE_VERSION;
-declare const index_INDEXEDDB_VERSION: typeof INDEXEDDB_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_KeysItem = KeysItem;
-type index_V1StorageKeyItem = V1StorageKeyItem;
-type index_V2StorageKeyItem = V2StorageKeyItem;
-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;
-type index_keysByFingerprint = keysByFingerprint;
-declare const index_keysByFingerprint: typeof keysByFingerprint;
-declare const index_registerKeyBagProviderFactory: typeof registerKeyBagProviderFactory;
-declare const index_runtimeFn: typeof runtimeFn;
-declare const index_toKeyWithFingerPrint: typeof toKeyWithFingerPrint;
+type index$2_AddKeyToDbMetaGateway = AddKeyToDbMetaGateway;
+declare const index$2_AddKeyToDbMetaGateway: typeof AddKeyToDbMetaGateway;
+declare const index$2_FILESTORE_VERSION: typeof FILESTORE_VERSION;
+declare const index$2_INDEXEDDB_VERSION: typeof INDEXEDDB_VERSION;
+type index$2_KeyBackProviderFactory = KeyBackProviderFactory;
+type index$2_KeyBag = KeyBag;
+declare const index$2_KeyBag: typeof KeyBag;
+type index$2_KeyBagFile = KeyBagFile;
+type index$2_KeyBagOpts = KeyBagOpts;
+type index$2_KeyBagProvider = KeyBagProvider;
+type index$2_KeyBagProviderFactoryItem = KeyBagProviderFactoryItem;
+type index$2_KeyBagRuntime = KeyBagRuntime;
+type index$2_KeysItem = KeysItem;
+type index$2_V1StorageKeyItem = V1StorageKeyItem;
+type index$2_V2SerializedMetaKey = V2SerializedMetaKey;
+declare const index$2_V2SerializedMetaKeyExtractKey: typeof V2SerializedMetaKeyExtractKey;
+type index$2_V2StorageKeyItem = V2StorageKeyItem;
+declare const index$2_addKeyToDbMetaDecoder: typeof addKeyToDbMetaDecoder;
+declare const index$2_addKeyToDbMetaEncoder: typeof addKeyToDbMetaEncoder;
+declare const index$2_decodeAsToSerializedMeta: typeof decodeAsToSerializedMeta;
+declare const index$2_defaultKeyBagOpts: typeof defaultKeyBagOpts;
+declare const index$2_defaultKeyBagUrl: typeof defaultKeyBagUrl;
+declare const index$2_encodeAsV1SerializedMetaKey: typeof encodeAsV1SerializedMetaKey;
+declare const index$2_encodeAsV2SerializedMetaKey: typeof encodeAsV2SerializedMetaKey;
+declare const index$2_files: typeof files;
+declare const index$2_getFileName: typeof getFileName;
+declare const index$2_getKeyBag: typeof getKeyBag;
+declare const index$2_getPath: typeof getPath;
+type index$2_keysByFingerprint = keysByFingerprint;
+declare const index$2_keysByFingerprint: typeof keysByFingerprint;
+declare const index$2_registerKeyBagProviderFactory: typeof registerKeyBagProviderFactory;
+declare const index$2_runtimeFn: typeof runtimeFn;
+declare const index$2_toKeyWithFingerPrint: typeof toKeyWithFingerPrint;
+declare namespace index$2 {
+  export { index$2_AddKeyToDbMetaGateway as AddKeyToDbMetaGateway, index$2_FILESTORE_VERSION as FILESTORE_VERSION, index$2_INDEXEDDB_VERSION as INDEXEDDB_VERSION, type index$2_KeyBackProviderFactory as KeyBackProviderFactory, index$2_KeyBag as KeyBag, type index$2_KeyBagFile as KeyBagFile, type index$2_KeyBagOpts as KeyBagOpts, type index$2_KeyBagProvider as KeyBagProvider, type index$2_KeyBagProviderFactoryItem as KeyBagProviderFactoryItem, type index$2_KeyBagRuntime as KeyBagRuntime, type index$2_KeysItem as KeysItem, type index$2_V1StorageKeyItem as V1StorageKeyItem, type index$2_V2SerializedMetaKey as V2SerializedMetaKey, index$2_V2SerializedMetaKeyExtractKey as V2SerializedMetaKeyExtractKey, type index$2_V2StorageKeyItem as V2StorageKeyItem, index$2_addKeyToDbMetaDecoder as addKeyToDbMetaDecoder, index$2_addKeyToDbMetaEncoder as addKeyToDbMetaEncoder, index$2_decodeAsToSerializedMeta as decodeAsToSerializedMeta, index$2_defaultKeyBagOpts as defaultKeyBagOpts, index$2_defaultKeyBagUrl as defaultKeyBagUrl, index$2_encodeAsV1SerializedMetaKey as encodeAsV1SerializedMetaKey, index$2_encodeAsV2SerializedMetaKey as encodeAsV2SerializedMetaKey, index$2_files as files, index$2_getFileName as getFileName, index$2_getKeyBag as getKeyBag, index$2_getPath as getPath, index$3 as gw, keyBag as kb, keyedCrypto as kc, index$2_keysByFingerprint as keysByFingerprint, index$6 as mf, index$2_registerKeyBagProviderFactory as registerKeyBagProviderFactory, index$2_runtimeFn as runtimeFn, index$5 as sts, index$2_toKeyWithFingerPrint as toKeyWithFingerPrint };
+}
+
+declare class MsgRawConnectionBase {
+    readonly sthis: SuperThis;
+    readonly exchangedGestalt: ExchangedGestalt;
+    constructor(sthis: SuperThis, exGestalt: ExchangedGestalt);
+    readonly onErrorFns: Map<string, OnErrorFn>;
+    onError(fn: OnErrorFn): UnReg;
+    buildErrorMsg(msgCtx: {
+        readonly logger: Logger;
+        readonly sthis: SuperThis;
+    }, msg: Partial<MsgBase>, err: Error): ErrorMsg;
+}
+
+declare class HttpConnection extends MsgRawConnectionBase implements MsgRawConnection {
+    #private;
+    readonly logger: Logger;
+    readonly msgP: MsgerParamsWithEnDe;
+    readonly baseURIs: {
+        in: URI;
+        cleaned: URI;
+    }[];
+    constructor(sthis: SuperThis, uris: URI[], msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt);
+    send<S extends MsgBase, Q extends MsgBase>(_msg: Q): Promise<MsgWithError<S>>;
+    start(): Promise<Result<void>>;
+    close(): Promise<Result<void>>;
+    toMsg<S extends MsgBase>(msg: MsgWithError<S>): MsgWithError<S>;
+    onMsg(fn: OnMsgFn): UnReg;
+    readonly activeBinds: Map<string, ActiveStream<MsgBase, MsgBase>>;
+    bind<Q extends MsgBase, S extends MsgBase>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    request<Q extends MsgBase, S extends MsgBase>(req: Q, _opts: RequestOpts): Promise<MsgWithError<S>>;
+}
+
+interface ReqPutMeta extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly type: "reqPutMeta";
+    readonly methodParams: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+    readonly meta: V2SerializedMetaKey;
+}
+interface ResPutMeta extends MsgWithTenantLedger<MsgWithConnAuth>, ResSignedUrl {
+    readonly type: "resPutMeta";
+    readonly meta: V2SerializedMetaKey;
+}
+declare function buildReqPutMeta(sthis: NextId, auth: AuthType, signedUrlParams: SignedUrlParam, meta: V2SerializedMetaKey, gwCtx: GwCtx): ReqPutMeta;
+declare function MsgIsReqPutMeta(msg: MsgBase): msg is ReqPutMeta;
+declare function buildResPutMeta(_msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqPutMeta>>, meta: V2SerializedMetaKey, signedUrl: string): ResPutMeta;
+declare function MsgIsResPutMeta(qs: MsgBase): qs is ResPutMeta;
+interface BindGetMeta extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly type: "bindGetMeta";
+    readonly params: SignedUrlParam;
+}
+declare function MsgIsBindGetMeta(msg: MsgBase): msg is BindGetMeta;
+interface EventGetMeta extends MsgWithTenantLedger<MsgWithConnAuth>, ResSignedUrl {
+    readonly type: "eventGetMeta";
+    readonly meta: V2SerializedMetaKey;
+}
+declare function buildBindGetMeta(sthis: NextId, auth: AuthType, params: SignedUrlParam, gwCtx: GwCtx): BindGetMeta;
+declare function buildEventGetMeta(_msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<BindGetMeta>>, meta: V2SerializedMetaKey, gwCtx: GwCtx, signedUrl: string): EventGetMeta;
+declare function MsgIsEventGetMeta(qs: MsgBase): qs is EventGetMeta;
+interface ReqDelMeta extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly type: "reqDelMeta";
+    readonly params: SignedUrlParam;
+    readonly meta?: V2SerializedMetaKey;
+}
+declare function buildReqDelMeta(sthis: NextId, auth: AuthType, params: SignedUrlParam, gwCtx: GwCtx, meta?: V2SerializedMetaKey): ReqDelMeta;
+declare function MsgIsReqDelMeta(msg: MsgBase): msg is ReqDelMeta;
+interface ResDelMeta extends MsgWithTenantLedger<MsgWithConnAuth>, ResOptionalSignedUrl {
+    readonly type: "resDelMeta";
+}
+declare function buildResDelMeta(req: MsgWithTenantLedger<MsgWithConnAuth<ReqDelMeta>>, params: SignedUrlParam, signedUrl?: string): ResDelMeta;
+declare function MsgIsResDelMeta(qs: MsgBase): qs is ResDelMeta;
+
+interface ReqGetWAL extends ReqSignedUrl {
+    readonly type: "reqGetWAL";
+}
+declare function MsgIsReqGetWAL(msg: MsgBase): msg is ReqGetWAL;
+declare function buildReqGetWAL(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqGetWAL;
+interface ResGetWAL extends ResSignedUrl {
+    readonly type: "resGetWAL";
+}
+declare function MsgIsResGetWAL(msg: MsgBase): msg is ResGetWAL;
+declare function buildResGetWAL(msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqGetWAL>>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResGetWAL>>;
+interface ReqPutWAL extends Omit<ReqSignedUrl, "type"> {
+    readonly type: "reqPutWAL";
+}
+declare function MsgIsReqPutWAL(msg: MsgBase): msg is ReqPutWAL;
+declare function buildReqPutWAL(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqPutWAL;
+interface ResPutWAL extends Omit<ResSignedUrl, "type"> {
+    readonly type: "resPutWAL";
+}
+declare function MsgIsResPutWAL(msg: MsgBase): msg is ResPutWAL;
+declare function buildResPutWAL(msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqPutWAL>>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResPutWAL>>;
+interface ReqDelWAL extends Omit<ReqSignedUrl, "type"> {
+    readonly type: "reqDelWAL";
+}
+declare function MsgIsReqDelWAL(msg: MsgBase): msg is ReqDelWAL;
+declare function buildReqDelWAL(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqDelWAL;
+interface ResDelWAL extends Omit<ResSignedUrl, "type"> {
+    readonly type: "resDelWAL";
+}
+declare function MsgIsResDelWAL(msg: MsgBase): msg is ResDelWAL;
+declare function buildResDelWAL(msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqDelWAL>>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResDelWAL>>;
+
+interface WSReqOpen {
+    readonly reqOpen: ReqOpen;
+    readonly ws: WebSocket;
+}
+declare class WSConnection extends MsgRawConnectionBase implements MsgRawConnection {
+    #private;
+    readonly logger: Logger;
+    readonly msgP: MsgerParamsWithEnDe;
+    readonly ws: WebSocket;
+    readonly waitForTid: Map<string, WaitForTid>;
+    opened: boolean;
+    readonly id: string;
+    constructor(sthis: SuperThis, ws: WebSocket, msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt);
+    start(): Promise<Result<void>>;
+    close(): Promise<Result<void>>;
+    toMsg<S extends MsgBase>(msg: MsgWithError<S>): MsgWithError<S>;
+    send<Q extends MsgBase, S extends MsgBase>(msg: Q): Promise<S>;
+    onMsg<S extends MsgBase>(fn: OnMsgFn<S>): UnReg;
+    onClose(fn: UnReg): UnReg;
+    readonly activeBinds: Map<string, ActiveStream<MsgBase, MsgBase>>;
+    bind<Q extends MsgBase, S extends MsgBase>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    request<Q extends MsgBase, S extends MsgBase>(req: Q, opts: RequestOpts): Promise<MsgWithError<S>>;
+}
+
+type index$1_ActiveStream<S extends MsgBase, Q extends MsgBase> = ActiveStream<S, Q>;
+type index$1_AuthFactory = AuthFactory;
+type index$1_AuthType = AuthType;
+type index$1_BaseTokenParam = BaseTokenParam;
+type index$1_BindGetMeta = BindGetMeta;
+type index$1_CalculatePreSignedUrl = CalculatePreSignedUrl;
+type index$1_ConnInfo = ConnInfo;
+type index$1_EnDeCoder = EnDeCoder;
+type index$1_ErrorMsg = ErrorMsg;
+type index$1_EventGetMeta = EventGetMeta;
+type index$1_ExchangedGestalt = ExchangedGestalt;
+type index$1_FPCloudAuthType = FPCloudAuthType;
+type index$1_FPCloudClaim = FPCloudClaim;
+type index$1_FPJWKCloudAuthType = FPJWKCloudAuthType;
+type index$1_FPStoreTypes = FPStoreTypes;
+type index$1_Gestalt = Gestalt;
+type index$1_GestaltParam = GestaltParam;
+type index$1_GwCtx = GwCtx;
+type index$1_GwCtxConn = GwCtxConn;
+type index$1_HttpConnection = HttpConnection;
+declare const index$1_HttpConnection: typeof HttpConnection;
+type index$1_HttpMethods = HttpMethods;
+type index$1_MethodSignedUrlParam = MethodSignedUrlParam;
+type index$1_MsgBase = MsgBase;
+type index$1_MsgConnected = MsgConnected;
+declare const index$1_MsgConnected: typeof MsgConnected;
+type index$1_MsgConnectedAuth = MsgConnectedAuth;
+declare const index$1_MsgConnectedAuth: typeof MsgConnectedAuth;
+declare const index$1_MsgIsBindGetMeta: typeof MsgIsBindGetMeta;
+declare const index$1_MsgIsConnected: typeof MsgIsConnected;
+declare const index$1_MsgIsError: typeof MsgIsError;
+declare const index$1_MsgIsEventGetMeta: typeof MsgIsEventGetMeta;
+declare const index$1_MsgIsQSError: typeof MsgIsQSError;
+declare const index$1_MsgIsReqChat: typeof MsgIsReqChat;
+declare const index$1_MsgIsReqClose: typeof MsgIsReqClose;
+declare const index$1_MsgIsReqDelData: typeof MsgIsReqDelData;
+declare const index$1_MsgIsReqDelMeta: typeof MsgIsReqDelMeta;
+declare const index$1_MsgIsReqDelWAL: typeof MsgIsReqDelWAL;
+declare const index$1_MsgIsReqGestalt: typeof MsgIsReqGestalt;
+declare const index$1_MsgIsReqGetData: typeof MsgIsReqGetData;
+declare const index$1_MsgIsReqGetWAL: typeof MsgIsReqGetWAL;
+declare const index$1_MsgIsReqOpen: typeof MsgIsReqOpen;
+declare const index$1_MsgIsReqPutData: typeof MsgIsReqPutData;
+declare const index$1_MsgIsReqPutMeta: typeof MsgIsReqPutMeta;
+declare const index$1_MsgIsReqPutWAL: typeof MsgIsReqPutWAL;
+declare const index$1_MsgIsResChat: typeof MsgIsResChat;
+declare const index$1_MsgIsResClose: typeof MsgIsResClose;
+declare const index$1_MsgIsResDelData: typeof MsgIsResDelData;
+declare const index$1_MsgIsResDelMeta: typeof MsgIsResDelMeta;
+declare const index$1_MsgIsResDelWAL: typeof MsgIsResDelWAL;
+declare const index$1_MsgIsResGestalt: typeof MsgIsResGestalt;
+declare const index$1_MsgIsResGetData: typeof MsgIsResGetData;
+declare const index$1_MsgIsResGetWAL: typeof MsgIsResGetWAL;
+declare const index$1_MsgIsResOpen: typeof MsgIsResOpen;
+declare const index$1_MsgIsResPutData: typeof MsgIsResPutData;
+declare const index$1_MsgIsResPutMeta: typeof MsgIsResPutMeta;
+declare const index$1_MsgIsResPutWAL: typeof MsgIsResPutWAL;
+declare const index$1_MsgIsTenantLedger: typeof MsgIsTenantLedger;
+declare const index$1_MsgIsTid: typeof MsgIsTid;
+declare const index$1_MsgIsWithConn: typeof MsgIsWithConn;
+declare const index$1_MsgIsWithConnAuth: typeof MsgIsWithConnAuth;
+type index$1_MsgRawConnection<T extends MsgBase = MsgBase> = MsgRawConnection<T>;
+type index$1_MsgRawConnectionBase = MsgRawConnectionBase;
+declare const index$1_MsgRawConnectionBase: typeof MsgRawConnectionBase;
+type index$1_MsgTypesCtx = MsgTypesCtx;
+type index$1_MsgTypesCtxSync = MsgTypesCtxSync;
+type index$1_MsgWithConnAuth<T extends MsgBase = MsgBase> = MsgWithConnAuth<T>;
+type index$1_MsgWithError<T extends MsgBase> = MsgWithError<T>;
+type index$1_MsgWithTenantLedger<T extends MsgWithConnAuth> = MsgWithTenantLedger<T>;
+type index$1_Msger = Msger;
+declare const index$1_Msger: typeof Msger;
+type index$1_MsgerParams = MsgerParams;
+type index$1_MsgerParamsWithEnDe = MsgerParamsWithEnDe;
+type index$1_NextId = NextId;
+type index$1_OnErrorFn = OnErrorFn;
+type index$1_OnMsgFn<T extends MsgBase = MsgBase> = OnMsgFn<T>;
+type index$1_OpenParams = OpenParams;
+type index$1_PreSignedMsg = PreSignedMsg;
+type index$1_ProtocolCapabilities = ProtocolCapabilities;
+type index$1_QSId = QSId;
+type index$1_ReqChat = ReqChat;
+type index$1_ReqClose = ReqClose;
+type index$1_ReqDelData = ReqDelData;
+type index$1_ReqDelMeta = ReqDelMeta;
+type index$1_ReqDelWAL = ReqDelWAL;
+type index$1_ReqGestalt = ReqGestalt;
+type index$1_ReqGetData = ReqGetData;
+type index$1_ReqGetWAL = ReqGetWAL;
+type index$1_ReqOpen = ReqOpen;
+type index$1_ReqOpenConn = ReqOpenConn;
+type index$1_ReqOpenConnection = ReqOpenConnection;
+type index$1_ReqPutData = ReqPutData;
+type index$1_ReqPutMeta = ReqPutMeta;
+type index$1_ReqPutWAL = ReqPutWAL;
+type index$1_ReqRes<Q extends MsgBase, S extends MsgBase> = ReqRes<Q, S>;
+type index$1_ReqSignedUrl = ReqSignedUrl;
+type index$1_ReqSignedUrlParam = ReqSignedUrlParam;
+type index$1_ReqSignedUrlWithoutMethodParams = ReqSignedUrlWithoutMethodParams;
+type index$1_RequestOpts = RequestOpts;
+type index$1_ResChat = ResChat;
+type index$1_ResClose = ResClose;
+type index$1_ResDelData = ResDelData;
+type index$1_ResDelMeta = ResDelMeta;
+type index$1_ResDelWAL = ResDelWAL;
+type index$1_ResGestalt = ResGestalt;
+type index$1_ResGetData = ResGetData;
+type index$1_ResGetWAL = ResGetWAL;
+type index$1_ResOpen = ResOpen;
+type index$1_ResOptionalSignedUrl = ResOptionalSignedUrl;
+type index$1_ResPutData = ResPutData;
+type index$1_ResPutMeta = ResPutMeta;
+type index$1_ResPutWAL = ResPutWAL;
+type index$1_ResSignedUrl = ResSignedUrl;
+type index$1_SignedUrlParam = SignedUrlParam;
+type index$1_TenantLedger = TenantLedger;
+type index$1_TokenForParam = TokenForParam;
+type index$1_UCanAuth = UCanAuth;
+type index$1_UnReg = UnReg;
+type index$1_UpdateReqRes<Q extends MsgBase, S extends MsgBase> = UpdateReqRes<Q, S>;
+declare const index$1_VERSION: typeof VERSION;
+type index$1_WSConnection = WSConnection;
+declare const index$1_WSConnection: typeof WSConnection;
+type index$1_WSReqOpen = WSReqOpen;
+type index$1_WaitForTid = WaitForTid;
+declare const index$1_applyStart: typeof applyStart;
+declare const index$1_authTypeFromUri: typeof authTypeFromUri;
+declare const index$1_buildBindGetMeta: typeof buildBindGetMeta;
+declare const index$1_buildErrorMsg: typeof buildErrorMsg;
+declare const index$1_buildEventGetMeta: typeof buildEventGetMeta;
+declare const index$1_buildReqChat: typeof buildReqChat;
+declare const index$1_buildReqClose: typeof buildReqClose;
+declare const index$1_buildReqDelData: typeof buildReqDelData;
+declare const index$1_buildReqDelMeta: typeof buildReqDelMeta;
+declare const index$1_buildReqDelWAL: typeof buildReqDelWAL;
+declare const index$1_buildReqGestalt: typeof buildReqGestalt;
+declare const index$1_buildReqGetData: typeof buildReqGetData;
+declare const index$1_buildReqGetWAL: typeof buildReqGetWAL;
+declare const index$1_buildReqOpen: typeof buildReqOpen;
+declare const index$1_buildReqPutData: typeof buildReqPutData;
+declare const index$1_buildReqPutMeta: typeof buildReqPutMeta;
+declare const index$1_buildReqPutWAL: typeof buildReqPutWAL;
+declare const index$1_buildReqSignedUrl: typeof buildReqSignedUrl;
+declare const index$1_buildRes: typeof buildRes;
+declare const index$1_buildResChat: typeof buildResChat;
+declare const index$1_buildResClose: typeof buildResClose;
+declare const index$1_buildResDelData: typeof buildResDelData;
+declare const index$1_buildResDelMeta: typeof buildResDelMeta;
+declare const index$1_buildResDelWAL: typeof buildResDelWAL;
+declare const index$1_buildResGestalt: typeof buildResGestalt;
+declare const index$1_buildResGetData: typeof buildResGetData;
+declare const index$1_buildResGetWAL: typeof buildResGetWAL;
+declare const index$1_buildResOpen: typeof buildResOpen;
+declare const index$1_buildResPutData: typeof buildResPutData;
+declare const index$1_buildResPutMeta: typeof buildResPutMeta;
+declare const index$1_buildResPutWAL: typeof buildResPutWAL;
+declare const index$1_coerceFPStoreTypes: typeof coerceFPStoreTypes;
+declare const index$1_defaultGestalt: typeof defaultGestalt;
+declare const index$1_defaultMsgParams: typeof defaultMsgParams;
+declare const index$1_isAuthTypeFPCloud: typeof isAuthTypeFPCloud;
+declare const index$1_isAuthTypeFPCloudJWK: typeof isAuthTypeFPCloudJWK;
+declare const index$1_isProtocolCapabilities: typeof isProtocolCapabilities;
+declare const index$1_jsonEnDe: typeof jsonEnDe;
+declare const index$1_keyTenantLedger: typeof keyTenantLedger;
+declare const index$1_qsidEqual: typeof qsidEqual;
+declare const index$1_qsidKey: typeof qsidKey;
+declare const index$1_resAuth: typeof resAuth;
+declare const index$1_selectRandom: typeof selectRandom;
+declare const index$1_timeout: typeof timeout;
+declare namespace index$1 {
+  export { type index$1_ActiveStream as ActiveStream, type index$1_AuthFactory as AuthFactory, type index$1_AuthType as AuthType, type index$1_BaseTokenParam as BaseTokenParam, type index$1_BindGetMeta as BindGetMeta, type index$1_CalculatePreSignedUrl as CalculatePreSignedUrl, type index$1_ConnInfo as ConnInfo, type index$1_EnDeCoder as EnDeCoder, type index$1_ErrorMsg as ErrorMsg, type index$1_EventGetMeta as EventGetMeta, type index$1_ExchangedGestalt as ExchangedGestalt, type index$1_FPCloudAuthType as FPCloudAuthType, type index$1_FPCloudClaim as FPCloudClaim, type index$1_FPJWKCloudAuthType as FPJWKCloudAuthType, type index$1_FPStoreTypes as FPStoreTypes, type index$1_Gestalt as Gestalt, type index$1_GestaltParam as GestaltParam, type index$1_GwCtx as GwCtx, type index$1_GwCtxConn as GwCtxConn, index$1_HttpConnection as HttpConnection, type index$1_HttpMethods as HttpMethods, type index$1_MethodSignedUrlParam as MethodSignedUrlParam, type index$1_MsgBase as MsgBase, index$1_MsgConnected as MsgConnected, index$1_MsgConnectedAuth as MsgConnectedAuth, index$1_MsgIsBindGetMeta as MsgIsBindGetMeta, index$1_MsgIsConnected as MsgIsConnected, index$1_MsgIsError as MsgIsError, index$1_MsgIsEventGetMeta as MsgIsEventGetMeta, index$1_MsgIsQSError as MsgIsQSError, index$1_MsgIsReqChat as MsgIsReqChat, index$1_MsgIsReqClose as MsgIsReqClose, index$1_MsgIsReqDelData as MsgIsReqDelData, index$1_MsgIsReqDelMeta as MsgIsReqDelMeta, index$1_MsgIsReqDelWAL as MsgIsReqDelWAL, index$1_MsgIsReqGestalt as MsgIsReqGestalt, index$1_MsgIsReqGetData as MsgIsReqGetData, index$1_MsgIsReqGetWAL as MsgIsReqGetWAL, index$1_MsgIsReqOpen as MsgIsReqOpen, index$1_MsgIsReqPutData as MsgIsReqPutData, index$1_MsgIsReqPutMeta as MsgIsReqPutMeta, index$1_MsgIsReqPutWAL as MsgIsReqPutWAL, index$1_MsgIsResChat as MsgIsResChat, index$1_MsgIsResClose as MsgIsResClose, index$1_MsgIsResDelData as MsgIsResDelData, index$1_MsgIsResDelMeta as MsgIsResDelMeta, index$1_MsgIsResDelWAL as MsgIsResDelWAL, index$1_MsgIsResGestalt as MsgIsResGestalt, index$1_MsgIsResGetData as MsgIsResGetData, index$1_MsgIsResGetWAL as MsgIsResGetWAL, index$1_MsgIsResOpen as MsgIsResOpen, index$1_MsgIsResPutData as MsgIsResPutData, index$1_MsgIsResPutMeta as MsgIsResPutMeta, index$1_MsgIsResPutWAL as MsgIsResPutWAL, index$1_MsgIsTenantLedger as MsgIsTenantLedger, index$1_MsgIsTid as MsgIsTid, index$1_MsgIsWithConn as MsgIsWithConn, index$1_MsgIsWithConnAuth as MsgIsWithConnAuth, type index$1_MsgRawConnection as MsgRawConnection, index$1_MsgRawConnectionBase as MsgRawConnectionBase, type index$1_MsgTypesCtx as MsgTypesCtx, type index$1_MsgTypesCtxSync as MsgTypesCtxSync, type index$1_MsgWithConnAuth as MsgWithConnAuth, type index$1_MsgWithError as MsgWithError, type index$1_MsgWithTenantLedger as MsgWithTenantLedger, index$1_Msger as Msger, type index$1_MsgerParams as MsgerParams, type index$1_MsgerParamsWithEnDe as MsgerParamsWithEnDe, type index$1_NextId as NextId, type index$1_OnErrorFn as OnErrorFn, type index$1_OnMsgFn as OnMsgFn, type index$1_OpenParams as OpenParams, type index$1_PreSignedMsg as PreSignedMsg, type index$1_ProtocolCapabilities as ProtocolCapabilities, type index$1_QSId as QSId, type index$1_ReqChat as ReqChat, type index$1_ReqClose as ReqClose, type index$1_ReqDelData as ReqDelData, type index$1_ReqDelMeta as ReqDelMeta, type index$1_ReqDelWAL as ReqDelWAL, type index$1_ReqGestalt as ReqGestalt, type index$1_ReqGetData as ReqGetData, type index$1_ReqGetWAL as ReqGetWAL, type index$1_ReqOpen as ReqOpen, type index$1_ReqOpenConn as ReqOpenConn, type index$1_ReqOpenConnection as ReqOpenConnection, type index$1_ReqPutData as ReqPutData, type index$1_ReqPutMeta as ReqPutMeta, type index$1_ReqPutWAL as ReqPutWAL, type index$1_ReqRes as ReqRes, type index$1_ReqSignedUrl as ReqSignedUrl, type index$1_ReqSignedUrlParam as ReqSignedUrlParam, type index$1_ReqSignedUrlWithoutMethodParams as ReqSignedUrlWithoutMethodParams, type index$1_RequestOpts as RequestOpts, type index$1_ResChat as ResChat, type index$1_ResClose as ResClose, type index$1_ResDelData as ResDelData, type index$1_ResDelMeta as ResDelMeta, type index$1_ResDelWAL as ResDelWAL, type index$1_ResGestalt as ResGestalt, type index$1_ResGetData as ResGetData, type index$1_ResGetWAL as ResGetWAL, type index$1_ResOpen as ResOpen, type index$1_ResOptionalSignedUrl as ResOptionalSignedUrl, type index$1_ResPutData as ResPutData, type index$1_ResPutMeta as ResPutMeta, type index$1_ResPutWAL as ResPutWAL, type index$1_ResSignedUrl as ResSignedUrl, type index$1_SignedUrlParam as SignedUrlParam, type index$1_TenantLedger as TenantLedger, type index$1_TokenForParam as TokenForParam, type index$1_UCanAuth as UCanAuth, type index$1_UnReg as UnReg, type index$1_UpdateReqRes as UpdateReqRes, index$1_VERSION as VERSION, index$1_WSConnection as WSConnection, type index$1_WSReqOpen as WSReqOpen, type index$1_WaitForTid as WaitForTid, index$1_applyStart as applyStart, index$1_authTypeFromUri as authTypeFromUri, index$1_buildBindGetMeta as buildBindGetMeta, index$1_buildErrorMsg as buildErrorMsg, index$1_buildEventGetMeta as buildEventGetMeta, index$1_buildReqChat as buildReqChat, index$1_buildReqClose as buildReqClose, index$1_buildReqDelData as buildReqDelData, index$1_buildReqDelMeta as buildReqDelMeta, index$1_buildReqDelWAL as buildReqDelWAL, index$1_buildReqGestalt as buildReqGestalt, index$1_buildReqGetData as buildReqGetData, index$1_buildReqGetWAL as buildReqGetWAL, index$1_buildReqOpen as buildReqOpen, index$1_buildReqPutData as buildReqPutData, index$1_buildReqPutMeta as buildReqPutMeta, index$1_buildReqPutWAL as buildReqPutWAL, index$1_buildReqSignedUrl as buildReqSignedUrl, index$1_buildRes as buildRes, index$1_buildResChat as buildResChat, index$1_buildResClose as buildResClose, index$1_buildResDelData as buildResDelData, index$1_buildResDelMeta as buildResDelMeta, index$1_buildResDelWAL as buildResDelWAL, index$1_buildResGestalt as buildResGestalt, index$1_buildResGetData as buildResGetData, index$1_buildResGetWAL as buildResGetWAL, index$1_buildResOpen as buildResOpen, index$1_buildResPutData as buildResPutData, index$1_buildResPutMeta as buildResPutMeta, index$1_buildResPutWAL as buildResPutWAL, index$1_coerceFPStoreTypes as coerceFPStoreTypes, index$1_defaultGestalt as defaultGestalt, index$1_defaultMsgParams as defaultMsgParams, index$1_isAuthTypeFPCloud as isAuthTypeFPCloud, index$1_isAuthTypeFPCloudJWK as isAuthTypeFPCloudJWK, index$1_isProtocolCapabilities as isProtocolCapabilities, index$1_jsonEnDe as jsonEnDe, index$1_keyTenantLedger as keyTenantLedger, index$1_qsidEqual as qsidEqual, index$1_qsidKey as qsidKey, index$1_resAuth as resAuth, index$1_selectRandom as selectRandom, index$1_timeout as timeout };
+}
+
 declare namespace index {
-  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXEDDB_VERSION as INDEXEDDB_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_KeysItem as KeysItem, type index_V1StorageKeyItem as V1StorageKeyItem, type index_V2StorageKeyItem as V2StorageKeyItem, 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_keysByFingerprint as keysByFingerprint, index$3 as mf, index_registerKeyBagProviderFactory as registerKeyBagProviderFactory, index_runtimeFn as runtimeFn, index_toKeyWithFingerPrint as toKeyWithFingerPrint };
+  export { index$1 as cloud };
 }
 
 declare const PACKAGE_VERSION: string;
 
-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 };
+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$1 as UnReg, type UnknownDoc, type Unreg, type UpdateListenerFn, type VoidFn, type WriteQueue, index$8 as blockstore, index$8 as bs, coerceIntoUint8, coercePromiseIntoUint8, defaultWriteQueueOpts, ensureLogger, ensureSuperLog, ensureSuperThis, ensureURIDefaults, exceptionWrapper, falsyToUndef, fireproof, getKey, getName, getStore, index$7 as index, inplaceFilter, isDatabase, isFalsy, isLedger, isNotFoundError, keyConfigOpts, makeName, onSuperThis, index as protocols, index as ps, index$2 as rt, index$2 as runtime, storeType2DataMetaWal, throwFalsy, toSortedArray, toStoreURIRuntime };
 declare module '@fireproof/core'