@livestore/common 0.4.0 → 0.5.0-dev.1

package/src/MaterializationJournal.ts

@@ -0,0 +1,184 @@
+import { Context, Effect, Layer, Predicate, ReadonlyArray, Schema } from '@livestore/utils/effect'
+
+import { SqliteError, type SqliteDb } from './adapter-types.ts'
+import { execSql, execSqlPrepared } from './leader-thread/connection.ts'
+import * as EventSequenceNumber from './schema/EventSequenceNumber/mod.ts'
+import { SystemTables } from './schema/mod.ts'
+import { findManyRows, insertRow } from './sql-queries/index.ts'
+import * as SqliteDbHelper from './sqlite-db-helper.ts'
+import { prepareBindValues, sql } from './util.ts'
+
+export const TypeId = '~@livestore/common/MaterializationJournal' as const
+export type TypeId = typeof TypeId
+
+export const MaterializationJournalErrorTypeId = '~@livestore/common/MaterializationJournalError' as const
+
+export const isMaterializationJournalError = (u: unknown): u is MaterializationJournalError =>
+  Predicate.hasProperty(u, MaterializationJournalErrorTypeId)
+
+export class MaterializationJournalError extends Schema.TaggedError<MaterializationJournalError>(
+  MaterializationJournalErrorTypeId,
+)('MaterializationJournalError', {
+  method: Schema.Literals(['record', 'rollback', 'discardUpTo']),
+  cause: Schema.Defect(),
+}) {
+  readonly [MaterializationJournalErrorTypeId] = MaterializationJournalErrorTypeId
+}
+
+export type MaterializationChangeset = { _tag: 'changeset'; data: Uint8Array<ArrayBuffer> } | { _tag: 'no-op' }
+
+export type MaterializationRecord = {
+  key: EventSequenceNumber.Client.Composite
+  changeset: MaterializationChangeset
+}
+
+export interface Service {
+  readonly [TypeId]: TypeId
+  /** Stores a materialization record, replacing any record at the same key. */
+  record: (record: MaterializationRecord) => Effect.Effect<void, MaterializationJournalError>
+  /** Reverts the keyed materializations in reverse order, then discards their records. */
+  rollback: (
+    keys: ReadonlyArray<EventSequenceNumber.Client.Composite>,
+  ) => Effect.Effect<void, MaterializationJournalError>
+  /** Discards records whose key is less than or equal to `key`, ignoring rebase generation. */
+  discardUpTo: (key: EventSequenceNumber.Client.Composite) => Effect.Effect<void, MaterializationJournalError>
+}
+
+export class MaterializationJournal extends Context.Service<MaterializationJournal, Service>()(
+  '@livestore/common/MaterializationJournal',
+) {}
+
+interface Options {
+  readonly dbState: SqliteDb
+}
+
+export const make = ({ dbState }: Options) => {
+  const deleteByKeys = Effect.fnUntraced(function* (keys: ReadonlyArray<EventSequenceNumber.Client.Composite>) {
+    // Keep DELETE statements below SQLite's bound-parameter limit.
+    const keyChunks = ReadonlyArray.chunksOf(100)(keys)
+
+    for (const keyChunk of keyChunks) {
+      const placeholders = keyChunk.map(() => '(?, ?, ?)').join(', ')
+      const bindValues = keyChunk.flatMap((key) => [key.global, key.client, key.rebaseGeneration])
+      const statement = sql`DELETE FROM ${SystemTables.MATERIALIZATION_JOURNAL_META_TABLE}
+                            WHERE (seqNumGlobal, seqNumClient, seqNumRebaseGeneration) IN (${placeholders})`
+
+      yield* execSqlPrepared(dbState, statement, prepareBindValues(bindValues, statement))
+    }
+  }, SqliteDbHelper.withSavepoint(dbState))
+
+  return MaterializationJournal.of({
+    [TypeId]: TypeId,
+    record: Effect.fnUntraced(
+      function* (record: MaterializationRecord) {
+        yield* deleteByKeys([record.key])
+
+        // Generate the parameterized INSERT statement
+        const [statement, bindValues] = insertRow({
+          tableName: SystemTables.MATERIALIZATION_JOURNAL_META_TABLE,
+          columns: SystemTables.materializationJournalMetaTable.sqliteDef.columns,
+          values: {
+            seqNumGlobal: record.key.global,
+            seqNumClient: record.key.client,
+            seqNumRebaseGeneration: record.key.rebaseGeneration,
+            changeset: record.changeset._tag === 'changeset' ? record.changeset.data : null,
+            // Legacy processors still expose this column for development diagnostics.
+            debug: null,
+          },
+        })
+
+        yield* execSqlPrepared(dbState, statement, prepareBindValues(bindValues, statement))
+      },
+      SqliteDbHelper.withSavepoint(dbState),
+      Effect.mapError((cause) => new MaterializationJournalError({ method: 'record', cause })),
+    ),
+    rollback: Effect.fnUntraced(
+      function* (keys: ReadonlyArray<EventSequenceNumber.Client.Composite>) {
+        const sortedKeys = keys.toSorted((a, b) => EventSequenceNumber.Client.compare(b, a))
+        const rollbackRecords = yield* Effect.forEach(
+          sortedKeys,
+          Effect.fnUntraced(function* (key) {
+            const [statement, bindValues] = findManyRows({
+              tableName: SystemTables.MATERIALIZATION_JOURNAL_META_TABLE,
+              columns: SystemTables.materializationJournalMetaTable.sqliteDef.columns,
+              where: {
+                seqNumGlobal: key.global,
+                seqNumClient: key.client,
+                seqNumRebaseGeneration: key.rebaseGeneration,
+              },
+              limit: 1,
+            })
+            const preparedBindValues = prepareBindValues(bindValues, statement)
+            const row = yield* Effect.try({
+              try: () => dbState.select<SystemTables.MaterializationJournalMetaRow>(statement, preparedBindValues)[0],
+              catch: (cause) => new SqliteError({ cause, query: { sql: statement, bindValues: preparedBindValues } }),
+            })
+
+            if (row === undefined) {
+              return yield* new MaterializationJournalError({
+                method: 'rollback',
+                cause: new Error(
+                  `Missing materialization journal record for ${EventSequenceNumber.Client.toString(key)}`,
+                ),
+              })
+            }
+
+            return {
+              key,
+              changeset:
+                row.changeset === null
+                  ? { _tag: 'no-op' as const }
+                  : { _tag: 'changeset' as const, data: row.changeset },
+            }
+          }),
+        )
+
+        for (const record of rollbackRecords) {
+          if (record.changeset._tag === 'changeset') {
+            const data = record.changeset.data
+            yield* Effect.try({
+              try: () => dbState.makeChangeset(data).invert().apply(),
+              catch: (cause) => new SqliteError({ cause }),
+            })
+          }
+        }
+
+        yield* deleteByKeys(sortedKeys)
+      },
+      SqliteDbHelper.withSavepoint(dbState),
+      Effect.mapError((cause) =>
+        isMaterializationJournalError(cause) === true
+          ? cause
+          : new MaterializationJournalError({ method: 'rollback', cause }),
+      ),
+    ),
+    discardUpTo: Effect.fnUntraced(
+      function* (key: EventSequenceNumber.Client.Composite) {
+        yield* execSql(
+          dbState,
+          sql`DELETE FROM ${SystemTables.MATERIALIZATION_JOURNAL_META_TABLE}
+              WHERE seqNumGlobal < ${key.global}
+                 OR (
+                  seqNumGlobal = ${key.global}
+                      AND seqNumClient <= ${key.client}
+                  )`,
+          {},
+        )
+      },
+      SqliteDbHelper.withSavepoint(dbState),
+      Effect.mapError((cause) => new MaterializationJournalError({ method: 'discardUpTo', cause })),
+    ),
+  })
+}
+
+export const layer = (options: Options) => Layer.succeed(MaterializationJournal, make(options))
+
+export const layerTest = Layer.succeed(
+  MaterializationJournal,
+  MaterializationJournal.of({
+    [TypeId]: TypeId,
+    record: () => Effect.void,
+    rollback: () => Effect.void,
+    discardUpTo: () => Effect.void,
+  }),
+)

