@livestore/common 0.0.54-dev.3 → 0.0.54-dev.31

package/src/devtools/devtools-messages.ts

@@ -1,11 +1,10 @@
-import { version as pkgVersion } from '@livestore/common/package.json'
-import { Schema } from '@livestore/utils/effect'
-import { type SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+import { Schema, Transferable } from '@livestore/utils/effect'
 
 import { NetworkStatus } from '../adapter-types.js'
 import { DebugInfo } from '../debug-info.js'
 import { mutationEventSchemaEncodedAny } from '../schema/mutations.js'
 import { PreparedBindValues } from '../util.js'
+import { liveStoreVersion as pkgVersion } from '../version.js'
 
 const requestId = Schema.String
 const channelId = Schema.String
@@ -15,36 +14,67 @@ export class SnapshotReq extends Schema.TaggedStruct('LSD.SnapshotReq', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.SnapshotReq' }) {}
 
 export class SnapshotRes extends Schema.TaggedStruct('LSD.SnapshotRes', {
   liveStoreVersion,
   requestId,
-  snapshot: Schema.Uint8Array,
-}) {}
+  snapshot: Transferable.Uint8Array,
+}).annotations({ identifier: 'LSD.SnapshotRes' }) {}
+
+export class LoadDatabaseFileReq extends Schema.TaggedStruct('LSD.LoadDatabaseFileReq', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+  data: Transferable.Uint8Array,
+}).annotations({ identifier: 'LSD.LoadDatabaseFileReq' }) {}
+
+export class LoadDatabaseFileRes extends Schema.TaggedStruct('LSD.LoadDatabaseFileRes', {
+  liveStoreVersion,
+  requestId,
+  status: Schema.Literal('ok', 'unsupported-file', 'unsupported-database'),
+}).annotations({ identifier: 'LSD.LoadDatabaseFileRes' }) {}
 
 export class DebugInfoReq extends Schema.TaggedStruct('LSD.DebugInfoReq', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.DebugInfoReq' }) {}
 
 export class DebugInfoRes extends Schema.TaggedStruct('LSD.DebugInfoRes', {
   liveStoreVersion,
   requestId,
   debugInfo: DebugInfo,
-}) {}
+}).annotations({ identifier: 'LSD.DebugInfoRes' }) {}
+
+export class DebugInfoHistorySubscribe extends Schema.TaggedStruct('LSD.DebugInfoHistorySubscribe', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+}).annotations({ identifier: 'LSD.DebugInfoHistorySubscribe' }) {}
+
+export class DebugInfoHistoryRes extends Schema.TaggedStruct('LSD.DebugInfoHistoryRes', {
+  liveStoreVersion,
+  requestId,
+  debugInfoHistory: Schema.Array(DebugInfo),
+}).annotations({ identifier: 'LSD.DebugInfoHistoryRes' }) {}
+
+export class DebugInfoHistoryUnsubscribe extends Schema.TaggedStruct('LSD.DebugInfoHistoryUnsubscribe', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+}).annotations({ identifier: 'LSD.DebugInfoHistoryUnsubscribe' }) {}
 
 export class DebugInfoResetReq extends Schema.TaggedStruct('LSD.DebugInfoResetReq', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.DebugInfoResetReq' }) {}
 
 export class DebugInfoResetRes extends Schema.TaggedStruct('LSD.DebugInfoResetRes', {
   liveStoreVersion,
   requestId,
-}) {}
+}).annotations({ identifier: 'LSD.DebugInfoResetRes' }) {}
 
 export class DebugInfoRerunQueryReq extends Schema.TaggedStruct('LSD.DebugInfoRerunQueryReq', {
   liveStoreVersion,
@@ -53,62 +83,76 @@ export class DebugInfoRerunQueryReq extends Schema.TaggedStruct('LSD.DebugInfoRe
   queryStr: Schema.String,
   bindValues: Schema.UndefinedOr(PreparedBindValues),
   queriedTables: Schema.ReadonlySet(Schema.String),
-}) {}
+}).annotations({ identifier: 'LSD.DebugInfoRerunQueryReq' }) {}
 
 export class DebugInfoRerunQueryRes extends Schema.TaggedStruct('LSD.DebugInfoRerunQueryRes', {
   liveStoreVersion,
   requestId,
-}) {}
+}).annotations({ identifier: 'LSD.DebugInfoRerunQueryRes' }) {}
 
 export class MutationBroadcast extends Schema.TaggedStruct('LSD.MutationBroadcast', {
+  liveStoreVersion,
+  mutationEventEncoded: mutationEventSchemaEncodedAny,
+  persisted: Schema.Boolean,
+}).annotations({ identifier: 'LSD.MutationBroadcast' }) {}
+
+export class RunMutationReq extends Schema.TaggedStruct('LSD.RunMutationReq', {
   liveStoreVersion,
   requestId,
+  channelId,
   mutationEventEncoded: mutationEventSchemaEncodedAny,
   persisted: Schema.Boolean,
-}) {}
+}).annotations({ identifier: 'LSD.RunMutationReq' }) {}
+
+export class RunMutationRes extends Schema.TaggedStruct('LSD.RunMutationRes', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+}).annotations({ identifier: 'LSD.RunMutationRes' }) {}
 
 export class MutationLogReq extends Schema.TaggedStruct('LSD.MutationLogReq', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.MutationLogReq' }) {}
 
 export class MutationLogRes extends Schema.TaggedStruct('LSD.MutationLogRes', {
   liveStoreVersion,
   requestId,
-  mutationLog: Schema.Uint8Array,
-}) {}
+  channelId,
+  mutationLog: Transferable.Uint8Array,
+}).annotations({ identifier: 'LSD.MutationLogRes' }) {}
 
