@livestore/common 0.3.0-dev.5 → 0.3.0-dev.51

package/src/schema/EventDef.ts

@@ -0,0 +1,227 @@
+import type { SingleOrReadonlyArray } from '@livestore/utils'
+import { shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
+
+import type { BindValues } from '../sql-queries/sql-queries.js'
+import type { ParamsObject } from '../util.js'
+import type { QueryBuilder } from './state/sqlite/query-builder/mod.js'
+
+export type EventDefMap = {
+  map: Map<string | 'livestore.RawSql', EventDef.Any>
+}
+export type EventDefRecord = {
+  'livestore.RawSql': RawSqlEvent
+  [name: string]: EventDef.Any
+}
+
+export type EventDef<TName extends string, TType, TEncoded = TType, TDerived extends boolean = false> = {
+  name: TName
+  schema: Schema.Schema<TType, TEncoded>
+  options: {
+    /**
+     * When set to true, the mutation won't be synced across clients but
+     */
+    clientOnly: boolean
+    /** Warning: This feature is not fully implemented yet */
+    facts: FactsCallback<TType> | undefined
+    derived: TDerived
+  }
+
+  /** Helper function to construct a partial mutation event */
+  (args: TType): {
+    name: TName
+    args: TType
+  }
+
+  readonly Event: {
+    name: TName
+    args: TType
+  }
+}
+
+export type FactsCallback<TTo> = (
+  args: TTo,
+  currentFacts: EventDefFacts,
+) => {
+  modify: {
+    set: Iterable<EventDefFactInput>
+    unset: Iterable<EventDefFactInput>
+  }
+  require: Iterable<EventDefFactInput>
+}
+
+export namespace EventDef {
+  export type Any = EventDef<string, any, any, boolean>
+
+  export type AnyWithoutFn = Pick<Any, 'name' | 'schema' | 'options'>
+}
+
+export type EventDefKey = string
+export type EventDefFact = string
+export type EventDefFacts = ReadonlyMap<string, any>
+
+export type EventDefFactsGroup = {
+  modifySet: EventDefFacts
+  modifyUnset: EventDefFacts
+
+  /**
+   * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
+   */
+  depRequire: EventDefFacts
+  depRead: EventDefFacts
+}
+
+export type EventDefFactsSnapshot = Map<string, any>
+
+export type EventDefFactInput = string | readonly [string, any]
+
+export const defineFacts = <
+  TRecord extends Record<string, EventDefFactInput | ((...args: any[]) => EventDefFactInput)>,
+>(
+  record: TRecord,
+): TRecord => record
+
+export type DefineEventOptions<TTo, TDerived extends boolean = false> = {
+  // TODO actually implement this
+  // onError?: (error: any) => void
+  /** Warning: This feature is not fully implemented yet */
+  facts?: (
+    args: TTo,
+    currentFacts: EventDefFacts,
+  ) => {
+    modify?: {
+      set?: Iterable<EventDefFactInput>
+      unset?: Iterable<EventDefFactInput>
+    }
+    /**
+     * Two purposes: constrain history and constrain compaction
+     */
+    require?: Iterable<EventDefFactInput>
+  }
+  /**
+   * When set to true, the event won't be synced over the network
+   */
+  clientOnly?: boolean
+  derived?: TDerived
+}
+
+export const defineEvent = <TName extends string, TType, TEncoded = TType, TDerived extends boolean = false>(
+  args: {
+    name: TName
+    schema: Schema.Schema<TType, TEncoded>
+  } & DefineEventOptions<TType, TDerived>,
+): EventDef<TName, TType, TEncoded, TDerived> => {
+  const { name, schema, ...options } = args
+
+  const makePartialEvent = (args: TType) => {
+    const res = Schema.validateEither(schema)(args)
+    if (res._tag === 'Left') {
+      shouldNeverHappen(`Invalid event args for event '${name}':`, res.left.message, '\n')
+    }
+    return { name: name, args }
+  }
+
+  Object.defineProperty(makePartialEvent, 'name', { value: name })
+  Object.defineProperty(makePartialEvent, 'schema', { value: schema })
+  Object.defineProperty(makePartialEvent, 'options', {
+    value: {
+      clientOnly: options?.clientOnly ?? false,
+      facts: options?.facts
+        ? (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(),
+              },
+              require: res.require ? new Set(res.require) : new Set(),
+            }
+          }
+        : undefined,
+      derived: options?.derived ?? false,
+    } satisfies EventDef.Any['options'],
+  })
+
+  return makePartialEvent as EventDef<TName, TType, TEncoded, TDerived>
+}
+
+export const synced = <TName extends string, TType, TEncoded = TType>(
+  args: {
+    name: TName
+    schema: Schema.Schema<TType, TEncoded>
+  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
+): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: false })
+
+export const clientOnly = <TName extends string, TType, TEncoded = TType>(
+  args: {
+    name: TName
+    schema: Schema.Schema<TType, TEncoded>
+  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
+): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: true })
+
+export type MaterializerResult =
+  | {
+      sql: string
+      bindValues: BindValues
+      writeTables?: ReadonlySet<string>
+    }
+  | QueryBuilder.Any
+  | string
+
+export type MaterializerContextQuery = {
+  (args: { query: string; bindValues: ParamsObject }): ReadonlyArray<unknown>
+  <TResult>(qb: QueryBuilder<TResult, any, any>): TResult
+}
+
+export type Materializer<TEventDef extends EventDef.AnyWithoutFn = EventDef.AnyWithoutFn> = (
+  event: TEventDef['schema']['Type'],
+  context: {
+    currentFacts: EventDefFacts
+    eventDef: TEventDef
+    /** Can be used to query the current state */
+    query: MaterializerContextQuery
+  },
+) => SingleOrReadonlyArray<MaterializerResult>
+
+export const defineMaterializer = <TEventDef extends EventDef.AnyWithoutFn>(
+  eventDef: TEventDef,
+  materializer: Materializer<TEventDef>,
+): Materializer<TEventDef> => {
+  return materializer
+}
+
+export const materializers = <TInputRecord extends Record<string, EventDef.AnyWithoutFn>>(
+  eventDefRecord: TInputRecord,
+  handlers: {
+    [TEventName in TInputRecord[keyof TInputRecord]['name'] as Extract<
+      TInputRecord[keyof TInputRecord],
+      { name: TEventName }
+    >['options']['derived'] extends true
+      ? never
+      : TEventName]: Materializer<Extract<TInputRecord[keyof TInputRecord], { name: TEventName }>>
+    // [K in TInputRecord[keyof TInputRecord]['name']]: Materializer<
+    //   Extract<TInputRecord[keyof TInputRecord], { name: K }>
+    // >
+  },
+) => {
+  return handlers
+}
+
+export const rawSqlEvent = defineEvent({
+  name: 'livestore.RawSql',
+  schema: Schema.Struct({
+    sql: Schema.String,
+    bindValues: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+    writeTables: Schema.optional(Schema.ReadonlySet(Schema.String)),
+  }),
+  clientOnly: true,
+  derived: true,
+})
+
+export const rawSqlMaterializer = defineMaterializer(rawSqlEvent, ({ sql, bindValues, writeTables }) => ({
+  sql,
+  bindValues: bindValues ?? {},
+  writeTables,
+}))
+
+export type RawSqlEvent = typeof rawSqlEvent