package/src/StateHead.ts

@@ -0,0 +1,80 @@
+import { Context, Effect, Layer } from '@livestore/utils/effect'
+
+import type { SqliteDb, SqliteError } from './adapter-types.ts'
+import { execSql, selectSql } from './leader-thread/connection.ts'
+import * as EventSequenceNumber from './schema/EventSequenceNumber/mod.ts'
+import { SystemTables } from './schema/mod.ts'
+import { findManyRows, insertRow } from './sql-queries/index.ts'
+
+export const TypeId = '~@livestore/common/StateHead' as const
+export type TypeId = typeof TypeId
+
+const STATE_HEAD_ROW_ID = 1
+
+/**
+ * Persists and reads the latest event sequence number reflected by the state database.
+ */
+export interface Service {
+  readonly [TypeId]: TypeId
+  /** Persists the latest event sequence number reflected by the state database. */
+  set: (head: EventSequenceNumber.Client.Composite) => Effect.Effect<void, SqliteError>
+  /** Returns the persisted head, or the root when the current-schema table has no row. */
+  get: Effect.Effect<EventSequenceNumber.Client.Composite, SqliteError>
+}
+
+export class StateHead extends Context.Service<StateHead, Service>()('@livestore/common/StateHead') {}
+
+interface Options {
+  readonly dbState: SqliteDb
+}
+
+export const make = ({ dbState }: Options) => {
+  return StateHead.of({
+    [TypeId]: TypeId,
+    set: (head) => {
+      const [statement, bindValues] = insertRow({
+        tableName: SystemTables.STATE_HEAD_META_TABLE,
+        columns: SystemTables.stateHeadMetaTable.sqliteDef.columns,
+        values: {
+          id: STATE_HEAD_ROW_ID,
+          seqNumGlobal: head.global,
+          seqNumClient: head.client,
+          seqNumRebaseGeneration: head.rebaseGeneration,
+        },
+        options: { orReplace: true },
+      })
+
+      return execSql(dbState, statement, bindValues)
+    },
+    get: Effect.suspend(() => {
+      const [statement, bindValues] = findManyRows({
+        tableName: SystemTables.STATE_HEAD_META_TABLE,
+        columns: SystemTables.stateHeadMetaTable.sqliteDef.columns,
+        where: { id: STATE_HEAD_ROW_ID },
+        limit: 1,
+      })
+      return selectSql<SystemTables.StateHeadMetaRow>(dbState, statement, bindValues).pipe(
+        Effect.map(([row]) =>
+          row === undefined
+            ? EventSequenceNumber.Client.ROOT
+            : EventSequenceNumber.Client.Composite.make({
+                global: row.seqNumGlobal,
+                client: row.seqNumClient,
+                rebaseGeneration: row.seqNumRebaseGeneration,
+              }),
+        ),
+      )
+    }),
+  })
+}
+
+export const layer = (options: Options) => Layer.succeed(StateHead, make(options))
+
+export const layerTest = Layer.succeed(
+  StateHead,
+  StateHead.of({
+    [TypeId]: TypeId,
+    set: () => Effect.void,
+    get: Effect.succeed(EventSequenceNumber.Client.ROOT),
+  }),
+)

