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

package/src/sync/next/facts.ts

@@ -6,14 +6,13 @@ import type {
   EventDefFactsGroup,
   EventDefFactsSnapshot,
   FactsCallback,
-} from '../../schema/EventDef.ts'
-import type * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
-import { graphologyDag } from './graphology_.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>()
 
@@ -30,11 +29,11 @@ export const factsSnapshotForEvents = (
 
 export const factsSnapshotForDag = (
   dag: HistoryDag,
-  endEventSequenceNumber: EventSequenceNumber.EventSequenceNumber | undefined,
+  endEventSequenceNumber: EventSequenceNumber.Client.Composite | undefined,
 ): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
-  const orderedEventSequenceNumberStrs = graphologyDag.topologicalSort(dag)
+  const orderedEventSequenceNumberStrs = dag.topologicalNodeIds()
 
   for (let i = 0; i < orderedEventSequenceNumberStrs.length; i++) {
     const event = dag.getNodeAttributes(orderedEventSequenceNumberStrs[i]!)
@@ -131,7 +130,7 @@ const isSubSetMapByValue = (setA: EventDefFacts, setB: EventDefFacts) => {
 /** Check if setA is a subset of setB */
 const isSubSetMapByKey = (setA: EventDefFacts, setB: EventDefFacts) => {
   for (const [key, _value] of setA) {
-    if (!setB.has(key)) {
+    if (setB.has(key) === false) {
       return false
     }
   }
@@ -169,7 +168,7 @@ export const factsToString = (facts: EventDefFacts) => {
 
 export const factsIntersect = (setA: EventDefFacts, setB: EventDefFacts): boolean => {
   for (const [key, _value] of setA) {
-    if (setB.has(key)) {
+    if (setB.has(key) === true) {
       return true
     }
   }
@@ -200,7 +199,7 @@ export const getFactsGroupForEventArgs = ({
         }
       }
 
-      notYetImplemented(`getFactsGroupForEventArgs: ${prop.toString()} is not yet implemented`)
+      return notYetImplemented(`getFactsGroupForEventArgs: ${prop.toString()} is not yet implemented`)
     },
   })
 
@@ -217,9 +216,9 @@ export const getFactsGroupForEventArgs = ({
     return map
   }
   const facts = {
-    modifySet: factsRes?.modify.set ? iterableToMap(factsRes.modify.set) : new Map(),
-    modifyUnset: factsRes?.modify.unset ? iterableToMap(factsRes.modify.unset) : new Map(),
-    depRequire: factsRes?.require ? iterableToMap(factsRes.require) : new Map(),
+    modifySet: factsRes?.modify.set !== undefined ? iterableToMap(factsRes.modify.set) : new Map(),
+    modifyUnset: factsRes?.modify.unset !== undefined ? iterableToMap(factsRes.modify.unset) : new Map(),
+    depRequire: factsRes?.require !== undefined ? iterableToMap(factsRes.require) : new Map(),
     depRead,
   }
 
@@ -227,8 +226,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,33 +1,15 @@
-import type { EventDefFactsGroup } from '../../schema/EventDef.ts'
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
-import { graphology } from './graphology_.ts'
+import { shouldNeverHappen } from '@livestore/utils'
+import { Graph, Option } from '@livestore/utils/effect'
+
+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]
 
-/**
- * Eventlog represented as a multi-DAG including edges for
- * - total-order (parent) relationships
- * - dependency (requires/reads facts) relationships
- */
-export type HistoryDag = graphology.IGraph<HistoryDagNode, { type: ConnectionType }>
-
-export const emptyHistoryDag = (): HistoryDag =>
-  new graphology.Graph({
-    allowSelfLoops: false,
-    multi: true,
-    type: 'directed',
-  })
-
-// TODO consider making `ROOT_ID` parent to itself
-export const rootParentNum = EventSequenceNumber.make({
-  global: EventSequenceNumber.ROOT.global - 1,
-  client: EventSequenceNumber.clientDefault,
-})
-
 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 */
@@ -37,8 +19,306 @@ export type HistoryDagNode = {
   sessionId: string | undefined
 }
 
+type HistoryDagEdgeAttributes = { type: ConnectionType }
+
+type HistoryDagEdgeEntry = {
+  edge: Graph.EdgeIndex
+  source: string
+  target: string
+  attributes: HistoryDagEdgeAttributes
+}
+
+type HistoryDagOptions = {
+  allowSelfLoops: boolean
+}
+
+const defaultOptions: HistoryDagOptions = {
+  allowSelfLoops: false,
+}
+
+const cloneFactsGroup = (factsGroup: EventDefFactsGroup): EventDefFactsGroup => ({
+  depRead: new Map(factsGroup.depRead),
+  depRequire: new Map(factsGroup.depRequire),
+  modifySet: new Map(factsGroup.modifySet),
+  modifyUnset: new Map(factsGroup.modifyUnset),
+})
+
+const cloneHistoryDagNode = (node: HistoryDagNode): HistoryDagNode => ({
+  ...node,
+  // Copy the event sequence numbers to avoid accidental aliasing
+  parentSeqNum: { ...node.parentSeqNum },
+  seqNum: { ...node.seqNum },
+  // Facts are represented via maps which should not be shared across DAG copies
+  factsGroup: cloneFactsGroup(node.factsGroup),
+})
+
+/**
+ * Mutable DAG wrapper that retains the previous string-based node ids API
+ * while delegating storage and algorithms to Effect's graph module.
+ */
+export class HistoryDag {
+  private readonly options: HistoryDagOptions
+  private readonly idToIndex: Map<string, Graph.NodeIndex>
+  private readonly indexToId: Map<Graph.NodeIndex, string>
+  private readonly incomingEdges: Map<Graph.NodeIndex, Set<Graph.EdgeIndex>>
+  private readonly outgoingEdges: Map<Graph.NodeIndex, Set<Graph.EdgeIndex>>
+  private readonly graph: Graph.MutableDirectedGraph<HistoryDagNode, HistoryDagEdgeAttributes>
+
+  private constructor({
+    graph,
+    idToIndex,
+    indexToId,
+    options,
+  }: {
+    graph: Graph.MutableDirectedGraph<HistoryDagNode, HistoryDagEdgeAttributes>
+    idToIndex?: Map<string, Graph.NodeIndex>
+    indexToId?: Map<Graph.NodeIndex, string>
+    options?: Partial<HistoryDagOptions>
+  }) {
+    this.graph = graph
+    this.options = { ...defaultOptions, ...options }
+    this.idToIndex = idToIndex !== undefined ? new Map(idToIndex) : new Map()
+    this.indexToId = indexToId !== undefined ? new Map(indexToId) : new Map()
+    this.incomingEdges = new Map()
+    this.outgoingEdges = new Map()
+  }
+
+  static create(options?: Partial<HistoryDagOptions>): HistoryDag {
+    const graph = Graph.beginMutation(Graph.directed<HistoryDagNode, HistoryDagEdgeAttributes>())
+    return options !== undefined ? new HistoryDag({ graph, options }) : new HistoryDag({ graph })
+  }
+
+  copy(): HistoryDag {
+    const clone = HistoryDag.create(this.options)
+
+    for (const [id, index] of this.idToIndex) {
+      const node = this.nodeAt(index, `HistoryDag.copy missing node for ${id}`)
+      clone.addNode(id, cloneHistoryDagNode(node))
+    }
+
+    for (const [, edge] of Graph.edges(this.graph)) {
+      const sourceId = this.indexToId.get(edge.source) ?? shouldNeverHappen('HistoryDag.copy missing source id')
+      const targetId = this.indexToId.get(edge.target) ?? shouldNeverHappen('HistoryDag.copy missing target id')
+      clone.addEdge(sourceId, targetId, { ...edge.data })
+    }
+
+    return clone
+  }
+
+  topologicalNodeIds(): Array<string> {
+    const walker = Graph.topo(this.graph)
+    const indices = Array.from(Graph.indices(walker))
+    return indices.map(
+      (index) => this.indexToId.get(index) ?? shouldNeverHappen(`Missing node id for index ${String(index)}`),
+    )
+  }
+
+  addNode(id: string, attributes: HistoryDagNode): void {
+    if (this.idToIndex.has(id) === true) {
+      shouldNeverHappen(`HistoryDag node ${id} already exists`)
+    }
+
+    const nodeIndex = Graph.addNode(this.graph, attributes)
+    this.idToIndex.set(id, nodeIndex)
+    this.indexToId.set(nodeIndex, id)
+    this.incomingEdges.set(nodeIndex, new Set())
+    this.outgoingEdges.set(nodeIndex, new Set())
+  }
+
+  hasNode(id: string): boolean {
+    return this.idToIndex.has(id)
+  }
+
+  getNodeAttributes(id: string): HistoryDagNode {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return shouldNeverHappen(`HistoryDag node ${id} not found`)
+    }
+
+    return this.nodeAt(index, `HistoryDag node data missing for ${id}`)
+  }
+
+  nodes(): IterableIterator<string> {
+    return this.idToIndex.keys()
+  }
+
+  nodeEntries(): IterableIterator<{ key: string; attributes: HistoryDagNode }> {
+    return function* (this: HistoryDag) {
+      for (const [id, index] of this.idToIndex) {
+        const attributes = this.nodeAt(index, `HistoryDag node data missing for ${id}`)
+        yield { key: id, attributes }
+      }
+    }.call(this)
+  }
+
+  addEdge(sourceId: string, targetId: string, attributes: HistoryDagEdgeAttributes): Graph.EdgeIndex {
+    if (this.options.allowSelfLoops === false && sourceId === targetId) {
+      return shouldNeverHappen('HistoryDag self-loops are disabled')
+    }
+
+    const sourceIndex = this.idToIndex.get(sourceId)
+    const targetIndex = this.idToIndex.get(targetId)
+
+    if (sourceIndex === undefined || targetIndex === undefined) {
+      return shouldNeverHappen(`HistoryDag edge references unknown nodes: ${sourceId} -> ${targetId}`)
+    }
+
+    const edgeIndex = Graph.addEdge(this.graph, sourceIndex, targetIndex, attributes)
+    const outgoingEdges = this.outgoingEdges.get(sourceIndex)
+    const incomingEdges = this.incomingEdges.get(targetIndex)
+    if (outgoingEdges === undefined || incomingEdges === undefined) {
+      return shouldNeverHappen(`HistoryDag edge index missing for ${sourceId} -> ${targetId}`)
+    }
+    outgoingEdges.add(edgeIndex)
+    incomingEdges.add(edgeIndex)
+    return edgeIndex
+  }
+
+  edges(sourceId: string, targetId: string): Array<Graph.EdgeIndex> {
+    const sourceIndex = this.idToIndex.get(sourceId)
+    const targetIndex = this.idToIndex.get(targetId)
+
+    if (sourceIndex === undefined || targetIndex === undefined) {
+      return []
+    }
+
+    return Array.from(this.outgoingEdges.get(sourceIndex) ?? []).filter((edgeIndex) => {
+      const edge = Option.getOrUndefined(Graph.getEdge(this.graph, edgeIndex))
+      return edge?.target === targetIndex
+    })
+  }
+
+  inEdges(id: string): Array<Graph.EdgeIndex> {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return []
+    }
+    return [...(this.incomingEdges.get(index) ?? [])]
+  }
+
+  outboundEdgeEntries(id: string): Array<HistoryDagEdgeEntry> {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return []
+    }
+
+    return [...(this.outgoingEdges.get(index) ?? [])]
+      .map((edgeIndex) => this.edgeEntry(edgeIndex))
+      .filter((entry): entry is HistoryDagEdgeEntry => entry !== undefined)
+  }
+
+  inboundEdgeEntries(id: string): Array<HistoryDagEdgeEntry> {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return []
+    }
+
+    return [...(this.incomingEdges.get(index) ?? [])]
+      .map((edgeIndex) => this.edgeEntry(edgeIndex))
+      .filter((entry): entry is HistoryDagEdgeEntry => entry !== undefined)
+  }
+
+  getEdgeAttributes(edgeIndex: Graph.EdgeIndex): HistoryDagEdgeAttributes {
+    return this.edgeAt(edgeIndex, `HistoryDag edge ${edgeIndex} not found`).data
+  }
+
+  getEdgeAttribute<TKey extends keyof HistoryDagEdgeAttributes>(
+    edgeIndex: Graph.EdgeIndex,
+    key: TKey,
+  ): HistoryDagEdgeAttributes[TKey] {
+    const attributes = this.getEdgeAttributes(edgeIndex)
+    return attributes[key]
+  }
+
+  source(edgeIndex: Graph.EdgeIndex): string {
+    const edge = Option.getOrUndefined(Graph.getEdge(this.graph, edgeIndex))
+    const sourceId = edge !== undefined ? this.indexToId.get(edge.source) : undefined
+    return sourceId ?? shouldNeverHappen(`HistoryDag edge ${edgeIndex} missing source`)
+  }
+
+  target(edgeIndex: Graph.EdgeIndex): string {
+    const edge = Option.getOrUndefined(Graph.getEdge(this.graph, edgeIndex))
+    const targetId = edge !== undefined ? this.indexToId.get(edge.target) : undefined
+    return targetId ?? shouldNeverHappen(`HistoryDag edge ${edgeIndex} missing target`)
+  }
+
+  dropNode(id: string): void {
+    const index = this.idToIndex.get(id)
+    if (index === undefined) {
+      return
+    }
+
+    for (const edgeIndex of this.outgoingEdges.get(index) ?? []) {
+      const edge = this.edgeAt(edgeIndex, `HistoryDag edge ${edgeIndex} missing while dropping ${id}`)
+      removeEdgeIndex(this.incomingEdges, edge.target, edgeIndex)
+    }
+    for (const edgeIndex of this.incomingEdges.get(index) ?? []) {
+      const edge = this.edgeAt(edgeIndex, `HistoryDag edge ${edgeIndex} missing while dropping ${id}`)
+      removeEdgeIndex(this.outgoingEdges, edge.source, edgeIndex)
+    }
+
+    Graph.removeNode(this.graph, index)
+    this.idToIndex.delete(id)
+    this.indexToId.delete(index)
+    this.incomingEdges.delete(index)
+    this.outgoingEdges.delete(index)
+  }
+
+  get size(): number {
+    return this.idToIndex.size
+  }
+
+  private edgeEntry(edgeIndex: Graph.EdgeIndex): HistoryDagEdgeEntry | undefined {
+    const edge = Option.getOrUndefined(Graph.getEdge(this.graph, edgeIndex))
+    if (edge === undefined) {
+      return undefined
+    }
+
+    const source = this.indexToId.get(edge.source)
+    const target = this.indexToId.get(edge.target)
+
+    if (source === undefined || target === undefined) {
+      return undefined
+    }
+
+    return {
+      edge: edgeIndex,
+      source,
+      target,
+      attributes: edge.data,
+    }
+  }
+
+  private nodeAt(index: Graph.NodeIndex, message: string): HistoryDagNode {
+    return Option.getOrElse(Graph.getNode(this.graph, index), () => shouldNeverHappen(message))
+  }
+
+  private edgeAt(edgeIndex: Graph.EdgeIndex, message: string): Graph.Edge<HistoryDagEdgeAttributes> {
+    return Option.getOrElse(Graph.getEdge(this.graph, edgeIndex), () => shouldNeverHappen(message))
+  }
+}
+
+const removeEdgeIndex = (
+  edgeIndices: Map<Graph.NodeIndex, Set<Graph.EdgeIndex>>,
+  nodeIndex: Graph.NodeIndex,
+  edgeIndex: Graph.EdgeIndex,
+): void => {
+  const indices = edgeIndices.get(nodeIndex) ?? shouldNeverHappen(`HistoryDag edge index missing for node ${nodeIndex}`)
+  if (indices.delete(edgeIndex) === false) {
+    shouldNeverHappen(`HistoryDag edge ${edgeIndex} missing from node ${nodeIndex}`)
+  }
+}
+
+export const emptyHistoryDag = (): HistoryDag => HistoryDag.create({ allowSelfLoops: false })
+
+// TODO consider making `ROOT_ID` parent to itself
+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,16 +39,19 @@ 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
+          if (parentEdge == null) return null
 
           const parentSeqNumStr = dag.source(parentEdge)
           const parentNode = dag.getNodeAttributes(parentSeqNumStr)
 
-          if (parentNode.factsGroup.modifySet.has(factKey) || parentNode.factsGroup.modifyUnset.has(factKey)) {
+          if (
+            parentNode.factsGroup.modifySet.has(factKey) === true ||
+            parentNode.factsGroup.modifyUnset.has(factKey) === true
+          ) {
             return parentNode
           }
 
@@ -54,9 +61,9 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
         return null
       })()
 
