@livestore/adapter-node 0.4.0-dev.9 → 0.5.0-dev.0

package/dist/worker-schema.d.ts

@@ -1,228 +1,364 @@
-import { Devtools, LeaderAheadError, SyncState, UnexpectedError } from '@livestore/common';
-import { Schema } from '@livestore/utils/effect';
-export declare const WorkerArgv: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
-    clientId: typeof Schema.String;
-    storeId: typeof Schema.String;
-    sessionId: typeof Schema.String;
-    extraArgs: Schema.UndefinedOr<Schema.Schema<Schema.JsonValue, Schema.JsonValue, never>>;
+import { SyncState, UnknownError } from '@livestore/common';
+import { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema';
+import { Rpc, RpcGroup, Schema, Transferable } from '@livestore/utils/effect';
+export declare const WorkerArgv: Schema.fromJsonString<Schema.Struct<{
+    readonly clientId: Schema.String;
+    readonly storeId: Schema.String;
+    readonly sessionId: Schema.String;
+    readonly extraArgs: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 }>>;
 export declare const StorageTypeInMemory: Schema.Struct<{
-    type: Schema.Literal<["in-memory"]>;
+    readonly type: Schema.Literal<"in-memory">;
     /**
      * Only works with single-threaded leader thread for now.
      * Should be mostly used for testing.
      */
-    importSnapshot: Schema.optional<Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>>;
+    readonly importSnapshot: Schema.optional<Transferable.Transferable<Schema.instanceOf<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
 }>;
 export type StorageTypeInMemory = typeof StorageTypeInMemory.Type;
 export declare const StorageTypeFs: Schema.Struct<{
-    type: Schema.Literal<["fs"]>;
+    readonly type: Schema.Literal<"fs">;
     /**
      * Where to store the database files
      *
      * @default Current working directory
      */
-    baseDirectory: Schema.optional<typeof Schema.String>;
+    readonly baseDirectory: Schema.optional<Schema.String>;
 }>;
 export type StorageTypeFs = typeof StorageTypeFs.Type;
-export declare const StorageType: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["in-memory"]>;
+export declare const StorageType: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"in-memory">;
     /**
      * Only works with single-threaded leader thread for now.
      * Should be mostly used for testing.
      */
-    importSnapshot: Schema.optional<Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>>;
+    readonly importSnapshot: Schema.optional<Transferable.Transferable<Schema.instanceOf<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["fs"]>;
+    readonly type: Schema.Literal<"fs">;
     /**
      * Where to store the database files
      *
      * @default Current working directory
      */
-    baseDirectory: Schema.optional<typeof Schema.String>;
+    readonly baseDirectory: Schema.optional<Schema.String>;
 }>]>;
 export type StorageType = typeof StorageType.Type;
 export type StorageTypeEncoded = typeof StorageType.Encoded;
-export declare const SyncBackendOptions: Schema.Record$<typeof Schema.String, Schema.Schema<Schema.JsonValue, Schema.JsonValue, never>>;
-export type SyncBackendOptions = Record<string, Schema.JsonValue>;
-declare const LeaderWorkerOuterInitialMessage_base: Schema.TaggedRequestClass<LeaderWorkerOuterInitialMessage, "InitialMessage", {
-    readonly _tag: Schema.tag<"InitialMessage">;
-} & {
-    port: Schema.Schema<MessagePort, MessagePort, never>;
-}, typeof Schema.Void, typeof UnexpectedError>;
+export declare const SyncBackendOptions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type SyncBackendOptions = Record<string, Schema.Json>;
+declare const LeaderWorkerOuterInitialMessage_base: Rpc.Rpc<"InitialMessage", Schema.Struct<{
+    port: Transferable.Transferable<Schema.declare<MessagePort, MessagePort>>;
+}>, Schema.Void, Schema.Never, never, never>;
 export declare class LeaderWorkerOuterInitialMessage extends LeaderWorkerOuterInitialMessage_base {
 }