package/src/WorkerTransportError.ts

@@ -1,12 +1,12 @@
-import { ParseResult, WorkerError } from '@livestore/utils/effect'
+import { Schema, WorkerError } from '@livestore/utils/effect'
 
 /**
  * Type guard that identifies infrastructure errors from the Effect Worker transport layer.
  *
  * @remarks
  *
- * These errors ({@link WorkerError.WorkerError}, {@link ParseResult.ParseError}) represent communication failures between
+ * These errors ({@link WorkerError.WorkerError}, {@link Schema.SchemaError}) represent communication failures between
  * threads/processes — not application-level failures.
  */
-export const isWorkerTransportError = (e: unknown): e is WorkerError.WorkerError | ParseResult.ParseError =>
-  ParseResult.isParseError(e) || WorkerError.isWorkerError(e)
+export const isWorkerTransportError = (e: unknown): e is WorkerError.WorkerError | Schema.SchemaError =>
+  Schema.isSchemaError(e) || WorkerError.isWorkerError(e)

package/src/__tests__/fixture.ts

@@ -1,7 +1,7 @@
 import { Schema } from '@livestore/utils/effect'
 
-import { SessionIdSymbol } from '../adapter-types.ts'
 import { makeSchema, State } from '../schema/mod.ts'
+import { SessionIdSymbol } from '../session-id-symbol.ts'
 
 export const UiState = State.SQLite.clientDocument({
   name: 'UiState',
@@ -14,8 +14,8 @@ export const UiState = State.SQLite.clientDocument({
 })
 
 const Config = Schema.Struct({
-  fontSize: Schema.Number,
-  theme: Schema.Literal('light', 'dark'),
+  fontSize: Schema.Finite,
+  theme: Schema.Literals(['light', 'dark']),
 })
 
 export const appConfig = State.SQLite.clientDocument({

package/src/adapter-types.ts

@@ -2,6 +2,7 @@ import {
   type Effect,
   type Exit,
   type Queue,
+  type Latch,
   Schema,
   type Scope,
   type SubscriptionRef,
@@ -28,16 +29,13 @@ export * from './sqlite-types.ts'
 export interface ClientSession {
   /** SQLite database with synchronous API running in the same thread (usually in-memory) */
   sqliteDb: SqliteDb
-  devtools: { enabled: false } | { enabled: true; pullLatch: Effect.Latch; pushLatch: Effect.Latch }
+  devtools: { enabled: false } | { enabled: true; pullLatch: Latch.Latch; pushLatch: Latch.Latch }
   clientId: string
   sessionId: string
   /** Status info whether current session is leader or not */
   lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
   shutdown: (
-    cause: Exit.Exit<
-      IntentionalShutdownCause,
-      UnknownError | MaterializeError | BackendIdMismatchError
-    >,
+    cause: Exit.Exit<IntentionalShutdownCause, UnknownError | MaterializeError | BackendIdMismatchError>,
   ) => Effect.Effect<void>
   /** A proxy API to communicate with the leader thread */
   leaderThread: ClientSessionLeaderThreadProxy
@@ -48,8 +46,8 @@ export interface ClientSession {
 export type ResetMode = 'all-data' | 'only-app-db'
 
 export const BootStateProgress = Schema.Struct({
-  done: Schema.Number,
-  total: Schema.Number,
+  done: Schema.Finite,
+  total: Schema.Finite,
 })
 
 /**
@@ -60,7 +58,7 @@ export const BootStateProgress = Schema.Struct({
  * - `storage-unavailable`: OPFS access denied for other reasons (permissions, quota)
  * - `unknown`: Unexpected error during storage initialization
  */
-export const BootWarningReason = Schema.Literal('private-browsing', 'storage-unavailable', 'unknown')
+export const BootWarningReason = Schema.Literals(['private-browsing', 'storage-unavailable', 'unknown'])
 export type BootWarningReason = typeof BootWarningReason.Type
 
 /**
@@ -70,10 +68,10 @@ export type BootWarningReason = typeof BootWarningReason.Type
  * - `persisted`: Data is persisted to disk (e.g., via OPFS)
  * - `in-memory`: Data is only stored in memory and will be lost on page refresh
  */
-export const StorageMode = Schema.Literal('persisted', 'in-memory')
+export const StorageMode = Schema.Literals(['persisted', 'in-memory'])
 export type StorageMode = typeof StorageMode.Type
 
-export const BootStatus = Schema.Union(
+export const BootStatus = Schema.Union([
   Schema.Struct({ stage: Schema.Literal('loading') }),
   Schema.Struct({ stage: Schema.Literal('migrating'), progress: BootStateProgress }),
   Schema.Struct({ stage: Schema.Literal('rehydrating'), progress: BootStateProgress }),
@@ -88,67 +86,35 @@ export const BootStatus = Schema.Union(
     reason: BootWarningReason,
     message: Schema.String,
   }),
-).annotations({ title: 'BootStatus' })
+]).annotate({ title: 'BootStatus' })
 
 export type BootStatus = typeof BootStatus.Type
 
-/**
- * Can be used in queries to refer to the current session id.
- * Will be replaced with the actual session id at runtime
- *
- * In client document table:
- * ```ts
- * const uiState = State.SQLite.clientDocument({
- *   name: 'ui_state',
- *   schema: Schema.Struct({
- *     theme: Schema.Literal('dark', 'light', 'system'),
- *     user: Schema.String,
- *     showToolbar: Schema.Boolean,
- *   }),
- *   default: { value: defaultFrontendState, id: SessionIdSymbol },
- * })
- * ```
- *
- * Or in a client document query:
- * ```ts
- * const query$ = queryDb(tables.uiState.get(SessionIdSymbol))
- * ```
- */
-export const SessionIdSymbol = Symbol.for('@livestore/session-id')
-export type SessionIdSymbol = typeof SessionIdSymbol
-
 export type LockStatus = 'has-lock' | 'no-lock'
 
-// TODO possibly allow a combination of these options
 // TODO allow a way to stream the migration progress back to the app
-export type MigrationOptions =
-  | {
-      strategy: 'auto'
-      hooks?: Partial<MigrationHooks>
-      logging?: {
-        excludeAffectedRows?: (sqlStmt: string) => boolean
-      }
-    }
-  | {
-      strategy: 'manual'
-      migrate: (
-        oldDb: Uint8Array<ArrayBuffer>,
-      ) => Uint8Array<ArrayBuffer> | Promise<Uint8Array<ArrayBuffer>> | Effect.Effect<Uint8Array<ArrayBuffer>, unknown>
-    }
+export type MigrationOptions = {
+  hooks?: Partial<MigrationHooks>
+  logging?: {
+    excludeAffectedRows?: (sqlStmt: string) => boolean
+  }
+}
 
 export type MigrationHooks = {
   /** Runs on the empty in-memory database with no database schemas applied yet */
   init: MigrationHook
-  /** Runs before applying the migration strategy but after table schemas have been applied and singleton rows have been created */
+  /** Runs after table schemas and singleton rows are created, but before rematerializing state from the eventlog */
   pre: MigrationHook
-  /** Runs after applying the migration strategy before creating export snapshot and closing the database */
+  /** Runs after rematerializing state from the eventlog */
   post: MigrationHook
 }
 
 export type MigrationHook = (db: SqliteDb) => void | Promise<void> | Effect.Effect<void, unknown>
 
-export interface ClientSessionDevtoolsChannel
-  extends WebChannel.WebChannel<Devtools.ClientSession.MessageToApp, Devtools.ClientSession.MessageFromApp> {}
+export interface ClientSessionDevtoolsChannel extends WebChannel.WebChannel<
+  Devtools.ClientSession.MessageToApp,
+  Devtools.ClientSession.MessageFromApp
+> {}
 
 export type ConnectDevtoolsToStore = (
   storeDevtoolsChannel: ClientSessionDevtoolsChannel,
@@ -159,14 +125,15 @@ export type Adapter = (args: AdapterArgs) => Effect.Effect<ClientSession, Unknow
 export interface AdapterArgs {
   schema: LiveStoreSchema
   storeId: string
+  /** Runtime parameters resolved by `createStore` before the adapter is invoked. */
+  params: {
+    stateRebuildBatchSize: number
+  }
   devtoolsEnabled: boolean
   debugInstanceId: string
   bootStatusQueue: Queue.Queue<BootStatus>
   shutdown: (
-    exit: Exit.Exit<
-      IntentionalShutdownCause,
-      UnknownError | MaterializeError | BackendIdMismatchError
-    >,
+    exit: Exit.Exit<IntentionalShutdownCause, UnknownError | MaterializeError | BackendIdMismatchError>,
   ) => Effect.Effect<void>
   connectDevtoolsToStore: ConnectDevtoolsToStore
   /**
@@ -174,7 +141,7 @@ export interface AdapterArgs {
    *
    * @default undefined
    */
-  syncPayloadSchema: Schema.Schema<any> | undefined
+  syncPayloadSchema: Schema.Decoder<Schema.Json> | undefined
   /** Encoded representation of the sync payload matching `syncPayloadSchema`. */
-  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.Json | undefined
 }

package/src/debug-info.ts

@@ -1,5 +1,5 @@
 /// <reference lib="dom" />
-import { ParseResult, Schema } from '@livestore/utils/effect'
+import { Schema, SchemaGetter, Struct } from '@livestore/utils/effect'
 
 import { BoundArray } from './bounded-collections.ts'
 import { PreparedBindValues } from './util.ts'
@@ -16,93 +16,76 @@ export type SlowQueryInfo = {
 export const SlowQueryInfo = Schema.Struct({
   queryStr: Schema.String,
   bindValues: Schema.UndefinedOr(PreparedBindValues),
-  durationMs: Schema.Number,
-  rowsCount: Schema.UndefinedOr(Schema.Number),
+  durationMs: Schema.Finite,
+  rowsCount: Schema.UndefinedOr(Schema.Finite),
   queriedTables: Schema.ReadonlySet(Schema.String),
-  startTimePerfNow: Schema.Number,
+  startTimePerfNow: Schema.Finite,
 })
 
-const getSizeLimit = (value: unknown): number =>
-  typeof (value as { sizeLimit?: number }).sizeLimit === 'number'
-    ? (value as { sizeLimit: number }).sizeLimit
-    : Number.POSITIVE_INFINITY
+const isBoundArrayLike = <A>(value: unknown): value is BoundArray<A> => value instanceof BoundArray
 
-const isBoundArrayLike = (value: unknown): value is BoundArray<unknown> =>
-  value instanceof BoundArray ||
-  (value !== null && typeof value === 'object' && typeof (value as { sizeLimit?: number }).sizeLimit === 'number')
-
-const BoundArraySchemaFromSelf = <A, I, R>(
-  item: Schema.Schema<A, I, R>,
-): Schema.Schema<BoundArray<A>, BoundArray<I>, R> =>
-  Schema.declare(
-    [item],
-    {
-      decode: (item) => (input, parseOptions, ast) => {
-        if (isBoundArrayLike(input) === true) {
-          const elements = ParseResult.decodeUnknown(Schema.Array(item))([...input], parseOptions)
-          return ParseResult.map(elements, (as): BoundArray<A> => BoundArray.make(getSizeLimit(input), as))
+const BoundArraySchemaFromSelf = <A, I, RD, RE>(
+  item: Schema.Codec<A, I, RD, RE>,
+): Schema.Codec<BoundArray<A>, BoundArray<A>> =>
+  Schema.declare<BoundArray<A>>(isBoundArrayLike, {
+    identifier: 'BoundArray',
+    expected: 'BoundArray',
+    description: 'Bounded array',
+    toFormatter: () => (_) => `BoundArray(${_.length})`,
+    toCodecArbitrary: () =>
+      Schema.link<BoundArray<A>>()(
+        Schema.Struct({
+          size: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 })),
+          items: Schema.Array(item).check(Schema.isMaxLength(100)),
+        }),
+        {
+          decode: SchemaGetter.transform(({ size, items }) => BoundArray.make(size, items)),
+          encode: SchemaGetter.forbiddenEncoding,
+        },
+      ),
+    toEquivalence: () => {
+      const elementEquivalence = Schema.toEquivalence(item)
+      return (a, b) => {
+        if (a === b) {
+          return true
         }
-        return ParseResult.fail(new ParseResult.Type(ast, input))
-      },
-      encode: (item) => (input, parseOptions, ast) => {
-        if (isBoundArrayLike(input) === true) {
-          const items = [...input]
-          const elements = ParseResult.encodeUnknown(Schema.Array(item))(items, parseOptions)
-          return ParseResult.map(elements, (is): BoundArray<I> => BoundArray.make(getSizeLimit(input), is))
+        if (isBoundArrayLike(a) === false || isBoundArrayLike(b) === false) {
+          return false
         }
-        return ParseResult.fail(new ParseResult.Type(ast, input))
-      },
-    },
-    {
-      description: `BoundArray<${Schema.format(item)}>`,
-      pretty: () => (_) => `BoundArray(${_.length})`,
-      arbitrary: () => (fc) => fc.anything() as any,
-      equivalence: () => {
-        const elementEquivalence = Schema.equivalence(item)
-        return (a: unknown, b: unknown) => {
-          if (a === b) {
-            return true
-          }
-          if (isBoundArrayLike(a) === false || isBoundArrayLike(b) === false) {
-            return false
-          }
-          if (getSizeLimit(a) !== getSizeLimit(b) || a.length !== b.length) {
+        if (a.sizeLimit !== b.sizeLimit || a.length !== b.length) {
+          return false
+        }
+        const itemsA = [...a]
+        const itemsB = [...b]
+        for (let i = 0; i < itemsA.length; i++) {
+          if (elementEquivalence(itemsA[i]!, itemsB[i]!) === false) {
             return false
           }
-          const itemsA = [...a]
-          const itemsB = [...b]
-          for (let i = 0; i < itemsA.length; i++) {
-            if (elementEquivalence(itemsA[i] as any, itemsB[i] as any) === false) {
-              return false
-            }
-          }
-          return true
         }
-      },
+        return true
+      }
     },
-  )
+  })
 
-export const BoundArraySchema = <ItemDecoded, ItemEncoded>(elSchema: Schema.Schema<ItemDecoded, ItemEncoded>) =>
-  Schema.transform(
-    Schema.Struct({
-      size: Schema.Number,
-      items: Schema.Array(elSchema),
+export const BoundArraySchema = <ItemDecoded, ItemEncoded>(elSchema: Schema.Codec<ItemDecoded, ItemEncoded>) =>
+  Schema.Struct({
+    size: Schema.Finite,
+    items: Schema.Array(elSchema),
+  }).pipe(
+    Schema.decodeTo(BoundArraySchemaFromSelf(Schema.toType(elSchema)), {
+      decode: SchemaGetter.transform((_) => BoundArray.make(_.size, _.items)),
+      encode: SchemaGetter.transform((_) => ({ size: _.sizeLimit, items: [..._] })),
     }),
-    BoundArraySchemaFromSelf(Schema.typeSchema(elSchema)),
-    {
-      encode: (_) => ({ size: _.sizeLimit, items: [..._] }),
-      decode: (_) => BoundArray.make(_.size, _.items),
-    },
   )
 
 export const DebugInfo = Schema.Struct({
   slowQueries: BoundArraySchema(SlowQueryInfo),
-  queryFrameDuration: Schema.Number,
-  queryFrameCount: Schema.Number,
-  events: BoundArraySchema(Schema.Tuple(Schema.String, Schema.Any)),
+  queryFrameDuration: Schema.Finite,
+  queryFrameCount: Schema.Finite,
+  events: BoundArraySchema(Schema.Tuple([Schema.String, Schema.Any])),
 })
 
 export type DebugInfo = typeof DebugInfo.Type
 
-export const MutableDebugInfo = Schema.mutable(DebugInfo)
+export const MutableDebugInfo = DebugInfo.mapFields(Struct.map(Schema.mutableKey))
 export type MutableDebugInfo = typeof MutableDebugInfo.Type

package/src/defs.ts

@@ -3,8 +3,8 @@ import { Schema } from '@livestore/utils/effect'
 export const MigrationsReportEntry = Schema.Struct({
   tableName: Schema.String,
   hashes: Schema.Struct({
-    expected: Schema.Number,
-    actual: Schema.optional(Schema.Number),
+    expected: Schema.String,
+    actual: Schema.optional(Schema.String),
   }),
 })
 

package/src/devtools/devtools-compatibility.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import { isDevtoolsProtocolVersionSupported, resolveDevtoolsProtocolVersion } from '../version.ts'
 
+/** Verifies: LS.SYS.DT-R02, LS.SYS.VER.PROTO-R01 */
 describe('DevTools protocol compatibility', () => {
   it('treats legacy pings without a protocol version as protocol 1', () => {
     expect(resolveDevtoolsProtocolVersion(undefined)).toBe(1)