package/src/schema/EventSequenceNumber.test.ts

@@ -0,0 +1,12 @@
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+
+import { EventSequenceNumber } from './mod.js'
+
+Vitest.describe('EventSequenceNumber', () => {
+  Vitest.test('nextPair', () => {
+    const e_0_0 = EventSequenceNumber.make({ global: 0, client: 0 })
+    expect(EventSequenceNumber.nextPair(e_0_0, false).seqNum).toStrictEqual({ global: 1, client: 0 })
+    expect(EventSequenceNumber.nextPair(e_0_0, true).seqNum).toStrictEqual({ global: 0, client: 1 })
+  })
+})

package/src/schema/EventSequenceNumber.ts

@@ -0,0 +1,121 @@
+import { Brand, Schema } from '@livestore/utils/effect'
+
+export type ClientEventSequenceNumber = Brand.Branded<number, 'ClientEventSequenceNumber'>
+export const localEventSequenceNumber = Brand.nominal<ClientEventSequenceNumber>()
+export const ClientEventSequenceNumber = Schema.fromBrand(localEventSequenceNumber)(Schema.Int)
+
+export type GlobalEventSequenceNumber = Brand.Branded<number, 'GlobalEventSequenceNumber'>
+export const globalEventSequenceNumber = Brand.nominal<GlobalEventSequenceNumber>()
+export const GlobalEventSequenceNumber = Schema.fromBrand(globalEventSequenceNumber)(Schema.Int)
+
+export const clientDefault = 0 as any as ClientEventSequenceNumber
+
+/**
+ * LiveStore event sequence number value consisting of a globally unique event sequence number
+ * and a client sequence number.
+ *
+ * The client sequence number is only used for clientOnly events and starts from 0 for each global sequence number.
+ */
+export type EventSequenceNumber = {
+  global: GlobalEventSequenceNumber
+  client: ClientEventSequenceNumber
+  /**
+   * TODO add generation number in favour of LEADER_MERGE_COUNTER_TABLE
+   */
+  // generation: number
+}
+
+// export const EventSequenceNumber = Schema.Struct({})
+// export const EventSequenceNumber = Schema.Struct({})
+// export const ClientEventSequenceNumber = Schema.Struct({})
+// export const GlobalEventSequenceNumber = Schema.Struct({})
+
+/**
+ * NOTE: Client mutation events with a non-0 client id, won't be synced to the sync backend.
+ */
+export const EventSequenceNumber = Schema.Struct({
+  global: GlobalEventSequenceNumber,
+  /** Only increments for clientOnly events */
+  client: ClientEventSequenceNumber,
+
+  // TODO also provide a way to see "confirmation level" of event (e.g. confirmed by leader/sync backend)
+
+  // TODO: actually add this field
+  // Client only
+  // generation: Schema.Number.pipe(Schema.optional),
+}).annotations({ title: 'LiveStore.EventSequenceNumber' })
+
+/**
+ * Compare two event sequence numbers i.e. checks if the first event sequence number is less than the second.
+ */
+export const compare = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  if (a.global !== b.global) {
+    return a.global - b.global
+  }
+  return a.client - b.client
+}
+
+/**
+ * Convert an event sequence number to a string representation.
+ */
+export const toString = (seqNum: EventSequenceNumber) =>
+  seqNum.client === 0 ? `e${seqNum.global}` : `e${seqNum.global}+${seqNum.client}`
+
+/**
+ * Convert a string representation of an event sequence number to an event sequence number.
+ */
+export const fromString = (str: string): EventSequenceNumber => {
+  const [global, client] = str.slice(1, -1).split(',').map(Number)
+  if (global === undefined || client === undefined) {
+    throw new Error('Invalid event sequence number string')
+  }
+  return { global, client } as EventSequenceNumber
+}
+
+export const isEqual = (a: EventSequenceNumber, b: EventSequenceNumber) =>
+  a.global === b.global && a.client === b.client
+
+export type EventSequenceNumberPair = { seqNum: EventSequenceNumber; parentSeqNum: EventSequenceNumber }
+
+export const ROOT = {
+  global: 0 as any as GlobalEventSequenceNumber,
+  client: clientDefault,
+} satisfies EventSequenceNumber
+
+export const isGreaterThan = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return a.global > b.global || (a.global === b.global && a.client > b.client)
+}
+
+export const isGreaterThanOrEqual = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return a.global > b.global || (a.global === b.global && a.client >= b.client)
+}
+
+export const max = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return a.global > b.global || (a.global === b.global && a.client > b.client) ? a : b
+}
+
+export const diff = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return {
+    global: a.global - b.global,
+    client: a.client - b.client,
+  }
+}
+
+export const make = (seqNum: EventSequenceNumber | typeof EventSequenceNumber.Encoded): EventSequenceNumber => {
+  return Schema.is(EventSequenceNumber)(seqNum) ? seqNum : Schema.decodeSync(EventSequenceNumber)(seqNum)
+}
+
+export const nextPair = (seqNum: EventSequenceNumber, isLocal: boolean): EventSequenceNumberPair => {
+  if (isLocal) {
+    return {
+      seqNum: { global: seqNum.global, client: (seqNum.client + 1) as any as ClientEventSequenceNumber },
+      parentSeqNum: seqNum,
+    }
+  }
+
+  return {
+    seqNum: { global: (seqNum.global + 1) as any as GlobalEventSequenceNumber, client: clientDefault },
+    // NOTE we always point to `client: 0` for non-clientOnly events
+    parentSeqNum: { global: seqNum.global, client: clientDefault },
+  }
+}