-export class SignalsSubscribe extends Schema.TaggedStruct('LSD.SignalsSubscribe', {
+export class ReactivityGraphSubscribe extends Schema.TaggedStruct('LSD.ReactivityGraphSubscribe', {
   liveStoreVersion,
   requestId,
   channelId,
   includeResults: Schema.Boolean,
-}) {}
+}).annotations({ identifier: 'LSD.ReactivityGraphSubscribe' }) {}
 
-export class SignalsUnsubscribe extends Schema.TaggedStruct('LSD.SignalsUnsubscribe', {
+export class ReactivityGraphUnsubscribe extends Schema.TaggedStruct('LSD.ReactivityGraphUnsubscribe', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.ReactivityGraphUnsubscribe' }) {}
 
-export class SignalsRes extends Schema.TaggedStruct('LSD.SignalsRes', {
+export class ReactivityGraphRes extends Schema.TaggedStruct('LSD.ReactivityGraphRes', {
   liveStoreVersion,
   requestId,
-  signals: Schema.Any,
-}) {}
+  reactivityGraph: Schema.Any,
+}).annotations({ identifier: 'LSD.ReactivityGraphRes' }) {}
 
 export class LiveQueriesSubscribe extends Schema.TaggedStruct('LSD.LiveQueriesSubscribe', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.LiveQueriesSubscribe' }) {}
 
 export class LiveQueriesUnsubscribe extends Schema.TaggedStruct('LSD.LiveQueriesUnsubscribe', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.LiveQueriesUnsubscribe' }) {}
 
 export class SerializedLiveQuery extends Schema.Struct({
   _tag: Schema.Literal('js', 'sql', 'graphql'),
@@ -120,94 +164,131 @@ export class SerializedLiveQuery extends Schema.Struct({
   activeSubscriptions: Schema.Array(
     Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) }),
   ),
-}) {}
+}).annotations({ identifier: 'SerializedLiveQuery' }) {}
 
 export class LiveQueriesRes extends Schema.TaggedStruct('LSD.LiveQueriesRes', {
   liveStoreVersion,
   requestId,
   liveQueries: Schema.Array(SerializedLiveQuery),
-}) {}
+}).annotations({ identifier: 'LSD.LiveQueriesRes' }) {}
 
 export class ResetAllDataReq extends Schema.TaggedStruct('LSD.ResetAllDataReq', {
   liveStoreVersion,
   requestId,
   channelId,
   mode: Schema.Literal('all-data', 'only-app-db'),
-}) {}
+}).annotations({ identifier: 'LSD.ResetAllDataReq' }) {}
 
 export class ResetAllDataRes extends Schema.TaggedStruct('LSD.ResetAllDataRes', {
   liveStoreVersion,
   requestId,
-}) {}
+}).annotations({ identifier: 'LSD.ResetAllDataRes' }) {}
 
