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

package/dist/sync/next/test/mutation-fixtures.d.ts

@@ -10,18 +10,18 @@ export declare const facts: {
 };
 export declare const mutations: {
     createTodo: MutationDef<"createTodo", {
-        readonly id: string;
         readonly text: string;
-    }, {
         readonly id: string;
+    }, {
         readonly text: string;
+        readonly id: string;
     }>;
     upsertTodo: MutationDef<"upsertTodo", {
         readonly id: string;
         readonly text?: string | undefined;
     }, {
-        readonly id: string;
         readonly text?: string | undefined;
+        readonly id: string;
     }>;
     completeTodo: MutationDef<"completeTodo", {
         readonly id: string;
@@ -51,18 +51,18 @@ export declare const mutations: {
         readonly readonly: boolean;
     }>;
     setTextTodo: MutationDef<"setTextTodo", {
-        readonly id: string;
         readonly text: string;
-    }, {
         readonly id: string;
+    }, {
         readonly text: string;
+        readonly id: string;
     }>;
     setInputValue: MutationDef<"setInputValue", {
-        readonly id: string;
         readonly text: string;
-    }, {
         readonly id: string;
+    }, {
         readonly text: string;
+        readonly id: string;
     }>;
 };
 export type PartialEvent = {

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const liveStoreVersion: "0.3.0-dev.4";
+export declare const liveStoreVersion: "0.3.0-dev.6";
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.
  * Whenever this version changes, LiveStore will start with fresh database files. Old database files are not deleted.

package/dist/version.js

@@ -1,7 +1,7 @@
 // TODO bring back when Expo and Playwright supports `with` imports
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
-export const liveStoreVersion = '0.3.0-dev.4';
+export const liveStoreVersion = '0.3.0-dev.6';
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.
  * Whenever this version changes, LiveStore will start with fresh database files. Old database files are not deleted.

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@livestore/common",
-  "version": "0.3.0-dev.5",
+  "version": "0.3.0-dev.6",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -49,12 +50,12 @@
     }
   },
   "dependencies": {
-    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api": "1.9.0",
     "graphology": "0.26.0-alpha1",
     "graphology-dag": "0.4.1",
-    "graphology-types": "0.24.7",
-    "@livestore/utils": "0.3.0-dev.5",
-    "@livestore/db-schema": "0.3.0-dev.5"
+    "graphology-types": "0.24.8",
+    "@livestore/db-schema": "0.3.0-dev.6",
+    "@livestore/utils": "0.3.0-dev.6"
   },
   "devDependencies": {
     "vitest": "^2.1.4"

package/src/derived-mutations.test.ts

@@ -94,7 +94,7 @@ describe('derived mutations', () => {
   })
 })
 
