@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,10 +1,12 @@
1
1
  import {
2
2
  type Adapter,
3
+ type AdapterArgs,
3
4
  ClientSessionLeaderThreadProxy,
4
5
  Devtools,
5
6
  type LockStatus,
6
7
  makeClientSession,
7
8
  migrateDb,
9
+ StateHead,
8
10
  type SyncOptions,
9
11
  UnknownError,
10
12
  } from '@livestore/common'
@@ -14,24 +16,39 @@ import {
14
16
  Eventlog,
15
17
  LeaderThreadCtx,
16
18
  makeLeaderThreadLayer,
19
+ markStateAsCompleted,
17
20
  streamEventsWithSyncState,
18
21
  } from '@livestore/common/leader-thread'
19
22
  import type { LiveStoreSchema } from '@livestore/common/schema'
20
23
  import { LiveStoreEvent } from '@livestore/common/schema'
21
- import * as DevtoolsWeb from '@livestore/devtools-web-common/web-channel'
22
- import type * as WebmeshWorker from '@livestore/devtools-web-common/worker'
23
24
  import type { MakeWebSqliteDb } from '@livestore/sqlite-wasm/browser'
24
25
  import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
25
26
  import { tryAsFunctionAndNew } from '@livestore/utils'
26
- import type { Scope } from '@livestore/utils/effect'
27
- import { Effect, FetchHttpClient, Fiber, Layer, type Schema, SubscriptionRef, Worker } from '@livestore/utils/effect'
27
+ import {
28
+ type Scope,
29
+ Effect,
30
+ FetchHttpClient,
31
+ Layer,
32
+ Queue,
33
+ RpcClient,
34
+ type Schema,
35
+ SubscriptionRef,
36
+ } from '@livestore/utils/effect'
28
37
  import { BrowserWorker } from '@livestore/utils/effect/browser'
29
38
  import { nanoid } from '@livestore/utils/nanoid'
30
39
  import * as Webmesh from '@livestore/webmesh'
40
+ import * as WebmeshWorker from '@livestore/webmesh/worker'
31
41
 
32
42
  import { connectWebmeshNodeClientSession } from '../web-worker/client-session/client-session-devtools.ts'
33
43
  import { loadSqlite3 } from '../web-worker/client-session/sqlite-loader.ts'
44
+ import {
45
+ dieOnRpcClientError,
46
+ makeWebmeshWorkerProxy,
47
+ type WebmeshWorkerProxy,
48
+ } from '../web-worker/common/rpc-worker.ts'
34
49
  import { makeShutdownChannel } from '../web-worker/common/shutdown-channel.ts'
50
+ import { makeSharedWorkerNodeName } from '../web-worker/common/webmesh-node-names.ts'
51
+ import * as WorkerSchema from '../web-worker/common/worker-schema.ts'
35
52
 
