@livestore/common 0.4.0-dev.22 → 0.4.0-dev.23

package/src/leader-thread/stream-events.ts

@@ -1,5 +1,6 @@
 import type { Subscribable } from '@livestore/utils/effect'
 import { Chunk, Effect, Option, Queue, Stream } from '@livestore/utils/effect'
+
 import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
 import type * as SyncState from '../sync/syncstate.ts'
 import * as Eventlog from './eventlog.ts'
@@ -109,7 +110,10 @@ export const streamEventsWithSyncState = ({
              * since === until : Prevent empty query
              * since > until : Incorrectly inverted interval
              */
-            if (options.until && EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, options.until)) {
+            if (
+              options.until !== undefined &&
+              EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, options.until) === true
+            ) {
               return [Chunk.empty(), Option.none()]
             }
 
@@ -144,9 +148,10 @@ export const streamEventsWithSyncState = ({
              * nextHead: The latest head from headQueue
              */
             const waitForHead = EventSequenceNumber.Client.isGreaterThanOrEqual(cursor, head)
-            const maybeHead = waitForHead
-              ? yield* Queue.take(headQueue).pipe(Effect.map(Option.some))
-              : yield* Queue.poll(headQueue)
+            const maybeHead =
+              waitForHead === true
+                ? yield* Queue.take(headQueue).pipe(Effect.map(Option.some))
+                : yield* Queue.poll(headQueue)
             const nextHead = Option.getOrElse(maybeHead, () => head)
             const hardStop = options.until?.global ?? Number.POSITIVE_INFINITY
             const target = EventSequenceNumber.Client.Composite.make({
@@ -181,7 +186,7 @@ export const streamEventsWithSyncState = ({
             const nextState: Option.Option<{
               cursor: EventSequenceNumber.Client.Composite
               head: EventSequenceNumber.Client.Composite
-            }> = reachedUntil ? Option.none() : Option.some({ cursor: target, head: nextHead })
+            }> = reachedUntil === true ? Option.none() : Option.some({ cursor: target, head: nextHead })
 
             const spanAttributes = {
               'livestore.streamEvents.cursor.global': cursor.global,

package/src/leader-thread/types.ts

@@ -17,13 +17,14 @@ import type { MaterializeError } from '../errors.ts'
 import type {
   BootStatus,
   Devtools,
-  LeaderAheadError,
   MakeSqliteDb,
   PersistenceInfo,
   SqliteDb,
   SyncBackend,
   UnknownError,
+  UnknownEventError,
 } from '../index.ts'
+import type { RejectedPushError } from './RejectedPushError.ts'
 import { EventSequenceNumber, type LiveStoreEvent, type LiveStoreSchema } from '../schema/mod.ts'
 import type * as SyncState from '../sync/syncstate.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
@@ -186,11 +187,11 @@ export interface LeaderSyncProcessor {
   /** Used by client sessions to subscribe to upstream sync state changes */
   pull: (args: {
     cursor: EventSequenceNumber.Client.Composite
-  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type }, UnknownError>
+  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type }>
   /** The `pullQueue` API can be used instead of `pull` when more convenient */
   pullQueue: (args: {
     cursor: EventSequenceNumber.Client.Composite
-  }) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, UnknownError, Scope.Scope>
+  }) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, never, Scope.Scope>
 
   /** Used by client sessions to push events to the leader thread */
   push: (
@@ -204,18 +205,18 @@ export interface LeaderSyncProcessor {
        */
       waitForProcessing?: boolean
     },
-  ) => Effect.Effect<void, LeaderAheadError>
+  ) => Effect.Effect<void, RejectedPushError>
 
   /** Currently only used by devtools which don't provide their own event numbers */
   pushPartial: (args: {
     event: LiveStoreEvent.Input.Encoded
     clientId: string
     sessionId: string
-  }) => Effect.Effect<void, UnknownError>
+  }) => Effect.Effect<void, UnknownEventError>
 
   boot: Effect.Effect<
     { initialLeaderHead: EventSequenceNumber.Client.Composite },
-    UnknownError,
+    never,
     LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
   >
   syncState: Subscribable.Subscribable<SyncState.SyncState>

package/src/logging.ts

@@ -33,11 +33,11 @@ export type LoggerDefaults = {
  * Resolve the logger layer to provide to the Effect runtime.
  */
 export const resolveLoggerLayer = (config?: WithLoggerOptions, defaults?: LoggerDefaults): Layer.Layer<never> => {
-  if (config?.logger) return config.logger
-  if (defaults?.defaultLogger) return defaults.defaultLogger
+  if (config?.logger !== undefined) return config.logger
+  if (defaults?.defaultLogger !== undefined) return defaults.defaultLogger
   const threadName = defaults?.threadName ?? 'livestore'
   const mode = defaults?.mode
-  return Logger.prettyWithThread(threadName, mode ? { mode } : {})
+  return Logger.prettyWithThread(threadName, mode !== undefined ? { mode } : {})
 }
 
 /**
@@ -46,7 +46,7 @@ export const resolveLoggerLayer = (config?: WithLoggerOptions, defaults?: Logger
 export const resolveLogLevel = (config?: WithLoggerOptions, defaults?: LoggerDefaults): LogLevel.LogLevel => {
   if (config?.logLevel !== undefined) return config.logLevel
   if (defaults?.defaultLogLevel !== undefined) return defaults.defaultLogLevel
-  return isDevEnv() ? LogLevel.Debug : LogLevel.Info
+  return isDevEnv() === true ? LogLevel.Debug : LogLevel.Info
 }
 
 /**

package/src/make-client-session.ts

@@ -51,11 +51,11 @@ export const makeClientSession = <R>({
   origin: string | undefined
 }): Effect.Effect<ClientSession, never, Scope.Scope | R> =>
   Effect.gen(function* () {
-    const devtools: ClientSession['devtools'] = devtoolsEnabled
+    const devtools: ClientSession['devtools'] = devtoolsEnabled === true
       ? { enabled: true, pullLatch: yield* Effect.makeLatch(true), pushLatch: yield* Effect.makeLatch(true) }
       : { enabled: false }
 
-    if (devtoolsEnabled) {
+    if (devtoolsEnabled === true) {
       yield* Effect.gen(function* () {
         const webmeshNode = yield* Webmesh.makeMeshNode(
           Devtools.makeNodeName.client.session({ storeId, clientId, sessionId }),

package/src/materializer-helper.ts

@@ -34,14 +34,14 @@ export const getExecStatementsFromMaterializer = ({
   const eventDecoded =
     event.decoded === undefined
       ? {
-          ...event.encoded!,
-          args: Schema.decodeUnknownSync(eventDef.schema)(event.encoded!.args),
+          ...event.encoded,
+          args: Schema.decodeUnknownSync(eventDef.schema)(event.encoded.args),
         }
       : event.decoded
 
-  const eventArgsEncoded = isNil(event.decoded?.args)
+  const eventArgsEncoded = isNil(event.decoded?.args) === true
     ? undefined
-    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded!.args)
+    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded.args)
 
   const query: MaterializerContextQuery = (
     rawQueryOrQueryBuilder:
@@ -51,7 +51,7 @@ export const getExecStatementsFromMaterializer = ({
         }
       | QueryBuilder.Any,
   ) => {
-    if (isQueryBuilder(rawQueryOrQueryBuilder)) {
+    if (isQueryBuilder(rawQueryOrQueryBuilder) === true) {
       const { query, bindValues } = rawQueryOrQueryBuilder.asSql()
       const rawResults = dbState.select(query, prepareBindValues(bindValues, query))
       const resultSchema = getResultSchema(rawQueryOrQueryBuilder)
@@ -86,7 +86,7 @@ export const getExecStatementsFromMaterializer = ({
 export const makeMaterializerHash =
   ({ schema, dbState }: { schema: LiveStoreSchema; dbState: SqliteDb }) =>
   (event: LiveStoreEvent.Client.Encoded): Option.Option<number> => {
-    if (isDevEnv()) {
+    if (isDevEnv() === true) {
       // Hashing is only needed during dev-mode diagnostics. Skip work entirely for
       // unknown events (no definition/materializer) so we do not introduce noisy
       // warnings while still returning `Option.none()` to disable hash checks.
@@ -126,10 +126,10 @@ const fromMaterializerResult = (
   bindValues: BindValues
   writeTables: ReadonlySet<string> | undefined
 }> => {
-  if (isReadonlyArray(materializerResult)) {
+  if (isReadonlyArray(materializerResult) === true) {
     return materializerResult.flatMap(fromMaterializerResult)
   }
-  if (isQueryBuilder(materializerResult)) {
+  if (isQueryBuilder(materializerResult) === true) {
     const { query, bindValues, usedTables } = materializerResult.asSql()
     return [{ sql: query, bindValues: bindValues as BindValues, writeTables: usedTables }]
   } else if (typeof materializerResult === 'string') {
@@ -155,7 +155,7 @@ export const replaceSessionIdSymbol = (
 }
 
 const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
-  if (Array.isArray(input)) {
+  if (Array.isArray(input) === true) {
     for (const i in input) {
       if (input[i] === searchValue) {
         input[i] = replaceValue

package/src/otel.ts

@@ -1,6 +1,7 @@
+import * as otel from '@opentelemetry/api'
+
 import { makeNoopTracer } from '@livestore/utils'
 import { Effect, identity, Layer, OtelTracer } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
 
 export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend(() => {
   const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, makeNoopTracer())
@@ -22,7 +23,7 @@ export const provideOtel =
     ) as any as Layer.Layer<OtelTracer.OtelTracer>
 
     return effect.pipe(
-      parentSpanContext
+      parentSpanContext !== undefined
         ? Effect.withParentSpan(OtelTracer.makeExternalSpan(otel.trace.getSpanContext(parentSpanContext)!))
         : identity,
       Effect.provide(TracingLive),

package/src/rematerialize-from-eventlog.ts

@@ -8,7 +8,10 @@ import { EventSequenceNumber, LiveStoreEvent, resolveEventDef, SystemTables } fr
 import type { PreparedBindValues } from './util.ts'
 import { sql } from './util.ts'
 
-export const rematerializeFromEventlog = ({
+/** Parse JSON string to unknown value */
+const jsonParse = Schema.decodeUnknownSync(Schema.parseJson())
+
+export const rematerializeFromEventlog = Effect.fn('@livestore/common:rematerializeFromEventlog')(function* ({
   dbEventlog,
   // TODO re-use this db when bringing back the boot in-memory db implementation
   // db,
@@ -21,69 +24,69 @@ export const rematerializeFromEventlog = ({
   schema: LiveStoreSchema
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
   materializeEvent: MaterializeEvent
-}) =>
-  Effect.gen(function* () {
+}) {
     const eventsCount = dbEventlog.select<{ count: number }>(
       `SELECT COUNT(*) AS count FROM ${SystemTables.EVENTLOG_META_TABLE}`,
     )[0]!.count
 
     const hashEventDef = memoizeByRef((event: EventDef.AnyWithoutFn) => Schema.hash(event.schema))
 
-    const processEvent = (row: SystemTables.EventlogMetaRow) =>
-      Effect.gen(function* () {
-        const args = JSON.parse(row.argsJson)
-        const eventEncoded = LiveStoreEvent.Client.EncodedWithMeta.make({
-          name: row.name,
-          args,
-          seqNum: {
-            global: row.seqNumGlobal,
-            client: row.seqNumClient,
-            rebaseGeneration: row.seqNumRebaseGeneration,
-          },
-          parentSeqNum: {
-            global: row.parentSeqNumGlobal,
-            client: row.parentSeqNumClient,
-            rebaseGeneration: row.parentSeqNumRebaseGeneration,
-          },
-          clientId: row.clientId,
-          sessionId: row.sessionId,
-        })
-
-        const resolution = yield* resolveEventDef(schema, {
-          operation: '@livestore/common:rematerializeFromEventlog:processEvent',
-          event: eventEncoded,
-        }).pipe(UnknownError.mapToUnknownError)
-
-        if (resolution._tag === 'unknown') {
-          // Old snapshots can contain newer events. Skip until the runtime has
-          // been updated; the event stays in the log for future replays.
-          return
-        }
-
-        const { eventDef } = resolution
-
-        if (hashEventDef(eventDef) !== row.schemaHash) {
-          yield* Effect.logWarning(
-            `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
-          )
-        }
-
-        // Checking whether the schema has changed in an incompatible way
-        yield* Schema.decodeUnknown(eventDef.schema)(args).pipe(
-          Effect.mapError((cause) =>
-            UnknownError.make({
-              cause,
-              note: `\
+    const processEvent = Effect.fn(`@livestore/common:rematerializeFromEventlog:processEvent`)(function* (
+      row: SystemTables.EventlogMetaRow,
+    ) {
+      const args = jsonParse(row.argsJson)
+      const eventEncoded = LiveStoreEvent.Client.EncodedWithMeta.make({
+        name: row.name,
+        args,
+        seqNum: {
+          global: row.seqNumGlobal,
+          client: row.seqNumClient,
+          rebaseGeneration: row.seqNumRebaseGeneration,
+        },
+        parentSeqNum: {
+          global: row.parentSeqNumGlobal,
+          client: row.parentSeqNumClient,
+          rebaseGeneration: row.parentSeqNumRebaseGeneration,
+        },
+        clientId: row.clientId,
+        sessionId: row.sessionId,
+      })
+
+      const resolution = yield* resolveEventDef(schema, {
+        operation: '@livestore/common:rematerializeFromEventlog:processEvent',
+        event: eventEncoded,
+      }).pipe(UnknownError.mapToUnknownError)
+
+      if (resolution._tag === 'unknown') {
+        // Old snapshots can contain newer events. Skip until the runtime has
+        // been updated; the event stays in the log for future replays.
+        return
+      }
+
+      const { eventDef } = resolution
+
+      if (hashEventDef(eventDef) !== row.schemaHash) {
+        yield* Effect.logWarning(
+          `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
+        )
+      }
+
+      // Checking whether the schema has changed in an incompatible way
+      yield* Schema.decodeUnknown(eventDef.schema)(args).pipe(
+        Effect.mapError((cause) =>
+          UnknownError.make({
+            cause,
+            note: `\
 There was an error during rematerializing from the eventlog while decoding
 the persisted event args for event definition "${row.name}".
 This likely means the schema has changed in an incompatible way.
 `,
-            }),
-          ),
-        )
+          }),
+        ),
+      )
 
-        yield* materializeEvent(eventEncoded, { skipEventlog: true })
-      }).pipe(Effect.withSpan(`@livestore/common:rematerializeFromEventlog:processEvent`))
+      yield* materializeEvent(eventEncoded, { skipEventlog: true })
+    })
 
     const CHUNK_SIZE = 100
 
@@ -101,9 +104,9 @@ LIMIT ${CHUNK_SIZE}
       SystemTables.EventlogMetaRow
     >({ _tag: 'Initial' }, (item) => {
       // End stream if no more rows
-      if (Chunk.isChunk(item) && item.length === 0) return Option.none()
+      if (Chunk.isChunk(item) === true && item.length === 0) return Option.none()
 
-      const lastId = Chunk.isChunk(item)
+      const lastId = Chunk.isChunk(item) === true
         ? Chunk.last(item).pipe(
             Option.map((_) => ({ global: _.seqNumGlobal, client: _.seqNumClient })),
             Option.getOrElse(() => EventSequenceNumber.Client.ROOT),
@@ -115,7 +118,7 @@ LIMIT ${CHUNK_SIZE}
           $seqNumClient: lastId?.client,
         } as any as PreparedBindValues),
       )
-      const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
+      const prevItem = Chunk.isChunk(item) === true ? item : Chunk.empty()
       return Option.some([prevItem, nextItem])
     }).pipe(
       Stream.bufferChunks({ capacity: 2 }),
@@ -129,7 +132,4 @@ LIMIT ${CHUNK_SIZE}
       ),
       Stream.runDrain,
     )
-  }).pipe(
-    Effect.withPerformanceMeasure('@livestore/common:rematerializeFromEventlog'),
-    Effect.withSpan('@livestore/common:rematerializeFromEventlog'),
-  )
+}, Effect.withPerformanceMeasure('@livestore/common:rematerializeFromEventlog'))

package/src/schema/EventDef/define.ts

@@ -127,15 +127,15 @@ export const defineEvent = <TName extends string, TType, TEncoded = TType, TDeri
   Object.defineProperty(makePartialEvent, 'options', {
     value: {
       clientOnly: options?.clientOnly ?? false,
-      facts: options?.facts
+      facts: options?.facts !== undefined
         ? (args, currentFacts) => {
             const res = options.facts!(args, currentFacts)
             return {
               modify: {
-                set: res.modify?.set ? new Set(res.modify.set) : new Set(),
-                unset: res.modify?.unset ? new Set(res.modify.unset) : new Set(),
+                set: res.modify?.set !== undefined ? new Set(res.modify.set) : new Set(),
+                unset: res.modify?.unset !== undefined ? new Set(res.modify.unset) : new Set(),
               },
-              require: res.require ? new Set(res.require) : new Set(),
+              require: res.require !== undefined ? new Set(res.require) : new Set(),
             }
           }
         : undefined,
@@ -179,7 +179,7 @@ export const synced = <TName extends string, TType, TEncoded = TType>(
   args: {
     name: TName
     schema: Schema.Schema<TType, TEncoded>
-  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
+  } & Omit<DefineEventOptions<TType>, 'derived' | 'clientOnly'>,
 ): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: false })
 
 /**
@@ -213,5 +213,5 @@ export const clientOnly = <TName extends string, TType, TEncoded = TType>(
   args: {
     name: TName
     schema: Schema.Schema<TType, TEncoded>
-  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
+  } & Omit<DefineEventOptions<TType>, 'derived' | 'clientOnly'>,
 ): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: true })

package/src/schema/EventDef/deprecated.test.ts

@@ -1,6 +1,7 @@
-import { Effect, Logger, Schema } from '@livestore/utils/effect'
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
 
+import { Effect, Logger, Schema } from '@livestore/utils/effect'
+
 import { synced } from './define.ts'
 import {
   deprecated,

package/src/schema/EventDef/deprecated.ts

@@ -109,7 +109,7 @@ export const findDeprecatedFieldsWithValues = (
         // Also check deprecation on the type (for direct field deprecation)
         const typeDeprecation = SchemaAST.getAnnotation<string>(DeprecatedId)(prop.type)
 
-        const reason = deprecationReason ?? (Option.isSome(typeDeprecation) ? typeDeprecation.value : undefined)
+        const reason = deprecationReason ?? (Option.isSome(typeDeprecation) === true ? typeDeprecation.value : undefined)
         if (reason !== undefined) {
           result.push({ field: fieldName, reason })
         }
@@ -143,7 +143,7 @@ export const logDeprecationWarnings = (
 
     // Check for event-level deprecation
     const eventDeprecation = eventDef.options.deprecated
-    if (eventDeprecation !== undefined && !warnedDeprecatedEvents.has(eventName)) {
+    if (eventDeprecation !== undefined && warnedDeprecatedEvents.has(eventName) === false) {
       warnedDeprecatedEvents.add(eventName)
       yield* Effect.logWarning('@livestore/schema:deprecated-event', {
         event: eventName,
@@ -155,7 +155,7 @@ export const logDeprecationWarnings = (
     const deprecatedFields = findDeprecatedFieldsWithValues(eventDef.schema, args)
     for (const { field, reason } of deprecatedFields) {
       const key = `${eventName}:${field}`
-      if (!warnedDeprecatedFields.has(key)) {
+      if (warnedDeprecatedFields.has(key) === false) {
         warnedDeprecatedFields.add(key)
         yield* Effect.logWarning('@livestore/schema:deprecated-field', {
           event: eventName,

package/src/schema/EventSequenceNumber/client.ts

@@ -28,7 +28,7 @@ export const make = ClientBrand
  * const defaultSeq = EventSequenceNumber.Client.DEFAULT // 0
  * ```
  */
-export const DEFAULT = 0 as any as Type
+export const DEFAULT = make(0)
 
 /** Default rebase generation (0). Increments each time the client rebases unconfirmed events. */
 export const REBASE_GENERATION_DEFAULT = 0
@@ -91,7 +91,7 @@ export const toString = (seqNum: Composite) => {
  * For full notation documentation, see: contributor-docs/events-notation.md
  */
 export const fromString = (str: string): Composite => {
-  if (!str.startsWith('e')) {
+  if (str.startsWith('e') === false) {
     throw new Error('Invalid event sequence number string: must start with "e"')
   }
 
@@ -111,24 +111,24 @@ export const fromString = (str: string): Composite => {
   const parts = withoutRebase.split('.')
 
   // Validate that parts contain only digits (and possibly empty for client)
-  if (parts[0] === '' || !/^\d+$/.test(parts[0]!)) {
+  if (parts[0] === '' || /^\d+$/.test(parts[0]!) === false) {
     throw new Error('Invalid event sequence number string: invalid number format')
   }
 
-  if (parts.length > 1 && parts[1] !== undefined && (parts[1] === '' || !/^\d+$/.test(parts[1]))) {
+  if (parts.length > 1 && parts[1] !== undefined && (parts[1] === '' || /^\d+$/.test(parts[1]) === false)) {
     throw new Error('Invalid event sequence number string: invalid number format')
   }
 
   const global = Number.parseInt(parts[0]!, 10)
   const client = parts.length > 1 && parts[1] !== undefined ? Number.parseInt(parts[1], 10) : 0
 
-  if (Number.isNaN(global) || Number.isNaN(client) || Number.isNaN(rebaseGeneration)) {
+  if (Number.isNaN(global) === true || Number.isNaN(client) === true || Number.isNaN(rebaseGeneration) === true) {
     throw new TypeError('Invalid event sequence number string: invalid number format')
   }
 
   return {
-    global: global as any as Global,
-    client: client as any as Type,
+    global: makeGlobal(global),
+    client: make(client),
     rebaseGeneration,
   }
 }
@@ -187,7 +187,7 @@ const CompositeSchema = S.Struct({
  * If rebaseGeneration is omitted, defaults to REBASE_GENERATION_DEFAULT (0).
  */
 const makeComposite = (seqNum: CompositeInput): Composite => {
-  return S.is(CompositeSchema)(seqNum)
+  return S.is(CompositeSchema)(seqNum) === true
     ? seqNum
     : S.decodeSync(CompositeSchema)({
         ...seqNum,
@@ -234,11 +234,11 @@ export const nextPair = ({
   isClient: boolean
   rebaseGeneration?: number
 }): CompositePair => {
-  if (isClient) {
+  if (isClient === true) {
     return {
       seqNum: {
         global: seqNum.global,
-        client: (seqNum.client + 1) as any as Type,
+        client: make(seqNum.client + 1),
         rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
       },
       parentSeqNum: seqNum,
@@ -247,7 +247,7 @@ export const nextPair = ({
 
   return {
     seqNum: {
-      global: (seqNum.global + 1) as any as Global,
+      global: makeGlobal(seqNum.global + 1),
       client: DEFAULT,
       rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
     },

package/src/schema/EventSequenceNumber.test.ts

@@ -1,6 +1,7 @@
-import { Vitest } from '@livestore/utils-dev/node-vitest'
 import { expect } from 'vitest'
 
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+
 import { EventSequenceNumber } from './mod.ts'
 
 Vitest.describe('EventSequenceNumber', () => {

package/src/schema/LiveStoreEvent/client.test.ts

@@ -0,0 +1,97 @@
+import { expect } from 'vitest'
+
+import { Option } from '@livestore/utils/effect'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+
+import * as EventSequenceNumber from '../EventSequenceNumber/mod.ts'
+import { EncodedWithMeta, isEqualEncoded, type Encoded } from './client.ts'
+
+Vitest.describe('EncodedWithMeta', () => {
+  Vitest.test('toGlobal() produces numeric seqNums through JSON.stringify', () => {
+    const event = new EncodedWithMeta({
+      name: 'test-v1',
+      args: { id: '1' },
+      seqNum: EventSequenceNumber.Client.Composite.make({ global: 5, client: 0 }),
+      parentSeqNum: EventSequenceNumber.Client.Composite.make({ global: 4, client: 0 }),
+      clientId: 'client-1',
+      sessionId: 'session-1',
+      meta: {
+        sessionChangeset: { _tag: 'unset' },
+        syncMetadata: Option.none(),
+        materializerHashLeader: Option.none(),
+        materializerHashSession: Option.none(),
+      },
+    })
+
+    const global = event.toGlobal()
+    const parsed = JSON.parse(JSON.stringify(global))
+
+    expect(parsed.seqNum).toBe(5)
+    expect(parsed.parentSeqNum).toBe(4)
+  })
+})
+
+Vitest.describe('isEqualEncoded', () => {
+  const makeEncodedEvent = (args: unknown): Encoded => ({
+    name: 'testEvent-v1',
+    args,
+    seqNum: EventSequenceNumber.Client.Composite.make({ global: 1, client: 0 }),
+    parentSeqNum: EventSequenceNumber.Client.Composite.make(EventSequenceNumber.Client.ROOT),
+    clientId: 'client-1',
+    sessionId: 'session-1',
+  })
+
+  Vitest.it('should consider events with identical args as equal', () => {
+    const a = makeEncodedEvent({ id: 'abc', text: 'hello' })
+    const b = makeEncodedEvent({ id: 'abc', text: 'hello' })
+    expect(isEqualEncoded(a, b)).toBe(true)
+  })
+
+  Vitest.it('should consider events with different key order in args as equal', () => {
+    const a = makeEncodedEvent({ b: 2, a: 1 })
+    const b = makeEncodedEvent({ a: 1, b: 2 })
+    expect(isEqualEncoded(a, b)).toBe(true)
+  })
+
+  Vitest.it('should consider events with different key order in nested args as equal', () => {
+    const a = makeEncodedEvent({ outer: { b: 2, a: 1 }, x: 'y' })
+    const b = makeEncodedEvent({ x: 'y', outer: { a: 1, b: 2 } })
+    expect(isEqualEncoded(a, b)).toBe(true)
+  })
+
+  Vitest.it('should consider events with different args values as not equal', () => {
+    const a = makeEncodedEvent({ id: 'abc' })
+    const b = makeEncodedEvent({ id: 'def' })
+    expect(isEqualEncoded(a, b)).toBe(false)
+  })
+
+  Vitest.it('should consider events with different args keys as not equal', () => {
+    const a = makeEncodedEvent({ a: 1 })
+    const b = makeEncodedEvent({ b: 1 })
+    expect(isEqualEncoded(a, b)).toBe(false)
+  })
+
+  Vitest.it('should handle null args', () => {
+    const a = makeEncodedEvent(null)
+    const b = makeEncodedEvent(null)
+    expect(isEqualEncoded(a, b)).toBe(true)
+  })
+
+  Vitest.it('should handle array args', () => {
+    const a = makeEncodedEvent([1, 2, 3])
+    const b = makeEncodedEvent([1, 2, 3])
+    expect(isEqualEncoded(a, b)).toBe(true)
+  })
+
+  Vitest.it('should handle empty object args', () => {
+    const a = makeEncodedEvent({})
+    const b = makeEncodedEvent({})
+    expect(isEqualEncoded(a, b)).toBe(true)
+  })
+
+  Vitest.it('should consider events with different names as not equal', () => {
+    const a = { ...makeEncodedEvent({ id: 'abc' }), name: 'eventA' }
+    const b = { ...makeEncodedEvent({ id: 'abc' }), name: 'eventB' }
+    expect(isEqualEncoded(a, b)).toBe(false)
+  })
+})