-const patchId = (muationEvent: MutationEvent.PartialAny) => {
+const patchId = (muationEvent: MutationEvent.PartialAnyDecoded) => {
   // TODO use new id paradigm
   const id = `00000000-0000-0000-0000-000000000000`
   return { ...muationEvent, id }

package/src/derived-mutations.ts

@@ -136,8 +136,10 @@ export namespace DerivedMutationHelperFns {
   > = SqliteDsl.AnyIfConstained<
     TColumns,
     UseShortcut<TOptions> extends true
-      ? (values?: GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TColumns>, 'value'>) => MutationEvent.PartialAny
-      : (values: SqliteDsl.FromColumns.InsertRowDecoded<TColumns>) => MutationEvent.PartialAny
+      ? (
+          values?: GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TColumns>, 'value'>,
+        ) => MutationEvent.PartialAnyDecoded
+      : (values: SqliteDsl.FromColumns.InsertRowDecoded<TColumns>) => MutationEvent.PartialAnyDecoded
   >
 
   export type UpdateMutationFn<
@@ -146,17 +148,19 @@ export namespace DerivedMutationHelperFns {
   > = SqliteDsl.AnyIfConstained<
     TColumns,
     UseShortcut<TOptions> extends true
-      ? (values: Partial<GetValForKey<SqliteDsl.FromColumns.RowDecoded<TColumns>, 'value'>>) => MutationEvent.PartialAny
+      ? (
+          values: Partial<GetValForKey<SqliteDsl.FromColumns.RowDecoded<TColumns>, 'value'>>,
+        ) => MutationEvent.PartialAnyDecoded
       : (args: {
           where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
           values: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
-        }) => MutationEvent.PartialAny
+        }) => MutationEvent.PartialAnyDecoded
   >
 
   export type DeleteMutationFn<
     TColumns extends SqliteDsl.ConstraintColumns,
     _TOptions extends DbSchema.TableOptions,
-  > = (args: { where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>> }) => MutationEvent.PartialAny
+  > = (args: { where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>> }) => MutationEvent.PartialAnyDecoded
 
   type UseShortcut<TOptions extends DbSchema.TableOptions> = TOptions['isSingleColumn'] extends true
     ? TOptions['isSingleton'] extends true

package/src/leader-thread/apply-mutation.ts

@@ -3,20 +3,25 @@ import type { Scope } from '@livestore/utils/effect'
 import { Effect, Option, Schema } from '@livestore/utils/effect'
 
 import type { SqliteError, SynchronousDatabase, UnexpectedError } from '../index.js'
+import { getExecArgsFromMutation } from '../mutation.js'
 import {
-  getExecArgsFromMutation,
+  type LiveStoreSchema,
   MUTATION_LOG_META_TABLE,
+  type MutationEvent,
   mutationLogMetaTable,
   SESSION_CHANGESET_META_TABLE,
   sessionChangesetMetaTable,
-} from '../index.js'
-import type { LiveStoreSchema, MutationEvent } from '../schema/mod.js'
+} from '../schema/mod.js'
 import { insertRow } from '../sql-queries/index.js'
 import { execSql, execSqlPrepared } from './connection.js'
 import { LeaderThreadCtx } from './types.js'
 
 export type ApplyMutation = (
   mutationEventEncoded: MutationEvent.AnyEncoded,
+  options?: {
+    /** Needed for rehydrateFromMutationLog */
+    skipMutationLog?: boolean
+  },
 ) => Effect.Effect<void, SqliteError | UnexpectedError>
 
 export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope | LeaderThreadCtx> = Effect.gen(
@@ -31,15 +36,27 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
       [...leaderThreadCtx.schema.mutations.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
     )
 
-    return (mutationEventEncoded) =>
+    return (mutationEventEncoded, options) =>
       Effect.gen(function* () {
-        const { mutationEventSchema, schema, db, dbLog } = leaderThreadCtx
-        const mutationEventDecoded = Schema.decodeUnknownSync(mutationEventSchema)(mutationEventEncoded)
+        const { schema, db, dbLog } = leaderThreadCtx
+        const skipMutationLog = options?.skipMutationLog ?? false
 
-        const mutationName = mutationEventDecoded.mutation
+        const mutationName = mutationEventEncoded.mutation
         const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
 
-        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+        const execArgsArr = getExecArgsFromMutation({
+          mutationDef,
+          mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
+        })
+
+        // NOTE we might want to bring this back if we want to debug no-op mutations
+        // const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
+        //   onRowsChanged: (rowsChanged: number) => {
+        //     if (rowsChanged === 0) {
+        //       console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+        //     }
+        //   },
+        // })
 
         // console.group('[@livestore/common:leader-thread:applyMutation]', { mutationName })
 
@@ -53,30 +70,28 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
 
         const changeset = session.changeset()
         session.finish()
-        // NOTE for no-op mutations (e.g. if the state didn't change) the changeset will be empty
-        // TODO possibly write a null value instead of omitting the row
-        if (changeset !== undefined && changeset.length > 0) {
-          // TODO use prepared statements
-          yield* execSql(
-            db,
-            ...insertRow({
-              tableName: SESSION_CHANGESET_META_TABLE,
-              columns: sessionChangesetMetaTable.sqliteDef.columns,
-              values: {
-                idGlobal: mutationEventEncoded.id.global,
-                idLocal: mutationEventEncoded.id.local,
-                changeset,
-                debug: execArgsArr,
-              },
-            }),
-          )
-        }
+
+        // TODO use prepared statements
+        yield* execSql(
+          db,
+          ...insertRow({
+            tableName: SESSION_CHANGESET_META_TABLE,
+            columns: sessionChangesetMetaTable.sqliteDef.columns,
+            values: {
+              idGlobal: mutationEventEncoded.id.global,
+              idLocal: mutationEventEncoded.id.local,
+              // NOTE the changeset will be empty (i.e. null) for no-op mutations
+              changeset: changeset ?? null,
+              debug: execArgsArr,
+            },
+          }),
+        )
 
         // console.groupEnd()
 
         // write to mutation_log
-        const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventDecoded)
-        if (excludeFromMutationLog === false) {
+        const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventEncoded)
+        if (skipMutationLog === false && excludeFromMutationLog === false) {
           yield* insertIntoMutationLog(mutationEventEncoded, dbLog, mutationDefSchemaHashMap)
         } else {
           //   console.debug('[@livestore/common:leader-thread] skipping mutation log write', mutation, statementSql, bindValues)
@@ -132,11 +147,14 @@ const makeShouldExcludeMutationFromLog = memoizeByRef((schema: LiveStoreSchema)
       ? (migrationOptions.excludeMutations ?? new Set(['livestore.RawSql']))
       : new Set(['livestore.RawSql'])
 
-  return (mutationName: string, mutationEventDecoded: MutationEvent.AnyDecoded): boolean => {
+  return (mutationName: string, mutationEventEncoded: MutationEvent.AnyEncoded): boolean => {
     if (mutationLogExclude.has(mutationName)) return true
 
     const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
-    const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+    const execArgsArr = getExecArgsFromMutation({
+      mutationDef,
+      mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
+    })
 
     return execArgsArr.some((_) => _.statementSql.includes('__livestore'))
   }

package/src/leader-thread/leader-sync-processor.ts

@@ -509,9 +509,9 @@ const backgroundBackendPulling = ({
           })
         }
 
-        const fiber = yield* applyMutationItemsRef.current!({
-          batchItems: updateResult.newEvents,
-        }).pipe(Effect.fork)
+        trimChangesetRows(db, newBackendHead)
+
+        const fiber = yield* applyMutationItemsRef.current!({ batchItems: updateResult.newEvents }).pipe(Effect.fork)
 
         yield* Ref.set(stateRef, {
           _tag: 'applying-syncstate-advance',
@@ -519,7 +519,6 @@ const backgroundBackendPulling = ({
           syncState: updateResult.newSyncState,
           fiber,
         })
-        // console.log('setRef:applying-syncstate-advance after backgroundBackendPulling', -1)
       })
 
     yield* syncBackend.pull(cursorInfo).pipe(
@@ -574,7 +573,9 @@ const rollback = ({
     // Apply changesets in reverse order
     for (let i = rollbackEvents.length - 1; i >= 0; i--) {
       const { changeset } = rollbackEvents[i]!
-      db.makeChangeset(changeset).invert().apply()
+      if (changeset !== null) {
+        db.makeChangeset(changeset).invert().apply()
+      }
     }
 
     // Delete the changeset rows
@@ -668,3 +669,9 @@ const backgroundBackendPushing = ({
       }
     }
   }).pipe(Effect.interruptible, Effect.withSpan('@livestore/common:leader-thread:syncing:backend-pushing'))
+
+const trimChangesetRows = (db: SynchronousDatabase, newHead: EventId.EventId) => {
+  // Since we're using the session changeset rows to query for the current head,
+  // we're keeping at least one row for the current head, and thus are using `<` instead of `<=`
+  db.execute(sql`DELETE FROM ${SESSION_CHANGESET_META_TABLE} WHERE idGlobal < ${newHead.global}`)
+}

package/src/leader-thread/recreate-db.ts

@@ -24,7 +24,9 @@ export const recreateDb: Effect.Effect<
 
   // NOTE to speed up the operations below, we're creating a temporary in-memory database
   // and later we'll overwrite the persisted database with the new data
-  const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
+  // TODO bring back this optimization
+  // const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
+  const tmpSyncDb = db
   yield* configureConnection(tmpSyncDb, { fkEnabled: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
@@ -91,17 +93,19 @@ export const recreateDb: Effect.Effect<
     }
   }
 
+  // TODO bring back
   // Import the temporary in-memory database into the persistent database
-  yield* Effect.sync(() => db.import(tmpSyncDb)).pipe(
-    Effect.withSpan('@livestore/common:leader-thread:recreateDb:import'),
-  )
+  // yield* Effect.sync(() => db.import(tmpSyncDb)).pipe(
+  //   Effect.withSpan('@livestore/common:leader-thread:recreateDb:import'),
+  // )
 
   // TODO maybe bring back re-using this initial snapshot to avoid calling `.export()` again
   // We've disabled this for now as it made the code too complex, as we often run syncing right after
   // so the snapshot is no longer up to date
   // const snapshotFromTmpDb = tmpSyncDb.export()
 
-  tmpSyncDb.close()
+  // TODO bring back
+  // tmpSyncDb.close()
 }).pipe(
   Effect.scoped, // NOTE we're closing the scope here so finalizers are called when the effect is done
   Effect.withSpan('@livestore/common:leader-thread:recreateDb'),

package/src/mutation.ts

@@ -8,10 +8,19 @@ import { prepareBindValues } from './util.js'
 
 export const getExecArgsFromMutation = ({
   mutationDef,
-  mutationEventDecoded,
+  mutationEvent,
 }: {
   mutationDef: MutationDef.Any
-  mutationEventDecoded: MutationEvent.AnyDecoded | MutationEvent.PartialAny
+  /** Both encoded and decoded mutation events are supported to reduce the number of times we need to decode/encode */
+  mutationEvent:
+    | {
+        decoded: MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded
+        encoded: undefined
+      }
+    | {
+        decoded: undefined
+        encoded: MutationEvent.AnyEncoded | MutationEvent.PartialAnyEncoded
+      }
 }): ReadonlyArray<{
   statementSql: string
   bindValues: PreparedBindValues
@@ -23,7 +32,9 @@ export const getExecArgsFromMutation = ({
 
   switch (typeof mutationDef.sql) {
     case 'function': {
-      const res = mutationDef.sql(mutationEventDecoded.args)
+      const mutationArgsDecoded =
+        mutationEvent.decoded?.args ?? Schema.decodeUnknownSync(mutationDef.schema)(mutationEvent.encoded!.args)
+      const res = mutationDef.sql(mutationArgsDecoded)
       statementRes = Array.isArray(res) ? res : [res]
       break
     }
@@ -40,10 +51,9 @@ export const getExecArgsFromMutation = ({
   return statementRes.map((statementRes) => {
     const statementSql = typeof statementRes === 'string' ? statementRes : statementRes.sql
 
-    const bindValues =
-      typeof statementRes === 'string'
-        ? Schema.encodeUnknownSync(mutationDef.schema)(mutationEventDecoded.args)
-        : statementRes.bindValues
+    const mutationArgsEncoded =
+      mutationEvent.encoded?.args ?? Schema.encodeUnknownSync(mutationDef.schema)(mutationEvent.decoded!.args)
+    const bindValues = typeof statementRes === 'string' ? mutationArgsEncoded : statementRes.bindValues
 
     const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
 

package/src/rehydrate-from-mutationlog.ts

@@ -1,8 +1,8 @@
-import { isDevEnv, memoizeByRef, shouldNeverHappen } from '@livestore/utils'
+import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
 import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
-import { getExecArgsFromMutation } from './mutation.js'
+import { makeApplyMutation } from './leader-thread/apply-mutation.js'
 import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
 import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
 import type { PreparedBindValues } from './util.js'
@@ -10,7 +10,8 @@ import { sql } from './util.js'
 
 export const rehydrateFromMutationLog = ({
   logDb,
-  db,
+  // TODO re-use this db when bringing back the boot in-memory db implementation
+  // db,
   schema,
   migrationOptions,
   onProgress,
@@ -28,6 +29,8 @@ export const rehydrateFromMutationLog = ({
 
     const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
 
+    const applyMutation = yield* makeApplyMutation
+
     const processMutation = (row: MutationLogMetaRow) =>
       Effect.gen(function* () {
         const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
@@ -40,7 +43,10 @@ export const rehydrateFromMutationLog = ({
           )
         }
 
-        const argsDecoded = yield* Schema.decodeUnknown(Schema.parseJson(mutationDef.schema))(row.argsJson).pipe(
+        const args = JSON.parse(row.argsJson)
+
+        // Checking whether the schema has changed in an incompatible way
+        yield* Schema.decodeUnknown(mutationDef.schema)(args).pipe(
           Effect.mapError((cause) =>
             UnexpectedError.make({
               cause,
@@ -53,28 +59,14 @@ This likely means the schema has changed in an incompatible way.
           ),
         )
 
-        const mutationEventDecoded = {
+        const mutationEventEncoded = {
           id: { global: row.idGlobal, local: row.idLocal },
           parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
           mutation: row.mutation,
-          args: argsDecoded,
-        } satisfies MutationEvent.AnyDecoded
-
-        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-        const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
-          onRowsChanged: (rowsChanged: number) => {
-            if (rowsChanged === 0 && migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true) {
-              console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
-            }
-          },
-        })
-
-        for (const { statementSql, bindValues } of execArgsArr) {
-          // TODO cache prepared statements for mutations
-          db.execute(statementSql, bindValues, isDevEnv() ? makeExecuteOptions(statementSql, bindValues) : undefined)
-          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-        }
+          args,
+        } satisfies MutationEvent.AnyEncoded
+
+        yield* applyMutation(mutationEventEncoded, { skipMutationLog: true })
       }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
 
     const CHUNK_SIZE = 100

package/src/schema/MutationEvent.ts

@@ -54,7 +54,7 @@ export const AnyEncodedGlobal = Schema.Struct({
 }).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
 export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
-export type PartialAny = MutationEventPartial<MutationDef.Any>
+export type PartialAnyDecoded = MutationEventPartial<MutationDef.Any>
 export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
 
 export type PartialForSchema<TSchema extends LiveStoreSchema> = {
@@ -65,8 +65,9 @@ export type ForSchema<TSchema extends LiveStoreSchema> = {
   [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
 }[keyof TSchema['_MutationDefMapType']]
 
-export const isPartialMutationEvent = (mutationEvent: AnyDecoded | PartialAny): mutationEvent is PartialAny =>
-  'id' in mutationEvent === false && 'parentId' in mutationEvent === false
+export const isPartialMutationEvent = (
+  mutationEvent: AnyDecoded | PartialAnyDecoded,
+): mutationEvent is PartialAnyDecoded => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
 
 export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
   {

package/src/schema/system-tables.ts

@@ -49,12 +49,13 @@ export const sessionChangesetMetaTable = table(
     // TODO bring back primary key
     idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
     idLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
-    // idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    // idLocal: SqliteDsl.integer({ primaryKey: true }),
-    changeset: SqliteDsl.blob({}),
+    changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
-  { disableAutomaticIdColumn: true },
+  {
+    disableAutomaticIdColumn: true,
+    indexes: [{ columns: ['idGlobal', 'idLocal'], name: 'idx_session_changeset_id' }],
+  },
 )
 
 export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
@@ -84,7 +85,7 @@ export const mutationLogMetaTable = table(
     disableAutomaticIdColumn: true,
     indexes: [
       { columns: ['idGlobal'], name: 'idx_idGlobal' },
-      { columns: ['idGlobal', 'idLocal'], name: 'idx_idGlobal_idLocal' },
+      { columns: ['idGlobal', 'idLocal'], name: 'idx_mutationlog_id' },
     ],
   },
 )

package/src/sync/client-session-sync-processor.ts

@@ -34,7 +34,7 @@ export const makeClientSessionSyncProcessor = ({
   pushToLeader: (batch: ReadonlyArray<MutationEvent.AnyEncoded>) => void
   pullFromLeader: ClientSessionLeaderThreadProxy['mutations']['pull']
   applyMutation: (
-    mutationEventDecoded: MutationEvent.PartialAny,
+    mutationEventDecoded: MutationEvent.PartialAnyDecoded,
     options: { otelContext: otel.Context; withChangeset: boolean },
   ) => {
     writeTables: Set<string>
@@ -196,7 +196,7 @@ export const makeClientSessionSyncProcessor = ({
 
 export interface ClientSessionSyncProcessor {
   push: (
-    batch: ReadonlyArray<MutationEvent.PartialAny>,
+    batch: ReadonlyArray<MutationEvent.PartialAnyDecoded>,
     options: { otelContext: otel.Context },
   ) => {
     writeTables: Set<string>

package/src/sync/next/rebase-events.ts

@@ -19,13 +19,13 @@ export type RebaseInput = {
   newRemoteEvents: RebaseEventWithConflict[]
   pendingLocalEvents: RebaseEventWithConflict[]
   validate: (args: {
-    rebasedLocalEvents: MutationEvent.PartialAny[]
+    rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
     mutationDefs: Record<string, MutationDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: MutationEvent.PartialAny[]
+  rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
 }
 
 export type RebaseFn = (input: RebaseInput) => RebaseOutput

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.3.0-dev.4' as const
+export const liveStoreVersion = '0.3.0-dev.6' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.