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

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 (92) hide show
  1. package/README.md +5 -5
  2. package/dist/.tsbuildinfo +1 -1
  3. package/dist/in-memory/in-memory-adapter.d.ts +50 -8
  4. package/dist/in-memory/in-memory-adapter.d.ts.map +1 -1
  5. package/dist/in-memory/in-memory-adapter.js +100 -39
  6. package/dist/in-memory/in-memory-adapter.js.map +1 -1
  7. package/dist/index.d.ts +11 -1
  8. package/dist/index.d.ts.map +1 -1
  9. package/dist/index.js +11 -1
  10. package/dist/index.js.map +1 -1
  11. package/dist/single-tab/mod.d.ts +15 -0
  12. package/dist/single-tab/mod.d.ts.map +1 -0
  13. package/dist/single-tab/mod.js +15 -0
  14. package/dist/single-tab/mod.js.map +1 -0
  15. package/dist/single-tab/single-tab-adapter.d.ts +108 -0
  16. package/dist/single-tab/single-tab-adapter.d.ts.map +1 -0
  17. package/dist/single-tab/single-tab-adapter.js +252 -0
  18. package/dist/single-tab/single-tab-adapter.js.map +1 -0
  19. package/dist/web-worker/client-session/client-session-devtools.d.ts +4 -5
  20. package/dist/web-worker/client-session/client-session-devtools.d.ts.map +1 -1
  21. package/dist/web-worker/client-session/client-session-devtools.js +27 -14
  22. package/dist/web-worker/client-session/client-session-devtools.js.map +1 -1
  23. package/dist/web-worker/client-session/devtools-web-channel.d.ts +20 -0
  24. package/dist/web-worker/client-session/devtools-web-channel.d.ts.map +1 -0
  25. package/dist/web-worker/client-session/devtools-web-channel.js +34 -0
  26. package/dist/web-worker/client-session/devtools-web-channel.js.map +1 -0
  27. package/dist/web-worker/client-session/persisted-adapter.d.ts +18 -0
  28. package/dist/web-worker/client-session/persisted-adapter.d.ts.map +1 -1
  29. package/dist/web-worker/client-session/persisted-adapter.js +170 -103
  30. package/dist/web-worker/client-session/persisted-adapter.js.map +1 -1
  31. package/dist/web-worker/client-session/sqlite-loader.d.ts +2 -0
  32. package/dist/web-worker/client-session/sqlite-loader.d.ts.map +1 -0
  33. package/dist/web-worker/client-session/sqlite-loader.js +16 -0
  34. package/dist/web-worker/client-session/sqlite-loader.js.map +1 -0
  35. package/dist/web-worker/common/persisted-sqlite.d.ts +15 -35
  36. package/dist/web-worker/common/persisted-sqlite.d.ts.map +1 -1
  37. package/dist/web-worker/common/persisted-sqlite.js +91 -201
  38. package/dist/web-worker/common/persisted-sqlite.js.map +1 -1
  39. package/dist/web-worker/common/rpc-worker.d.ts +14 -0
  40. package/dist/web-worker/common/rpc-worker.d.ts.map +1 -0
  41. package/dist/web-worker/common/rpc-worker.js +8 -0
  42. package/dist/web-worker/common/rpc-worker.js.map +1 -0
  43. package/dist/web-worker/common/shutdown-channel.d.ts +3 -2
  44. package/dist/web-worker/common/shutdown-channel.d.ts.map +1 -1
  45. package/dist/web-worker/common/shutdown-channel.js +2 -2
  46. package/dist/web-worker/common/shutdown-channel.js.map +1 -1
  47. package/dist/web-worker/common/webmesh-node-names.d.ts +4 -0
  48. package/dist/web-worker/common/webmesh-node-names.d.ts.map +1 -0
  49. package/dist/web-worker/common/webmesh-node-names.js +2 -0
  50. package/dist/web-worker/common/webmesh-node-names.js.map +1 -0
  51. package/dist/web-worker/common/worker-disconnect-channel.d.ts +3 -10
  52. package/dist/web-worker/common/worker-disconnect-channel.d.ts.map +1 -1
  53. package/dist/web-worker/common/worker-disconnect-channel.js +4 -4
  54. package/dist/web-worker/common/worker-disconnect-channel.js.map +1 -1
  55. package/dist/web-worker/common/worker-schema.d.ts +295 -146
  56. package/dist/web-worker/common/worker-schema.d.ts.map +1 -1
  57. package/dist/web-worker/common/worker-schema.js +89 -54
  58. package/dist/web-worker/common/worker-schema.js.map +1 -1
  59. package/dist/web-worker/leader-worker/make-leader-worker.d.ts +6 -6
  60. package/dist/web-worker/leader-worker/make-leader-worker.d.ts.map +1 -1
  61. package/dist/web-worker/leader-worker/make-leader-worker.js +191 -80
  62. package/dist/web-worker/leader-worker/make-leader-worker.js.map +1 -1
  63. package/dist/web-worker/shared-worker/make-shared-worker.d.ts +2 -1
  64. package/dist/web-worker/shared-worker/make-shared-worker.d.ts.map +1 -1
  65. package/dist/web-worker/shared-worker/make-shared-worker.js +91 -94
  66. package/dist/web-worker/shared-worker/make-shared-worker.js.map +1 -1
  67. package/dist/web-worker/vite-dev-polyfill.js +1 -2
  68. package/dist/web-worker/vite-dev-polyfill.js.map +1 -1
  69. package/package.json +47 -19
  70. package/src/in-memory/in-memory-adapter.ts +147 -73
  71. package/src/index.ts +15 -1
  72. package/src/single-tab/mod.ts +15 -0
  73. package/src/single-tab/single-tab-adapter.ts +499 -0
  74. package/src/web-worker/ambient.d.ts +7 -24
  75. package/src/web-worker/client-session/client-session-devtools.ts +47 -25
  76. package/src/web-worker/client-session/devtools-web-channel.ts +57 -0
  77. package/src/web-worker/client-session/persisted-adapter.ts +259 -163
  78. package/src/web-worker/client-session/sqlite-loader.ts +19 -0
  79. package/src/web-worker/common/persisted-sqlite.ts +204 -309
  80. package/src/web-worker/common/rpc-worker.ts +39 -0
  81. package/src/web-worker/common/shutdown-channel.ts +10 -3
  82. package/src/web-worker/common/webmesh-node-names.ts +1 -0
  83. package/src/web-worker/common/worker-disconnect-channel.ts +11 -4
  84. package/src/web-worker/common/worker-schema.ts +138 -131
  85. package/src/web-worker/leader-worker/make-leader-worker.ts +396 -194
  86. package/src/web-worker/shared-worker/make-shared-worker.ts +143 -146
  87. package/src/web-worker/vite-dev-polyfill.ts +1 -2
  88. package/dist/opfs-utils.d.ts +0 -7
  89. package/dist/opfs-utils.d.ts.map +0 -1
  90. package/dist/opfs-utils.js +0 -43
  91. package/dist/opfs-utils.js.map +0 -1
  92. package/src/opfs-utils.ts +0 -61
