@livestore/common 0.4.0-dev.9 → 0.5.0-dev.0

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

@@ -1,116 +1,136 @@
 import { Schema, Transferable } from '@livestore/utils/effect'
 
-import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
 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', {
-  eventEncoded: LiveStoreEvent.AnyEncodedGlobal,
-  metadata: Schema.Option(Schema.JsonValue),
+})
+export const SyncHistoryRes = LSDReqResMessage('LSD.Leader.SyncHistoryRes', {
+  eventEncoded: LiveStoreEvent.Global.Encoded,
+  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', {
-  local: EventSequenceNumber.EventSequenceNumber,
-  upstream: EventSequenceNumber.EventSequenceNumber,
+})
+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('unexpected-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', {
-  eventEncoded: LiveStoreEvent.PartialAnyEncoded,
-}) {}
+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', {}) {}
+export const Ping = LSDReqResMessage('LSD.Leader.Ping', {
+  devtoolsProtocolVersion: Schema.optional(Schema.Finite),
+})
 
-export class Pong extends LSDReqResMessage('LSD.Leader.Pong', {}) {}
+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 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.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: {
@@ -121,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: {},
 })
@@ -133,7 +153,7 @@ export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
 //     liveStoreVersion,
 //   },
 //   success: DatabaseFileInfo,
-//   failure: UnexpectedError,
+//   failure: UnknownError,
 // }) {}
 
 // export class NetworkStatus_ extends Schema.TaggedRequest<NetworkStatus_>()('LSD.Leader.NetworkStatus', {
@@ -142,15 +162,15 @@ export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
 //     liveStoreVersion,
 //   },
 //   success: NetworkStatus,
-//   failure: UnexpectedError,
+//   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,
@@ -167,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,
@@ -180,12 +200,13 @@ export const MessageFromApp = Schema.Union(
   NetworkStatusRes,
   CommitEventRes,
   Pong,
+  VersionMismatch,
   DatabaseFileInfoRes,
   SyncHistoryRes,
   SyncingInfoRes,
   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,
@@ -21,10 +21,16 @@ export const SessionInfo = Schema.TaggedStruct('SessionInfo', {
   sessionId: Schema.String,
   schemaAlias: Schema.String,
   isLeader: Schema.Boolean,
+  /**
+   * Browser origin that produced this SessionInfo (for example, 'http://localhost:5173').
+   * Set by browser-based publishers so DevTools can defensively filter by origin.
+   * Currently only needed by the browser extension; non‑browser publishers typically set `undefined`.
+   */
+  origin: Schema.UndefinedOr(Schema.String),
 })
 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 */
@@ -34,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,
@@ -53,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<Set<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({}))
@@ -71,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))
@@ -95,7 +100,7 @@ export const requestSessionInfoSubscription = ({
     )
 
     return Subscribable.make({
-      get: sessionInfoSubRef.get.pipe(Effect.map((sessionInfos) => new Set(sessionInfos))),
-      changes: sessionInfoSubRef.changes.pipe(Stream.map((sessionInfos) => new Set(sessionInfos))),
+      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 = {
@@ -34,7 +33,15 @@ export const makeNodeName = {
 }
 
 export const makeChannelName = {
-  sessionInfo: () => `session-info`,
+  /**
+   * SessionInfo channel for DevTools discovery.
+   * When an `origin` is provided, it is incorporated into the channel name to scope
+   * broadcasts per origin (e.g. `session-info::http%3A%2F%2Flocalhost%3A5173`).
+   * The `origin` is currently required only for the browser extension path; non‑browser
+   * publishers can pass `undefined` to use the legacy global channel name.
+   */
+  sessionInfo: ({ origin }: { origin: string | undefined }) =>
+    origin !== undefined ? `session-info::${encodeURIComponent(origin)}` : `session-info`,
   devtoolsClientSession: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>
     `devtools-channel(client-session-${storeId}-${clientId}-${sessionId})`,
   devtoolsClientLeader: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>
@@ -52,8 +59,9 @@ export const isChannelName = {
 
 export const makeSessionInfoBroadcastChannel = (
   webmeshNode: MeshNode,
+  options: { origin: string | undefined },
 ): Effect.Effect<WebChannel.WebChannel<SessionInfo.Message, SessionInfo.Message>, never, Scope.Scope> =>
   webmeshNode.makeBroadcastChannel({
-    channelName: makeChannelName.sessionInfo(),
+    channelName: makeChannelName.sessionInfo({ origin: options?.origin }),
     schema: SessionInfo.Message,
   })

package/src/errors.ts

@@ -1,69 +1,89 @@
-import { Cause, Effect, Layer, Schema, Stream } from '@livestore/utils/effect'
+import { Cause, Effect, Layer, Option, Schema, Stream, Struct } from '@livestore/utils/effect'
 
-export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
-  cause: Schema.Defect,
+import * as LiveStoreEvent from './schema/LiveStoreEvent/mod.ts'
+
+export class UnknownError extends Schema.TaggedError<UnknownError>('~@livestore/common/UnknownError')('UnknownError', {
+  cause: Schema.Defect(),
   note: Schema.optional(Schema.String),
   payload: Schema.optional(Schema.Any),
 }) {
-  static mapToUnexpectedError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  static mapToUnknownError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
-      Effect.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
-      Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
+      Effect.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))),
+      Effect.catchDefect((cause) => new UnknownError({ cause })),
     )
 
-  static mapToUnexpectedErrorLayer = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
+  static mapToUnknownErrorLayer = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
     layer.pipe(
-      Layer.catchAllCause((cause) =>
-        Cause.isFailType(cause) && Schema.is(UnexpectedError)(cause.error)
-          ? Layer.fail(cause.error)
-          : Layer.fail(new UnexpectedError({ cause: cause })),
-      ),
+      Layer.catchCause((cause) => {
+        const error = Cause.findErrorOption(cause)
+        return Option.isSome(error) === true && Schema.is(UnknownError)(error.value) === true
+          ? Layer.effectContext<A, UnknownError, never>(Effect.fail(error.value))
+          : Layer.effectContext<A, UnknownError, never>(Effect.fail(new UnknownError({ cause: cause })))
+      }),
     )
 
-  static mapToUnexpectedErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
+  static mapToUnknownErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
     stream.pipe(
-      Stream.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
+      Stream.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))),
     )
 }
 