package/src/schema/LiveStoreEvent.ts

@@ -0,0 +1,240 @@
+import { memoizeByRef } from '@livestore/utils'
+import { Option, Schema } from '@livestore/utils/effect'
+
+import type { EventDef, EventDefRecord } from './EventDef.js'
+import * as EventSequenceNumber from './EventSequenceNumber.js'
+import type { LiveStoreSchema } from './schema.js'
+
+export namespace ForEventDef {
+  export type PartialDecoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Type<TEventDef['schema']>
+  }
+
+  export type PartialEncoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Encoded<TEventDef['schema']>
+  }
+
+  export type Decoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Type<TEventDef['schema']>
+    seqNum: EventSequenceNumber.EventSequenceNumber
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber
+    clientId: string
+    sessionId: string
+  }
+
+  export type Encoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Encoded<TEventDef['schema']>
+    seqNum: EventSequenceNumber.EventSequenceNumber
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber
+    clientId: string
+    sessionId: string
+  }
+}
+
+export type AnyDecoded = ForEventDef.Decoded<EventDef.Any>
+export const AnyDecoded = Schema.Struct({
+  name: Schema.String,
+  args: Schema.Any,
+  seqNum: EventSequenceNumber.EventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
+  clientId: Schema.String,
+  sessionId: Schema.String,
+}).annotations({ title: 'LiveStoreEvent.AnyDecoded' })
+
+export type AnyEncoded = ForEventDef.Encoded<EventDef.Any>
+export const AnyEncoded = Schema.Struct({
+  name: Schema.String,
+  args: Schema.Any,
+  seqNum: EventSequenceNumber.EventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
+  clientId: Schema.String,
+  sessionId: Schema.String,
+}).annotations({ title: 'LiveStoreEvent.AnyEncoded' })
+
+export const AnyEncodedGlobal = Schema.Struct({
+  name: Schema.String,
+  args: Schema.Any,
+  seqNum: EventSequenceNumber.GlobalEventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.GlobalEventSequenceNumber,
+  clientId: Schema.String,
+  sessionId: Schema.String,
+}).annotations({ title: 'LiveStoreEvent.AnyEncodedGlobal' })
+export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
+
+export type PartialAnyDecoded = ForEventDef.PartialDecoded<EventDef.Any>
+export type PartialAnyEncoded = ForEventDef.PartialEncoded<EventDef.Any>
+
+export const PartialAnyEncoded = Schema.Struct({
+  name: Schema.String,
+  args: Schema.Any,
+})
+
+export type PartialForSchema<TSchema extends LiveStoreSchema> = {
+  [K in keyof TSchema['_EventDefMapType']]: ForEventDef.PartialDecoded<TSchema['_EventDefMapType'][K]>
+}[keyof TSchema['_EventDefMapType']]
+
+export type ForSchema<TSchema extends LiveStoreSchema> = {
+  [K in keyof TSchema['_EventDefMapType']]: ForEventDef.Decoded<TSchema['_EventDefMapType'][K]>
+}[keyof TSchema['_EventDefMapType']]
+
+export const isPartialEventDef = (event: AnyDecoded | PartialAnyDecoded): event is PartialAnyDecoded =>
+  'num' in event === false && 'parentSeqNum' in event === false
+
+export type ForEventDefRecord<TEventDefRecord extends EventDefRecord> = Schema.Schema<
+  {
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
+      seqNum: EventSequenceNumber.EventSequenceNumber
+      parentSeqNum: EventSequenceNumber.EventSequenceNumber
+      clientId: string
+      sessionId: string
+    }
+  }[keyof TEventDefRecord],
+  {
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
+      seqNum: EventSequenceNumber.EventSequenceNumber
+      parentSeqNum: EventSequenceNumber.EventSequenceNumber
+      clientId: string
+      sessionId: string
+    }
+  }[keyof TEventDefRecord]
+>
+
+export type EventDefPartialSchema<TEventDefRecord extends EventDefRecord> = Schema.Schema<
+  {
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
+    }
+  }[keyof TEventDefRecord],
+  {
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
+    }
+  }[keyof TEventDefRecord]
+>
+
+export const makeEventDefSchema = <TSchema extends LiveStoreSchema>(
+  schema: TSchema,
+): ForEventDefRecord<TSchema['_EventDefMapType']> =>
+  Schema.Union(
+    ...[...schema.eventsDefsMap.values()].map((def) =>
+      Schema.Struct({
+        name: Schema.Literal(def.name),
+        args: def.schema,
+        seqNum: EventSequenceNumber.EventSequenceNumber,
+        parentSeqNum: EventSequenceNumber.EventSequenceNumber,
+        clientId: Schema.String,
+        sessionId: Schema.String,
+      }),
+    ),
+  ).annotations({ title: 'EventDef' }) as any
+
+export const makeEventDefPartialSchema = <TSchema extends LiveStoreSchema>(
+  schema: TSchema,
+): EventDefPartialSchema<TSchema['_EventDefMapType']> =>
+  Schema.Union(
+    ...[...schema.eventsDefsMap.values()].map((def) =>
+      Schema.Struct({
+        name: Schema.Literal(def.name),
+        args: def.schema,
+      }),
+    ),
+  ).annotations({ title: 'EventDefPartial' }) as any
+
+export const makeEventDefSchemaMemo = memoizeByRef(makeEventDefSchema)
+
+/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
+export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEvent.EncodedWithMeta')({
+  name: Schema.String,
+  args: Schema.Any,
+  seqNum: EventSequenceNumber.EventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
+  clientId: Schema.String,
+  sessionId: Schema.String,
+  // TODO get rid of `meta` again by cleaning up the usage implementations
+  meta: Schema.Struct({
+    sessionChangeset: Schema.Union(
+      Schema.TaggedStruct('sessionChangeset', {
+        data: Schema.Uint8Array,
+        debug: Schema.Any.pipe(Schema.optional),
+      }),
+      Schema.TaggedStruct('no-op', {}),
+      Schema.TaggedStruct('unset', {}),
+    ),
+    syncMetadata: Schema.Option(Schema.JsonValue),
+  }).pipe(
+    Schema.mutable,
+    Schema.optional,
+    Schema.withDefaults({
+      constructor: () => ({ sessionChangeset: { _tag: 'unset' as const }, syncMetadata: Option.none() }),
+      decoding: () => ({ sessionChangeset: { _tag: 'unset' as const }, syncMetadata: Option.none() }),
+    }),
+  ),
+}) {
+  toJSON = (): any => {
+    // Only used for logging/debugging
+    // - More readable way to print the seqNum + parentSeqNum
+    // - not including `meta`, `clientId`, `sessionId`
+    return {
+      seqNum: `${EventSequenceNumber.toString(this.seqNum)} → ${EventSequenceNumber.toString(this.parentSeqNum)} (${this.clientId}, ${this.sessionId})`,
+      name: this.name,
+      args: this.args,
+    }
+  }
+
+  /**
+   * Example: (global event)
+   * For event e2 → e1 which should be rebased on event e3 → e2
+   * the resulting event num will be e4 → e3
+   *
+   * Example: (client event)
+   * For event e2+1 → e2 which should be rebased on event e3 → e2
+   * the resulting event num will be e3+1 → e3
+   *
+   * Syntax: e2+2 → e2+1
+   *          ^ ^    ^ ^
+   *          | |    | +- client parent number
+   *          | |    +--- global parent number
+   *          | +-- client number
+   *          +---- global number
+   * Client num is ommitted for global events
+   */
+  rebase = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, isClient: boolean) =>
+    new EncodedWithMeta({
+      ...this,
+      ...EventSequenceNumber.nextPair(parentSeqNum, isClient),
+    })
+
+  static fromGlobal = (event: AnyEncodedGlobal, syncMetadata: Option.Option<Schema.JsonValue>) =>
+    new EncodedWithMeta({
+      ...event,
+      seqNum: { global: event.seqNum, client: EventSequenceNumber.clientDefault },
+      parentSeqNum: { global: event.parentSeqNum, client: EventSequenceNumber.clientDefault },
+      meta: { sessionChangeset: { _tag: 'unset' as const }, syncMetadata },
+    })
+
+  toGlobal = (): AnyEncodedGlobal => ({
+    ...this,
+    seqNum: this.seqNum.global,
+    parentSeqNum: this.parentSeqNum.global,
+  })
+}
+
+/** NOTE `meta` is not considered for equality */
+export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
+  a.seqNum.global === b.seqNum.global &&
+  a.seqNum.client === b.seqNum.client &&
+  a.name === b.name &&
+  a.clientId === b.clientId &&
+  a.sessionId === b.sessionId &&
+  // TODO use schema equality here
+  JSON.stringify(a.args) === JSON.stringify(b.args)

package/src/schema/events.ts

@@ -0,0 +1 @@
+export { defineEvent, synced, clientOnly } from './EventDef.js'

package/src/schema/mod.ts

@@ -1,7 +1,9 @@
-export * from './system-tables.js'
-export * as DbSchema from './table-def.js'
-export * from './mutations.js'
-export * from './schema-helpers.js'
+export * as SystemTables from './state/sqlite/system-tables.js'
+export { SqliteAst, SqliteDsl } from './state/sqlite/db-schema/mod.js'
+export * from './EventDef.js'
+export * from './state/sqlite/schema-helpers.js'
 export * from './schema.js'
-export * as MutationEvent from './MutationEvent.js'
-export * as EventId from './EventId.js'
+export * as State from './state/mod.js'
+export * as LiveStoreEvent from './LiveStoreEvent.js'
+export * as EventSequenceNumber from './EventSequenceNumber.js'
+export * as Events from './events.js'