@@ -0,0 +1,499 @@
1
+ /**
2
+ * Single-tab adapter for browsers without SharedWorker support (e.g. Android Chrome).
3
+ *
4
+ * This adapter is a fallback for browsers that don't support the SharedWorker API.
5
+ * It provides the same OPFS persistence as the regular persisted adapter, but without
6
+ * multi-tab synchronization capabilities.
7
+ *
8
+ * **IMPORTANT**: This code is intended to be removed once SharedWorker support is
9
+ * available in Android Chrome. Track progress at:
10
+ * - LiveStore issue: https://github.com/livestorejs/livestore/issues/321
11
+ * - Chromium bug: https://issues.chromium.org/issues/40290702
12
+ *
13
+ * @module
14
+ */
15
+
16
+ import type { Adapter, BootWarningReason, ClientSession, LockStatus } from '@livestore/common'
17
+ import {
18
+ IntentionalShutdownCause,
19
+ makeClientSession,
20
+ StateHead,
21
+ StoreInterrupted,
22
+ UnknownError,
23
+ } from '@livestore/common'
24
+ import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
25
+ import { shouldNeverHappen, tryAsFunctionAndNew } from '@livestore/utils'
26
+ import {
27
+ Cause,
28
+ Effect,
29
+ Exit,
30
+ Fiber,
31
+ Layer,
32
+ Queue,
33
+ RpcClient,
34
+ RpcWorker,
35
+ Schema,
36
+ Stream,
37
+ Subscribable,
38
+ SubscriptionRef,
39
+ } from '@livestore/utils/effect'
40
+ import { BrowserWorker, Opfs, WebError } from '@livestore/utils/effect/browser'
41
+ import { nanoid } from '@livestore/utils/nanoid'
42
+
43
+ import { loadSqlite3 } from '../web-worker/client-session/sqlite-loader.ts'
44
+ import {
45
+ readPersistedStateDbFromClientSession,
46
+ resetPersistedDataFromClientSession,
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'
53
+ import { makeShutdownChannel } from '../web-worker/common/shutdown-channel.ts'
54
+ import * as WorkerSchema from '../web-worker/common/worker-schema.ts'
55
+
56
+ /**
57
+ * Options for the single-tab adapter.
58
+ *
59
+ * This adapter is designed for browsers without SharedWorker support (e.g. Android Chrome).
60
+ * It provides OPFS persistence but without multi-tab synchronization.
61
+ *
62
+ * @see https://github.com/livestorejs/livestore/issues/321
63
+ * @see https://issues.chromium.org/issues/40290702
64
+ */
65
+ export type SingleTabAdapterOptions = {
66
+ /**
67
+ * The dedicated web worker that runs the LiveStore leader thread.
68
+ *
69
+ * @example
70
+ * ```ts
71
+ * import LiveStoreWorker from './livestore.worker.ts?worker'
72
+ *
73
+ * const adapter = makeSingleTabAdapter({
74
+ * worker: LiveStoreWorker,
75
+ * storage: { type: 'opfs' },
76
+ * })
77
+ * ```
78
+ */
79
+ worker: ((options: { name: string }) => globalThis.Worker) | (new (options: { name: string }) => globalThis.Worker)
80
+
81
+ /**
82
+ * Storage configuration. Currently only OPFS is supported.
83
+ */
84
+ storage: WorkerSchema.StorageTypeEncoded
85
+
86
+ /**
87
+ * Warning: This will reset both the app and eventlog database.
88
+ * This should only be used during development.
89
+ *
90
+ * @default false
91
+ */
92
+ resetPersistence?: boolean
93
+
94
+ /**
95
+ * By default the adapter will initially generate a random clientId (via `nanoid(5)`),
96
+ * store it in `localStorage` and restore it for subsequent client sessions.
97
+ */
98
+ clientId?: string
99
+
100
+ /**
101
+ * By default the adapter will initially generate a random sessionId (via `nanoid(5)`),
102
+ * store it in `sessionStorage` and restore it for subsequent client sessions in the same tab.
103
+ */
104
+ sessionId?: string
105
+
106
+ experimental?: {
107
+ /**
108
+ * When set to `true`, the adapter will always start with a snapshot from the leader
109
+ * instead of trying to load a snapshot from storage.
110
+ *
111
+ * @default false
112
+ */
113
+ disableFastPath?: boolean
114
+ }
115
+ }
116
+
117
+ /**
118
+ * Creates a single-tab web adapter with OPFS persistence.
119
+ *
120
+ * **This adapter is a fallback for browsers without SharedWorker support** (notably Android Chrome).
121
+ * It provides the same persistence capabilities as `makePersistedAdapter`, but without multi-tab
122
+ * synchronization. Each browser tab runs its own independent leader worker.
123
+ *
124
+ * In most cases, you should use `makePersistedAdapter` instead, which automatically falls back
125
+ * to this adapter when SharedWorker is unavailable.
126
+ *
127
+ * **Limitations**:
128
+ * - No multi-tab synchronization (each tab operates independently)
129
+ * - No devtools support (requires SharedWorker)
130
+ * - Opening multiple tabs with the same storeId may cause data conflicts
131
+ *
132
+ * @see https://github.com/livestorejs/livestore/issues/321 - LiveStore tracking issue
133
+ * @see https://issues.chromium.org/issues/40290702 - Chromium SharedWorker bug
134
+ *
135
+ * @example
136
+ * ```ts
137
+ * import { makeSingleTabAdapter } from '@livestore/adapter-web'
138
+ * import LiveStoreWorker from './livestore.worker.ts?worker'
139
+ *
140
+ * // Only use this directly if you specifically need single-tab mode.
141
+ * // Prefer makePersistedAdapter which auto-detects SharedWorker support.
142
+ * const adapter = makeSingleTabAdapter({
143
+ * worker: LiveStoreWorker,
144
+ * storage: { type: 'opfs' },
145
+ * })
146
+ * ```
147
+ */
148
+ export const makeSingleTabAdapter =
149
+ (options: SingleTabAdapterOptions): Adapter =>
150
+ (adapterArgs) =>
151
+ Effect.gen(function* () {
152
+ const { schema, storeId, bootStatusQueue, shutdown, syncPayloadEncoded } = adapterArgs
153
+ // Note: devtoolsEnabled is ignored in single-tab mode (devtools require SharedWorker)
154
+
155
+ yield* ensureBrowserRequirements
156
+
157
+ yield* Queue.offer(bootStatusQueue, { stage: 'loading' })
158
+
159
+ const sqlite3 = yield* Effect.promise(() => loadSqlite3())
160
+
161
+ const storageOptions = yield* Schema.decodeEffect(WorkerSchema.StorageType)(options.storage)
162
+
163
+ const shutdownChannel = yield* makeShutdownChannel(storeId)
164
+
165
+ // Check OPFS availability early and notify user if storage is unavailable (e.g. private browsing)
166
+ const opfsWarning = yield* checkOpfsAvailability
167
+ if (opfsWarning !== undefined) {
168
+ yield* Effect.logWarning('[@livestore/adapter-web:single-tab] OPFS unavailable', opfsWarning)
169
+ }
170
+
171
+ if (options.resetPersistence === true && opfsWarning === undefined) {
172
+ yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'adapter-reset' }))
173
+ yield* resetPersistedDataFromClientSession({ storageOptions, storeId })
174
+ } else if (options.resetPersistence === true) {
175
+ yield* Effect.logWarning(
176
+ '[@livestore/adapter-web:single-tab] Skipping persistence reset because storage is unavailable',
177
+ opfsWarning,
178
+ )
179
+ }
180
+
181
+ // Fast-path: try to load snapshot directly from storage
182
+ const dataFromFile =
183
+ options.experimental?.disableFastPath === true || opfsWarning !== undefined
184
+ ? undefined
185
+ : yield* readPersistedStateDbFromClientSession({ storageOptions, storeId, schema }).pipe(
186
+ Effect.tapError((error) =>
187
+ Effect.logDebug('[@livestore/adapter-web:single-tab] Could not read persisted state db', error, {
188
+ storeId,
189
+ }),
190
+ ),
191
+ Effect.orElseSucceed(() => undefined),
192
+ )
193
+
194
+ const clientId = options.clientId ?? getPersistedId(`clientId:${storeId}`, 'local')
195
+ const sessionId = options.sessionId ?? getPersistedId(`sessionId:${storeId}`, 'session')
196
+
197
+ yield* shutdownChannel.listen.pipe(
198
+ Stream.mapEffect(Effect.fromResult),
199
+ Stream.tap((cause) =>
200
+ shutdown(cause._tag === 'IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
201
+ ),
202
+ Stream.runDrain,
203
+ Effect.interruptible,
204
+ Effect.tapCauseLogPretty,
205
+ Effect.forkScoped,
206
+ )
207
+
208
+ // In single-tab mode, we always have the lock (we're always the leader)
209
+ const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
210
+
211
+ // Create MessageChannel for direct communication with the dedicated worker
212
+ const mc = new MessageChannel()
213
+
214
+ // Create the dedicated worker directly (no SharedWorker proxy)
215
+ const worker = tryAsFunctionAndNew(options.worker, { name: `livestore-worker-${storeId}-${sessionId}` })
216
+
217
+ // Set up communication with the dedicated worker via the outer protocol
218
+ const outerWorkerContext = yield* Layer.build(
219
+ RpcClient.layerProtocolWorker({ size: 1 }).pipe(
220
+ Layer.provide(BrowserWorker.layer(() => worker)),
221
+ Layer.provide(
222
+ RpcWorker.layerInitialMessage(
223
+ WorkerSchema.LeaderWorkerOuterInitialMessage.payloadSchema,
224
+ Effect.succeed({ port: mc.port1, storeId, clientId }),
225
+ ),
226
+ ),
227
+ ),
228
+ )
229
+ yield* RpcClient.make(WorkerSchema.LeaderWorkerOuterRpcs).pipe(
230
+ Effect.provide(outerWorkerContext),
231
+ UnknownError.mapToUnknownError,
232
+ Effect.tapCause((cause) => shutdown(Exit.failCause(cause))),
233
+ Effect.withSpan('@livestore/adapter-web:single-tab:setupDedicatedWorker'),
234
+ Effect.tapCauseLogPretty,
235
+ )
236
+
237
+ // Set up the inner worker communication via port2 (like SharedWorker would do)
238
+ // BrowserWorker.layer accepts a MessagePort as well as a Worker
239
+ const innerWorkerContext = yield* Layer.build(
240
+ RpcClient.layerProtocolWorker({ size: 1, concurrency: 100 }).pipe(
241
+ Layer.provide(BrowserWorker.layer(() => mc.port2)),
242
+ Layer.provide(
243
+ RpcWorker.layerInitialMessage(
244
+ WorkerSchema.LeaderWorkerInnerInitialMessage.payloadSchema,
245
+ Effect.succeed({
246
+ storageOptions,
247
+ storeId,
248
+ clientId,
249
+ // Devtools disabled in single-tab mode (requires SharedWorker)
250
+ devtoolsEnabled: false,
251
+ debugInstanceId: adapterArgs.debugInstanceId,
252
+ syncPayloadEncoded,
253
+ }),
254
+ ),
255
+ ),
256
+ ),
257
+ )
258
+ const innerWorker = yield* RpcClient.make(WorkerSchema.LeaderWorkerInnerRpcs).pipe(
259
+ Effect.provide(innerWorkerContext),
260
+ Effect.tapCauseLogPretty,
261
+ UnknownError.mapToUnknownError,
262
+ Effect.tapCause((cause) => shutdown(Exit.failCause(cause))),
263
+ Effect.withSpan('@livestore/adapter-web:single-tab:setupInnerWorker'),
264
+ )
265
+
266
+ // Helper to run requests against the worker
267
+ const runInWorker = <A, E, R>(
268
+ tag: string,
269
+ effect: Effect.Effect<A, E, R>,
270
+ ): Effect.Effect<A, WithoutRpcClientError<E>, R> =>
271
+ effect.pipe(
272
+ dieOnRpcClientError,
273
+ Effect.logWarnIfTakesLongerThan({
274
+ label: `@livestore/adapter-web:single-tab:runInWorker:${tag}`,
275
+ duration: 2000,
276
+ }),
277
+ Effect.withSpan(`@livestore/adapter-web:single-tab:runInWorker:${tag}`),
278
+ )
279
+
280
+ const runInWorkerStream = <A, E, R>(
281
+ tag: string,
282
+ stream: Stream.Stream<A, E, R>,
283
+ ): Stream.Stream<A, WithoutRpcClientError<E>, R> =>
284
+ stream.pipe(
285
+ dieOnRpcClientErrorStream,
286
+ Stream.withSpan(`@livestore/adapter-web:single-tab:runInWorkerStream:${tag}`),
287
+ )
288
+
289
+ // Forward boot status from worker
290
+ const bootStatusFiber = yield* runInWorkerStream('BootStatusStream', innerWorker.BootStatusStream({})).pipe(
291
+ Stream.tap((_) => Queue.offer(bootStatusQueue, _)),
292
+ Stream.runDrain,
293
+ Effect.tapCause((cause) =>
294
+ Cause.hasInterruptsOnly(cause) === true ? Effect.void : shutdown(Exit.failCause(cause)),
295
+ ),
296
+ Effect.interruptible,
297
+ Effect.tapCauseLogPretty,
298
+ Effect.forkScoped,
299
+ )
300
+
301
+ yield* Queue.await(bootStatusQueue).pipe(
302
+ Effect.andThen(Fiber.interrupt(bootStatusFiber)),
303
+ Effect.interruptible,
304
+ Effect.tapCauseLogPretty,
305
+ Effect.forkScoped,
306
+ )
307
+
308
+ // Get initial snapshot (either from fast-path or from worker)
309
+ const initialResult =
310
+ dataFromFile === undefined
311
+ ? yield* runInWorker('GetRecreateSnapshot', innerWorker.GetRecreateSnapshot({})).pipe(
312
+ Effect.map(({ snapshot, migrationsReport }) => ({
313
+ _tag: 'from-leader-worker' as const,
314
+ snapshot,
315
+ migrationsReport,
316
+ })),
317
+ )
318
+ : { _tag: 'fast-path' as const, snapshot: dataFromFile }
319
+
320
+ const migrationsReport =
321
+ initialResult._tag === 'from-leader-worker' ? initialResult.migrationsReport : { migrations: [] }
322
+
323
+ const makeSqliteDb = sqliteDbFactory({ sqlite3 })
324
+ const sqliteDb = yield* makeSqliteDb({ _tag: 'in-memory' })
325
+
326
+ sqliteDb.import(initialResult.snapshot)
327
+
328
+ const numberOfTables =
329
+ sqliteDb.select<{ count: number }>(`select count(*) as count from sqlite_master`)[0]?.count ?? 0
330
+ if (numberOfTables === 0) {
331
+ return yield* UnknownError.make({
332
+ cause: `Encountered empty or corrupted database`,
333
+ payload: { snapshotByteLength: initialResult.snapshot.byteLength, storageOptions: options.storage },
334
+ })
335
+ }
336
+
337
+ // The state snapshot carries its own cursor, so the fast path does not
338
+ // need to export or transfer the eventlog database.
339
+ const initialLeaderHead = yield* StateHead.make({ dbState: sqliteDb }).get
340
+
341
+ yield* Effect.addFinalizer((ex: Exit.Exit<unknown, unknown>) =>
342
+ Effect.gen(function* () {
343
+ if (Exit.isFailure(ex) === true) {
344
+ const cause = ex.cause
345
+ if (
346
+ Exit.hasInterrupts(ex) === false &&
347
+ Schema.is(IntentionalShutdownCause)(Cause.squash(cause)) === false &&
348
+ Schema.is(StoreInterrupted)(Cause.squash(cause)) === false
349
+ ) {
350
+ yield* Effect.logError('[@livestore/adapter-web:single-tab] client-session shutdown', cause)
351
+ return
352
+ }
353
+ }
354
+
355
+ yield* Effect.logDebug('[@livestore/adapter-web:single-tab] client-session shutdown', ex)
356
+ }).pipe(Effect.tapCauseLogPretty, Effect.orDie),
357
+ )
358
+
359
+ const leaderThread: ClientSession['leaderThread'] = {
360
+ export: runInWorker('Export', innerWorker.Export({})).pipe(
361
+ Effect.timeoutOrDie(10_000),
362
+ Effect.withSpan('@livestore/adapter-web:single-tab:export'),
363
+ ),
364
+
365
+ events: {
366
+ pull: ({ cursor }) => runInWorkerStream('PullStream', innerWorker.PullStream({ cursor })).pipe(Stream.orDie),
367
+ push: (batch) =>
368
+ runInWorker('PushToLeader', innerWorker.PushToLeader({ batch })).pipe(
369
+ Effect.withSpan('@livestore/adapter-web:single-tab:pushToLeader', {
370
+ attributes: { batchSize: batch.length },
371
+ }),
372
+ ),
373
+ stream: (options) =>
374
+ runInWorkerStream('StreamEvents', innerWorker.StreamEvents(options)).pipe(
375
+ Stream.withSpan('@livestore/adapter-web:single-tab:streamEvents'),
376
+ Stream.orDie,
377
+ ),
378
+ },
379
+
380
+ initialState: {
381
+ leaderHead: initialLeaderHead,
382
+ migrationsReport,
383
+ storageMode: opfsWarning === undefined ? 'persisted' : 'in-memory',
384
+ },
385
+
386
+ getEventlogData: runInWorker('ExportEventlog', innerWorker.ExportEventlog({})).pipe(
387
+ Effect.timeoutOrDie(10_000),
388
+ Effect.withSpan('@livestore/adapter-web:single-tab:getEventlogData'),
389
+ ),
390
+
391
+ syncState: Subscribable.make({
392
+ get: runInWorker('GetLeaderSyncState', innerWorker.GetLeaderSyncState({})).pipe(
393
+ Effect.withSpan('@livestore/adapter-web:single-tab:getLeaderSyncState'),
394
+ ),
395
+ changes: runInWorkerStream('SyncStateStream', innerWorker.SyncStateStream({})).pipe(Stream.orDie),
396
+ }),
397
+
398
+ sendDevtoolsMessage: (_message) =>
399
+ // Devtools not supported in single-tab mode
400
+ Effect.void,
401
+
402
+ networkStatus: Subscribable.make({
403
+ get: runInWorker('GetNetworkStatus', innerWorker.GetNetworkStatus({})).pipe(Effect.orDie),
404
+ changes: runInWorkerStream('NetworkStatusStream', innerWorker.NetworkStatusStream({})).pipe(Stream.orDie),
405
+ }),
406
+ }
407
+
408
+ const clientSession = yield* makeClientSession({
409
+ ...adapterArgs,
410
+ sqliteDb,
411
+ lockStatus,
412
+ clientId,
413
+ sessionId,
414
+ isLeader: true, // Always leader in single-tab mode
415
+ leaderThread,
416
+ webmeshMode: 'direct',
417
+ origin: globalThis.location?.origin,
418
+ // No webmesh connection in single-tab mode (devtools disabled)
419
+ connectWebmeshNode: () => Effect.void,
420
+ registerBeforeUnload: (onBeforeUnload) => {
421
+ if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
422
+ window.addEventListener('beforeunload', onBeforeUnload)
423
+ return () => window.removeEventListener('beforeunload', onBeforeUnload)
424
+ }
425
+ return () => {}
426
+ },
427
+ })
428
+
429
+ return clientSession
430
+ }).pipe(Effect.provide(Opfs.layer), UnknownError.mapToUnknownError)
431
+
432
+ /** Persists clientId/sessionId to storage */
433
+ const getPersistedId = (key: string, storageType: 'session' | 'local') => {
434
+ const makeId = () => nanoid(5)
435
+
436
+ const storage =
437
+ typeof window === 'undefined'
438
+ ? undefined
439
+ : storageType === 'session'
440
+ ? sessionStorage
441
+ : storageType === 'local'
442
+ ? localStorage
443
+ : shouldNeverHappen(`[@livestore/adapter-web] Invalid storage type: ${String(storageType)}`)
444
+
445
+ if (storage === undefined) {
446
+ return makeId()
447
+ }
448
+
449
+ const fullKey = `livestore:${key}`
450
+ const storedKey = storage.getItem(fullKey)
451
+
452
+ if (storedKey !== null) return storedKey
453
+
454
+ const newKey = makeId()
455
+ storage.setItem(fullKey, newKey)
456
+
457
+ return newKey
458
+ }
459
+
460
+ const ensureBrowserRequirements = Effect.gen(function* () {
461
+ const validate = (condition: boolean, label: string) =>
462
+ Effect.gen(function* () {
463
+ if (condition === true) {
464
+ return yield* UnknownError.make({
465
+ cause: `[@livestore/adapter-web] Browser not supported. The LiveStore web adapter needs '${label}' to work properly`,
466
+ })
467
+ }
468
+ })
469
+
470
+ yield* Effect.all([
471
+ validate(typeof navigator === 'undefined', 'navigator'),
472
+ validate(navigator.locks === undefined, 'navigator.locks'),
473
+ validate(navigator.storage === undefined, 'navigator.storage'),
474
+ validate(crypto.randomUUID === undefined, 'crypto.randomUUID'),
475
+ validate(typeof window === 'undefined', 'window'),
476
+ validate(typeof sessionStorage === 'undefined', 'sessionStorage'),
477
+ ])
478
+ })
479
+
480
+ /**
481
+ * Attempts to access OPFS and returns a warning if unavailable.
482
+ */
483
+ const checkOpfsAvailability = Effect.gen(function* () {
484
+ const opfs = yield* Opfs.Opfs
485
+ return yield* opfs.getRootDirectoryHandle.pipe(
486
+ Effect.as(undefined),
487
+ Effect.catch((error) => {
488
+ const reason: BootWarningReason =
489
+ Schema.is(WebError.SecurityError)(error) === true || Schema.is(WebError.NotAllowedError)(error) === true
490
+ ? 'private-browsing'
491
+ : 'storage-unavailable'
492
+ const message =
493
+ reason === 'private-browsing'
494
+ ? 'Storage unavailable in private browsing mode. LiveStore will continue without persistence.'
495
+ : 'Storage access denied. LiveStore will continue without persistence.'
496
+ return Effect.succeed({ reason, message } as const)
497
+ }),
498
+ )
499
+ })
@@ -1,23 +1,3 @@
1
- // TODO remove OPFS stuff
2
- // https://developer.mozilla.org/en-US/docs/Web/API/FileSystemSyncAccessHandle
3
- interface FileSystemSyncAccessHandle {
4
- close: () => void
5
- flush: () => Promise<void>
6
- getSize: () => number
7
- read: (buffer: ArrayBuffer, options?: FileSystemReadWriteOptions) => number
8
- truncate: (newSize: number) => void
9
- write: (buffer: ArrayBuffer, options?: FileSystemReadWriteOptions) => number
10
- seek: (offset: number) => void
11
- }
12
-
13
- interface FileSystemReadWriteOptions {
14
- at?: number
15
- }
16
-
17
- interface FileSystemFileHandle {
18
- createSyncAccessHandle: () => Promise<FileSystemSyncAccessHandle>
19
- }
20
-
21
1
  // TODO bring back when Vite limitation is resolved https://github.com/vitejs/vite/issues/8427