-export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>()(
-  'LiveStore.MaterializerHashMismatchError',
-  {
-    eventName: Schema.String,
-    note: Schema.optionalWith(Schema.String, {
-      default: () => 'Please make sure your event materializer is a pure function without side effects.',
-    }),
-  },
-) {}
+const materializerHashMismatchNote = 'Please make sure your event materializer is a pure function without side effects.'
 
-export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
-  'LiveStore.IntentionalShutdownCause',
+export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>(
+  '~@livestore/common/MaterializerHashMismatchError',
+)('MaterializerHashMismatchError', {
+  eventName: Schema.String,
+  note: Schema.String.pipe(
+    Schema.withDecodingDefaultType(Effect.succeed(materializerHashMismatchNote)),
+    Schema.withConstructorDefault(Effect.succeed(materializerHashMismatchNote)),
+  ),
+}) {}
+
+export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>(
+  '~@livestore/common/IntentionalShutdownCause',
+)('IntentionalShutdownCause', {
+  reason: Schema.Literals(['devtools-reset', 'devtools-import', 'adapter-reset', 'manual', 'backend-id-mismatch']),
+}) {}
+
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>('~@livestore/common/StoreInterrupted')(
+  'StoreInterrupted',
   {
-    reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual'),
+    reason: Schema.String,
   },
 ) {}
 
-export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {
-  reason: Schema.String,
-}) {}
-
-export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
+export class SqliteError extends Schema.TaggedError<SqliteError>('~@livestore/common/SqliteError')('SqliteError', {
   query: Schema.optional(
     Schema.Struct({
       sql: Schema.String,
-      bindValues: Schema.Union(Schema.Record({ key: Schema.String, value: Schema.Any }), Schema.Array(Schema.Any)),
+      bindValues: Schema.Union([Schema.Record(Schema.String, Schema.Any), Schema.Array(Schema.Any)]),
     }),
   ),
   /** The SQLite result code */
   // code: Schema.optional(Schema.Number),
   // Added string support for Expo SQLite (we should refactor this to have a unified error type)
-  code: Schema.optional(Schema.Union(Schema.Number, Schema.String)),
+  code: Schema.optional(Schema.Union([Schema.Finite, Schema.String])),
   /** The original SQLite3 error */
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
   note: Schema.optional(Schema.String),
 }) {}
 
-export class MaterializeError extends Schema.TaggedError<MaterializeError>()('LiveStore.MaterializeError', {
-  cause: Schema.Union(MaterializerHashMismatchError, SqliteError),
-  note: Schema.optional(Schema.String),
-}) {}
+export class UnknownEventError extends Schema.TaggedError<UnknownEventError>('~@livestore/common/UnknownEventError')(
+  'UnknownEventError',
+  {
+    event: LiveStoreEvent.Client.Encoded.mapFields(Struct.pick(['name', 'args', 'seqNum', 'clientId', 'sessionId'])),
+    reason: Schema.Literals(['event-definition-missing', 'materializer-missing']),
+    operation: Schema.String,
+    note: Schema.optional(Schema.String),
+  },
+) {}
+
+export class MaterializeError extends Schema.TaggedError<MaterializeError>('~@livestore/common/MaterializeError')(
+  'MaterializeError',
+  {
+    cause: Schema.Union([MaterializerHashMismatchError, SqliteError, UnknownEventError]),
+    note: Schema.optional(Schema.String),
+  },
+) {}

package/src/index.ts

@@ -2,15 +2,25 @@ export * from './adapter-types.ts'
 export * from './bounded-collections.ts'
 export * from './debug-info.ts'
 export * as Devtools from './devtools/mod.ts'
+export * from './leader-thread/RejectedPushError.ts'
+export * as LogConfig from './logging.ts'
 export * from './make-client-session.ts'
+export * as MaterializationJournal from './MaterializationJournal.ts'
 export * from './materializer-helper.ts'
 export * from './otel.ts'
 export * from './rematerialize-from-eventlog.ts'
 export * from './schema/state/sqlite/query-builder/mod.ts'
-export * from './schema/state/sqlite/system-tables.ts'
+export * from './schema/state/sqlite/system-tables/mod.ts'
 export * from './schema-management/migrations.ts'
+export {
+  resolveSessionIdSymbolInBindValues,
+  SessionIdSymbol,
+  type BindableWithSessionIdSymbol,
+} from './session-id-symbol.ts'
 export * as SqliteDbHelper from './sqlite-db-helper.ts'
+export * as StateHead from './StateHead.ts'
 export * from './sync/index.ts'
 export * as SyncState from './sync/syncstate.ts'
 export * from './util.ts'
 export * from './version.ts'
+export * from './WorkerTransportError.ts'