@livestore/adapter-web 0.4.0 → 0.5.0-dev.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (73) hide show
  1. package/dist/.tsbuildinfo +1 -1
  2. package/dist/common/connection.d.ts.map +1 -1
  3. package/dist/in-memory/in-memory-adapter.d.ts +7 -8
  4. package/dist/in-memory/in-memory-adapter.d.ts.map +1 -1
  5. package/dist/in-memory/in-memory-adapter.js +37 -30
  6. package/dist/in-memory/in-memory-adapter.js.map +1 -1
  7. package/dist/index.js +4 -4
  8. package/dist/single-tab/mod.js +1 -1
  9. package/dist/single-tab/single-tab-adapter.d.ts.map +1 -1
  10. package/dist/single-tab/single-tab-adapter.js +63 -83
  11. package/dist/single-tab/single-tab-adapter.js.map +1 -1
  12. package/dist/web-worker/client-session/client-session-devtools.d.ts +3 -4
  13. package/dist/web-worker/client-session/client-session-devtools.d.ts.map +1 -1
  14. package/dist/web-worker/client-session/client-session-devtools.js +7 -5
  15. package/dist/web-worker/client-session/client-session-devtools.js.map +1 -1
  16. package/dist/web-worker/client-session/devtools-web-channel.d.ts +20 -0
  17. package/dist/web-worker/client-session/devtools-web-channel.d.ts.map +1 -0
  18. package/dist/web-worker/client-session/devtools-web-channel.js +34 -0
  19. package/dist/web-worker/client-session/devtools-web-channel.js.map +1 -0
  20. package/dist/web-worker/client-session/persisted-adapter.d.ts.map +1 -1
  21. package/dist/web-worker/client-session/persisted-adapter.js +76 -85
  22. package/dist/web-worker/client-session/persisted-adapter.js.map +1 -1
  23. package/dist/web-worker/client-session/sqlite-loader.js.map +1 -1
  24. package/dist/web-worker/common/persisted-sqlite.d.ts +23 -10
  25. package/dist/web-worker/common/persisted-sqlite.d.ts.map +1 -1
  26. package/dist/web-worker/common/persisted-sqlite.js +29 -25
  27. package/dist/web-worker/common/persisted-sqlite.js.map +1 -1
  28. package/dist/web-worker/common/persisted-sqlite.test-fixture.d.ts +2 -0
  29. package/dist/web-worker/common/persisted-sqlite.test-fixture.d.ts.map +1 -0
  30. package/dist/web-worker/common/persisted-sqlite.test-fixture.js +57 -0
  31. package/dist/web-worker/common/persisted-sqlite.test-fixture.js.map +1 -0
  32. package/dist/web-worker/common/rpc-worker.d.ts +14 -0
  33. package/dist/web-worker/common/rpc-worker.d.ts.map +1 -0
  34. package/dist/web-worker/common/rpc-worker.js +8 -0
  35. package/dist/web-worker/common/rpc-worker.js.map +1 -0
  36. package/dist/web-worker/common/shutdown-channel.d.ts.map +1 -1
  37. package/dist/web-worker/common/webmesh-node-names.d.ts +4 -0
  38. package/dist/web-worker/common/webmesh-node-names.d.ts.map +1 -0
  39. package/dist/web-worker/common/webmesh-node-names.js +2 -0
  40. package/dist/web-worker/common/webmesh-node-names.js.map +1 -0
  41. package/dist/web-worker/common/worker-disconnect-channel.d.ts +1 -4
  42. package/dist/web-worker/common/worker-disconnect-channel.d.ts.map +1 -1
  43. package/dist/web-worker/common/worker-disconnect-channel.js +1 -2
  44. package/dist/web-worker/common/worker-disconnect-channel.js.map +1 -1
  45. package/dist/web-worker/common/worker-schema.d.ts +275 -211
  46. package/dist/web-worker/common/worker-schema.d.ts.map +1 -1
  47. package/dist/web-worker/common/worker-schema.js +71 -52
  48. package/dist/web-worker/common/worker-schema.js.map +1 -1
  49. package/dist/web-worker/leader-worker/make-leader-worker.d.ts +6 -8
  50. package/dist/web-worker/leader-worker/make-leader-worker.d.ts.map +1 -1
  51. package/dist/web-worker/leader-worker/make-leader-worker.js +147 -94
  52. package/dist/web-worker/leader-worker/make-leader-worker.js.map +1 -1
  53. package/dist/web-worker/shared-worker/make-shared-worker.d.ts +2 -2
  54. package/dist/web-worker/shared-worker/make-shared-worker.d.ts.map +1 -1
  55. package/dist/web-worker/shared-worker/make-shared-worker.js +54 -66
  56. package/dist/web-worker/shared-worker/make-shared-worker.js.map +1 -1
  57. package/dist/web-worker/vite-dev-polyfill.js +1 -2
  58. package/dist/web-worker/vite-dev-polyfill.js.map +1 -1
  59. package/package.json +38 -48
  60. package/src/in-memory/in-memory-adapter.ts +73 -58
  61. package/src/single-tab/single-tab-adapter.ts +112 -114
  62. package/src/web-worker/client-session/client-session-devtools.ts +16 -8
  63. package/src/web-worker/client-session/devtools-web-channel.ts +57 -0
  64. package/src/web-worker/client-session/persisted-adapter.ts +122 -124
  65. package/src/web-worker/common/persisted-sqlite.test-fixture.ts +68 -0
  66. package/src/web-worker/common/persisted-sqlite.ts +72 -50
  67. package/src/web-worker/common/rpc-worker.ts +39 -0
  68. package/src/web-worker/common/webmesh-node-names.ts +1 -0
  69. package/src/web-worker/common/worker-disconnect-channel.ts +1 -1
  70. package/src/web-worker/common/worker-schema.ts +132 -162
  71. package/src/web-worker/leader-worker/make-leader-worker.ts +347 -219
  72. package/src/web-worker/shared-worker/make-shared-worker.ts +95 -85
  73. package/src/web-worker/vite-dev-polyfill.ts +1 -2
