@livestore/common 0.4.0-dev.18 → 0.4.0-dev.19

package/src/sync/ClientSessionSyncProcessor.ts

@@ -15,10 +15,10 @@ import {
 } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
-import { type ClientSession, UnexpectedError } from '../adapter-types.ts'
+import { type ClientSession, UnknownError } from '../adapter-types.ts'
 import type { MaterializeError } from '../errors.ts'
-import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
-import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber/mod.ts'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import * as SyncState from './syncstate.ts'
 
@@ -52,7 +52,7 @@ export const makeClientSessionSyncProcessor = ({
   clientSession: ClientSession
   runtime: Runtime.Runtime<Scope.Scope>
   materializeEvent: (
-    eventEncoded: LiveStoreEvent.EncodedWithMeta,
+    eventEncoded: LiveStoreEvent.Client.EncodedWithMeta,
     options: { withChangeset: boolean; materializerHashLeader: Option.Option<number> },
   ) => Effect.Effect<
     {
@@ -78,7 +78,7 @@ export const makeClientSessionSyncProcessor = ({
    */
   confirmUnsavedChanges: boolean
 }): ClientSessionSyncProcessor => {
-  const eventSchema = LiveStoreEvent.makeEventDefSchemaMemo(schema)
+  const eventSchema = LiveStoreEvent.Client.makeSchemaMemo(schema)
 
   const simSleep = <TKey extends keyof ClientSessionSyncProcessorSimulationParams>(
     key: TKey,
@@ -97,11 +97,11 @@ export const makeClientSessionSyncProcessor = ({
 
   /** Only used for debugging / observability / testing, it's not relied upon for correctness of the sync processor. */
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
-  const isClientEvent = (eventEncoded: LiveStoreEvent.EncodedWithMeta) =>
+  const isClientEvent = (eventEncoded: LiveStoreEvent.Client.EncodedWithMeta) =>
     schema.eventsDefsMap.get(eventEncoded.name)?.options.clientOnly ?? false
 
   /** We're queuing push requests to reduce the number of messages sent to the leader by batching them */
-  const leaderPushQueue = BucketQueue.make<LiveStoreEvent.EncodedWithMeta>().pipe(Effect.runSync)
+  const leaderPushQueue = BucketQueue.make<LiveStoreEvent.Client.EncodedWithMeta>().pipe(Effect.runSync)
 
   const push: ClientSessionSyncProcessor['push'] = Effect.fn('client-session-sync-processor:push')(function* (batch) {
     // TODO validate batch
@@ -112,13 +112,13 @@ export const makeClientSessionSyncProcessor = ({
       if (eventDef === undefined) {
         return shouldNeverHappen(`No event definition found for \`${name}\`.`)
       }
-      const nextNumPair = EventSequenceNumber.nextPair({
+      const nextNumPair = EventSequenceNumber.Client.nextPair({
         seqNum: baseEventSequenceNumber,
         isClient: eventDef.options.clientOnly,
         rebaseGeneration: baseEventSequenceNumber.rebaseGeneration,
       })
       baseEventSequenceNumber = nextNumPair.seqNum
-      return new LiveStoreEvent.EncodedWithMeta(
+      return new LiveStoreEvent.Client.EncodedWithMeta(
         Schema.encodeUnknownSync(eventSchema)({
           name,
           args,
@@ -133,7 +133,7 @@ export const makeClientSessionSyncProcessor = ({
       syncState: syncStateRef.current,
       payload: { _tag: 'local-push', newEvents: encodedEventDefs },
       isClientEvent,
-      isEqualEvent: LiveStoreEvent.isEqualEncoded,
+      isEqualEvent: LiveStoreEvent.Client.isEqualEncoded,
     })
 
     yield* Effect.annotateCurrentSpan({
@@ -146,8 +146,8 @@ export const makeClientSessionSyncProcessor = ({
       ...(TRACE_VERBOSE && { mergeResult: JSON.stringify(mergeResult) }),
     })
 
-    if (mergeResult._tag === 'unexpected-error') {
-      return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.message)
+    if (mergeResult._tag === 'unknown-error') {
+      return shouldNeverHappen('Unknown error in client-session-sync-processor', mergeResult.message)
     }
 
     if (mergeResult._tag !== 'advance') {
@@ -233,11 +233,11 @@ export const makeClientSessionSyncProcessor = ({
             syncState: syncStateRef.current,
             payload,
             isClientEvent,
-            isEqualEvent: LiveStoreEvent.isEqualEncoded,
+            isEqualEvent: LiveStoreEvent.Client.isEqualEncoded,
           })
 
-          if (mergeResult._tag === 'unexpected-error') {
-            return yield* new UnexpectedError({ cause: mergeResult.message })
+          if (mergeResult._tag === 'unknown-error') {
+            return yield* new UnknownError({ cause: mergeResult.message })
           } else if (mergeResult._tag === 'reject') {
             return shouldNeverHappen('Unexpected reject in client-session-sync-processor', mergeResult)
           }
@@ -373,9 +373,9 @@ export const makeClientSessionSyncProcessor = ({
 
 export interface ClientSessionSyncProcessor {
   push: (
-    batch: ReadonlyArray<LiveStoreEvent.PartialAnyDecoded>,
+    batch: ReadonlyArray<LiveStoreEvent.Input.Decoded>,
   ) => Effect.Effect<{ writeTables: Set<string> }, MaterializeError>
-  boot: Effect.Effect<void, UnexpectedError, Scope.Scope>
+  boot: Effect.Effect<void, UnknownError, Scope.Scope>
   /**
    * Only used for debugging / observability.
    */

package/src/sync/errors.ts

@@ -1,5 +1,5 @@
 import { Schema } from '@livestore/utils/effect'
-import { UnexpectedError } from '../errors.ts'
+import { UnknownError } from '../errors.ts'
 import { EventSequenceNumber } from '../schema/mod.ts'
 
 export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {
@@ -15,12 +15,12 @@ export class BackendIdMismatchError extends Schema.TaggedError<BackendIdMismatch
 }) {}
 
 export class ServerAheadError extends Schema.TaggedError<ServerAheadError>()('ServerAheadError', {
-  minimumExpectedNum: EventSequenceNumber.GlobalEventSequenceNumber,
-  providedNum: EventSequenceNumber.GlobalEventSequenceNumber,
+  minimumExpectedNum: EventSequenceNumber.Global.Schema,
+  providedNum: EventSequenceNumber.Global.Schema,
 }) {}
 
 export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
-  cause: Schema.Union(UnexpectedError, ServerAheadError, BackendIdMismatchError),
+  cause: Schema.Union(UnknownError, ServerAheadError, BackendIdMismatchError),
 }) {}
 
 export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
@@ -28,8 +28,8 @@ export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('In
 }) {}
 
 export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
-  minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
-  providedNum: EventSequenceNumber.EventSequenceNumber,
+  minimumExpectedNum: EventSequenceNumber.Client.Composite,
+  providedNum: EventSequenceNumber.Client.Composite,
   /** Generation number the client session should use for subsequent pushes */
   // nextGeneration: Schema.Number,
 }) {}

package/src/sync/mock-sync-backend.ts

@@ -1,21 +1,21 @@
 import type { Schema, Scope } from '@livestore/utils/effect'
 import { Effect, Mailbox, Option, Queue, Stream, SubscriptionRef } from '@livestore/utils/effect'
-import { UnexpectedError } from '../errors.ts'
+import { UnknownError } from '../errors.ts'
 import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
 import { InvalidPushError } from './errors.ts'
 import * as SyncBackend from './sync-backend.ts'
 import { validatePushPayload } from './validate-push-payload.ts'
 
 export interface MockSyncBackend {
-  pushedEvents: Stream.Stream<LiveStoreEvent.AnyEncodedGlobal>
+  pushedEvents: Stream.Stream<LiveStoreEvent.Global.Encoded>
   connect: Effect.Effect<void>
   disconnect: Effect.Effect<void>
-  makeSyncBackend: Effect.Effect<SyncBackend.SyncBackend, UnexpectedError, Scope.Scope>
-  advance: (...batch: LiveStoreEvent.AnyEncodedGlobal[]) => Effect.Effect<void>
+  makeSyncBackend: Effect.Effect<SyncBackend.SyncBackend, UnknownError, Scope.Scope>
+  advance: (...batch: LiveStoreEvent.Global.Encoded[]) => Effect.Effect<void>
   /** Fail the next N push calls with an InvalidPushError (or custom error) */
   failNextPushes: (
     count: number,
-    error?: (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>,
+    error?: (batch: ReadonlyArray<LiveStoreEvent.Global.Encoded>) => Effect.Effect<never, InvalidPushError>,
   ) => Effect.Effect<void>
 }
 
@@ -29,13 +29,13 @@ export interface MockSyncBackendOptions {
 
 export const makeMockSyncBackend = (
   options?: MockSyncBackendOptions,
-): Effect.Effect<MockSyncBackend, UnexpectedError, Scope.Scope> =>
+): Effect.Effect<MockSyncBackend, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
-    const syncEventSequenceNumberRef = { current: EventSequenceNumber.ROOT.global }
-    const syncPullQueue = yield* Queue.unbounded<LiveStoreEvent.AnyEncodedGlobal>()
-    const pushedEventsQueue = yield* Mailbox.make<LiveStoreEvent.AnyEncodedGlobal>()
+    const syncEventSequenceNumberRef = { current: EventSequenceNumber.Client.ROOT.global }
+    const syncPullQueue = yield* Queue.unbounded<LiveStoreEvent.Global.Encoded>()
+    const pushedEventsQueue = yield* Mailbox.make<LiveStoreEvent.Global.Encoded>()
     const syncIsConnectedRef = yield* SubscriptionRef.make(options?.startConnected ?? false)
-    const allEventsRef: { current: LiveStoreEvent.AnyEncodedGlobal[] } = { current: [] }
+    const allEventsRef: { current: LiveStoreEvent.Global.Encoded[] } = { current: [] }
 
     const span = yield* Effect.currentSpan.pipe(Effect.orDie)
 
@@ -44,7 +44,7 @@ export const makeMockSyncBackend = (
     // TODO improve the API and implementation of simulating errors
     const failCounterRef = yield* SubscriptionRef.make(0)
     const failEffectRef = yield* SubscriptionRef.make<
-      ((batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>) | undefined
+      ((batch: ReadonlyArray<LiveStoreEvent.Global.Encoded>) => Effect.Effect<never, InvalidPushError>) | undefined
     >(undefined)
 
     const makeSyncBackend = Effect.gen(function* () {
@@ -73,14 +73,14 @@ export const makeMockSyncBackend = (
                 Effect.sync(() => {
                   const lastSeen = cursor.pipe(
                     Option.match({
-                      onNone: () => EventSequenceNumber.ROOT.global,
+                      onNone: () => EventSequenceNumber.Client.ROOT.global,
                       onSome: (_) => _.eventSequenceNumber,
                     }),
                   )
                   // All events with seqNum greater than lastSeen
                   const slice = allEventsRef.current.filter((e) => e.seqNum > lastSeen)
                   // Split into configured chunk size
-                  const chunks: { events: LiveStoreEvent.AnyEncodedGlobal[]; remaining: number }[] = []
+                  const chunks: { events: LiveStoreEvent.Global.Encoded[]; remaining: number }[] = []
                   for (let i = 0; i < slice.length; i += nonLiveChunkSize) {
                     const end = Math.min(i + nonLiveChunkSize, slice.length)
                     const remaining = Math.max(slice.length - end, 0)
@@ -115,7 +115,7 @@ export const makeMockSyncBackend = (
                 return yield* maybeFail(batch)
               }
               return yield* new InvalidPushError({
-                cause: new UnexpectedError({ cause: new Error('MockSyncBackend: simulated push failure') }),
+                cause: new UnknownError({ cause: new Error('MockSyncBackend: simulated push failure') }),
               })
             }
 
@@ -146,7 +146,7 @@ export const makeMockSyncBackend = (
       })
     })
 
-    const advance = (...batch: LiveStoreEvent.AnyEncodedGlobal[]) =>
+    const advance = (...batch: LiveStoreEvent.Global.Encoded[]) =>
       Effect.gen(function* () {
         syncEventSequenceNumberRef.current = batch.at(-1)!.seqNum
         allEventsRef.current = allEventsRef.current.concat(batch)
@@ -164,7 +164,7 @@ export const makeMockSyncBackend = (
 
     const failNextPushes = (
       count: number,
-      error?: (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>,
+      error?: (batch: ReadonlyArray<LiveStoreEvent.Global.Encoded>) => Effect.Effect<never, InvalidPushError>,
     ) =>
       Effect.gen(function* () {
         yield* SubscriptionRef.set(failCounterRef, count)

package/src/sync/next/compact-events.ts

@@ -206,14 +206,14 @@ const dagReplacesDag = (dagA: HistoryDag, dagB: HistoryDag): boolean => {
 const removeEvent = (dag: HistoryDag, eventNumStr: string) => {
   // console.debug('removing event', eventNumStr)
   const event = dag.getNodeAttributes(eventNumStr)
-  const parentSeqNumStr = EventSequenceNumber.toString(event.parentSeqNum)
+  const parentSeqNumStr = EventSequenceNumber.Client.toString(event.parentSeqNum)
   const childEdges = dag.outboundEdgeEntries(eventNumStr)
 
   for (const childEdge of childEdges) {
     if (childEdge.attributes.type === 'parent') {
       const childEvent = dag.getNodeAttributes(childEdge.target)
       childEvent.parentSeqNum = { ...event.parentSeqNum }
-      dag.addEdge(parentSeqNumStr, EventSequenceNumber.toString(childEvent.seqNum), { type: 'parent' })
+      dag.addEdge(parentSeqNumStr, EventSequenceNumber.Client.toString(childEvent.seqNum), { type: 'parent' })
     }
   }
 

package/src/sync/next/facts.ts

@@ -5,13 +5,13 @@ import type {
   EventDefFactsGroup,
   EventDefFactsSnapshot,
   FactsCallback,
-} from '../../schema/EventDef.ts'
-import type * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+} from '../../schema/EventDef/mod.ts'
+import type * as EventSequenceNumber from '../../schema/EventSequenceNumber/mod.ts'
 import { EMPTY_FACT_VALUE, type HistoryDag, type HistoryDagNode } from './history-dag-common.ts'
 
 export const factsSnapshotForEvents = (
   events: HistoryDagNode[],
-  endEventSequenceNumber: EventSequenceNumber.EventSequenceNumber,
+  endEventSequenceNumber: EventSequenceNumber.Client.Composite,
 ): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
@@ -28,7 +28,7 @@ export const factsSnapshotForEvents = (
 
 export const factsSnapshotForDag = (
   dag: HistoryDag,
-  endEventSequenceNumber: EventSequenceNumber.EventSequenceNumber | undefined,
+  endEventSequenceNumber: EventSequenceNumber.Client.Composite | undefined,
 ): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
@@ -225,8 +225,8 @@ export const getFactsGroupForEventArgs = ({
 }
 
 export const compareEventSequenceNumbers = (
-  a: EventSequenceNumber.EventSequenceNumber,
-  b: EventSequenceNumber.EventSequenceNumber,
+  a: EventSequenceNumber.Client.Composite,
+  b: EventSequenceNumber.Client.Composite,
 ) => {
   if (a.global !== b.global) {
     return a.global - b.global

package/src/sync/next/history-dag-common.ts

@@ -1,14 +1,14 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import { Graph } from '@livestore/utils/effect'
-import type { EventDefFactsGroup } from '../../schema/EventDef.ts'
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+import type { EventDefFactsGroup } from '../../schema/EventDef/mod.ts'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber/mod.ts'
 
 export const connectionTypeOptions = ['parent', 'facts'] as const
 export type ConnectionType = (typeof connectionTypeOptions)[number]
 
 export type HistoryDagNode = {
-  seqNum: EventSequenceNumber.EventSequenceNumber
-  parentSeqNum: EventSequenceNumber.EventSequenceNumber
+  seqNum: EventSequenceNumber.Client.Composite
+  parentSeqNum: EventSequenceNumber.Client.Composite
   name: string
   args: any
   /** Facts are being used for conflict detection and history compaction */
@@ -283,13 +283,13 @@ export class HistoryDag {
 export const emptyHistoryDag = (): HistoryDag => HistoryDag.create({ allowSelfLoops: false })
 
 // TODO consider making `ROOT_ID` parent to itself
-export const rootParentNum = EventSequenceNumber.make({
-  global: EventSequenceNumber.ROOT.global - 1,
-  client: EventSequenceNumber.clientDefault,
+export const rootParentNum = EventSequenceNumber.Client.Composite.make({
+  global: EventSequenceNumber.Client.ROOT.global - 1,
+  client: EventSequenceNumber.Client.DEFAULT,
 })
 
 export const rootEventNode: HistoryDagNode = {
-  seqNum: EventSequenceNumber.ROOT,
+  seqNum: EventSequenceNumber.Client.ROOT,
   parentSeqNum: rootParentNum,
   // unused below
   name: '__Root__',

package/src/sync/next/history-dag.ts

@@ -1,4 +1,4 @@
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber/mod.ts'
 import { factsToString, validateFacts } from './facts.ts'
 import { emptyHistoryDag, type HistoryDagNode, rootParentNum } from './history-dag-common.ts'
 
@@ -19,14 +19,18 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
   const dag = emptyHistoryDag()
 
   dagNodes.forEach((node) => {
-    dag.addNode(EventSequenceNumber.toString(node.seqNum), node)
+    dag.addNode(EventSequenceNumber.Client.toString(node.seqNum), node)
   })
 
   dagNodes.forEach((node) => {
-    if (EventSequenceNumber.toString(node.parentSeqNum) !== EventSequenceNumber.toString(rootParentNum)) {
-      dag.addEdge(EventSequenceNumber.toString(node.parentSeqNum), EventSequenceNumber.toString(node.seqNum), {
-        type: 'parent',
-      })
+    if (EventSequenceNumber.Client.toString(node.parentSeqNum) !== EventSequenceNumber.Client.toString(rootParentNum)) {
+      dag.addEdge(
+        EventSequenceNumber.Client.toString(node.parentSeqNum),
+        EventSequenceNumber.Client.toString(node.seqNum),
+        {
+          type: 'parent',
+        },
+      )
     }
   })
 
@@ -35,9 +39,9 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
     for (const factKey of factKeys) {
       // Find the first ancestor node with a matching fact key (via modifySet or modifyUnset) by traversing the graph backwards via the parent edges
       const depNode = (() => {
-        let currentSeqNumStr = EventSequenceNumber.toString(node.seqNum)
+        let currentSeqNumStr = EventSequenceNumber.Client.toString(node.seqNum)
 
-        while (currentSeqNumStr !== EventSequenceNumber.toString(rootParentNum)) {
+        while (currentSeqNumStr !== EventSequenceNumber.Client.toString(rootParentNum)) {
           const parentEdge = dag.inEdges(currentSeqNumStr).find((e) => dag.getEdgeAttribute(e, 'type') === 'parent')
           if (!parentEdge) return null
 
@@ -55,8 +59,8 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
       })()
 
       if (depNode) {
-        const depNodeIdStr = EventSequenceNumber.toString(depNode.seqNum)
-        const nodeIdStr = EventSequenceNumber.toString(node.seqNum)
+        const depNodeIdStr = EventSequenceNumber.Client.toString(depNode.seqNum)
+        const nodeIdStr = EventSequenceNumber.Client.toString(node.seqNum)
         if (dag.edges(depNodeIdStr, nodeIdStr).filter((e) => dag.getEdgeAttributes(e).type === 'facts').length === 0) {
           dag.addEdge(depNodeIdStr, nodeIdStr, { type: 'facts' })
         }

package/src/sync/next/rebase-events.ts

@@ -1,6 +1,6 @@
-import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.ts'
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
-import type * as LiveStoreEvent from '../../schema/LiveStoreEvent.ts'
+import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef/mod.ts'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber/mod.ts'
+import type * as LiveStoreEvent from '../../schema/LiveStoreEvent/mod.ts'
 import {
   applyFactGroups,
   type FactValidationResult,
@@ -19,13 +19,13 @@ export type RebaseInput = {
   newRemoteEvents: RebaseEventWithConflict[]
   pendingLocalEvents: RebaseEventWithConflict[]
   validate: (args: {
-    rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
+    rebasedLocalEvents: LiveStoreEvent.Input.Decoded[]
     eventDefs: Record<string, EventDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
+  rebasedLocalEvents: LiveStoreEvent.Input.Decoded[]
 }
 
 export type RebaseFn = (input: RebaseInput) => RebaseOutput
@@ -53,7 +53,7 @@ export const rebaseEvents = ({
   currentFactsSnapshot: EventDefFactsSnapshot
   clientId: string
   sessionId: string
-}): ReadonlyArray<LiveStoreEvent.AnyDecoded> => {
+}): ReadonlyArray<LiveStoreEvent.Client.Decoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -94,18 +94,18 @@ export const rebaseEvents = ({
   return rebasedLocalEvents.map(
     (event, index) =>
       ({
-        seqNum: EventSequenceNumber.make({
+        seqNum: EventSequenceNumber.Client.Composite.make({
           global: headGlobalId + index + 1,
-          client: EventSequenceNumber.clientDefault,
+          client: EventSequenceNumber.Client.DEFAULT,
         }),
-        parentSeqNum: EventSequenceNumber.make({
+        parentSeqNum: EventSequenceNumber.Client.Composite.make({
           global: headGlobalId + index,
-          client: EventSequenceNumber.clientDefault,
+          client: EventSequenceNumber.Client.DEFAULT,
         }),
         name: event.name,
         args: event.args,
         clientId,
         sessionId,
-      }) satisfies LiveStoreEvent.AnyDecoded,
+      }) satisfies LiveStoreEvent.Client.Decoded,
   )
 }

package/src/sync/next/test/event-fixtures.ts

@@ -1,16 +1,16 @@
 import { Schema } from '@livestore/utils/effect'
 
-import type { EventDef } from '../../../schema/EventDef.ts'
-import { defineEvent, defineFacts } from '../../../schema/EventDef.ts'
-import * as EventSequenceNumber from '../../../schema/EventSequenceNumber.ts'
+import type { EventDef } from '../../../schema/EventDef/mod.ts'
+import { defineEvent, defineFacts } from '../../../schema/EventDef/mod.ts'
+import * as EventSequenceNumber from '../../../schema/EventSequenceNumber/mod.ts'
 import { factsSnapshotForDag, getFactsGroupForEventArgs } from '../facts.ts'
 import { historyDagFromNodes } from '../history-dag.ts'
 import type { HistoryDagNode } from '../history-dag-common.ts'
 import { rootEventNode } from '../history-dag-common.ts'
 
 export const printEvent = ({ seqNum, parentSeqNum, factsGroup, ...rest }: HistoryDagNode) => ({
-  seqNum: EventSequenceNumber.toString(seqNum),
-  parentSeqNum: EventSequenceNumber.toString(parentSeqNum),
+  seqNum: EventSequenceNumber.Client.toString(seqNum),
+  parentSeqNum: EventSequenceNumber.Client.toString(parentSeqNum),
   ...rest,
   facts: factsGroup,
 })
@@ -140,11 +140,11 @@ export const toEventNodes = (
 ): HistoryDagNode[] => {
   const nodesAcc: HistoryDagNode[] = [rootEventNode]
 
-  let currentEventSequenceNumber: EventSequenceNumber.EventSequenceNumber = EventSequenceNumber.ROOT
+  let currentEventSequenceNumber: EventSequenceNumber.Client.Composite = EventSequenceNumber.Client.ROOT
 
   const eventNodes = partialEvents.map((partialEvent) => {
     const eventDef = eventDefs[partialEvent.name]!
-    const eventNum = EventSequenceNumber.nextPair({
+    const eventNum = EventSequenceNumber.Client.nextPair({
       seqNum: currentEventSequenceNumber,
       isClient: eventDef.options.clientOnly,
     }).seqNum
@@ -219,18 +219,18 @@ export const toEventNodes = (
   return eventNodes
 }
 
-const getParentNum = (eventNum: EventSequenceNumber.EventSequenceNumber): EventSequenceNumber.EventSequenceNumber => {
+const getParentNum = (eventNum: EventSequenceNumber.Client.Composite): EventSequenceNumber.Client.Composite => {
   const globalParentNum = eventNum.global
   const clientParentNum = eventNum.client - 1
 
   if (clientParentNum < 0) {
-    return EventSequenceNumber.make({
+    return EventSequenceNumber.Client.Composite.make({
       global: globalParentNum - 1,
-      client: EventSequenceNumber.clientDefault,
+      client: EventSequenceNumber.Client.DEFAULT,
     })
   }
 
-  return EventSequenceNumber.make({
+  return EventSequenceNumber.Client.Composite.make({
     global: globalParentNum,
     client: clientParentNum,
   })

package/src/sync/sync-backend-kv.ts

@@ -1,11 +1,11 @@
 import { Effect, KeyValueStore, Option } from '@livestore/utils/effect'
-import { UnexpectedError } from '../errors.ts'
+import { UnknownError } from '../errors.ts'
 
 export const makeBackendIdHelper = Effect.gen(function* () {
   const kv = yield* KeyValueStore.KeyValueStore
 
   const backendIdKey = `backendId`
-  const backendIdRef = { current: yield* kv.get(backendIdKey).pipe(UnexpectedError.mapToUnexpectedError) }
+  const backendIdRef = { current: yield* kv.get(backendIdKey).pipe(UnknownError.mapToUnknownError) }
 
   const setBackendId = (backendId: string) =>
     Effect.gen(function* () {
@@ -13,7 +13,7 @@ export const makeBackendIdHelper = Effect.gen(function* () {
         backendIdRef.current = Option.some(backendId)
         yield* kv.set(backendIdKey, backendId)
       }
-    }).pipe(UnexpectedError.mapToUnexpectedError)
+    }).pipe(UnknownError.mapToUnknownError)
 
   return {
     lazySet: setBackendId,

package/src/sync/sync-backend.ts

@@ -9,8 +9,8 @@ import {
   type Stream,
   type SubscriptionRef,
 } from '@livestore/utils/effect'
-import type { UnexpectedError } from '../adapter-types.ts'
-import type * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import type { UnknownError } from '../adapter-types.ts'
+import type * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
 import type { EventSequenceNumber } from '../schema/mod.ts'
 import type { InvalidPullError, InvalidPushError, IsOfflineError } from './errors.ts'
 
@@ -30,7 +30,7 @@ export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue, TPayload =
   args: MakeBackendArgs<TPayload>,
 ) => Effect.Effect<
   SyncBackend<TSyncMetadata>,
-  UnexpectedError,
+  UnknownError,
   Scope.Scope | HttpClient.HttpClient | KeyValueStore.KeyValueStore
 >
 
@@ -45,10 +45,10 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
   /**
    * Can be implemented to prepare a connection to the sync backend to speed up the first pull/push.
    */
-  connect: Effect.Effect<void, IsOfflineError | UnexpectedError, Scope.Scope>
+  connect: Effect.Effect<void, IsOfflineError | UnknownError, Scope.Scope>
   pull: (
     cursor: Option.Option<{
-      eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber
+      eventSequenceNumber: EventSequenceNumber.Global.Type
       /** Metadata is needed by some sync backends */
       metadata: Option.Option<TSyncMetadata>
     }>,
@@ -68,9 +68,9 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
      * - Number of events: 1-100
      * - sequence numbers must be in ascending order
      * */
-    batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
+    batch: ReadonlyArray<LiveStoreEvent.Global.Encoded>,
   ) => Effect.Effect<void, IsOfflineError | InvalidPushError>
-  ping: Effect.Effect<void, IsOfflineError | UnexpectedError | Cause.TimeoutException>
+  ping: Effect.Effect<void, IsOfflineError | UnknownError | Cause.TimeoutException>
   // TODO also expose latency information additionally to whether the backend is connected
   isConnected: SubscriptionRef.SubscriptionRef<boolean>
   /**
@@ -160,7 +160,7 @@ export const pullResItemEmpty = <TSyncMetadata = Schema.JsonValue>(): PullResIte
 
 export interface PullResItem<TSyncMetadata = Schema.JsonValue> {
   batch: ReadonlyArray<{
-    eventEncoded: LiveStoreEvent.AnyEncodedGlobal
+    eventEncoded: LiveStoreEvent.Global.Encoded
     metadata: Option.Option<TSyncMetadata>
   }>
   pageInfo: PullResPageInfo
@@ -174,7 +174,7 @@ export const of = <TSyncMetadata = Schema.JsonValue>(obj: SyncBackend<TSyncMetad
 export const cursorFromPullResItem = <TSyncMetadata = Schema.JsonValue>(
   item: PullResItem<TSyncMetadata>,
 ): Option.Option<{
-  eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber
+  eventSequenceNumber: EventSequenceNumber.Global.Type
   metadata: Option.Option<TSyncMetadata>
 }> => {
   const lastEvent = item.batch.at(-1)