-      if (depNode) {
-        const depNodeIdStr = EventSequenceNumber.toString(depNode.seqNum)
-        const nodeIdStr = EventSequenceNumber.toString(node.seqNum)
+      if (depNode !== null) {
+        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,19 +19,19 @@ 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
 
 export const defaultRebaseFn: RebaseFn = ({ pendingLocalEvents }) => {
-  if (pendingLocalEvents.some((_) => _.conflictType === 'missing-requirement')) {
+  if (pendingLocalEvents.some((_) => _.conflictType === 'missing-requirement') === true) {
     throw new Error('missing-requirement conflicts must be resolved before rebasing')
   }
 
@@ -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/compact-events.calculator.test.ts

@@ -1,6 +1,7 @@
+import { describe, expect, it } from 'vitest'
+
 import { defineEvent } from '@livestore/common/schema'
 import { Schema } from '@livestore/utils/effect'
-import { describe, expect, it } from 'vitest'
 
 import { compactEvents } from '../compact-events.ts'
 import { historyDagFromNodes } from '../history-dag.ts'
@@ -26,14 +27,14 @@ const facts = {
 const eventDefs = {
   add: defineEvent({
     name: 'add',
-    schema: Schema.Struct({ value: Schema.Number }),
+    schema: Schema.Struct({ value: Schema.Finite }),
   }),
   multiply: defineEvent({
     name: 'multiply',
-    schema: Schema.Struct({ value: Schema.Number }),
+    schema: Schema.Struct({ value: Schema.Finite }),
     facts: ({ value }, currentFacts) => ({
       modify: {
-        set: value === 0 || currentFacts.has(facts.multiplyByZero) ? [facts.multiplyByZero] : [],
+        set: value === 0 || currentFacts.has(facts.multiplyByZero) === true ? [facts.multiplyByZero] : [],
         unset: value === 0 ? [] : [facts.multiplyByZero],
       },
     }),

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

@@ -1,10 +1,11 @@
-import type { EventDefFacts } from '@livestore/common/schema'
 import { describe, expect, it } from 'vitest'
 
+import type { EventDefFacts } from '@livestore/common/schema'
+
 import { compactEvents } from '../compact-events.ts'
-import { historyDagFromNodes } from '../history-dag.ts'
 import type { HistoryDagNode } from '../history-dag-common.ts'
 import { EMPTY_FACT_VALUE } from '../history-dag-common.ts'
+import { historyDagFromNodes } from '../history-dag.ts'
 import { events as eventDefs, printEvent, toEventNodes } from './event-fixtures.ts'
 
 const customStringify = (value: any): string => {
@@ -19,7 +20,7 @@ const customStringify = (value: any): string => {
   if (type === 'number' || type === 'boolean') {
     return String(value)
   }
-  if (Array.isArray(value)) {
+  if (Array.isArray(value) === true) {
     const elements = value.map((el) => customStringify(el))
     return `[${elements.join(', ')}]`
   }

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'
+import { historyDagFromNodes } from '../history-dag.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,
 })
@@ -45,7 +45,7 @@ export const events = {
     // {
     facts: ({ id }, currentFacts) =>
       // TODO enable an API along the lines of `map.has(key, value)`
-      currentFacts.has(facts.todoExists(id)) && currentFacts.get(facts.todoIsWriteable(id, true)[0]) === false
+      currentFacts.has(facts.todoExists(id)) === true && currentFacts.get(facts.todoIsWriteable(id, true)[0]) === false
         ? { require: [facts.todoExists(id), facts.todoIsWriteable(id, true)] }
         : { modify: { set: [facts.todoExists(id), facts.todoIsWriteable(id, true), facts.todoTextUpdated(id)] } },
   }),
@@ -140,13 +140,13 @@ 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,
+      isClientOnly: eventDef.options.clientOnly,
     }).seqNum
     currentEventSequenceNumber = eventNum
 
@@ -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,
   })