36
53
  export interface InMemoryAdapterOptions {
37
54
  importSnapshot?: Uint8Array<ArrayBuffer>
@@ -53,9 +70,7 @@ export interface InMemoryAdapterOptions {
53
70
  devtools?: {
54
71
  sharedWorker:
55
72
  | ((options: { name: string }) => globalThis.SharedWorker)
56
- | (new (options: {
57
- name: string
58
- }) => globalThis.SharedWorker)
73
+ | (new (options: { name: string }) => globalThis.SharedWorker)
59
74
  }
60
75
  }
61
76
 
@@ -115,23 +130,26 @@ export const makeInMemoryAdapter =
115
130
  const clientId = options.clientId ?? nanoid(6)
116
131
  const sessionId = options.sessionId ?? nanoid(6)
117
132
 
118
- const sharedWebWorker = options.devtools?.sharedWorker !== undefined
119
- ? tryAsFunctionAndNew(options.devtools.sharedWorker, {
120
- name: `livestore-shared-worker-${storeId}`,
121
- })
122
- : undefined
123
-
124
- const sharedWorkerFiber = sharedWebWorker !== undefined
125
- ? yield* Worker.makePoolSerialized<typeof WebmeshWorker.Schema.Request.Type>({
126
- size: 1,
127
- concurrency: 100,
128
- }).pipe(
129
- Effect.provide(BrowserWorker.layer(() => sharedWebWorker)),
130
- Effect.tapCauseLogPretty,
131
- UnknownError.mapToUnknownError,
132
- Effect.forkScoped,
133
- )
134
- : undefined
133
+ const sharedWebWorker =
134
+ options.devtools?.sharedWorker !== undefined
135
+ ? tryAsFunctionAndNew(options.devtools.sharedWorker, {
136
+ name: `livestore-shared-worker-${storeId}`,
137
+ })
138
+ : undefined
139
+
140
+ const sharedWorkerClient =
141
+ sharedWebWorker !== undefined
142
+ ? yield* RpcClient.make(WorkerSchema.SharedWorkerRpcs).pipe(
143
+ Effect.provide(
144
+ Layer.provideMerge(
145
+ RpcClient.layerProtocolWorker({ size: 1, concurrency: 100 }),
146
+ BrowserWorker.layer(() => sharedWebWorker),
147
+ ),
148
+ ),
149
+ Effect.tapCauseLogPretty,
150
+ UnknownError.mapToUnknownError,
151
+ )
152
+ : undefined
135
153
 
136
154
  const { leaderThread, initialSnapshot } = yield* makeLeaderThread({
137
155
  schema,
@@ -141,9 +159,10 @@ export const makeInMemoryAdapter =
141
159
  syncOptions: options.sync,
142
160
  syncPayloadEncoded,
143
161
  syncPayloadSchema,
162
+ params: adapterArgs.params,
144
163
  importSnapshot: options.importSnapshot,
145
164
  devtoolsEnabled,
146
- sharedWorkerFiber,
165
+ sharedWorker: sharedWorkerClient === undefined ? undefined : makeWebmeshWorkerProxy(sharedWorkerClient),
147
166
  })
148
167
 
149
168
  sqliteDb.import(initialSnapshot)
@@ -164,13 +183,17 @@ export const makeInMemoryAdapter =
164
183
  origin: globalThis.location?.origin,
165
184
  connectWebmeshNode: ({ sessionInfo, webmeshNode }) =>
166
185
  Effect.gen(function* () {
167
- if (sharedWorkerFiber === undefined || devtoolsEnabled === false) {
186
+ if (sharedWorkerClient === undefined || devtoolsEnabled === false) {
168
187
  return
169
188
  }
170
189
 
171
- const sharedWorker = yield* sharedWorkerFiber.pipe(Fiber.join)
172
-
173
- yield* connectWebmeshNodeClientSession({ webmeshNode, sessionInfo, sharedWorker, devtoolsEnabled, schema })
190
+ yield* connectWebmeshNodeClientSession({
191
+ webmeshNode,
192
+ sessionInfo,
193
+ sharedWorker: makeWebmeshWorkerProxy(sharedWorkerClient),
194
+ devtoolsEnabled,
195
+ schema,
196
+ })
174
197
  }),
175
198
  registerBeforeUnload: (onBeforeUnload) => {
176
199
  if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
@@ -191,11 +214,12 @@ export interface MakeLeaderThreadArgs {
191
214
  clientId: string
192
215
  makeSqliteDb: MakeWebSqliteDb
193
216
  syncOptions: SyncOptions | undefined
194
- syncPayloadEncoded: Schema.JsonValue | undefined
195
- syncPayloadSchema: Schema.Schema<any> | undefined
217
+ syncPayloadEncoded: Schema.Json | undefined
218
+ syncPayloadSchema: Schema.Top | undefined
196
219
  importSnapshot: Uint8Array<ArrayBuffer> | undefined
197
220
  devtoolsEnabled: boolean
198
- sharedWorkerFiber: SharedWorkerFiber | undefined
221
+ sharedWorker: WebmeshWorkerProxy | undefined
222
+ params: AdapterArgs['params']
199
223
  }
200
224
 
201
225
  const makeLeaderThread = ({
@@ -208,16 +232,16 @@ const makeLeaderThread = ({
208
232
  syncPayloadSchema,
209
233
  importSnapshot,
210
234
  devtoolsEnabled,
211
- sharedWorkerFiber,
235
+ sharedWorker,
236
+ params,
212
237
  }: MakeLeaderThreadArgs) =>
213
238
  Effect.gen(function* () {
214
- const runtime = yield* Effect.runtime()
239
+ const services = yield* Effect.context()
215
240
 
216
241
  const makeDb = (_kind: 'state' | 'eventlog') => {
217
242
  return makeSqliteDb({
218
243
  _tag: 'in-memory',
219
- configureDb: (db) =>
220
- configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
244
+ configureDb: (db) => configureConnection(db, { foreignKeys: true }).pipe(Effect.runSyncWith(services)),
221
245
  })
222
246
  }
223
247
 
@@ -230,11 +254,12 @@ const makeLeaderThread = ({
230
254
  dbState.import(importSnapshot)
231
255
 
232
256
  const _migrationsReport = yield* migrateDb({ db: dbState, schema })
257
+ yield* markStateAsCompleted(dbState)
233
258
  }
234
259
 
235
260
  const devtoolsOptions = yield* makeDevtoolsOptions({
236
261
  devtoolsEnabled,
237
- sharedWorkerFiber,
262
+ sharedWorker,
238
263
  dbState,
239
264
  dbEventlog,
240
265
  storeId,
@@ -253,8 +278,9 @@ const makeLeaderThread = ({
253
278
  devtoolsOptions,
254
279
  shutdownChannel,
255
280
  syncPayloadEncoded,
256
- syncPayloadSchema,
257
- }),
281
+ syncPayloadSchema: syncPayloadSchema as Schema.Decoder<Schema.Json, never> | undefined,
282
+ params,
283
+ }).pipe(Layer.provide(StateHead.layer({ dbState }))),
258
284
  )
259
285
 
260
286
  return yield* Effect.gen(function* () {
@@ -266,11 +292,7 @@ const makeLeaderThread = ({
266
292
  const leaderThread = ClientSessionLeaderThreadProxy.of({
267
293
  events: {
268
294
  pull: ({ cursor }) => syncProcessor.pull({ cursor }),
269
- push: (batch) =>
270
- syncProcessor.push(
271
- batch.map((item) => new LiveStoreEvent.Client.EncodedWithMeta(item)),
272
- { waitForProcessing: true },
273
- ),
295
+ push: (batch) => syncProcessor.push(batch.map((item) => new LiveStoreEvent.Client.EncodedWithMeta(item))),
274
296
  stream: (options) =>
275
297
  streamEventsWithSyncState({
276
298
  dbEventlog,
@@ -286,7 +308,7 @@ const makeLeaderThread = ({
286
308
  export: Effect.sync(() => dbState.export()),
287
309
  getEventlogData: Effect.sync(() => dbEventlog.export()),
288
310
  syncState: syncProcessor.syncState,
289
- sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
311
+ sendDevtoolsMessage: (message) => Queue.offer(extraIncomingMessagesQueue, message),
290
312
  networkStatus,
291
313
  })
292
314
 
@@ -296,28 +318,23 @@ const makeLeaderThread = ({
296
318
  }).pipe(Effect.provide(layer))
297
319
  })
298
320
 
299
- type SharedWorkerFiber = Fiber.Fiber<
300
- Worker.SerializedWorkerPool<typeof WebmeshWorker.Schema.Request.Type>,
301
- UnknownError
302
- >
303
-
304
321
  const makeDevtoolsOptions = ({
305
322
  devtoolsEnabled,
306
- sharedWorkerFiber,
323
+ sharedWorker,
307
324
  dbState,
308
325
  dbEventlog,
309
326
  storeId,
310
327
  clientId,
311
328
  }: {
312
329
  devtoolsEnabled: boolean
313
- sharedWorkerFiber: SharedWorkerFiber | undefined
330
+ sharedWorker: WebmeshWorkerProxy | undefined
314
331
  dbState: LeaderSqliteDb
315
332
  dbEventlog: LeaderSqliteDb
316
333
  storeId: string
317
334
  clientId: string
318
335
  }): Effect.Effect<DevtoolsOptions, UnknownError, Scope.Scope> =>
319
336
  Effect.gen(function* () {
320
- if (devtoolsEnabled === false || sharedWorkerFiber === undefined) {
337
+ if (devtoolsEnabled === false || sharedWorker === undefined) {
321
338
  return { enabled: false }
322
339
  }
323
340
 
@@ -333,17 +350,15 @@ const makeDevtoolsOptions = ({
333
350
  // @ts-expect-error TODO type this
334
351
  globalThis.__debugWebmeshNodeLeader = node
335
352
 
336
- const sharedWorker = yield* sharedWorkerFiber.pipe(Fiber.join)
337
-
338
353
  // TODO also make this work with the browser extension
339
354
  // basic idea: instead of also connecting to the shared worker,
340
355
  // connect to the client session node above which will already connect to the shared worker + browser extension
341
356
 
342
- yield* DevtoolsWeb.connectViaWorker({
357
+ yield* WebmeshWorker.connectViaWorker({
343
358
  node,
344
359
  worker: sharedWorker,
345
- target: DevtoolsWeb.makeNodeName.sharedWorker({ storeId }),
346
- }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
360
+ target: makeSharedWorkerNodeName({ storeId }),
361
+ }).pipe(Effect.tapCauseLogPretty, dieOnRpcClientError, Effect.forkScoped)
347
362
 
348
363
  return { node, persistenceInfo, mode: 'direct' }
349
364
  }),
@@ -16,13 +16,11 @@
16
16
  import type { Adapter, BootWarningReason, ClientSession, LockStatus } from '@livestore/common'
17
17
  import {
18
18
  IntentionalShutdownCause,
19
- isWorkerTransportError,
20
19
  makeClientSession,
20
+ StateHead,
21
21
  StoreInterrupted,
22
- sessionChangesetMetaTable,
23
22
  UnknownError,
24
23
  } from '@livestore/common'
25
- import { EventSequenceNumber } from '@livestore/common/schema'
26
24
  import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
27
25
  import { shouldNeverHappen, tryAsFunctionAndNew } from '@livestore/utils'
28
26
  import {
@@ -31,13 +29,13 @@ import {
31
29
  Exit,
32
30
  Fiber,
33
31
  Layer,
34
- Option,
35
32
  Queue,
33
+ RpcClient,
34
+ RpcWorker,
36
35
  Schema,
37
36
  Stream,
38
37
  Subscribable,
39
38
  SubscriptionRef,
40
- Worker,
41
39
  } from '@livestore/utils/effect'
42
40
  import { BrowserWorker, Opfs, WebError } from '@livestore/utils/effect/browser'
43
41
  import { nanoid } from '@livestore/utils/nanoid'
@@ -47,6 +45,11 @@ import {
47
45
  readPersistedStateDbFromClientSession,
48
46
  resetPersistedDataFromClientSession,
49
47
  } from '../web-worker/common/persisted-sqlite.ts'
48
+ import {
49
+ type WithoutRpcClientError,
50
+ dieOnRpcClientError,
51
+ dieOnRpcClientErrorStream,
52
+ } from '../web-worker/common/rpc-worker.ts'
50
53
  import { makeShutdownChannel } from '../web-worker/common/shutdown-channel.ts'
51
54
  import * as WorkerSchema from '../web-worker/common/worker-schema.ts'
52
55
 
@@ -146,7 +149,7 @@ export const makeSingleTabAdapter =
146
149
  (options: SingleTabAdapterOptions): Adapter =>
147
150
  (adapterArgs) =>
148
151
  Effect.gen(function* () {
149
- const { schema, storeId, bootStatusQueue, shutdown, syncPayloadEncoded } = adapterArgs
152
+ const { schema, storeId, bootStatusQueue, shutdown, syncPayloadEncoded, params } = adapterArgs
150
153
  // Note: devtoolsEnabled is ignored in single-tab mode (devtools require SharedWorker)
151
154
 
152
155
  yield* ensureBrowserRequirements
@@ -154,8 +157,9 @@ export const makeSingleTabAdapter =
154
157
  yield* Queue.offer(bootStatusQueue, { stage: 'loading' })
155
158
 
156
159
  const sqlite3 = yield* Effect.promise(() => loadSqlite3())
160
+ const makeSqliteDb = sqliteDbFactory({ sqlite3 })
157
161
 
158
- const storageOptions = yield* Schema.decode(WorkerSchema.StorageType)(options.storage)
162
+ const storageOptions = yield* Schema.decodeEffect(WorkerSchema.StorageType)(options.storage)
159
163
 
160
164
  const shutdownChannel = yield* makeShutdownChannel(storeId)
161
165
 
@@ -179,7 +183,7 @@ export const makeSingleTabAdapter =
179
183
  const dataFromFile =
180
184
  options.experimental?.disableFastPath === true || opfsWarning !== undefined
181
185
  ? undefined
182
- : yield* readPersistedStateDbFromClientSession({ storageOptions, storeId, schema }).pipe(
186
+ : yield* readPersistedStateDbFromClientSession({ storageOptions, storeId, schema, makeSqliteDb }).pipe(
183
187
  Effect.tapError((error) =>
184
188
  Effect.logDebug('[@livestore/adapter-web:single-tab] Could not read persisted state db', error, {
185
189
  storeId,
@@ -192,7 +196,7 @@ export const makeSingleTabAdapter =
192
196
  const sessionId = options.sessionId ?? getPersistedId(`sessionId:${storeId}`, 'session')
193
197
 
194
198
  yield* shutdownChannel.listen.pipe(
195
- Stream.flatten(),
199
+ Stream.mapEffect(Effect.fromResult),
196
200
  Stream.tap((cause) =>
197
201
  shutdown(cause._tag === 'IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
198
202
  ),
@@ -212,166 +216,160 @@ export const makeSingleTabAdapter =
212
216
  const worker = tryAsFunctionAndNew(options.worker, { name: `livestore-worker-${storeId}-${sessionId}` })
213
217
 
214
218
  // Set up communication with the dedicated worker via the outer protocol
215
- const _dedicatedWorkerFiber = yield* Worker.makeSerialized<WorkerSchema.LeaderWorkerOuterRequest>({
216
- initialMessage: () => new WorkerSchema.LeaderWorkerOuterInitialMessage({ port: mc.port1, storeId, clientId }),
217
- }).pipe(
218
- Effect.provide(BrowserWorker.layer(() => worker)),
219
+ const outerWorkerContext = yield* Layer.build(
220
+ RpcClient.layerProtocolWorker({ size: 1 }).pipe(
221
+ Layer.provide(BrowserWorker.layer(() => worker)),
222
+ Layer.provide(
223
+ RpcWorker.layerInitialMessage(
224
+ WorkerSchema.LeaderWorkerOuterInitialMessage.payloadSchema,
225
+ Effect.succeed({ port: mc.port1, storeId, clientId }),
226
+ ),
227
+ ),
228
+ ),
229
+ )
230
+ yield* RpcClient.make(WorkerSchema.LeaderWorkerOuterRpcs).pipe(
231
+ Effect.provide(outerWorkerContext),
219
232
  UnknownError.mapToUnknownError,
220
- Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
233
+ Effect.tapCause((cause) => shutdown(Exit.failCause(cause))),
221
234
  Effect.withSpan('@livestore/adapter-web:single-tab:setupDedicatedWorker'),
222
235
  Effect.tapCauseLogPretty,
223
- Effect.forkScoped,
224
236
  )
225
237
 
226
238
  // Set up the inner worker communication via port2 (like SharedWorker would do)
227
239
  // BrowserWorker.layer accepts a MessagePort as well as a Worker
228
- const innerWorkerContext = yield* Layer.build(BrowserWorker.layer(() => mc.port2 as unknown as globalThis.Worker))
229
- const innerWorkerFiber = yield* Worker.makePoolSerialized<WorkerSchema.LeaderWorkerInnerRequest>({
230
- size: 1,
231
- concurrency: 100,
232
- initialMessage: () =>
233
- new WorkerSchema.LeaderWorkerInnerInitialMessage({
234
- storageOptions,
235
- storeId,
236
- clientId,
237
- // Devtools disabled in single-tab mode (requires SharedWorker)
238
- devtoolsEnabled: false,
239
- debugInstanceId: adapterArgs.debugInstanceId,
240
- syncPayloadEncoded,
241
- }),
242
- }).pipe(
240
+ const innerWorkerContext = yield* Layer.build(
241
+ RpcClient.layerProtocolWorker({ size: 1, concurrency: 100 }).pipe(
242
+ Layer.provide(BrowserWorker.layer(() => mc.port2)),
243
+ Layer.provide(
244
+ RpcWorker.layerInitialMessage(
245
+ WorkerSchema.LeaderWorkerInnerInitialMessage.payloadSchema,
246
+ Effect.succeed({
247
+ storageOptions,
248
+ storeId,
249
+ clientId,
250
+ // Devtools disabled in single-tab mode (requires SharedWorker)
251
+ devtoolsEnabled: false,
252
+ debugInstanceId: adapterArgs.debugInstanceId,
253
+ syncPayloadEncoded,
254
+ params,
255
+ }),
256
+ ),
257
+ ),
258
+ ),
259
+ )
260
+ const innerWorker = yield* RpcClient.make(WorkerSchema.LeaderWorkerInnerRpcs).pipe(
243
261
  Effect.provide(innerWorkerContext),
244
262
  Effect.tapCauseLogPretty,
245
- Effect.orDie,
246
- Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
263
+ UnknownError.mapToUnknownError,
264
+ Effect.tapCause((cause) => shutdown(Exit.failCause(cause))),
247
265
  Effect.withSpan('@livestore/adapter-web:single-tab:setupInnerWorker'),
248
- Effect.forkScoped,
249
266
  )
250
267
 
251
268
  // Helper to run requests against the worker
252
- const runInWorker = <A, I, E, EI, R>(
253
- req: WorkerSchema.LeaderWorkerInnerRequest & Schema.WithResult<A, I, E, EI, R>,
254
- ): Effect.Effect<A, E, R> =>
255
- Fiber.join(innerWorkerFiber).pipe(
256
- Effect.flatMap((worker) => worker.executeEffect(req)),
257
- Effect.catchIf(isWorkerTransportError, (e) => Effect.die(e)),
269
+ const runInWorker = <A, E, R>(
270
+ tag: string,
271
+ effect: Effect.Effect<A, E, R>,
272
+ ): Effect.Effect<A, WithoutRpcClientError<E>, R> =>
273
+ effect.pipe(
274
+ dieOnRpcClientError,
258
275
  Effect.logWarnIfTakesLongerThan({
259
- label: `@livestore/adapter-web:single-tab:runInWorker:${req._tag}`,
276
+ label: `@livestore/adapter-web:single-tab:runInWorker:${tag}`,
260
277
  duration: 2000,
261
278
  }),
262
- Effect.withSpan(`@livestore/adapter-web:single-tab:runInWorker:${req._tag}`),
279
+ Effect.withSpan(`@livestore/adapter-web:single-tab:runInWorker:${tag}`),
263
280
  )
264
281
 
265
- const runInWorkerStream = <A, I, E, EI, R>(
266
- req: WorkerSchema.LeaderWorkerInnerRequest & Schema.WithResult<A, I, E, EI, R>,
267
- ): Stream.Stream<A, E, R> =>
268
- Effect.gen(function* () {
269
- const innerWorker = yield* Fiber.join(innerWorkerFiber)
270
- return innerWorker.execute(req).pipe(
271
- Stream.refineOrDie((e) => isWorkerTransportError(e) === true ? Option.none() : Option.some(e)),
272
- Stream.withSpan(`@livestore/adapter-web:single-tab:runInWorkerStream:${req._tag}`),
273
- )
274
- }).pipe(Stream.unwrap)
282
+ const runInWorkerStream = <A, E, R>(
283
+ tag: string,
284
+ stream: Stream.Stream<A, E, R>,
285
+ ): Stream.Stream<A, WithoutRpcClientError<E>, R> =>
286
+ stream.pipe(
287
+ dieOnRpcClientErrorStream,
288
+ Stream.withSpan(`@livestore/adapter-web:single-tab:runInWorkerStream:${tag}`),
289
+ )
275
290
 
276
291
  // Forward boot status from worker
277
- const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInnerBootStatusStream()).pipe(
292
+ const bootStatusFiber = yield* runInWorkerStream('BootStatusStream', innerWorker.BootStatusStream({})).pipe(
278
293
  Stream.tap((_) => Queue.offer(bootStatusQueue, _)),
279
294
  Stream.runDrain,
280
- Effect.tapErrorCause((cause) =>
281
- Cause.isInterruptedOnly(cause) === true ? Effect.void : shutdown(Exit.failCause(cause)),
295
+ Effect.tapCause((cause) =>
296
+ Cause.hasInterruptsOnly(cause) === true ? Effect.void : shutdown(Exit.failCause(cause)),
282
297
  ),
283
298
  Effect.interruptible,
284
299
  Effect.tapCauseLogPretty,
285
300
  Effect.forkScoped,
286
301
  )
287
302
 
288
- yield* Queue.awaitShutdown(bootStatusQueue).pipe(
303
+ yield* Queue.await(bootStatusQueue).pipe(
289
304
  Effect.andThen(Fiber.interrupt(bootStatusFiber)),
305
+ Effect.interruptible,
290
306
  Effect.tapCauseLogPretty,
291
307
  Effect.forkScoped,
292
308
  )
293
309
 
294
310
  // Get initial snapshot (either from fast-path or from worker)
295
- const initialResult =
311
+ const { sqliteDb, snapshotByteLength, migrationsReport } =
296
312
  dataFromFile === undefined
297
- ? yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetRecreateSnapshot()).pipe(
298
- Effect.map(({ snapshot, migrationsReport }) => ({
299
- _tag: 'from-leader-worker' as const,
300
- snapshot,
301
- migrationsReport,
302
- })),
303
- )
304
- : { _tag: 'fast-path' as const, snapshot: dataFromFile }
305
-
306
- const migrationsReport =
307
- initialResult._tag === 'from-leader-worker' ? initialResult.migrationsReport : { migrations: [] }
308
-
309
- const makeSqliteDb = sqliteDbFactory({ sqlite3 })
310
- const sqliteDb = yield* makeSqliteDb({ _tag: 'in-memory' })
311
-
312
- sqliteDb.import(initialResult.snapshot)
313
+ ? yield* Effect.gen(function* () {
314
+ const { snapshot, migrationsReport } = yield* runInWorker(
315
+ 'GetRecreateSnapshot',
316
+ innerWorker.GetRecreateSnapshot({}),
317
+ )
318
+ const sqliteDb = yield* Effect.acquireRelease(makeSqliteDb({ _tag: 'in-memory' }), (db) =>
319
+ Effect.sync(() => db.close()),
320
+ )
321
+ sqliteDb.import(snapshot)
322
+ return { sqliteDb, snapshotByteLength: snapshot.byteLength, migrationsReport }
323
+ })
324
+ : { ...dataFromFile, migrationsReport: { migrations: [] } }
313
325
 
314
326
  const numberOfTables =
315
327
  sqliteDb.select<{ count: number }>(`select count(*) as count from sqlite_master`)[0]?.count ?? 0
316
328
  if (numberOfTables === 0) {
317
329
  return yield* UnknownError.make({
318
330
  cause: `Encountered empty or corrupted database`,
319
- payload: { snapshotByteLength: initialResult.snapshot.byteLength, storageOptions: options.storage },
331
+ payload: { snapshotByteLength, storageOptions: options.storage },
320
332
  })
321
333
  }
322
334
 
323
- // Restore leader head from SESSION_CHANGESET_META_TABLE
324
- const initialLeaderHeadRes = sqliteDb.select(
325
- sessionChangesetMetaTable
326
- .select('seqNumClient', 'seqNumGlobal', 'seqNumRebaseGeneration')
327
- .orderBy([
328
- { col: 'seqNumGlobal', direction: 'desc' },
329
- { col: 'seqNumClient', direction: 'desc' },
330
- ])
331
- .first(),
332
- )
335
+ // The state snapshot carries its own cursor, so the fast path does not
336
+ // need to export or transfer the eventlog database.
337
+ const initialLeaderHead = yield* StateHead.make({ dbState: sqliteDb }).get
333
338
 
334
- const initialLeaderHead =
335
- initialLeaderHeadRes !== undefined
336
- ? EventSequenceNumber.Client.Composite.make({
337
- global: initialLeaderHeadRes.seqNumGlobal,
338
- client: initialLeaderHeadRes.seqNumClient,
339
- rebaseGeneration: initialLeaderHeadRes.seqNumRebaseGeneration,
340
- })
341
- : EventSequenceNumber.Client.ROOT
342
-
343
- yield* Effect.addFinalizer((ex) =>
339
+ yield* Effect.addFinalizer((ex: Exit.Exit<unknown, unknown>) =>
344
340
  Effect.gen(function* () {
345
- if (
346
- Exit.isFailure(ex) === true &&
347
- Exit.isInterrupted(ex) === false &&
348
- Schema.is(IntentionalShutdownCause)(Cause.squash(ex.cause)) === false &&
349
- Schema.is(StoreInterrupted)(Cause.squash(ex.cause)) === false
350
- ) {
351
- yield* Effect.logError('[@livestore/adapter-web:single-tab] client-session shutdown', ex.cause)
352
- } else {
353
- yield* Effect.logDebug('[@livestore/adapter-web:single-tab] client-session shutdown', ex)
341
+ if (Exit.isFailure(ex) === true) {
342
+ const cause = ex.cause
343
+ if (
344
+ Exit.hasInterrupts(ex) === false &&
345
+ Schema.is(IntentionalShutdownCause)(Cause.squash(cause)) === false &&
346
+ Schema.is(StoreInterrupted)(Cause.squash(cause)) === false
347
+ ) {
348
+ yield* Effect.logError('[@livestore/adapter-web:single-tab] client-session shutdown', cause)
349
+ return
350
+ }
354
351
  }
352
+
353
+ yield* Effect.logDebug('[@livestore/adapter-web:single-tab] client-session shutdown', ex)
355
354
  }).pipe(Effect.tapCauseLogPretty, Effect.orDie),
356
355
  )
357
356
 
358
357
  const leaderThread: ClientSession['leaderThread'] = {
359
- export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
358
+ export: runInWorker('Export', innerWorker.Export({})).pipe(
360
359
  Effect.timeoutOrDie(10_000),
361
360
  Effect.withSpan('@livestore/adapter-web:single-tab:export'),
362
361
  ),
363
362
 
364
363
  events: {
365
- pull: ({ cursor }) =>
366
- runInWorkerStream(new WorkerSchema.LeaderWorkerInnerPullStream({ cursor })).pipe(Stream.orDie),
364
+ pull: ({ cursor }) => runInWorkerStream('PullStream', innerWorker.PullStream({ cursor })).pipe(Stream.orDie),
367
365
  push: (batch) =>
368
- runInWorker(new WorkerSchema.LeaderWorkerInnerPushToLeader({ batch })).pipe(
366
+ runInWorker('PushToLeader', innerWorker.PushToLeader({ batch })).pipe(
369
367
  Effect.withSpan('@livestore/adapter-web:single-tab:pushToLeader', {
370
368
  attributes: { batchSize: batch.length },
371
369
  }),
372
370
  ),
373
371
  stream: (options) =>
374
- runInWorkerStream(new WorkerSchema.LeaderWorkerInnerStreamEvents(options)).pipe(
372
+ runInWorkerStream('StreamEvents', innerWorker.StreamEvents(options)).pipe(
375
373
  Stream.withSpan('@livestore/adapter-web:single-tab:streamEvents'),
376
374
  Stream.orDie,
377
375
  ),
@@ -383,16 +381,16 @@ export const makeSingleTabAdapter =
383
381
  storageMode: opfsWarning === undefined ? 'persisted' : 'in-memory',
384
382
  },
385
383
 
386
- getEventlogData: runInWorker(new WorkerSchema.LeaderWorkerInnerExportEventlog()).pipe(
384
+ getEventlogData: runInWorker('ExportEventlog', innerWorker.ExportEventlog({})).pipe(
387
385
  Effect.timeoutOrDie(10_000),
388
386
  Effect.withSpan('@livestore/adapter-web:single-tab:getEventlogData'),
389
387
  ),
390
388
 
391
389
  syncState: Subscribable.make({
392
- get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
390
+ get: runInWorker('GetLeaderSyncState', innerWorker.GetLeaderSyncState({})).pipe(
393
391
  Effect.withSpan('@livestore/adapter-web:single-tab:getLeaderSyncState'),
394
392
  ),
395
- changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerSyncStateStream()).pipe(Stream.orDie),
393
+ changes: runInWorkerStream('SyncStateStream', innerWorker.SyncStateStream({})).pipe(Stream.orDie),
396
394
  }),
397
395
 
398
396
  sendDevtoolsMessage: (_message) =>
@@ -400,8 +398,8 @@ export const makeSingleTabAdapter =
400
398
  Effect.void,
401
399
 
402
400
  networkStatus: Subscribable.make({
403
- get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetNetworkStatus()).pipe(Effect.orDie),
404
- changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerNetworkStatusStream()).pipe(Stream.orDie),
401
+ get: runInWorker('GetNetworkStatus', innerWorker.GetNetworkStatus({})).pipe(Effect.orDie),
402
+ changes: runInWorkerStream('NetworkStatusStream', innerWorker.NetworkStatusStream({})).pipe(Stream.orDie),
405
403
  }),
406
404
  }
407
405
 
@@ -427,7 +425,7 @@ export const makeSingleTabAdapter =
427
425
  })
428
426
 
429
427
  return clientSession
430
- }).pipe(Effect.provide(Opfs.Opfs.Default), UnknownError.mapToUnknownError)
428
+ }).pipe(Effect.provide(Opfs.layer), UnknownError.mapToUnknownError)
431
429
 
432
430
  /** Persists clientId/sessionId to storage */
433
431
  const getPersistedId = (key: string, storageType: 'session' | 'local') => {
@@ -484,7 +482,7 @@ const checkOpfsAvailability = Effect.gen(function* () {
484
482
  const opfs = yield* Opfs.Opfs
485
483
  return yield* opfs.getRootDirectoryHandle.pipe(
486
484
  Effect.as(undefined),
487
- Effect.catchAll((error) => {
485
+ Effect.catch((error) => {
488
486
  const reason: BootWarningReason =
489
487
  Schema.is(WebError.SecurityError)(error) === true || Schema.is(WebError.NotAllowedError)(error) === true
490
488
  ? 'private-browsing'