@livestore/common 0.4.0 → 0.5.0-dev.1

package/src/devtools/devtools-messages-client-session.ts

@@ -5,128 +5,119 @@ import { EventSequenceNumber } from '../schema/mod.ts'
 import { PreparedBindValues } from '../util.ts'
 import { LSDClientSessionChannelMessage, LSDClientSessionReqResMessage } from './devtools-messages-common.ts'
 
-export class DebugInfoReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoReq', {}) {}
+export const DebugInfoReq = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoReq', {})
 
-export class DebugInfoRes extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRes', {
+export const DebugInfoRes = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRes', {
   debugInfo: DebugInfo,
-}) {}
+})
 
-export class DebugInfoHistorySubscribe extends LSDClientSessionReqResMessage(
-  'LSD.ClientSession.DebugInfoHistorySubscribe',
-  {
-    subscriptionId: Schema.String,
-  },
-) {}
+export const DebugInfoHistorySubscribe = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoHistorySubscribe', {
+  subscriptionId: Schema.String,
+})
 
-export class DebugInfoHistoryRes extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoHistoryRes', {
+export const DebugInfoHistoryRes = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoHistoryRes', {
   debugInfoHistory: Schema.Array(DebugInfo),
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class DebugInfoHistoryUnsubscribe extends LSDClientSessionReqResMessage(
+export const DebugInfoHistoryUnsubscribe = LSDClientSessionReqResMessage(
   'LSD.ClientSession.DebugInfoHistoryUnsubscribe',
   {
     subscriptionId: Schema.String,
   },
-) {}
+)
 
-export class DebugInfoResetReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoResetReq', {}) {}
+export const DebugInfoResetReq = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoResetReq', {})
 
-export class DebugInfoResetRes extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoResetRes', {}) {}
+export const DebugInfoResetRes = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoResetRes', {})
 
-export class DebugInfoRerunQueryReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRerunQueryReq', {
+export const DebugInfoRerunQueryReq = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRerunQueryReq', {
   queryStr: Schema.String,
   bindValues: Schema.UndefinedOr(PreparedBindValues),
   queriedTables: Schema.ReadonlySet(Schema.String),
-}) {}
+})
 
-export class DebugInfoRerunQueryRes extends LSDClientSessionReqResMessage(
-  'LSD.ClientSession.DebugInfoRerunQueryRes',
-  {},
-) {}
+export const DebugInfoRerunQueryRes = LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRerunQueryRes', {})
 
-export class SyncHeadSubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadSubscribe', {
+export const SyncHeadSubscribe = LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadSubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class SyncHeadUnsubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadUnsubscribe', {
+})
+export const SyncHeadUnsubscribe = LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadUnsubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class SyncHeadRes extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadRes', {
+})
+export const SyncHeadRes = LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadRes', {
   local: EventSequenceNumber.Client.Composite,
   upstream: EventSequenceNumber.Client.Composite,
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class ReactivityGraphSubscribe extends LSDClientSessionReqResMessage(
-  'LSD.ClientSession.ReactivityGraphSubscribe',
-  {
-    includeResults: Schema.Boolean,
-    subscriptionId: Schema.String,
-  },
-) {}
+export const ReactivityGraphSubscribe = LSDClientSessionReqResMessage('LSD.ClientSession.ReactivityGraphSubscribe', {
+  includeResults: Schema.Boolean,
+  subscriptionId: Schema.String,
+})
 
-export class ReactivityGraphUnsubscribe extends LSDClientSessionReqResMessage(
+export const ReactivityGraphUnsubscribe = LSDClientSessionReqResMessage(
   'LSD.ClientSession.ReactivityGraphUnsubscribe',
   {
     subscriptionId: Schema.String,
   },
-) {}
+)
 