-export class NetworkStatusBroadcast extends Schema.TaggedStruct('LSD.NetworkStatusBroadcast', {
+export class MessagePortForStoreReq extends Schema.TaggedStruct('LSD.MessagePortForStoreReq', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+}).annotations({ identifier: 'LSD.MessagePortForStoreReq' }) {}
+
+export class MessagePortForStoreRes extends Schema.TaggedStruct('LSD.MessagePortForStoreRes', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+  port: Transferable.MessagePort,
+}).annotations({ identifier: 'LSD.MessagePortForStoreRes' }) {}
+
+export class NetworkStatusChanged extends Schema.TaggedStruct('LSD.NetworkStatusChanged', {
   liveStoreVersion,
   channelId,
   networkStatus: NetworkStatus,
-}) {}
+}).annotations({ identifier: 'LSD.NetworkStatusChanged' }) {}
 
-export class DevtoolsReadyBroadcast extends Schema.TaggedStruct('LSD.DevtoolsReadyBroadcast', {
+export class DevtoolsReady extends Schema.TaggedStruct('LSD.DevtoolsReady', {
   liveStoreVersion,
-}) {}
+}).annotations({ identifier: 'LSD.DevtoolsReady' }) {}
 
 export class DevtoolsConnected extends Schema.TaggedStruct('LSD.DevtoolsConnected', {
   liveStoreVersion,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.DevtoolsConnected' }) {}
 
-export class AppHostReadyBroadcast extends Schema.TaggedStruct('LSD.AppHostReadyBroadcast', {
+export class AppHostReady extends Schema.TaggedStruct('LSD.AppHostReady', {
   liveStoreVersion,
   channelId,
-}) {}
+  isLeaderTab: Schema.Boolean,
+}).annotations({ identifier: 'LSD.AppHostReady' }) {}
 
 export class Disconnect extends Schema.TaggedStruct('LSD.Disconnect', {
   liveStoreVersion,
   requestId,
   channelId,
-}) {}
+}).annotations({ identifier: 'LSD.Disconnect' }) {}
 
-// export class SchemaChanged extends Schema.TaggedStruct('LSD.SchemaChanged', {
-//   requestId,
-// }) {}
+export class Ping extends Schema.TaggedStruct('LSD.Ping', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+}).annotations({ identifier: 'LSD.Ping' }) {}
+
+export class Pong extends Schema.TaggedStruct('LSD.Pong', {
+  liveStoreVersion,
+  requestId,
+}).annotations({ identifier: 'LSD.Pong' }) {}
 
-export const MessageToAppHost = Schema.Union(
+export const MessageToAppHostCoordinator = Schema.Union(
   SnapshotReq,
+  LoadDatabaseFileReq,
   MutationLogReq,
+  ResetAllDataReq,
+  MessagePortForStoreRes,
+  DevtoolsReady,
+  Disconnect,
+  DevtoolsConnected,
+  RunMutationReq,
+  Ping,
+).annotations({ identifier: 'LSD.MessageToAppHostCoordinator' })
+
+export type MessageToAppHostCoordinator = typeof MessageToAppHostCoordinator.Type
+
+export const MessageToAppHostStore = Schema.Union(
   DebugInfoReq,
+  DebugInfoHistorySubscribe,
+  DebugInfoHistoryUnsubscribe,
   DebugInfoResetReq,
   DebugInfoRerunQueryReq,
-  SignalsSubscribe,
-  SignalsUnsubscribe,
+  ReactivityGraphSubscribe,
+  ReactivityGraphUnsubscribe,
   LiveQueriesSubscribe,
   LiveQueriesUnsubscribe,
-  ResetAllDataReq,
-  DevtoolsReadyBroadcast,
-  Disconnect,
-  DevtoolsConnected,
-)
+  // Ping,
+).annotations({ identifier: 'LSD.MessageToAppHostStore' })
 
-export type MessageToAppHost = typeof MessageToAppHost.Type
+export type MessageToAppHostStore = typeof MessageToAppHostStore.Type
 