@@ -1,60 +1,69 @@
1
- import { liveStoreStorageFormatVersion } from '@livestore/common'
2
- import type { LiveStoreSchema } from '@livestore/common/schema'
1
+ import { liveStoreStorageFormatVersion, type MakeSqliteDb } from '@livestore/common'
2
+ import { hasCompletedState } from '@livestore/common/leader-thread'
3
+ import { getStateDbBaseName, type LiveStoreSchema } from '@livestore/common/schema'
3
4
  import {
4
5
  decodeAccessHandlePoolFilename,
5
6
  HEADER_OFFSET_DATA,
6
7
  type WebDatabaseMetadataOpfs,
7
8
  } from '@livestore/sqlite-wasm/browser'
8
9
  import { isDevEnv } from '@livestore/utils'
9
- import { Chunk, Effect, Option, Order, Schedule, Schema, Stream } from '@livestore/utils/effect'
10
+ import {
11
+ Effect,
12
+ Option,
13
+ Order,
14
+ pipe,
15
+ ReadonlyArray as EffectArray,
16
+ Schedule,
17
+ Schema,
18
+ Stream,
19
+ } from '@livestore/utils/effect'
10
20
  import { Opfs, type WebError } from '@livestore/utils/effect/browser'
11
21
 
12
22
  import type * as WorkerSchema from './worker-schema.ts'
13
23
 