-export class ReactivityGraphRes extends LSDClientSessionReqResMessage('LSD.ClientSession.ReactivityGraphRes', {
+export const ReactivityGraphRes = LSDClientSessionReqResMessage('LSD.ClientSession.ReactivityGraphRes', {
   reactivityGraph: Schema.Any,
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class LiveQueriesSubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesSubscribe', {
+export const LiveQueriesSubscribe = LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesSubscribe', {
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class LiveQueriesUnsubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesUnsubscribe', {
+export const LiveQueriesUnsubscribe = LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesUnsubscribe', {
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class SerializedLiveQuery extends Schema.Struct({
-  _tag: Schema.Literal('computed', 'db', 'graphql', 'signal'),
-  id: Schema.Number,
+export const SerializedLiveQuery = Schema.Struct({
+  _tag: Schema.Literals(['computed', 'db', 'graphql', 'signal']),
+  id: Schema.Finite,
   label: Schema.String,
   hash: Schema.String,
-  runs: Schema.Number,
-  executionTimes: Schema.Array(Schema.Number),
+  runs: Schema.Finite,
+  executionTimes: Schema.Array(Schema.Finite),
   lastestResult: Schema.Any,
   activeSubscriptions: Schema.Array(
     Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) }),
   ),
-}) {}
+})
 
-export class LiveQueriesRes extends LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesRes', {
+export const LiveQueriesRes = LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesRes', {
   liveQueries: Schema.Array(SerializedLiveQuery),
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class Ping extends LSDClientSessionReqResMessage('LSD.ClientSession.Ping', {
-  devtoolsProtocolVersion: Schema.optional(Schema.Number),
-}) {}
+export const Ping = LSDClientSessionReqResMessage('LSD.ClientSession.Ping', {
+  devtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
-export class Pong extends LSDClientSessionReqResMessage('LSD.ClientSession.Pong', {
-  devtoolsProtocolVersion: Schema.optional(Schema.Number),
-}) {}
+export const Pong = LSDClientSessionReqResMessage('LSD.ClientSession.Pong', {
+  devtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
 /**
  * Sent by the app when the DevTools protocol isn't compatible.
  * Contains package versions for display and protocol versions for the actual compatibility decision.
  */
-export class VersionMismatch extends LSDClientSessionReqResMessage('LSD.ClientSession.VersionMismatch', {
+export const VersionMismatch = LSDClientSessionReqResMessage('LSD.ClientSession.VersionMismatch', {
   /** The version running in the app */
   appVersion: Schema.String,
   /** The version that was sent by DevTools (that caused the mismatch) */
   receivedVersion: Schema.String,
-  appDevtoolsProtocolVersion: Schema.Number,
-  receivedDevtoolsProtocolVersion: Schema.optional(Schema.Number),
-}) {}
+  appDevtoolsProtocolVersion: Schema.Finite,
+  receivedDevtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
-export class Disconnect extends LSDClientSessionChannelMessage('LSD.ClientSession.Disconnect', {}) {}
+export const Disconnect = LSDClientSessionChannelMessage('LSD.ClientSession.Disconnect', {})
 
-export const MessageToApp = Schema.Union(
+export const MessageToApp = Schema.Union([
   DebugInfoReq,
   DebugInfoHistorySubscribe,
   DebugInfoHistoryUnsubscribe,
@@ -140,11 +131,11 @@ export const MessageToApp = Schema.Union(
   Ping,
   SyncHeadSubscribe,
   SyncHeadUnsubscribe,
-).annotations({ identifier: 'LSD.ClientSession.MessageToApp' })
+]).annotate({ identifier: 'LSD.ClientSession.MessageToApp' })
 
 export type MessageToApp = typeof MessageToApp.Type
 
-export const MessageFromApp = Schema.Union(
+export const MessageFromApp = Schema.Union([
   DebugInfoRes,
   DebugInfoHistoryRes,
   DebugInfoResetRes,
@@ -155,6 +146,6 @@ export const MessageFromApp = Schema.Union(
   Pong,
   VersionMismatch,
   SyncHeadRes,
-).annotations({ identifier: 'LSD.ClientSession.MessageFromApp' })
+]).annotate({ identifier: 'LSD.ClientSession.MessageFromApp' })
 
 export type MessageFromApp = typeof MessageFromApp.Type

package/src/devtools/devtools-messages-common.ts

@@ -15,7 +15,7 @@ export const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fiel
   Schema.TaggedStruct(tag, {
     liveStoreVersion,
     ...fields,
-  }).annotations({ identifier: tag })
+  }).annotate({ identifier: tag })
 
 export const LSDChannelMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
   LSDMessage(tag, {
@@ -87,23 +87,24 @@ export const LeaderReqResMessage = <
     requestId,
     liveStoreVersion,
     ...fields.success,
-  }).annotations({ identifier: `${tag}.Response.Success` })
+  }).annotate({ identifier: `${tag}.Response.Success` })
 
-  const Error = fields.error !== undefined
-    ? Schema.TaggedStruct(`${tag}.Response.Error`, {
-        requestId,
-        liveStoreVersion,
-        ...fields.error,
-      }).annotations({ identifier: `${tag}.Response.Error` })
-    : Schema.Never
+  const Error =
+    fields.error !== undefined
+      ? Schema.TaggedStruct(`${tag}.Response.Error`, {
+          requestId,
+          liveStoreVersion,
+          ...fields.error,
+        }).annotate({ identifier: `${tag}.Response.Error` })
+      : Schema.Never
 
   return {
     Request: Schema.TaggedStruct(`${tag}.Request`, {
       requestId,
       liveStoreVersion,
       ...fields.payload,
-    }).annotations({ identifier: `${tag}.Request` }),
-    Response: Schema.Union(Success, Error),
+    }).annotate({ identifier: `${tag}.Request` }),
+    Response: Schema.Union([Success, Error]),
     Success,
     Error,
   } as any

package/src/devtools/devtools-messages-leader.ts

@@ -5,130 +5,132 @@ import { EventSequenceNumber } from '../schema/mod.ts'
 import * as SyncState from '../sync/syncstate.ts'
 import { LeaderReqResMessage, LSDMessage, LSDReqResMessage, NetworkStatus } from './devtools-messages-common.ts'
 
-export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
-  mode: Schema.Literal('all-data', 'only-app-db'),
-}) {}
+export const ResetAllDataReq = LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
+  mode: Schema.Literals(['all-data', 'only-app-db']),
+})
 