-export const MessageFromAppHost = Schema.Union(
+export const MessageFromAppHostCoordinator = Schema.Union(
   SnapshotRes,
+  LoadDatabaseFileRes,
   MutationLogRes,
-  DebugInfoRes,
-  DebugInfoResetRes,
-  DebugInfoRerunQueryRes,
-  SignalsRes,
-  LiveQueriesRes,
   ResetAllDataRes,
+  MessagePortForStoreReq,
   Disconnect,
-  // SchemaChanged,
   MutationBroadcast,
-  AppHostReadyBroadcast,
-  NetworkStatusBroadcast,
-)
+  AppHostReady,
+  NetworkStatusChanged,
+  RunMutationRes,
+  Pong,
+).annotations({ identifier: 'LSD.MessageFromAppHostCoordinator' })
 
-export type MessageFromAppHost = typeof MessageFromAppHost.Type
+export type MessageFromAppHostCoordinator = typeof MessageFromAppHostCoordinator.Type
+
+export const MessageFromAppHostStore = Schema.Union(
+  DebugInfoRes,
+  DebugInfoHistoryRes,
+  DebugInfoResetRes,
+  DebugInfoRerunQueryRes,
+  ReactivityGraphRes,
+  LiveQueriesRes,
+  // Pong,
+).annotations({ identifier: 'LSD.MessageFromAppHostStore' })
 
-// TODO make specific over app key
-export const makeBroadcastChannels = () => ({
-  fromAppHost: new BroadcastChannel(`livestore-devtools-from-app-host`),
-  toAppHost: new BroadcastChannel(`livestore-devtools-to-app-host`),
-})
+export type MessageFromAppHostStore = typeof MessageFromAppHostStore.Type

package/src/devtools/devtools-window-message.ts

@@ -0,0 +1,27 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+const channelId = Schema.String
+
+export namespace DevtoolsWindowMessage {
+  /** Message is being created in contentscript-iframe, sent to contentscript and then sent to Store */
+  export class MessagePortReady extends Schema.TaggedStruct('LSD.WindowMessage.MessagePortForStore', {
+    port: Transferable.MessagePort,
+    channelId,
+  }) {}
+
+  export class ContentscriptListening extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptListening', {}) {}
+
+  // export class ContentscriptReady extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptReady', {
+  // 	channelId,
+  // }) {}
+
+  export class LoadIframe extends Schema.TaggedStruct('LSD.WindowMessage.LoadIframe', {}) {}
+
+  export class StoreReady extends Schema.TaggedStruct('LSD.WindowMessage.StoreReady', {
+    channelId,
+  }) {}
+
+  export class MessageForStore extends Schema.Union(MessagePortReady, ContentscriptListening) {}
+
+  export class MessageForContentscript extends Schema.Union(StoreReady, LoadIframe) {}
+}

package/src/devtools/index.ts

@@ -1 +1,2 @@
 export * from './devtools-messages.js'
+export * from './devtools-window-message.js'

package/src/index.ts

@@ -11,3 +11,4 @@ export * from './sync/index.js'
 export * as Devtools from './devtools/index.js'
 export * from './debug-info.js'
 export * from './bounded-collections.js'
+export * from './version.js'

package/src/rehydrate-from-mutationlog.ts

@@ -1,91 +1,126 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
+import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
-import type { InMemoryDatabase, MigrationOptionsFromMutationLog } from './adapter-types.js'
+import { type InMemoryDatabase, type MigrationOptionsFromMutationLog, SqliteError } from './adapter-types.js'
 import { getExecArgsFromMutation } from './mutation.js'
 import type { LiveStoreSchema, MutationLogMetaRow } from './schema/index.js'
 import { MUTATION_LOG_META_TABLE } from './schema/index.js'
+import type { PreparedBindValues } from './util.js'
+import { sql } from './util.js'
 