14
- export class PersistedSqliteError extends Schema.TaggedError<PersistedSqliteError>('~@livestore/adapter-web/PersistedSqliteError')('PersistedSqliteError', {
24
+ export class PersistedSqliteError extends Schema.TaggedError<PersistedSqliteError>(
25
+ '~@livestore/adapter-web/PersistedSqliteError',
26
+ )('PersistedSqliteError', {
15
27
  message: Schema.String,
16
- cause: Schema.optional(Schema.Defect),
28
+ cause: Schema.optional(Schema.Defect()),
17
29
  }) {}
18
30
 
19
- export const readPersistedStateDbFromClientSession: (args: {
20
- storageOptions: WorkerSchema.StorageType
21
- storeId: string
22
- schema: LiveStoreSchema
23
- }) => Effect.Effect<
24
- Uint8Array<ArrayBuffer>,
25
- // All the following errors could actually happen:
26
- | PersistedSqliteError
27
- | WebError.UnknownError
28
- | WebError.TypeError
29
- | WebError.NotFoundError
30
- | WebError.NotAllowedError
31
- | WebError.TypeMismatchError
32
- | WebError.SecurityError
33
- | Opfs.OpfsError,
34
- Opfs.Opfs
35
- > = Effect.fn('@livestore/adapter-web:readPersistedStateDbFromClientSession')(
36
- function* ({ storageOptions, storeId, schema }) {
31
+ export const readPersistedStateDbFromClientSession = Effect.fn(
32
+ '@livestore/adapter-web:readPersistedStateDbFromClientSession',
33
+ )(
34
+ function* ({
35
+ storageOptions,
36
+ storeId,
37
+ schema,
38
+ makeSqliteDb,
39
+ }: {
40
+ storageOptions: WorkerSchema.StorageType
41
+ storeId: string
42
+ schema: LiveStoreSchema
43
+ makeSqliteDb: (input: { _tag: 'in-memory' }) => ReturnType<MakeSqliteDb>
44
+ }) {
37
45
  const accessHandlePoolDirString = yield* sanitizeOpfsDir(storageOptions.directory, storeId)
38
46
 
39
47
  const accessHandlePoolDirHandle = yield* Opfs.getDirectoryHandleByPath(accessHandlePoolDirString)
40
48
 
41
49
  const stateDbFileName = `/${getStateDbFileName(schema)}`
42
50
 
43
- const handlesStream = yield* Opfs.Opfs.values(accessHandlePoolDirHandle)
51
+ const opfs = yield* Opfs.Opfs
52
+ const handlesStream = opfs.values(accessHandlePoolDirHandle)
44
53
 
45
54
  const stateDbFileOption = yield* handlesStream.pipe(
46
55
  Stream.filter((handle): handle is FileSystemFileHandle => handle.kind === 'file'),
47
56
  Stream.mapEffect(
48
57
  (fileHandle) =>
49
58
  Effect.gen(function* () {
50
- const file = yield* Opfs.Opfs.getFile(fileHandle)
59
+ const file = yield* opfs.getFile(fileHandle)
51
60
  const fileName = yield* Effect.promise(() => decodeAccessHandlePoolFilename(file))
52
61
  return { file, fileName }
53
62
  }),
54
63
  { concurrency: 'unbounded' },
55
64
  ),
56
- Stream.find(({ fileName }) => fileName === stateDbFileName),
57
- Stream.runHead,
65
+ Stream.filter(({ fileName }) => fileName === stateDbFileName),
66
+ Stream.runFirst,
58
67
  )
59
68
 
60
69
  if (Option.isNone(stateDbFileOption) === true) {
@@ -75,7 +84,33 @@ export const readPersistedStateDbFromClientSession: (args: {
75
84
  })
76
85
  }
77
86
 
78
- return new Uint8Array(stateDbBuffer)
87
+ const snapshot = new Uint8Array(stateDbBuffer)
88
+ const sqliteDb = yield* Effect.acquireRelease(
89
+ makeSqliteDb({ _tag: 'in-memory' }).pipe(
90
+ Effect.tap((db) =>
91
+ Effect.try({
92
+ try: () => {
93
+ db.import(snapshot)
94
+ return hasCompletedState(db)
95
+ },
96
+ catch: (cause) => new PersistedSqliteError({ message: 'Could not load persisted state snapshot', cause }),
97
+ }).pipe(
98
+ Effect.filterOrFail(
99
+ (completed) => completed,
100
+ () =>
101
+ new PersistedSqliteError({
102
+ message: 'Persisted state rebuild is incomplete; waiting for leader recovery',
103
+ }),
104
+ ),
105
+ // A failed acquisition has no scope finalizer yet, so release it here.
106
+ Effect.onError(() => Effect.sync(() => db.close())),
107
+ ),
108
+ ),
109
+ ),
110
+ (db) => Effect.sync(() => db.close()),
111
+ )
112
+
113
+ return { sqliteDb, snapshotByteLength: snapshot.byteLength }
79
114
  },
80
115
  Effect.logWarnIfTakesLongerThan({
81
116
  duration: 1000,
@@ -116,11 +151,7 @@ export const sanitizeOpfsDir = Effect.fn('@livestore/adapter-web:sanitizeOpfsDir
116
151
  return `${directory}@${liveStoreStorageFormatVersion}`
117
152
  })
118
153
 
119
- export const getStateDbFileName = (schema: LiveStoreSchema) => {
120
- const schemaHashSuffix =
121
- schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
122
- return `state${schemaHashSuffix}.db`
123
- }
154
+ export const getStateDbFileName = (schema: LiveStoreSchema) => `${getStateDbBaseName(schema)}.db`
124
155
 
125
156
  export const MAX_ARCHIVED_STATE_DBS_IN_DEV = 3
126
157
  export const ARCHIVE_DIR_NAME = 'archive'
@@ -159,16 +190,6 @@ export const cleanupOldStateDbFiles: (options: {
159
190
  | PersistedSqliteError,
160
191
  Opfs.Opfs
161
192
  > = Effect.fn('@livestore/adapter-web:cleanupOldStateDbFiles')(function* ({ vfs, currentSchema, opfsDirectory }) {
162
- // Only cleanup for auto migration strategy because:
163
- // - Auto strategy: Creates new database files per schema change (e.g., state123.db, state456.db)
164
- // which accumulate over time and can exhaust OPFS file pool capacity
165
- // - Manual strategy: Always reuses the same database file (statefixed.db) across schema changes,
166
- // so there are never multiple old files to clean up
167
- if (currentSchema.state.sqlite.migrations.strategy === 'manual') {
168
- yield* Effect.logDebug('Skipping state db cleanup - manual migration strategy uses fixed filename')
169
- return
170
- }
171
-
172
193
  const isDev = isDevEnv()
173
194
  const currentDbFileName = getStateDbFileName(currentSchema)
174
195
  const currentPath = `/${currentDbFileName}`
@@ -243,22 +264,23 @@ const pruneArchiveDirectory = Effect.fn('@livestore/adapter-web:pruneArchiveDire
243
264
  keep: number
244
265
  }) {
245
266
  const archiveDirHandle = yield* Opfs.getDirectoryHandleByPath(archiveDirectory)
246
- const handlesStream = yield* Opfs.Opfs.values(archiveDirHandle)
267
+ const opfs = yield* Opfs.Opfs
268
+ const handlesStream = opfs.values(archiveDirHandle)
247
269
  const filesWithMetadata = yield* handlesStream.pipe(
248
270
  Stream.filter((handle): handle is FileSystemFileHandle => handle.kind === 'file'),
249
271
  Stream.mapEffect((fileHandle) => Opfs.getMetadata(fileHandle)),
250
272
  Stream.runCollect,
251
273
  )
252
- const filesToDelete = filesWithMetadata.pipe(
253
- // oxlint-disable-next-line unicorn/no-array-sort -- false positive: Effect Chunk.sort is immutable, not Array#sort (https://github.com/oxc-project/oxc/issues/19110)
254
- Chunk.sort(Order.mapInput(Order.number, (entry: { lastModified: number }) => entry.lastModified)),
255
- Chunk.drop(keep),
256
- Chunk.toReadonlyArray,
274
+ const filesToDelete = pipe(
275
+ filesWithMetadata,
276
+ // oxlint-disable-next-line eslint-plugin-unicorn(no-array-sort) -- EffectArray has no toSorted helper in the current Effect version; sort returns a sorted copy.
277
+ EffectArray.sort(Order.mapInput(Order.Number, (entry: { lastModified: number }) => entry.lastModified)),
278
+ EffectArray.drop(keep),
257
279
  )
258
280
 
259
281
  if (filesToDelete.length === 0) return
260
282
 
261
- yield* Effect.forEach(filesToDelete, ({ name }) => Opfs.Opfs.removeEntry(archiveDirHandle, name))
283
+ yield* Effect.forEach(filesToDelete, ({ name }) => opfs.removeEntry(archiveDirHandle, name))
262
284
 
263
285
  yield* Effect.logDebug(`Pruned ${filesToDelete.length} old database file(s) from archive directory`)
264
286
  })
@@ -0,0 +1,39 @@
1
+ import { Effect, RpcClientError, Schema, Stream } from '@livestore/utils/effect'
2
+ import type * as WebmeshWorker from '@livestore/webmesh/worker'
3
+
4
+ export type WebmeshWorkerProxy = Parameters<typeof WebmeshWorker.connectViaWorker>[0]['worker']
5
+ export type WithoutRpcClientError<E> = E extends { readonly _tag: infer Tag }
6
+ ? 'RpcClientError' extends Tag
7
+ ? never
8
+ : E
9
+ : E
10
+ export type WebmeshWorkerRpcClient = {
11
+ readonly ['WebmeshWorker.CreateConnection']: (
12
+ request: typeof WebmeshWorker.Schema.CreateConnection.Type,
13
+ ) => Stream.Stream<{}, RpcClientError.RpcClientError>
14
+ }
15
+
16
+ export const isRpcClientError = (error: unknown): error is RpcClientError.RpcClientError =>
17
+ Schema.is(RpcClientError.RpcClientError)(error)
18
+
19
+ export const dieOnRpcClientError = <A, E, R>(
20
+ effect: Effect.Effect<A, E, R>,
21
+ ): Effect.Effect<A, WithoutRpcClientError<E>, R> =>
22
+ (effect as Effect.Effect<A, RpcClientError.RpcClientError | WithoutRpcClientError<E>, R>).pipe(
23
+ Effect.catchIf(isRpcClientError, (error) => Effect.die(error)),
24
+ ) as Effect.Effect<A, WithoutRpcClientError<E>, R>
25
+
26
+ export const dieOnRpcClientErrorStream = <A, E, R>(
27
+ stream: Stream.Stream<A, E, R>,
28
+ ): Stream.Stream<A, WithoutRpcClientError<E>, R> =>
29
+ (stream as Stream.Stream<A, RpcClientError.RpcClientError | WithoutRpcClientError<E>, R>).pipe(
30
+ Stream.catchIf(
31
+ isRpcClientError,
32
+ (error) => Stream.die(error),
33
+ (error) => Stream.fail(error),
34
+ ),
35
+ ) as Stream.Stream<A, WithoutRpcClientError<E>, R>
36
+
37
+ export const makeWebmeshWorkerProxy = (client: WebmeshWorkerRpcClient): WebmeshWorkerProxy => ({
38
+ execute: (request) => dieOnRpcClientErrorStream(client['WebmeshWorker.CreateConnection'](request)),
39
+ })
@@ -0,0 +1 @@
1
+ export const makeSharedWorkerNodeName = ({ storeId }: { storeId: string }) => `shared-worker-${storeId}`
@@ -1,7 +1,7 @@
1
1
  import { type Effect, Schema, type Scope, type WebChannel } from '@livestore/utils/effect'
2
2
  import { WebChannelBrowser } from '@livestore/utils/effect/browser'
3
3
 
4
- export class DedicatedWorkerDisconnectBroadcast extends Schema.TaggedStruct('DedicatedWorkerDisconnectBroadcast', {}) {}
4
+ export const DedicatedWorkerDisconnectBroadcast = Schema.TaggedStruct('DedicatedWorkerDisconnectBroadcast', {})
5
5
 
6
6
  /** Used across workers for leader election purposes */
7
7
  export const makeWorkerDisconnectChannel = (
@@ -1,17 +1,17 @@
1
1
  import {
2
2
  BootStatus,
3
3
  Devtools,
4
- RejectedPushError,
5
4
  liveStoreVersion,
6
5
  MigrationsReport,
6
+ RejectedPushError,
7
7
  SyncBackend,
8
8
  SyncState,
9
9
  UnknownError,
10
10
  } from '@livestore/common'
11
- import { StreamEventsOptionsFields } from '@livestore/common/leader-thread'
11
+ import { StateRebuildBatchSizeSchema, StreamEventsOptionsFields } from '@livestore/common/leader-thread'
12
12
  import { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema'
13
- import * as WebmeshWorker from '@livestore/devtools-web-common/worker'
14
- import { Schema, Transferable } from '@livestore/utils/effect'
13
+ import { Rpc, RpcGroup, Schema, Transferable } from '@livestore/utils/effect'
14
+ import * as WebmeshWorker from '@livestore/webmesh/worker'
15
15
 
16
16
  export const StorageTypeOpfs = Schema.Struct({
17
17
  type: Schema.Literal('opfs'),
@@ -29,180 +29,155 @@ export type StorageTypeOpfs = typeof StorageTypeOpfs.Type
29
29
  // export const StorageTypeIndexeddb = Schema.Struct({
30
30
  // type: Schema.Literal('indexeddb'),
31
31
  // /** @default "livestore" */
32
- // databaseName: Schema.optionalWith(Schema.String, { default: () => 'livestore' }),
32
+ // databaseName: Schema.String.pipe(Schema.withDecodingDefaultType(Effect.succeed('livestore'))),
33
33
  // /** @default "livestore-" */
34
- // storeNamePrefix: Schema.optionalWith(Schema.String, { default: () => 'livestore-' }),
34
+ // storeNamePrefix: Schema.String.pipe(Schema.withDecodingDefaultType(Effect.succeed('livestore-'))),
35
35
  // })
36
36
 
37
- export const StorageType = Schema.Union(
37
+ export const StorageType = Schema.Union([
38
38
  StorageTypeOpfs,
39
39
  // StorageTypeIndexeddb
40
- )
40
+ ])
41
41
  export type StorageType = typeof StorageType.Type
42
42
  export type StorageTypeEncoded = typeof StorageType.Encoded
43
43
 
44
- // export const SyncBackendOptions = Schema.Union(SyncBackendOptionsWebsocket)
45
- export const SyncBackendOptions = Schema.Record({ key: Schema.String, value: Schema.JsonValue })
46
- export type SyncBackendOptions = Record<string, Schema.JsonValue>
44
+ // export const SyncBackendOptions = Schema.Union([SyncBackendOptionsWebsocket])
45
+ export const SyncBackendOptions = Schema.Record(Schema.String, Schema.Json)
46
+ export type SyncBackendOptions = Record<string, Schema.Json>
47
47
 
48
- export class LeaderWorkerOuterInitialMessage extends Schema.TaggedRequest<LeaderWorkerOuterInitialMessage>()(
49
- 'InitialMessage',
50
- {
51
- payload: { port: Transferable.MessagePort, storeId: Schema.String, clientId: Schema.String },
52
- success: Schema.Void,
53
- failure: Schema.Never,
54
- },
55
- ) {}
48
+ export class LeaderWorkerOuterInitialMessage extends Rpc.make('InitialMessage', {
49
+ payload: { port: Transferable.MessagePort, storeId: Schema.String, clientId: Schema.String },
50
+ success: Schema.Void,
51
+ error: Schema.Never,
52
+ }) {}
56
53
 
57
- export class LeaderWorkerOuterRequest extends Schema.Union(LeaderWorkerOuterInitialMessage) {}
54
+ export class LeaderWorkerOuterRpcs extends RpcGroup.make(LeaderWorkerOuterInitialMessage) {}
55
+
56
+ export const LeaderWorkerParams = Schema.Struct({ stateRebuildBatchSize: StateRebuildBatchSizeSchema })
58
57
 
59
58
  // TODO unify this code with schema from node adapter
60
- export class LeaderWorkerInnerInitialMessage extends Schema.TaggedRequest<LeaderWorkerInnerInitialMessage>()(
61
- 'InitialMessage',
62
- {
63
- payload: {
64
- storageOptions: StorageType,
65
- devtoolsEnabled: Schema.Boolean,
66
- storeId: Schema.String,
67
- clientId: Schema.String,
68
- debugInstanceId: Schema.String,
69
- syncPayloadEncoded: Schema.UndefinedOr(Schema.JsonValue),
70
- },
71
- success: Schema.Void,
72
- failure: UnknownError,
59
+ export class LeaderWorkerInnerInitialMessage extends Rpc.make('InitialMessage', {
60
+ payload: {
61
+ storageOptions: StorageType,
62
+ devtoolsEnabled: Schema.Boolean,
63
+ storeId: Schema.String,
64
+ clientId: Schema.String,
65
+ debugInstanceId: Schema.String,
66
+ syncPayloadEncoded: Schema.UndefinedOr(Schema.Json),
67
+ params: LeaderWorkerParams,
73
68
  },
74
- ) {}
69
+ success: Schema.Void,
70
+ error: UnknownError,
71
+ }) {}
75
72
 
76
- export class LeaderWorkerInnerBootStatusStream extends Schema.TaggedRequest<LeaderWorkerInnerBootStatusStream>()(
77
- 'BootStatusStream',
78
- {
79
- payload: {},
80
- success: BootStatus,
81
- failure: Schema.Never,
82
- },
83
- ) {}
73
+ export class LeaderWorkerInnerBootStatusStream extends Rpc.make('BootStatusStream', {
74
+ payload: {},
75
+ success: BootStatus,
76
+ error: Schema.Never,
77
+ stream: true,
78
+ }) {}
84
79
 
85
- export class LeaderWorkerInnerPushToLeader extends Schema.TaggedRequest<LeaderWorkerInnerPushToLeader>()(
86
- 'PushToLeader',
87
- {
88
- payload: {
89
- batch: Schema.Array(Schema.typeSchema(LiveStoreEvent.Client.Encoded)),
90
- },
91
- success: Schema.Void as Schema.Schema<void>,
92
- failure: RejectedPushError,
80
+ export class LeaderWorkerInnerPushToLeader extends Rpc.make('PushToLeader', {
81
+ payload: {
82
+ batch: Schema.Array(Schema.toType(LiveStoreEvent.Client.Encoded)),
93
83
  },
94
- ) {}
84
+ success: Schema.Void,
85
+ error: RejectedPushError,
86
+ }) {}
95
87
 
96
- export class LeaderWorkerInnerPullStream extends Schema.TaggedRequest<LeaderWorkerInnerPullStream>()('PullStream', {
88
+ export class LeaderWorkerInnerPullStream extends Rpc.make('PullStream', {
97
89
  payload: {
98
- cursor: Schema.typeSchema(EventSequenceNumber.Client.Composite),
90
+ cursor: Schema.toType(EventSequenceNumber.Client.Composite),
99
91
  },
100
92
  success: Schema.Struct({
101
93
  payload: SyncState.PayloadUpstream,
102
94
  }),
103
- failure: Schema.Never,
95
+ error: Schema.Never,
96
+ stream: true,
104
97
  }) {}
105
98
 
106
- export class LeaderWorkerInnerStreamEvents extends Schema.TaggedRequest<LeaderWorkerInnerStreamEvents>()(
107
- 'StreamEvents',
108
- {
109
- payload: StreamEventsOptionsFields,
110
- success: LiveStoreEvent.Client.Encoded,
111
- failure: Schema.Never,
112
- },
113
- ) {}
99
+ export class LeaderWorkerInnerStreamEvents extends Rpc.make('StreamEvents', {
100
+ payload: StreamEventsOptionsFields,
101
+ success: LiveStoreEvent.Client.Encoded,
102
+ error: Schema.Never,
103
+ stream: true,
104
+ }) {}
114
105
 
115
- export class LeaderWorkerInnerExport extends Schema.TaggedRequest<LeaderWorkerInnerExport>()('Export', {
106
+ export class LeaderWorkerInnerExport extends Rpc.make('Export', {
116
107
  payload: {},
117
- success: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
118
- failure: Schema.Never,
108
+ success: Transferable.Uint8Array as Schema.Codec<Uint8Array<ArrayBuffer>>,
109
+ error: Schema.Never,
119
110
  }) {}
120
111
 
121
- export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<LeaderWorkerInnerExportEventlog>()(
122
- 'ExportEventlog',
123
- {
124
- payload: {},
125
- success: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
126
- failure: Schema.Never,
127
- },
128
- ) {}
112
+ export class LeaderWorkerInnerExportEventlog extends Rpc.make('ExportEventlog', {
113
+ payload: {},
114
+ success: Transferable.Uint8Array as Schema.Codec<Uint8Array<ArrayBuffer>>,
115
+ error: Schema.Never,
116
+ }) {}
129
117
 
130
- export class LeaderWorkerInnerGetRecreateSnapshot extends Schema.TaggedRequest<LeaderWorkerInnerGetRecreateSnapshot>()(
131
- 'GetRecreateSnapshot',
132
- {
133
- payload: {},
134
- success: Schema.Struct({
135
- snapshot: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
136
- migrationsReport: MigrationsReport,
137
- }),
138
- failure: Schema.Never,
139
- },
140
- ) {}
118
+ export class LeaderWorkerInnerGetRecreateSnapshot extends Rpc.make('GetRecreateSnapshot', {
119
+ payload: {},
120
+ success: Schema.Struct({
121
+ snapshot: Transferable.Uint8Array as Schema.Codec<Uint8Array<ArrayBuffer>>,
122
+ migrationsReport: MigrationsReport,
123
+ }),
124
+ error: Schema.Never,
125
+ }) {}
141
126
 
142
- export class LeaderWorkerInnerGetLeaderHead extends Schema.TaggedRequest<LeaderWorkerInnerGetLeaderHead>()(
143
- 'GetLeaderHead',
144
- {
145
- payload: {},
146
- success: Schema.typeSchema(EventSequenceNumber.Client.Composite),
147
- failure: Schema.Never,
148
- },
149
- ) {}
127
+ export class LeaderWorkerInnerGetLeaderHead extends Rpc.make('GetLeaderHead', {
128
+ payload: {},
129
+ success: Schema.toType(EventSequenceNumber.Client.Composite),
130
+ error: Schema.Never,
131
+ }) {}
150
132
 
151
- export class LeaderWorkerInnerGetLeaderSyncState extends Schema.TaggedRequest<LeaderWorkerInnerGetLeaderSyncState>()(
152
- 'GetLeaderSyncState',
153
- {
154
- payload: {},
155
- success: SyncState.SyncState,
156
- failure: Schema.Never,
157
- },
158
- ) {}
133
+ export class LeaderWorkerInnerGetLeaderSyncState extends Rpc.make('GetLeaderSyncState', {
134
+ payload: {},
135
+ success: SyncState.SyncState,
136
+ error: Schema.Never,
137
+ }) {}
159
138
 
160
- export class LeaderWorkerInnerSyncStateStream extends Schema.TaggedRequest<LeaderWorkerInnerSyncStateStream>()(
161
- 'SyncStateStream',
162
- {
163
- payload: {},
164
- success: SyncState.SyncState,
165
- failure: Schema.Never,
166
- },
167
- ) {}
139
+ export class LeaderWorkerInnerSyncStateStream extends Rpc.make('SyncStateStream', {
140
+ payload: {},
141
+ success: SyncState.SyncState,
142
+ error: Schema.Never,
143
+ stream: true,
144
+ }) {}
168
145
 
169
- export class LeaderWorkerInnerGetNetworkStatus extends Schema.TaggedRequest<LeaderWorkerInnerGetNetworkStatus>()(
170
- 'GetNetworkStatus',
171
- {
172
- payload: {},
173
- success: SyncBackend.NetworkStatus,
174
- failure: Schema.Never,
175
- },
176
- ) {}
146
+ export class LeaderWorkerInnerGetNetworkStatus extends Rpc.make('GetNetworkStatus', {
147
+ payload: {},
148
+ success: SyncBackend.NetworkStatus,
149
+ error: Schema.Never,
150
+ }) {}
177
151
 
178
- export class LeaderWorkerInnerNetworkStatusStream extends Schema.TaggedRequest<LeaderWorkerInnerNetworkStatusStream>()(
179
- 'NetworkStatusStream',
180
- {
181
- payload: {},
182
- success: SyncBackend.NetworkStatus,
183
- failure: Schema.Never,
184
- },
185
- ) {}
152
+ export class LeaderWorkerInnerNetworkStatusStream extends Rpc.make('NetworkStatusStream', {
153
+ payload: {},
154
+ success: SyncBackend.NetworkStatus,
155
+ error: Schema.Never,
156
+ stream: true,
157
+ }) {}
186
158
 
187
- export class LeaderWorkerInnerShutdown extends Schema.TaggedRequest<LeaderWorkerInnerShutdown>()('Shutdown', {
159
+ export class LeaderWorkerInnerShutdown extends Rpc.make('Shutdown', {
188
160
  payload: {},
189
161
  success: Schema.Void,
190
- failure: Schema.Never,
162
+ error: Schema.Never,
191
163
  }) {}
192
164
 
193
- export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<LeaderWorkerInnerExtraDevtoolsMessage>()(
194
- 'ExtraDevtoolsMessage',
195
- {
196
- payload: {
197
- message: Devtools.Leader.MessageToApp,
198
- },
199
- success: Schema.Void,
200
- failure: Schema.Never,
165
+ export class LeaderWorkerInnerExtraDevtoolsMessage extends Rpc.make('ExtraDevtoolsMessage', {
166
+ payload: {
167
+ message: Devtools.Leader.MessageToApp,
201
168
  },
202
- ) {}
169
+ success: Schema.Void,
170
+ error: Schema.Never,
171
+ }) {}
203
172
 
204
- export const LeaderWorkerInnerRequest = Schema.Union(
205
- LeaderWorkerInnerInitialMessage,
173
+ export class WebmeshWorkerCreateConnection extends Rpc.make('WebmeshWorker.CreateConnection', {
174
+ payload: WebmeshWorker.Schema.CreateConnection,
175
+ success: Schema.Struct({}),
176
+ error: Schema.Never,
177
+ stream: true,
178
+ }) {}
179
+
180
+ export class LeaderWorkerInnerRpcs extends RpcGroup.make(
206
181
  LeaderWorkerInnerBootStatusStream,
207
182
  LeaderWorkerInnerPushToLeader,
208
183
  LeaderWorkerInnerPullStream,
@@ -217,31 +192,27 @@ export const LeaderWorkerInnerRequest = Schema.Union(
217
192
  LeaderWorkerInnerNetworkStatusStream,
218
193
  LeaderWorkerInnerShutdown,
219
194
  LeaderWorkerInnerExtraDevtoolsMessage,
220
- WebmeshWorker.Schema.CreateConnection,
221
- )
222
- export type LeaderWorkerInnerRequest = typeof LeaderWorkerInnerRequest.Type
195
+ WebmeshWorkerCreateConnection,
196
+ ) {}
223
197
 
224
- export class SharedWorkerUpdateMessagePort extends Schema.TaggedRequest<SharedWorkerUpdateMessagePort>()(
225
- 'UpdateMessagePort',
226
- {
227
- payload: {
228
- port: Transferable.MessagePort,
229
- // Version gate to prevent mixed LiveStore builds talking to the same SharedWorker
230
- liveStoreVersion: Schema.Literal(liveStoreVersion),
231
- /**
232
- * Initial configuration for the leader worker. This replaces the previous
233
- * two-phase SharedWorker handshake and is sent under the tab lock by the
234
- * elected leader. Subsequent calls can omit changes and will simply rebind
235
- * the port (join) without reinitializing the store.
236
- */
237
- initial: LeaderWorkerInnerInitialMessage,
238
- },
239
- success: Schema.Void,
240
- failure: UnknownError,
198
+ export class SharedWorkerUpdateMessagePort extends Rpc.make('UpdateMessagePort', {
199
+ payload: {
200
+ port: Transferable.MessagePort,
201
+ // Version gate to prevent mixed LiveStore builds talking to the same SharedWorker
202
+ liveStoreVersion: Schema.Literal(liveStoreVersion),
203
+ /**
204
+ * Initial configuration for the leader worker. This replaces the previous
205
+ * two-phase SharedWorker handshake and is sent under the tab lock by the
206
+ * elected leader. Subsequent calls can omit changes and will simply rebind
207
+ * the port (join) without reinitializing the store.
208
+ */
209
+ initial: LeaderWorkerInnerInitialMessage.payloadSchema,
241
210
  },
242
- ) {}
211
+ success: Schema.Void,
212
+ error: UnknownError,
213
+ }) {}
243
214
 
244
- export const SharedWorkerRequest = Schema.Union(
215
+ export class SharedWorkerRpcs extends RpcGroup.make(
245
216
  SharedWorkerUpdateMessagePort,
246
217
 
247
218
  // Proxied requests
@@ -260,6 +231,5 @@ export const SharedWorkerRequest = Schema.Union(
260
231
  LeaderWorkerInnerShutdown,
261
232
  LeaderWorkerInnerExtraDevtoolsMessage,
262
233
 
263
- WebmeshWorker.Schema.CreateConnection,
264
- )
265
- export type SharedWorkerRequest = typeof SharedWorkerRequest.Type
234
+ WebmeshWorkerCreateConnection,
235
+ ) {}