22
2
  // declare module '*?sharedworker' {
23
3
  // const sharedWorkerConstructor: {
@@ -26,11 +6,14 @@ interface FileSystemFileHandle {
26
6
  // export default sharedWorkerConstructor
27
7
  // }
28
8
 
9
+ declare interface ImportMetaEnv {
10
+ readonly SSR?: string | boolean
11
+ readonly DEV: boolean | undefined
12
+ readonly VITE_LIVESTORE_EXPERIMENTAL_SYNC_NEXT: boolean | undefined
13
+ }
14
+
29
15
  declare interface ImportMeta {
30
- env: {
31
- DEV: boolean | undefined
32
- VITE_LIVESTORE_EXPERIMENTAL_SYNC_NEXT: boolean | undefined
33
- }
16
+ readonly env: ImportMetaEnv
34
17
  }
35
18
 
36
19
  declare var __debugLiveStoreUtils: any
@@ -1,12 +1,16 @@
1
- import { Devtools } from '@livestore/common'
1
+ import { Devtools, liveStoreVersion } from '@livestore/common'
2
2
  import type { LiveStoreSchema } from '@livestore/common/schema'
3
- import * as DevtoolsWeb from '@livestore/devtools-web-common/web-channel'
4
3
  import { isDevEnv } from '@livestore/utils'
5
- import type { Worker } from '@livestore/utils/effect'
6
- import { Effect, Stream, WebChannel } from '@livestore/utils/effect'
4
+ import { Effect, Stream } from '@livestore/utils/effect'
5
+ import { WebChannelBrowser } from '@livestore/utils/effect/browser'
7
6
  import * as Webmesh from '@livestore/webmesh'
7
+ import * as WebmeshWorker from '@livestore/webmesh/worker'
8
8
 
9
- export const logDevtoolsUrl = ({
9
+ import type { WebmeshWorkerProxy } from '../common/rpc-worker.ts'
10
+ import { makeSharedWorkerNodeName } from '../common/webmesh-node-names.ts'
11
+ import * as DevtoolsWeb from './devtools-web-channel.ts'
12
+
13
+ export const logDevtoolsUrl = Effect.fn('@livestore/adapter-web:client-session:devtools:logDevtoolsUrl')(function* ({
10
14
  schema,
11
15
  storeId,
12
16
  clientId,
@@ -16,23 +20,37 @@ export const logDevtoolsUrl = ({
16
20
  storeId: string
17
21
  clientId: string
18
22
  sessionId: string
19
- }) =>
20
- Effect.gen(function* () {
21
- if (isDevEnv()) {
22
- const devtoolsPath = globalThis.LIVESTORE_DEVTOOLS_PATH ?? `/_livestore`
23
- const devtoolsBaseUrl = `${location.origin}${devtoolsPath}`
23
+ }) {
24
+ if (isDevEnv() === true) {
25
+ const devtoolsPath =
26
+ (globalThis as unknown as { LIVESTORE_DEVTOOLS_PATH?: string }).LIVESTORE_DEVTOOLS_PATH ?? `/_livestore`
27
+ const devtoolsBaseUrl = `${location.origin}${devtoolsPath}`
28
+
29
+ // Check whether devtools are available and then log the URL
30
+ const response = yield* Effect.promise(() => fetch(devtoolsBaseUrl))
31
+ if (response.ok === true) {
32
+ const text = yield* Effect.promise(() => response.text())
33
+ if (text.includes('<meta name="livestore-devtools" content="true" />') === true) {
34
+ const url = `${devtoolsBaseUrl}/web/${storeId}/${clientId}/${sessionId}/${schema.devtools.alias}`
35
+ yield* Effect.log(`[@livestore/adapter-web] Devtools ready on ${url}`)
36
+ }
24
37
 
25
- // Check whether devtools are available and then log the URL
26
- const response = yield* Effect.promise(() => fetch(devtoolsBaseUrl))
27
- if (response.ok) {
28
- const text = yield* Effect.promise(() => response.text())
29
- if (text.includes('<meta name="livestore-devtools" content="true" />')) {
30
- const url = `${devtoolsBaseUrl}/web/${storeId}/${clientId}/${sessionId}/${schema.devtools.alias}`
31
- yield* Effect.log(`[@livestore/adapter-web] Devtools ready on ${url}`)
38
+ // Check for DevTools Chrome extension presence via iframe container the extension injects
39
+ const hasExt = document.querySelector('[id^="livestore-devtools-iframe-"]') !== null
40
+ if (hasExt === false) {
41
+ const g = globalThis as { __livestoreDevtoolsChromeNoticeShown?: boolean }
42
+ if (g.__livestoreDevtoolsChromeNoticeShown !== true) {
43
+ g.__livestoreDevtoolsChromeNoticeShown = true
44
+
45
+ const urlToLog = `https://github.com/livestorejs/livestore/releases/download/v${liveStoreVersion}/livestore-devtools-chrome-${liveStoreVersion}.zip`
46
+ yield* Effect.log(
47
+ `[@livestore/adapter-web] LiveStore DevTools Chrome extension not detected. Install v${liveStoreVersion}: ${urlToLog}`,
48
+ )
32
49
  }
33
50
  }
34
51
  }
35
- }).pipe(Effect.withSpan('@livestore/adapter-web:client-session:devtools:logDevtoolsUrl'))
52
+ }
53
+ })
36
54
 
37
55
  export const connectWebmeshNodeClientSession = Effect.fn(function* ({
38
56
  webmeshNode,
@@ -43,11 +61,11 @@ export const connectWebmeshNodeClientSession = Effect.fn(function* ({
43
61
  }: {
44
62
  webmeshNode: Webmesh.MeshNode
45
63
  sessionInfo: Devtools.SessionInfo.SessionInfo
46
- sharedWorker: Worker.SerializedWorkerPool<typeof DevtoolsWeb.WorkerSchema.Request.Type>
64
+ sharedWorker: WebmeshWorkerProxy
47
65
  devtoolsEnabled: boolean
48
66
  schema: LiveStoreSchema
49
67
  }) {
50
- if (devtoolsEnabled) {
68
+ if (devtoolsEnabled === true) {
51
69
  const { clientId, sessionId, storeId } = sessionInfo
52
70
  yield* logDevtoolsUrl({ clientId, sessionId, schema, storeId })
53
71
 
@@ -65,11 +83,15 @@ export const connectWebmeshNodeClientSession = Effect.fn(function* ({
65
83
  DevtoolsWeb.ClientSessionContentscriptMainReq.make({ clientId, sessionId, storeId }),
66
84
  )
67
85
 
68
- const { tabId } = yield* clientSessionStaticChannel.listen.pipe(Stream.flatten(), Stream.runHead, Effect.flatten)
86
+ const { tabId } = yield* clientSessionStaticChannel.listen.pipe(
87
+ Stream.mapEffect(Effect.fromResult),
88
+ Stream.runHead,
89
+ Effect.flatMap(Effect.fromOption),
90
+ )
69
91
 
70
- const contentscriptMainNodeName = DevtoolsWeb.makeNodeName.browserExtension.contentscriptMain(tabId)
92
+ const contentscriptMainNodeName = DevtoolsWeb.makeBrowserExtensionNodeName.contentscriptMain(tabId)
71
93
 
72
- const contentscriptMainChannel = yield* WebChannel.windowChannel({
94
+ const contentscriptMainChannel = yield* WebChannelBrowser.windowChannel({
73
95
  listenWindow: window,
74
96
  sendWindow: window,
75
97
  schema: Webmesh.WebmeshSchema.Packet,
@@ -83,9 +105,9 @@ export const connectWebmeshNodeClientSession = Effect.fn(function* ({
83
105
  Effect.forkScoped,
84
106
  )
85
107
 
86
- yield* DevtoolsWeb.connectViaWorker({
108
+ yield* WebmeshWorker.connectViaWorker({
87
109
  node: webmeshNode,
88
- target: DevtoolsWeb.makeNodeName.sharedWorker({ storeId }),
110
+ target: makeSharedWorkerNodeName({ storeId }),
89
111
  worker: sharedWorker,
90
112
  })
91
113
  }