-export const rehydrateFromMutationLog = async ({
+export const rehydrateFromMutationLog = ({
   logDb,
   db,
   schema,
   migrationOptions,
+  onProgress,
 }: {
   logDb: InMemoryDatabase
   db: InMemoryDatabase
   schema: LiveStoreSchema
   migrationOptions: MigrationOptionsFromMutationLog
-}) => {
-  try {
-    // TODO possibly implement this in a streaming fashion
-    const stmt = logDb.prepare(`SELECT * FROM ${MUTATION_LOG_META_TABLE} ORDER BY id ASC`)
-    const results = stmt.select<MutationLogMetaRow>(undefined)
+  onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
+}) =>
+  Effect.gen(function* () {
+    const mutationsCount = logDb
+      .prepare(`SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`)
+      .select<{ count: number }>(undefined)[0]!.count
 
-    performance.mark('livestore:hydrate-from-mutationlog:start')
+    const processMutation = (row: MutationLogMetaRow) =>
+      Effect.gen(function* () {
+        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
 
-    for (const row of results) {
-      const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
+        if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
 
-      if (migrationOptions.excludeMutations?.has(row.mutation) === true) continue
-
-      if (Schema.hash(mutationDef.schema) !== row.schemaHash) {
-        console.warn(`Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`)
-      }
+        if (Schema.hash(mutationDef.schema) !== row.schemaHash) {
+          console.warn(`Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`)
+        }
 
-      const argsDecodedEither = Schema.decodeUnknownEither(Schema.parseJson(mutationDef.schema))(row.argsJson)
-      if (argsDecodedEither._tag === 'Left') {
-        return shouldNeverHappen(`\
+        const argsDecodedEither = Schema.decodeUnknownEither(Schema.parseJson(mutationDef.schema))(row.argsJson)
+        if (argsDecodedEither._tag === 'Left') {
+          return shouldNeverHappen(`\
 There was an error decoding the persisted mutation event args for mutation "${row.mutation}".
 This likely means the schema has changed in an incompatible way.
 
 Error: ${argsDecodedEither.left}
         `)
-      }
-
-      const mutationEventDecoded = {
-        id: row.id,
-        mutation: row.mutation,
-        args: argsDecodedEither.right,
-      }
-      // const argsEncoded = JSON.parse(row.args_json)
-      // const mutationSqlRes =
-      //   typeof mutation.sql === 'string'
-      //     ? mutation.sql
-      //     : mutation.sql(Schema.decodeUnknownSync(mutation.schema)(argsEncoded))
-      // const mutationSql = typeof mutationSqlRes === 'string' ? mutationSqlRes : mutationSqlRes.sql
-      // const bindValues = typeof mutationSqlRes === 'string' ? argsEncoded : mutationSqlRes.bindValues
-
-      const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-      for (const { statementSql, bindValues } of execArgsArr) {
-        try {
-          const getRowsChanged = db.execute(statementSql, bindValues)
-          if (
-            import.meta.env.DEV &&
-            getRowsChanged() === 0 &&
-            migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true
-          ) {
-            console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+        }
+
+        const mutationEventDecoded = {
+          id: row.id,
+          mutation: row.mutation,
+          args: argsDecodedEither.right,
+        }
+        // const argsEncoded = JSON.parse(row.args_json)
+        // const mutationSqlRes =
+        //   typeof mutation.sql === 'string'
+        //     ? mutation.sql
+        //     : mutation.sql(Schema.decodeUnknownSync(mutation.schema)(argsEncoded))
+        // const mutationSql = typeof mutationSqlRes === 'string' ? mutationSqlRes : mutationSqlRes.sql
+        // const bindValues = typeof mutationSqlRes === 'string' ? argsEncoded : mutationSqlRes.bindValues
+
+        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+
+        for (const { statementSql, bindValues } of execArgsArr) {
+          try {
+            // TODO cache prepared statements for mutations
+            const getRowsChanged = db.execute(statementSql, bindValues)
+            if (
+              import.meta.env.DEV &&
+              getRowsChanged() === 0 &&
+              migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true
+            ) {
+              console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+            }
+            // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
+          } catch (e) {
+            yield* new SqliteError({
+              sql: statementSql,
+              bindValues,
+              code: (e as any).resultCode,
+              cause: e,
+            })
           }
-          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-        } catch (e) {
-          console.error(`Error executing migration for mutation ${statementSql}`, bindValues, e)
-          debugger
-          throw e
         }
-      }
-    }
-  } catch (e) {
-    console.error('Error while rehydrating database from mutation log', e)
-    debugger
-    throw e
-  } finally {
-    performance.mark('livestore:hydrate-from-mutationlog:end')
-    performance.measure(
-      'livestore:hydrate-from-mutationlog',
-      'livestore:hydrate-from-mutationlog:start',
-      'livestore:hydrate-from-mutationlog:end',
+      }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
+
+    const CHUNK_SIZE = 100
+
+    const stmt = logDb.prepare(sql`\
+SELECT * FROM ${MUTATION_LOG_META_TABLE} 
+WHERE id > COALESCE($id, '') 
+ORDER BY id ASC
+LIMIT ${CHUNK_SIZE}
+`)
+
+    let processedMutations = 0
+
+    yield* Stream.unfoldChunk<Chunk.Chunk<MutationLogMetaRow> | { _tag: 'Initial ' }, MutationLogMetaRow>(
+      { _tag: 'Initial ' },
+      (item) => {
+        // End stream if no more rows
+        if (Chunk.isChunk(item) && item.length === 0) return Option.none()
+
+        const lastId = Chunk.isChunk(item) ? Chunk.last(item).pipe(Option.getOrUndefined)?.id : undefined
+        const nextItem = Chunk.fromIterable(
+          stmt.select<MutationLogMetaRow>({ $id: lastId } as any as PreparedBindValues),
+        )
+        const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
+        return Option.some([prevItem, nextItem])
+      },
+    ).pipe(
+      Stream.bufferChunks({ capacity: 2 }),
+      Stream.tap((row) =>
+        Effect.gen(function* () {
+          yield* processMutation(row)
+
+          processedMutations++
+          yield* onProgress({ done: processedMutations, total: mutationsCount })
+        }),
+      ),
+      Stream.runDrain,
     )
-  }
-}
+  }).pipe(
+    Effect.withPerformanceMeasure('@livestore/common:rehydrateFromMutationLog'),
+    Effect.withSpan('@livestore/common:rehydrateFromMutationLog'),
+  )

package/src/schema/mutations.ts

@@ -1,3 +1,4 @@
+import { memoizeByRef } from '@livestore/utils'
 import { cuid } from '@livestore/utils/cuid'
 import { Schema } from '@livestore/utils/effect'
 
@@ -92,7 +93,7 @@ export const rawSqlMutation = defineMutation(
   'livestore.RawSql',
   Schema.Struct({
     sql: Schema.String,
-    bindValues: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+    bindValues: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
     writeTables: Schema.optional(Schema.ReadonlySet(Schema.String)),
   }),
   ({ sql, bindValues, writeTables }) => ({ sql, bindValues: bindValues ?? {}, writeTables }),
@@ -139,11 +140,11 @@ export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> =
   }[keyof TMutationsDefRecord]
 >
 
-export const makeMutationEventSchema = <TMutationsDefRecord extends MutationDefRecord>(
-  mutationDefRecord: TMutationsDefRecord,
-): MutationEventSchema<TMutationsDefRecord> =>
+export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
+  schema: TSchema,
+): MutationEventSchema<TSchema['_MutationDefMapType']> =>
   Schema.Union(
-    ...Object.values(mutationDefRecord).map((def) =>
+    ...[...schema.mutations.values()].map((def) =>
       Schema.Struct({
         mutation: Schema.Literal(def.name),
         args: def.schema,
@@ -152,6 +153,8 @@ export const makeMutationEventSchema = <TMutationsDefRecord extends MutationDefR
     ),
   ).annotations({ title: 'MutationEventSchema' }) as any
 
+export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
+
 export const mutationEventSchemaDecodedAny = Schema.Struct({
   mutation: Schema.String,
   args: Schema.Any,

package/src/schema/table-def.ts

@@ -86,8 +86,6 @@ export type TableOptions = {
    * @default false
    */
   isSingleton: boolean
-  // TODO remove
-  dynamicRegistration: boolean
   disableAutomaticIdColumn: boolean
   /**
    * Setting this to true will automatically derive insert, update and delete mutations for this table. Example:
@@ -139,7 +137,6 @@ export const table = <
 
   const options_: TableOptions = {
     isSingleton: options?.isSingleton ?? false,
-    dynamicRegistration: options?.dynamicRegistration ?? false,
     disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
     deriveMutations:
       options?.deriveMutations === true
@@ -239,7 +236,6 @@ type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> =
 
 type WithDefaults<TOptionsInput extends TableOptionsInput, TIsSingleColumn extends boolean> = {
   isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
-  dynamicRegistration: TOptionsInput['dynamicRegistration'] extends true ? true : false
   disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
   deriveMutations: TOptionsInput['deriveMutations'] extends true
     ? { enabled: true; localOnly: boolean }