-declare const LeaderWorkerOuterRequest_base: typeof LeaderWorkerOuterInitialMessage;
-export declare class LeaderWorkerOuterRequest extends LeaderWorkerOuterRequest_base {
+declare const LeaderWorkerOuterRpcs_base: RpcGroup.RpcGroup<typeof LeaderWorkerOuterInitialMessage>;
+export declare class LeaderWorkerOuterRpcs extends LeaderWorkerOuterRpcs_base {
 }
-declare const LeaderWorkerInnerInitialMessage_base: Schema.TaggedRequestClass<LeaderWorkerInnerInitialMessage, "InitialMessage", {
-    readonly _tag: Schema.tag<"InitialMessage">;
-} & {
-    storeId: typeof Schema.String;
-    clientId: typeof Schema.String;
-    storage: Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["in-memory"]>;
+declare const LeaderWorkerInnerInitialMessage_base: Rpc.Rpc<"InitialMessage", Schema.Struct<{
+    storeId: Schema.String;
+    clientId: Schema.String;
+    storage: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"in-memory">;
         /**
          * Only works with single-threaded leader thread for now.
          * Should be mostly used for testing.
          */
-        importSnapshot: Schema.optional<Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>>;
+        readonly importSnapshot: Schema.optional<Transferable.Transferable<Schema.instanceOf<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["fs"]>;
+        readonly type: Schema.Literal<"fs">;
         /**
          * Where to store the database files
          *
          * @default Current working directory
          */
-        baseDirectory: Schema.optional<typeof Schema.String>;
+        readonly baseDirectory: Schema.optional<Schema.String>;
     }>]>;
-    syncPayload: Schema.UndefinedOr<Schema.Schema<Schema.JsonValue, Schema.JsonValue, never>>;
-    devtools: Schema.Union<[Schema.Struct<{
-        enabled: Schema.Literal<[true]>;
-        schemaPath: typeof Schema.String;
-        port: typeof Schema.Number;
-        host: typeof Schema.String;
-        schemaAlias: typeof Schema.String;
-        useExistingDevtoolsServer: typeof Schema.Boolean;
+    syncPayloadEncoded: Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    devtools: Schema.Union<readonly [Schema.Struct<{
+        readonly enabled: Schema.Literal<true>;
+        readonly schemaPath: Schema.String;
+        readonly port: Schema.Int;
+        readonly host: Schema.String;
+        readonly schemaAlias: Schema.String;
+        readonly useExistingDevtoolsServer: Schema.Boolean;
     }>, Schema.Struct<{
-        enabled: Schema.Literal<[false]>;
+        readonly enabled: Schema.Literal<false>;
     }>]>;
-}, typeof Schema.Void, typeof UnexpectedError>;
+}>, Schema.Void, typeof UnknownError, never, never>;
 export declare class LeaderWorkerInnerInitialMessage extends LeaderWorkerInnerInitialMessage_base {
 }
-declare const LeaderWorkerInnerBootStatusStream_base: Schema.TaggedRequestClass<LeaderWorkerInnerBootStatusStream, "BootStatusStream", {
-    readonly _tag: Schema.tag<"BootStatusStream">;
-}, Schema.Union<[Schema.Struct<{
-    stage: Schema.Literal<["loading"]>;
+export type LeaderWorkerInnerInitialMessagePayload = typeof LeaderWorkerInnerInitialMessage.payloadSchema.Type;
+declare const LeaderWorkerInnerBootStatusStream_base: Rpc.Rpc<"BootStatusStream", Schema.Struct<{}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+    readonly stage: Schema.Literal<"loading">;
 }>, Schema.Struct<{
-    stage: Schema.Literal<["migrating"]>;
-    progress: Schema.Struct<{
-        done: typeof Schema.Number;
-        total: typeof Schema.Number;
+    readonly stage: Schema.Literal<"migrating">;
+    readonly progress: Schema.Struct<{
+        readonly done: Schema.Finite;
+        readonly total: Schema.Finite;
     }>;
 }>, Schema.Struct<{
-    stage: Schema.Literal<["rehydrating"]>;
-    progress: Schema.Struct<{
-        done: typeof Schema.Number;
-        total: typeof Schema.Number;
+    readonly stage: Schema.Literal<"rehydrating">;
+    readonly progress: Schema.Struct<{
+        readonly done: Schema.Finite;
+        readonly total: Schema.Finite;
     }>;
 }>, Schema.Struct<{
-    stage: Schema.Literal<["syncing"]>;
-    progress: Schema.Struct<{
-        done: typeof Schema.Number;
-        total: typeof Schema.Number;
+    readonly stage: Schema.Literal<"syncing">;
+    readonly progress: Schema.Struct<{
+        readonly done: Schema.Finite;
+        readonly total: Schema.Finite;
     }>;
 }>, Schema.Struct<{
-    stage: Schema.Literal<["done"]>;
-}>]>, typeof UnexpectedError>;
+    readonly stage: Schema.Literal<"done">;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"warning">;
+    readonly reason: Schema.Literals<readonly ["private-browsing", "storage-unavailable", "unknown"]>;
+    readonly message: Schema.String;
+}>]>, Schema.Never>, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerBootStatusStream extends LeaderWorkerInnerBootStatusStream_base {
 }
-declare const LeaderWorkerInnerPullStream_base: Schema.TaggedRequestClass<LeaderWorkerInnerPullStream, "PullStream", {
-    readonly _tag: Schema.tag<"PullStream">;
-} & {
-    cursor: Schema.Struct<{
-        global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
-        client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
-        rebaseGeneration: typeof Schema.Int;
+declare const LeaderWorkerInnerPullStream_base: Rpc.Rpc<"PullStream", Schema.Struct<{
+    cursor: Schema.toType<Schema.Struct<{
+        readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+        readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+        readonly rebaseGeneration: Schema.Int;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
     }>;
-}, Schema.Struct<{
-    payload: typeof SyncState.PayloadUpstream;
-}>, typeof UnexpectedError>;
+}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Struct<{
+    readonly payload: Schema.Union<readonly [Schema.TaggedStruct<"upstream-rebase", {
+        readonly rollbackEvents: Schema.$Array<typeof LiveStoreEvent.Client.EncodedWithMeta>;
+        readonly newEvents: Schema.$Array<typeof LiveStoreEvent.Client.EncodedWithMeta>;
+    }>, Schema.TaggedStruct<"upstream-advance", {
+        readonly newEvents: Schema.$Array<typeof LiveStoreEvent.Client.EncodedWithMeta>;
+    }>]>;
+}>, Schema.Never>, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerPullStream extends LeaderWorkerInnerPullStream_base {
 }
-declare const LeaderWorkerInnerPushToLeader_base: Schema.TaggedRequestClass<LeaderWorkerInnerPushToLeader, "PushToLeader", {
-    readonly _tag: Schema.tag<"PushToLeader">;
-} & {
-    batch: Schema.Array$<Schema.Struct<{
-        name: typeof Schema.String;
-        args: typeof Schema.Any;
-        seqNum: Schema.Struct<{
-            global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
-            client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
-            rebaseGeneration: typeof Schema.Int;
-        }>;
-        parentSeqNum: Schema.Struct<{
-            global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
-            client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
-            rebaseGeneration: typeof Schema.Int;
-        }>;
-        clientId: typeof Schema.String;
-        sessionId: typeof Schema.String;
-    }>>;
-}, typeof Schema.Void, Schema.Union<[typeof UnexpectedError, typeof LeaderAheadError]>>;
+declare const LeaderWorkerInnerStreamEvents_base: Rpc.Rpc<"StreamEvents", Schema.Struct<{
+    readonly since: Schema.optional<Schema.Struct<{
+        readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+        readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+        readonly rebaseGeneration: Schema.Int;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    }>;
+    readonly until: Schema.optional<Schema.Struct<{
+        readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+        readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+        readonly rebaseGeneration: Schema.Int;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    }>;
+    readonly filter: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly clientIds: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly sessionIds: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly batchSize: Schema.optional<Schema.Int>;
+    readonly includeClientOnly: Schema.optional<Schema.Boolean>;
+}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly args: Schema.Any;
+    readonly seqNum: Schema.Struct<{
+        readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+        readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+        readonly rebaseGeneration: Schema.Int;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
+    readonly parentSeqNum: Schema.Struct<{
+        readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+        readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+        readonly rebaseGeneration: Schema.Int;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
+    readonly clientId: Schema.String;
+    readonly sessionId: Schema.String;
+}>, Schema.Never>, Schema.Never, never, never>;
+export declare class LeaderWorkerInnerStreamEvents extends LeaderWorkerInnerStreamEvents_base {
+}
+declare const LeaderWorkerInnerPushToLeader_base: Rpc.Rpc<"PushToLeader", Schema.Struct<{
+    batch: Schema.$Array<Schema.toType<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly args: Schema.Any;
+        readonly seqNum: Schema.Struct<{
+            readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+            readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+            readonly rebaseGeneration: Schema.Int;
+        }> & {
+            make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+        };
+        readonly parentSeqNum: Schema.Struct<{
+            readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+            readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+            readonly rebaseGeneration: Schema.Int;
+        }> & {
+            make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+        };
+        readonly clientId: Schema.String;
+        readonly sessionId: Schema.String;
+    }>>>;
+}>, Schema.Void, Schema.Union<readonly [typeof import("@livestore/common").LeaderAheadError, typeof import("@livestore/common").NonContiguousBatchError, typeof import("@livestore/common").NonMonotonicBatchError, typeof import("@livestore/common").StaleRebaseGenerationError]>, never, never>;
 export declare class LeaderWorkerInnerPushToLeader extends LeaderWorkerInnerPushToLeader_base {
 }
-declare const LeaderWorkerInnerExport_base: Schema.TaggedRequestClass<LeaderWorkerInnerExport, "Export", {
-    readonly _tag: Schema.tag<"Export">;
-}, Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>, typeof UnexpectedError>;
+declare const LeaderWorkerInnerExport_base: Rpc.Rpc<"Export", Schema.Struct<{}>, Transferable.Transferable<Schema.instanceOf<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerExport extends LeaderWorkerInnerExport_base {
 }
-declare const LeaderWorkerInnerGetRecreateSnapshot_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetRecreateSnapshot, "GetRecreateSnapshot", {
-    readonly _tag: Schema.tag<"GetRecreateSnapshot">;
-}, Schema.Struct<{
-    snapshot: Schema.Schema<Uint8Array<ArrayBuffer>>;
-    migrationsReport: Schema.Struct<{
-        migrations: Schema.Array$<Schema.Struct<{
-            tableName: typeof Schema.String;
-            hashes: Schema.Struct<{
-                expected: typeof Schema.Number;
-                actual: Schema.optional<typeof Schema.Number>;
+declare const LeaderWorkerInnerGetRecreateSnapshot_base: Rpc.Rpc<"GetRecreateSnapshot", Schema.Struct<{}>, Schema.Struct<{
+    readonly snapshot: Transferable.Transferable<Schema.instanceOf<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+    readonly migrationsReport: Schema.Struct<{
+        readonly migrations: Schema.$Array<Schema.Struct<{
+            readonly tableName: Schema.String;
+            readonly hashes: Schema.Struct<{
+                readonly expected: Schema.Finite;
+                readonly actual: Schema.optional<Schema.Finite>;
             }>;
         }>>;
     }>;
-}>, typeof UnexpectedError>;
+}>, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerGetRecreateSnapshot extends LeaderWorkerInnerGetRecreateSnapshot_base {
 }
-declare const LeaderWorkerInnerExportEventlog_base: Schema.TaggedRequestClass<LeaderWorkerInnerExportEventlog, "ExportEventlog", {
-    readonly _tag: Schema.tag<"ExportEventlog">;
-}, Schema.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, never>, typeof UnexpectedError>;
+declare const LeaderWorkerInnerExportEventlog_base: Rpc.Rpc<"ExportEventlog", Schema.Struct<{}>, Transferable.Transferable<Schema.instanceOf<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerExportEventlog extends LeaderWorkerInnerExportEventlog_base {
 }
-declare const LeaderWorkerInnerGetLeaderHead_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetLeaderHead, "GetLeaderHead", {
-    readonly _tag: Schema.tag<"GetLeaderHead">;
-}, Schema.Struct<{
-    global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
-    client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
-    rebaseGeneration: typeof Schema.Int;
-}>, typeof UnexpectedError>;
+declare const LeaderWorkerInnerGetLeaderHead_base: Rpc.Rpc<"GetLeaderHead", Schema.Struct<{}>, Schema.toType<Schema.Struct<{
+    readonly global: Schema.brand<Schema.Int, "GlobalEventSequenceNumber">;
+    readonly client: Schema.brand<Schema.Int, "ClientEventSequenceNumber">;
+    readonly rebaseGeneration: Schema.Int;
+}> & {
+    make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+}>, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerGetLeaderHead extends LeaderWorkerInnerGetLeaderHead_base {
 }
-declare const LeaderWorkerInnerGetLeaderSyncState_base: Schema.TaggedRequestClass<LeaderWorkerInnerGetLeaderSyncState, "GetLeaderSyncState", {
-    readonly _tag: Schema.tag<"GetLeaderSyncState">;
-}, typeof SyncState.SyncState, typeof UnexpectedError>;
+declare const LeaderWorkerInnerGetLeaderSyncState_base: Rpc.Rpc<"GetLeaderSyncState", Schema.Struct<{}>, typeof SyncState.SyncState, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerGetLeaderSyncState extends LeaderWorkerInnerGetLeaderSyncState_base {
 }
-declare const LeaderWorkerInnerShutdown_base: Schema.TaggedRequestClass<LeaderWorkerInnerShutdown, "Shutdown", {
-    readonly _tag: Schema.tag<"Shutdown">;
-}, typeof Schema.Void, typeof UnexpectedError>;
+declare const LeaderWorkerInnerSyncStateStream_base: Rpc.Rpc<"SyncStateStream", Schema.Struct<{}>, import("effect/unstable/rpc/RpcSchema").Stream<typeof SyncState.SyncState, Schema.Never>, Schema.Never, never, never>;
+export declare class LeaderWorkerInnerSyncStateStream extends LeaderWorkerInnerSyncStateStream_base {
+}
+declare const LeaderWorkerInnerGetNetworkStatus_base: Rpc.Rpc<"GetNetworkStatus", Schema.Struct<{}>, Schema.Struct<{
+    readonly isConnected: Schema.Boolean;
+    readonly timestampMs: Schema.Finite;
+    readonly devtools: Schema.Struct<{
+        readonly latchClosed: Schema.Boolean;
+    }>;
+}>, Schema.Never, never, never>;
+export declare class LeaderWorkerInnerGetNetworkStatus extends LeaderWorkerInnerGetNetworkStatus_base {
+}
+declare const LeaderWorkerInnerNetworkStatusStream_base: Rpc.Rpc<"NetworkStatusStream", Schema.Struct<{}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Struct<{
+    readonly isConnected: Schema.Boolean;
+    readonly timestampMs: Schema.Finite;
+    readonly devtools: Schema.Struct<{
+        readonly latchClosed: Schema.Boolean;
+    }>;
+}>, Schema.Never>, Schema.Never, never, never>;
+export declare class LeaderWorkerInnerNetworkStatusStream extends LeaderWorkerInnerNetworkStatusStream_base {
+}
+declare const LeaderWorkerInnerShutdown_base: Rpc.Rpc<"Shutdown", Schema.Struct<{}>, Schema.Void, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerShutdown extends LeaderWorkerInnerShutdown_base {
 }
-declare const LeaderWorkerInnerExtraDevtoolsMessage_base: Schema.TaggedRequestClass<LeaderWorkerInnerExtraDevtoolsMessage, "ExtraDevtoolsMessage", {
-    readonly _tag: Schema.tag<"ExtraDevtoolsMessage">;
-} & {
-    message: Schema.Union<[typeof Devtools.Leader.SnapshotReq, Schema.TaggedStruct<"LSD.Leader.LoadDatabaseFile.Request", {
-        data: Schema.Schema<Uint8Array<ArrayBuffer>>;
+declare const LeaderWorkerInnerExtraDevtoolsMessage_base: Rpc.Rpc<"ExtraDevtoolsMessage", Schema.Struct<{
+    message: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.SnapshotReq">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+    }>, Schema.TaggedStruct<"LSD.Leader.LoadDatabaseFile.Request", {
+        data: Schema.Codec<Uint8Array<ArrayBuffer>>;
+        batchId: Schema.optional<Schema.String>;
     } & {
         readonly requestId: typeof Schema.String;
-        readonly liveStoreVersion: Schema.Literal<["0.4.0-dev.9"]>;
+        readonly liveStoreVersion: Schema.String;
         readonly clientId: typeof Schema.String;
-    }>, typeof Devtools.Leader.EventlogReq, Schema.TaggedStruct<"LSD.Leader.ResetAllData.Request", {
-        mode: Schema.Literal<["all-data", "only-app-db"]>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.EventlogReq">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+    }>, Schema.TaggedStruct<"LSD.Leader.ResetAllData.Request", {
+        mode: Schema.Literals<readonly ["all-data", "only-app-db"]>;
     } & {
         readonly requestId: typeof Schema.String;
-        readonly liveStoreVersion: Schema.Literal<["0.4.0-dev.9"]>;
+        readonly liveStoreVersion: Schema.String;
         readonly clientId: typeof Schema.String;
-    }>, typeof Devtools.Leader.NetworkStatusSubscribe, typeof Devtools.Leader.NetworkStatusUnsubscribe, typeof Devtools.Leader.Disconnect, typeof Devtools.Leader.CommitEventReq, typeof Devtools.Leader.Ping, typeof Devtools.Leader.DatabaseFileInfoReq, typeof Devtools.Leader.SyncHistorySubscribe, typeof Devtools.Leader.SyncHistoryUnsubscribe, typeof Devtools.Leader.SyncingInfoReq, typeof Devtools.Leader.SyncHeadSubscribe, typeof Devtools.Leader.SyncHeadUnsubscribe, Schema.TaggedStruct<"LSD.Leader.SetSyncLatch.Request", {
-        closeLatch: typeof Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.NetworkStatusSubscribe">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        subscriptionId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.NetworkStatusUnsubscribe">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        subscriptionId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.Disconnect">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.CommitEventReq">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        eventEncoded: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly args: Schema.Any;
+        }>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.Ping">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        devtoolsProtocolVersion: Schema.optional<Schema.Finite>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.DatabaseFileInfoReq">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.SyncHistorySubscribe">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        subscriptionId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.SyncHistoryUnsubscribe">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        subscriptionId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.SyncingInfoReq">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.SyncHeadSubscribe">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        subscriptionId: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"LSD.Leader.SyncHeadUnsubscribe">;
+        readonly liveStoreVersion: Schema.String;
+        clientId: Schema.String;
+        requestId: Schema.String;
+        subscriptionId: Schema.String;
+    }>, Schema.TaggedStruct<"LSD.Leader.SetSyncLatch.Request", {
+        closeLatch: Schema.Boolean;
     } & {
         readonly requestId: typeof Schema.String;
-        readonly liveStoreVersion: Schema.Literal<["0.4.0-dev.9"]>;
+        readonly liveStoreVersion: Schema.String;
         readonly clientId: typeof Schema.String;
     }>]>;
-}, typeof Schema.Void, typeof UnexpectedError>;
+}>, Schema.Void, Schema.Never, never, never>;
 export declare class LeaderWorkerInnerExtraDevtoolsMessage extends LeaderWorkerInnerExtraDevtoolsMessage_base {
 }
-export declare const LeaderWorkerInnerRequest: Schema.Union<[typeof LeaderWorkerInnerInitialMessage, typeof LeaderWorkerInnerBootStatusStream, typeof LeaderWorkerInnerPullStream, typeof LeaderWorkerInnerPushToLeader, typeof LeaderWorkerInnerExport, typeof LeaderWorkerInnerGetRecreateSnapshot, typeof LeaderWorkerInnerExportEventlog, typeof LeaderWorkerInnerGetLeaderHead, typeof LeaderWorkerInnerGetLeaderSyncState, typeof LeaderWorkerInnerShutdown, typeof LeaderWorkerInnerExtraDevtoolsMessage]>;
-export type LeaderWorkerInnerRequest = typeof LeaderWorkerInnerRequest.Type;
+declare const LeaderWorkerInnerRpcs_base: RpcGroup.RpcGroup<typeof LeaderWorkerInnerBootStatusStream | typeof LeaderWorkerInnerPullStream | typeof LeaderWorkerInnerStreamEvents | typeof LeaderWorkerInnerPushToLeader | typeof LeaderWorkerInnerExport | typeof LeaderWorkerInnerGetRecreateSnapshot | typeof LeaderWorkerInnerExportEventlog | typeof LeaderWorkerInnerGetLeaderHead | typeof LeaderWorkerInnerGetLeaderSyncState | typeof LeaderWorkerInnerSyncStateStream | typeof LeaderWorkerInnerGetNetworkStatus | typeof LeaderWorkerInnerNetworkStatusStream | typeof LeaderWorkerInnerShutdown | typeof LeaderWorkerInnerExtraDevtoolsMessage>;
+export declare class LeaderWorkerInnerRpcs extends LeaderWorkerInnerRpcs_base {
+}
 export {};
 //# sourceMappingURL=worker-schema.d.ts.map

package/dist/worker-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-schema.d.ts","sourceRoot":"","sources":["../src/worker-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,QAAQ,EAAE,gBAAgB,EAAoB,SAAS,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExH,OAAO,EAAE,MAAM,EAAgB,MAAM,yBAAyB,CAAA;AAE9D,eAAO,MAAM,UAAU;;;;;GAOtB,CAAA;AAED,eAAO,MAAM,mBAAmB;;IAE9B;;;OAGG;;EAEH,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE,eAAO,MAAM,aAAa;;IAExB;;;;OAIG;;EAEH,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,eAAO,MAAM,WAAW;;IArBtB;;;OAGG;;;;IAQH;;;;OAIG;;IAMsE,CAAA;AAC3E,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AACjD,MAAM,MAAM,kBAAkB,GAAG,OAAO,WAAW,CAAC,OAAO,CAAA;AAS3D,eAAO,MAAM,kBAAkB,gGAAiE,CAAA;AAChG,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,CAAA;;;;;;AAEjE,qBAAa,+BAAgC,SAAQ,oCAOpD;CAAG;;AAEJ,qBAAa,wBAAyB,SAAQ,6BAA6C;CAAG;;;;;;;;QA5C5F;;;WAGG;;;;QAQH;;;;WAIG;;;;;;;;;;;;;;;AA+BL,qBAAa,+BAAgC,SAAQ,oCAuBpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,iCAAkC,SAAQ,sCAOtD;CAAG;;;;;;;;;;;;AAEJ,qBAAa,2BAA4B,SAAQ,gCAQ/C;CAAG;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,6BAA8B,SAAQ,kCASlD;CAAG;;;;AAEJ,qBAAa,uBAAwB,SAAQ,4BAI3C;CAAG;;;;cAOsC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;;;;;;;;;;;AALjF,qBAAa,oCAAqC,SAAQ,yCAUzD;CAAG;;;;AAEJ,qBAAa,+BAAgC,SAAQ,oCAOpD;CAAG;;;;;;;;AAEJ,qBAAa,8BAA+B,SAAQ,mCAOnD;CAAG;;;;AAEJ,qBAAa,mCAAoC,SAAQ,wCAOxD;CAAG;;;;AAEJ,qBAAa,yBAA0B,SAAQ,8BAI7C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,qCAAsC,SAAQ,0CAS1D;CAAG;AAEJ,eAAO,MAAM,wBAAwB,ocAYpC,CAAA;AACD,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC,IAAI,CAAA"}
+{"version":3,"file":"worker-schema.d.ts","sourceRoot":"","sources":["../src/worker-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,SAAS,EACT,YAAY,EACb,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAC9E,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE7E,eAAO,MAAM,UAAU;;;;;GAOtB,CAAA;AAED,eAAO,MAAM,mBAAmB;;IAE9B;;;OAGG;;EAEH,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE,eAAO,MAAM,aAAa;;IAExB;;;;OAIG;;EAEH,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,eAAO,MAAM,WAAW;;IArBtB;;;OAGG;;;;IAQH;;;;OAIG;;IAMwE,CAAA;AAC7E,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AACjD,MAAM,MAAM,kBAAkB,GAAG,OAAO,WAAW,CAAC,OAAO,CAAA;AAS3D,eAAO,MAAM,kBAAkB,qFAA4C,CAAA;AAC3E,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;;;;AAE5D,qBAAa,+BAAgC,SAAQ,oCAInD;CAAG;;AAEL,qBAAa,qBAAsB,SAAQ,0BAA8C;CAAG;;;;;;QAzC1F;;;WAGG;;;;QAQH;;;;WAIG;;;;;;;;;;;;;;;AA4BL,qBAAa,+BAAgC,SAAQ,oCAoBnD;CAAG;AAEL,MAAM,MAAM,sCAAsC,GAAG,OAAO,+BAA+B,CAAC,aAAa,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9G,qBAAa,iCAAkC,SAAQ,sCAKrD;CAAG;;;;;;;;;;;;;;;;;AAEL,qBAAa,2BAA4B,SAAQ,gCAS/C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,6BAA8B,SAAQ,kCAKjD;CAAG;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,6BAA8B,SAAQ,kCAMjD;CAAG;;AAEL,qBAAa,uBAAwB,SAAQ,4BAI3C;CAAG;;;;;;;;;;;;;AAEL,qBAAa,oCAAqC,SAAQ,yCAOxD;CAAG;;AAEL,qBAAa,+BAAgC,SAAQ,oCAInD;CAAG;;;;;;;;AAEL,qBAAa,8BAA+B,SAAQ,mCAIlD;CAAG;;AAEL,qBAAa,mCAAoC,SAAQ,wCAIvD;CAAG;;AAEL,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAIrD;CAAG;;;;;;;;AAEL,qBAAa,oCAAqC,SAAQ,yCAKxD;CAAG;;AAEL,qBAAa,yBAA0B,SAAQ,8BAI7C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,qCAAsC,SAAQ,0CAMzD;CAAG;;AAEL,qBAAa,qBAAsB,SAAQ,0BAe1C;CAAG"}