-export class DatabaseFileInfoReq extends LSDReqResMessage('LSD.Leader.DatabaseFileInfoReq', {}) {}
+export const DatabaseFileInfoReq = LSDReqResMessage('LSD.Leader.DatabaseFileInfoReq', {})
 
-export class DatabaseFileInfo extends Schema.Struct({
-  fileSize: Schema.Number,
-  persistenceInfo: Schema.Struct({ fileName: Schema.String }, { key: Schema.String, value: Schema.Any }),
-}) {}
+export const DatabaseFileInfo = Schema.Struct({
+  fileSize: Schema.Finite,
+  persistenceInfo: Schema.StructWithRest(Schema.Struct({ fileName: Schema.String }), [
+    Schema.Record(Schema.String, Schema.Any),
+  ]),
+})
 
-export class DatabaseFileInfoRes extends LSDReqResMessage('LSD.Leader.DatabaseFileInfoRes', {
+export const DatabaseFileInfoRes = LSDReqResMessage('LSD.Leader.DatabaseFileInfoRes', {
   state: DatabaseFileInfo,
   eventlog: DatabaseFileInfo,
-}) {}
+})
 
-export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {
+export const NetworkStatusSubscribe = LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {
+})
+export const NetworkStatusUnsubscribe = LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class NetworkStatusRes extends LSDReqResMessage('LSD.Leader.NetworkStatusRes', {
+export const NetworkStatusRes = LSDReqResMessage('LSD.Leader.NetworkStatusRes', {
   networkStatus: NetworkStatus,
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class SyncingInfoReq extends LSDReqResMessage('LSD.Leader.SyncingInfoReq', {}) {}
+export const SyncingInfoReq = LSDReqResMessage('LSD.Leader.SyncingInfoReq', {})
 
-export class SyncingInfo extends Schema.Struct({
+export const SyncingInfo = Schema.Struct({
   enabled: Schema.Boolean,
-  metadata: Schema.Record({ key: Schema.String, value: Schema.Any }),
-}) {}
+  metadata: Schema.Record(Schema.String, Schema.Any),
+})
 
-export class SyncingInfoRes extends LSDReqResMessage('LSD.Leader.SyncingInfoRes', {
+export const SyncingInfoRes = LSDReqResMessage('LSD.Leader.SyncingInfoRes', {
   syncingInfo: SyncingInfo,
-}) {}
+})
 
-export class SyncHistorySubscribe extends LSDReqResMessage('LSD.Leader.SyncHistorySubscribe', {
+export const SyncHistorySubscribe = LSDReqResMessage('LSD.Leader.SyncHistorySubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHistoryUnsubscribe', {
+})
+export const SyncHistoryUnsubscribe = LSDReqResMessage('LSD.Leader.SyncHistoryUnsubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class SyncHistoryRes extends LSDReqResMessage('LSD.Leader.SyncHistoryRes', {
+})
+export const SyncHistoryRes = LSDReqResMessage('LSD.Leader.SyncHistoryRes', {
   eventEncoded: LiveStoreEvent.Global.Encoded,
-  metadata: Schema.Option(Schema.JsonValue),
+  metadata: Schema.Option(Schema.Json),
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class SyncHeadSubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadSubscribe', {
+export const SyncHeadSubscribe = LSDReqResMessage('LSD.Leader.SyncHeadSubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class SyncHeadUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadUnsubscribe', {
+})
+export const SyncHeadUnsubscribe = LSDReqResMessage('LSD.Leader.SyncHeadUnsubscribe', {
   subscriptionId: Schema.String,
-}) {}
-export class SyncHeadRes extends LSDReqResMessage('LSD.Leader.SyncHeadRes', {
+})
+export const SyncHeadRes = LSDReqResMessage('LSD.Leader.SyncHeadRes', {
   local: EventSequenceNumber.Client.Composite,
   upstream: EventSequenceNumber.Client.Composite,
   subscriptionId: Schema.String,
-}) {}
+})
 
-export class SnapshotReq extends LSDReqResMessage('LSD.Leader.SnapshotReq', {}) {}
+export const SnapshotReq = LSDReqResMessage('LSD.Leader.SnapshotReq', {})
 
-export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
-  snapshot: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
-}) {}
+export const SnapshotRes = LSDReqResMessage('LSD.Leader.SnapshotRes', {
+  snapshot: Transferable.Uint8Array as Schema.Codec<Uint8Array<ArrayBuffer>>,
+})
 
 export const LoadDatabaseFile = LeaderReqResMessage('LSD.Leader.LoadDatabaseFile', {
   payload: {
-    data: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
+    data: Transferable.Uint8Array as Schema.Codec<Uint8Array<ArrayBuffer>>,
     batchId: Schema.optional(Schema.String),
   },
   success: {},
   error: {
-    cause: Schema.Union(
+    cause: Schema.Union([
       Schema.TaggedStruct('unsupported-file', {}),
       Schema.TaggedStruct('unsupported-database', {}),
-      Schema.TaggedStruct('unknown-error', { cause: Schema.Defect }),
-    ),
+      Schema.TaggedStruct('unknown-error', { cause: Schema.Defect() }),
+    ]),
   },
 })
 
 // TODO refactor this to use push/pull semantics
-export class SyncPull extends LSDMessage('LSD.Leader.SyncPull', {
+export const SyncPull = LSDMessage('LSD.Leader.SyncPull', {
   payload: SyncState.PayloadUpstream,
-}) {}
+})
 
 // TODO refactor this to use push/pull semantics
-export class CommitEventReq extends LSDReqResMessage('LSD.Leader.CommitEventReq', {
+export const CommitEventReq = LSDReqResMessage('LSD.Leader.CommitEventReq', {
   eventEncoded: LiveStoreEvent.Input.Encoded,
-}) {}
+})
 
-export class CommitEventRes extends LSDReqResMessage('LSD.Leader.CommitEventRes', {}) {}
+export const CommitEventRes = LSDReqResMessage('LSD.Leader.CommitEventRes', {})
 
-export class EventlogReq extends LSDReqResMessage('LSD.Leader.EventlogReq', {}) {}
+export const EventlogReq = LSDReqResMessage('LSD.Leader.EventlogReq', {})
 
-export class EventlogRes extends LSDReqResMessage('LSD.Leader.EventlogRes', {
-  eventlog: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
-}) {}
+export const EventlogRes = LSDReqResMessage('LSD.Leader.EventlogRes', {
+  eventlog: Transferable.Uint8Array as Schema.Codec<Uint8Array<ArrayBuffer>>,
+})
 
-export class Ping extends LSDReqResMessage('LSD.Leader.Ping', {
-  devtoolsProtocolVersion: Schema.optional(Schema.Number),
-}) {}
+export const Ping = LSDReqResMessage('LSD.Leader.Ping', {
+  devtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
-export class Pong extends LSDReqResMessage('LSD.Leader.Pong', {
-  devtoolsProtocolVersion: Schema.optional(Schema.Number),
-}) {}
+export const Pong = LSDReqResMessage('LSD.Leader.Pong', {
+  devtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
 /**
  * Sent by the app when the DevTools protocol isn't compatible.
  * Contains package versions for display and protocol versions for the actual compatibility decision.
  */
-export class VersionMismatch extends LSDReqResMessage('LSD.Leader.VersionMismatch', {
+export const VersionMismatch = LSDReqResMessage('LSD.Leader.VersionMismatch', {
   /** The version running in the app */
   appVersion: Schema.String,
   /** The version that was sent by DevTools (that caused the mismatch) */
   receivedVersion: Schema.String,
-  appDevtoolsProtocolVersion: Schema.Number,
-  receivedDevtoolsProtocolVersion: Schema.optional(Schema.Number),
-}) {}
+  appDevtoolsProtocolVersion: Schema.Finite,
+  receivedDevtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
-export class Disconnect extends LSDReqResMessage('LSD.Leader.Disconnect', {}) {}
+export const Disconnect = LSDReqResMessage('LSD.Leader.Disconnect', {})
 
 export const SetSyncLatch = LeaderReqResMessage('LSD.Leader.SetSyncLatch', {
   payload: {
@@ -139,7 +141,7 @@ export const SetSyncLatch = LeaderReqResMessage('LSD.Leader.SetSyncLatch', {
 
 export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
   payload: {
-    mode: Schema.Literal('all-data', 'only-app-db'),
+    mode: Schema.Literals(['all-data', 'only-app-db']),
   },
   success: {},
 })
@@ -163,12 +165,12 @@ export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
 //   failure: UnknownError,
 // }) {}
 
-// export const MessageToApp_ = Schema.Union(DatabaseFileInfo_, NetworkStatus_)
+// export const MessageToApp_ = Schema.Union([DatabaseFileInfo_, NetworkStatus_])
 
 // export type MessageToApp_ = typeof MessageToApp_.Type
 //
 
-export const MessageToApp = Schema.Union(
+export const MessageToApp = Schema.Union([
   SnapshotReq,
   LoadDatabaseFile.Request,
   EventlogReq,
@@ -185,11 +187,11 @@ export const MessageToApp = Schema.Union(
   SyncHeadSubscribe,
   SyncHeadUnsubscribe,
   SetSyncLatch.Request,
-).annotations({ identifier: 'LSD.Leader.MessageToApp' })
+]).annotate({ identifier: 'LSD.Leader.MessageToApp' })
 
 export type MessageToApp = typeof MessageToApp.Type
 
-export const MessageFromApp = Schema.Union(
+export const MessageFromApp = Schema.Union([
   SnapshotRes,
   LoadDatabaseFile.Response,
   EventlogRes,
@@ -205,6 +207,6 @@ export const MessageFromApp = Schema.Union(
   SyncHeadRes,
   ResetAllData.Success,
   SetSyncLatch.Success,
-).annotations({ identifier: 'LSD.Leader.MessageFromApp' })
+]).annotate({ identifier: 'LSD.Leader.MessageFromApp' })
 
 export type MessageFromApp = typeof MessageFromApp.Type

package/src/devtools/devtools-sessioninfo.ts

@@ -1,6 +1,6 @@
-import type { ParseResult, Scope, WebChannel } from '@livestore/utils/effect'
 import {
-  Data,
+  type Scope,
+  type WebChannel,
   Duration,
   Effect,
   FiberMap,
@@ -30,7 +30,7 @@ export const SessionInfo = Schema.TaggedStruct('SessionInfo', {
 })
 export type SessionInfo = typeof SessionInfo.Type
 
-export const Message = Schema.Union(RequestSessions, SessionInfo)
+export const Message = Schema.Union([RequestSessions, SessionInfo])
 export type Message = typeof Message.Type
 
 /** Usually called in client session */
@@ -40,12 +40,12 @@ export const provideSessionInfo = ({
 }: {
   webChannel: WebChannel.WebChannel<Message, Message>
   sessionInfo: SessionInfo
-}): Effect.Effect<void, ParseResult.ParseError> =>
+}): Effect.Effect<void, Schema.SchemaError> =>
   Effect.gen(function* () {
     yield* webChannel.send(sessionInfo)
 
     yield* webChannel.listen.pipe(
-      Stream.flatten(),
+      Stream.mapEffect(Effect.fromResult),
       Stream.filter(Schema.is(RequestSessions)),
       Stream.tap(() => webChannel.send(sessionInfo)),
       Stream.runDrain,
@@ -59,9 +59,9 @@ export const requestSessionInfoSubscription = ({
   staleTimeout = Duration.seconds(5),
 }: {
   webChannel: WebChannel.WebChannel<Message, Message>
-  pollInterval?: Duration.DurationInput
-  staleTimeout?: Duration.DurationInput
-}): Effect.Effect<Subscribable.Subscribable<HashSet.HashSet<SessionInfo>>, ParseResult.ParseError, Scope.Scope> =>
+  pollInterval?: Duration.Input
+  staleTimeout?: Duration.Input
+}): Effect.Effect<Subscribable.Subscribable<HashSet.HashSet<SessionInfo>>, Schema.SchemaError, Scope.Scope> =>
   Effect.gen(function* () {
     yield* webChannel
       .send(RequestSessions.make({}))
@@ -77,9 +77,8 @@ export const requestSessionInfoSubscription = ({
     const sessionInfoSubRef = yield* SubscriptionRef.make<HashSet.HashSet<SessionInfo>>(HashSet.empty())
 
     yield* webChannel.listen.pipe(
-      Stream.flatten(),
+      Stream.mapEffect(Effect.fromResult),
       Stream.filter(Schema.is(SessionInfo)),
-      Stream.map(Data.struct),
       Stream.tap(
         Effect.fn(function* (sessionInfo) {
           yield* SubscriptionRef.getAndUpdate(sessionInfoSubRef, HashSet.add(sessionInfo))
@@ -100,5 +99,8 @@ export const requestSessionInfoSubscription = ({
       Effect.forkScoped,
     )
 
-    return Subscribable.make({ get: sessionInfoSubRef.get, changes: sessionInfoSubRef.changes })
+    return Subscribable.make({
+      get: SubscriptionRef.get(sessionInfoSubRef),
+      changes: SubscriptionRef.changes(sessionInfoSubRef),
+    })
   })

package/src/devtools/mod.ts

@@ -1,5 +1,4 @@
-import type { Effect, Scope, WebChannel } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
+import { type Effect, type Scope, type WebChannel, Schema } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 import type { MeshNode } from '@livestore/webmesh'
 
@@ -8,18 +7,18 @@ import * as SessionInfo from './devtools-sessioninfo.ts'
 export * from './devtools-messages.ts'
 export * as SessionInfo from './devtools-sessioninfo.ts'
 
-export const DevtoolsMode = Schema.Union(
+export const DevtoolsMode = Schema.Union([
   Schema.TaggedStruct('node', {
     /** WebSocket URL */
     url: Schema.String,
   }),
   Schema.TaggedStruct('web', {}),
   Schema.TaggedStruct('browser-extension', {}),
-)
+])
 
 export type DevtoolsMode = typeof DevtoolsMode.Type
 
-export const DevtoolsModeTag = DevtoolsMode.pipe(Schema.pluck('_tag'), Schema.typeSchema)
+export const DevtoolsModeTag = Schema.Literals(['node', 'web', 'browser-extension'])
 export type DevtoolsModeTag = typeof DevtoolsModeTag.Type
 
 export const makeNodeName = {