@livestore/common 0.3.0-dev.27 → 0.3.0-dev.29

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,WAAW,CAAA;AACzB,cAAc,oBAAoB,CAAA;AAClC,cAAc,mCAAmC,CAAA;AACjD,cAAc,eAAe,CAAA;AAC7B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,OAAO,KAAK,SAAS,MAAM,qBAAqB,CAAA;AAChD,cAAc,WAAW,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,WAAW,CAAA;AACzB,cAAc,oBAAoB,CAAA;AAClC,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,iBAAiB,CAAA;AAC/B,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,OAAO,KAAK,SAAS,MAAM,qBAAqB,CAAA;AAChD,cAAc,WAAW,CAAA"}

package/dist/leader-thread/LeaderSyncProcessor.d.ts

@@ -4,18 +4,16 @@ import type { SqliteDb } from '../adapter-types.js';
 import { UnexpectedError } from '../adapter-types.js';
 import type { LiveStoreSchema } from '../schema/mod.js';
 import type { InitialBlockingSyncContext, LeaderSyncProcessor } from './types.js';
-export declare const BACKEND_PUSH_BATCH_SIZE = 50;
-export declare const LOCAL_PUSH_BATCH_SIZE = 10;
 /**
- * The LeaderSyncProcessor manages synchronization of mutations between
+ * The LeaderSyncProcessor manages synchronization of events between
  * the local state and the sync backend, ensuring efficient and orderly processing.
  *
  * In the LeaderSyncProcessor, pulling always has precedence over pushing.
  *
  * Responsibilities:
- * - Queueing incoming local mutations in a localPushesQueue.
- * - Broadcasting mutations to client sessions via pull queues.
- * - Pushing mutations to the sync backend.
+ * - Queueing incoming local events in a localPushesQueue.
+ * - Broadcasting events to client sessions via pull queues.
+ * - Pushing events to the sync backend.
  *
  * Notes:
  *
@@ -23,27 +21,42 @@ export declare const LOCAL_PUSH_BATCH_SIZE = 10;
  * - localPushesQueue:
  *   - Maintains events in ascending order.
  *   - Uses `Deferred` objects to resolve/reject events based on application success.
- * - Processes events from the queue, applying mutations in batches.
+ * - Processes events from the queue, applying events in batches.
  * - Controlled by a `Latch` to manage execution flow.
  * - The latch closes on pull receipt and re-opens post-pull completion.
  * - Processes up to `maxBatchSize` events per cycle.
  *
- * Currently we're advancing the db read model and mutation log in lockstep, but we could also decouple this in the future
+ * Currently we're advancing the db read model and eventlog in lockstep, but we could also decouple this in the future
  *
  * Tricky concurrency scenarios:
  * - Queued local push batches becoming invalid due to a prior local push item being rejected.
  *   Solution: Introduce a generation number for local push batches which is used to filter out old batches items in case of rejection.
  *
  */
-export declare const makeLeaderSyncProcessor: ({ schema, dbMutationLogMissing, dbMutationLog, dbReadModel, dbReadModelMissing, initialBlockingSyncContext, onError, }: {
+export declare const makeLeaderSyncProcessor: ({ schema, dbEventlogMissing, dbEventlog, dbReadModel, dbReadModelMissing, initialBlockingSyncContext, onError, params, testing, }: {
     schema: LiveStoreSchema;
-    /** Only used to know whether we can safely query dbMutationLog during setup execution */
-    dbMutationLogMissing: boolean;
-    dbMutationLog: SqliteDb;
+    /** Only used to know whether we can safely query dbEventlog during setup execution */
+    dbEventlogMissing: boolean;
+    dbEventlog: SqliteDb;
     dbReadModel: SqliteDb;
     /** Only used to know whether we can safely query dbReadModel during setup execution */
     dbReadModelMissing: boolean;
     initialBlockingSyncContext: InitialBlockingSyncContext;
     onError: "shutdown" | "ignore";
+    params: {
+        /**
+         * @default 10
+         */
+        localPushBatchSize?: number;
+        /**
+         * @default 50
+         */
+        backendPushBatchSize?: number;
+    };
+    testing: {
+        delays?: {
+            localPushProcessing?: Effect.Effect<void>;
+        };
+    };
 }) => Effect.Effect<LeaderSyncProcessor, UnexpectedError, Scope.Scope>;
 //# sourceMappingURL=LeaderSyncProcessor.d.ts.map

package/dist/leader-thread/LeaderSyncProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LeaderSyncProcessor.d.ts","sourceRoot":"","sources":["../../src/leader-thread/LeaderSyncProcessor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAuB,KAAK,EAAU,MAAM,yBAAyB,CAAA;AACjF,OAAO,EAGL,MAAM,EASP,MAAM,yBAAyB,CAAA;AAGhC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAavD,OAAO,KAAK,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAGjF,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC,eAAO,MAAM,qBAAqB,KAAK,CAAA;AASvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,GAAI,wHAQrC;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,yFAAyF;IACzF,oBAAoB,EAAE,OAAO,CAAA;IAC7B,aAAa,EAAE,QAAQ,CAAA;IACvB,WAAW,EAAE,QAAQ,CAAA;IACrB,uFAAuF;IACvF,kBAAkB,EAAE,OAAO,CAAA;IAC3B,0BAA0B,EAAE,0BAA0B,CAAA;IACtD,OAAO,EAAE,UAAU,GAAG,QAAQ,CAAA;CAC/B,KAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,eAAe,EAAE,KAAK,CAAC,KAAK,CAgR/D,CAAA"}
+{"version":3,"file":"LeaderSyncProcessor.d.ts","sourceRoot":"","sources":["../../src/leader-thread/LeaderSyncProcessor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAuB,KAAK,EAAU,MAAM,yBAAyB,CAAA;AACjF,OAAO,EAGL,MAAM,EASP,MAAM,yBAAyB,CAAA;AAGhC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAavD,OAAO,KAAK,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAUjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,GAAI,mIAUrC;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,sFAAsF;IACtF,iBAAiB,EAAE,OAAO,CAAA;IAC1B,UAAU,EAAE,QAAQ,CAAA;IACpB,WAAW,EAAE,QAAQ,CAAA;IACrB,uFAAuF;IACvF,kBAAkB,EAAE,OAAO,CAAA;IAC3B,0BAA0B,EAAE,0BAA0B,CAAA;IACtD,OAAO,EAAE,UAAU,GAAG,QAAQ,CAAA;IAC9B,MAAM,EAAE;QACN;;WAEG;QACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;QAC3B;;WAEG;QACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;KAC9B,CAAA;IACD,OAAO,EAAE;QACP,MAAM,CAAC,EAAE;YACP,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;SAC1C,CAAA;KACF,CAAA;CACF,KAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,eAAe,EAAE,KAAK,CAAC,KAAK,CA2R/D,CAAA"}

package/dist/leader-thread/LeaderSyncProcessor.js

@@ -1,25 +1,23 @@
 import { casesHandled, isNotUndefined, LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils';
 import { BucketQueue, Deferred, Effect, Exit, FiberHandle, OtelTracer, Queue, ReadonlyArray, Stream, Subscribable, SubscriptionRef, } from '@livestore/utils/effect';
 import { UnexpectedError } from '../adapter-types.js';
-import { EventId, getMutationDef, LEADER_MERGE_COUNTER_TABLE, MutationEvent, SESSION_CHANGESET_META_TABLE, } from '../schema/mod.js';
+import { EventId, getEventDef, LEADER_MERGE_COUNTER_TABLE, LiveStoreEvent, SESSION_CHANGESET_META_TABLE, } from '../schema/mod.js';
 import { LeaderAheadError } from '../sync/sync.js';
 import * as SyncState from '../sync/syncstate.js';
 import { sql } from '../util.js';
-import { rollback } from './apply-mutation.js';
-import * as Mutationlog from './mutationlog.js';
+import { rollback } from './apply-event.js';
+import * as Eventlog from './eventlog.js';
 import { LeaderThreadCtx } from './types.js';
-export const BACKEND_PUSH_BATCH_SIZE = 50;
-export const LOCAL_PUSH_BATCH_SIZE = 10;
 /**
- * The LeaderSyncProcessor manages synchronization of mutations between
+ * The LeaderSyncProcessor manages synchronization of events between
  * the local state and the sync backend, ensuring efficient and orderly processing.
  *
  * In the LeaderSyncProcessor, pulling always has precedence over pushing.
  *
  * Responsibilities:
- * - Queueing incoming local mutations in a localPushesQueue.
- * - Broadcasting mutations to client sessions via pull queues.
- * - Pushing mutations to the sync backend.
+ * - Queueing incoming local events in a localPushesQueue.
+ * - Broadcasting events to client sessions via pull queues.
+ * - Pushing events to the sync backend.
  *
  * Notes:
  *
@@ -27,24 +25,26 @@ export const LOCAL_PUSH_BATCH_SIZE = 10;
  * - localPushesQueue:
  *   - Maintains events in ascending order.
  *   - Uses `Deferred` objects to resolve/reject events based on application success.
- * - Processes events from the queue, applying mutations in batches.
+ * - Processes events from the queue, applying events in batches.
  * - Controlled by a `Latch` to manage execution flow.
  * - The latch closes on pull receipt and re-opens post-pull completion.
  * - Processes up to `maxBatchSize` events per cycle.
  *
- * Currently we're advancing the db read model and mutation log in lockstep, but we could also decouple this in the future
+ * Currently we're advancing the db read model and eventlog in lockstep, but we could also decouple this in the future
  *
  * Tricky concurrency scenarios:
  * - Queued local push batches becoming invalid due to a prior local push item being rejected.
  *   Solution: Introduce a generation number for local push batches which is used to filter out old batches items in case of rejection.
  *
  */
-export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutationLog, dbReadModel, dbReadModelMissing, initialBlockingSyncContext, onError, }) => Effect.gen(function* () {
+export const makeLeaderSyncProcessor = ({ schema, dbEventlogMissing, dbEventlog, dbReadModel, dbReadModelMissing, initialBlockingSyncContext, onError, params, testing, }) => Effect.gen(function* () {
     const syncBackendPushQueue = yield* BucketQueue.make();
+    const localPushBatchSize = params.localPushBatchSize ?? 10;
+    const backendPushBatchSize = params.backendPushBatchSize ?? 50;
     const syncStateSref = yield* SubscriptionRef.make(undefined);
-    const isClientEvent = (mutationEventEncoded) => {
-        const mutationDef = getMutationDef(schema, mutationEventEncoded.mutation);
-        return mutationDef.options.clientOnly;
+    const isClientEvent = (eventEncoded) => {
+        const eventDef = getEventDef(schema, eventEncoded.name);
+        return eventDef.eventDef.options.clientOnly;
     };
     const connectedClientSessionPullQueues = yield* makePullQueueSet;
     /**
@@ -52,6 +52,7 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
      * If a local-push batch is rejected, all subsequent push queue items with the same generation are also rejected,
      * even if they would be valid on their own.
      */
+    // TODO get rid of this in favour of the `mergeGeneration` event id field
     const currentLocalPushGenerationRef = { current: 0 };
     const mergeCounterRef = { current: dbReadModelMissing ? 0 : yield* getMergeCounterFromDb(dbReadModel) };
     const mergePayloads = new Map();
@@ -62,43 +63,57 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
     const localPushesQueue = yield* BucketQueue.make();
     const localPushesLatch = yield* Effect.makeLatch(true);
     const pullLatch = yield* Effect.makeLatch(true);
+    /**
+     * Additionally to the `syncStateSref` we also need the `pushHeadRef` in order to prevent old/duplicate
+     * events from being pushed in a scenario like this:
+     * - client session A pushes e1
+     * - leader sync processor takes a bit and hasn't yet taken e1 from the localPushesQueue
+     * - client session B also pushes e1 (which should be rejected)
+     *
+     * Thus the purpoe of the pushHeadRef is the guard the integrity of the local push queue
+     */
+    const pushHeadRef = { current: EventId.ROOT };
+    const advancePushHead = (eventId) => {
+        pushHeadRef.current = EventId.max(pushHeadRef.current, eventId);
+    };
     // NOTE: New events are only pushed to sync backend after successful local push processing
     const push = (newEvents, options) => Effect.gen(function* () {
-        // TODO validate batch
         if (newEvents.length === 0)
             return;
+        yield* validatePushBatch(newEvents, pushHeadRef.current);
+        advancePushHead(newEvents.at(-1).id);
         const waitForProcessing = options?.waitForProcessing ?? false;
         const generation = currentLocalPushGenerationRef.current;
         if (waitForProcessing) {
             const deferreds = yield* Effect.forEach(newEvents, () => Deferred.make());
-            const items = newEvents.map((mutationEventEncoded, i) => [mutationEventEncoded, deferreds[i], generation]);
+            const items = newEvents.map((eventEncoded, i) => [eventEncoded, deferreds[i], generation]);
             yield* BucketQueue.offerAll(localPushesQueue, items);
             yield* Effect.all(deferreds);
         }
         else {
-            const items = newEvents.map((mutationEventEncoded) => [mutationEventEncoded, undefined, generation]);
+            const items = newEvents.map((eventEncoded) => [eventEncoded, undefined, generation]);
             yield* BucketQueue.offerAll(localPushesQueue, items);
         }
-    }).pipe(Effect.withSpan('@livestore/common:LeaderSyncProcessor:local-push', {
+    }).pipe(Effect.withSpan('@livestore/common:LeaderSyncProcessor:push', {
         attributes: {
             batchSize: newEvents.length,
             batch: TRACE_VERBOSE ? newEvents : undefined,
         },
         links: ctxRef.current?.span ? [{ _tag: 'SpanLink', span: ctxRef.current.span, attributes: {} }] : undefined,
     }));
-    const pushPartial = ({ mutationEvent: { mutation, args }, clientId, sessionId, }) => Effect.gen(function* () {
+    const pushPartial = ({ event: { name, args }, clientId, sessionId }) => Effect.gen(function* () {
         const syncState = yield* syncStateSref;
         if (syncState === undefined)
             return shouldNeverHappen('Not initialized');
-        const mutationDef = getMutationDef(schema, mutation);
-        const mutationEventEncoded = new MutationEvent.EncodedWithMeta({
-            mutation,
+        const eventDef = getEventDef(schema, name);
+        const eventEncoded = new LiveStoreEvent.EncodedWithMeta({
+            name,
             args,
             clientId,
             sessionId,
-            ...EventId.nextPair(syncState.localHead, mutationDef.options.clientOnly),
+            ...EventId.nextPair(syncState.localHead, eventDef.eventDef.options.clientOnly),
         });
-        yield* push([mutationEventEncoded]);
+        yield* push([eventEncoded]);
     }).pipe(Effect.catchTag('LeaderAheadError', Effect.orDie));
     // Starts various background loops
     const boot = Effect.gen(function* () {
@@ -112,33 +127,31 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
             devtoolsLatch: devtools.enabled ? devtools.syncBackendLatch : undefined,
             runtime,
         };
-        const initialBackendHead = dbMutationLogMissing
-            ? EventId.ROOT.global
-            : Mutationlog.getBackendHeadFromDb(dbMutationLog);
-        const initialLocalHead = dbMutationLogMissing ? EventId.ROOT : Mutationlog.getClientHeadFromDb(dbMutationLog);
+        const initialLocalHead = dbEventlogMissing ? EventId.ROOT : Eventlog.getClientHeadFromDb(dbEventlog);
+        const initialBackendHead = dbEventlogMissing ? EventId.ROOT.global : Eventlog.getBackendHeadFromDb(dbEventlog);
         if (initialBackendHead > initialLocalHead.global) {
             return shouldNeverHappen(`During boot the backend head (${initialBackendHead}) should never be greater than the local head (${initialLocalHead.global})`);
         }
-        const pendingMutationEvents = dbMutationLogMissing
+        const pendingEvents = dbEventlogMissing
             ? []
-            : yield* Mutationlog.getMutationEventsSince({ global: initialBackendHead, client: EventId.clientDefault });
+            : yield* Eventlog.getEventsSince({ global: initialBackendHead, client: EventId.clientDefault });
         const initialSyncState = new SyncState.SyncState({
-            pending: pendingMutationEvents,
+            pending: pendingEvents,
             upstreamHead: { global: initialBackendHead, client: EventId.clientDefault },
             localHead: initialLocalHead,
         });
         /** State transitions need to happen atomically, so we use a Ref to track the state */
         yield* SubscriptionRef.set(syncStateSref, initialSyncState);
         // Rehydrate sync queue
-        if (pendingMutationEvents.length > 0) {
-            const globalPendingMutationEvents = pendingMutationEvents
-                // Don't sync clientOnly mutations
-                .filter((mutationEventEncoded) => {
-                const mutationDef = getMutationDef(schema, mutationEventEncoded.mutation);
-                return mutationDef.options.clientOnly === false;
+        if (pendingEvents.length > 0) {
+            const globalPendingEvents = pendingEvents
+                // Don't sync clientOnly events
+                .filter((eventEncoded) => {
+                const eventDef = getEventDef(schema, eventEncoded.name);
+                return eventDef.eventDef.options.clientOnly === false;
             });
-            if (globalPendingMutationEvents.length > 0) {
-                yield* BucketQueue.offerAll(syncBackendPushQueue, globalPendingMutationEvents);
+            if (globalPendingEvents.length > 0) {
+                yield* BucketQueue.offerAll(syncBackendPushQueue, globalPendingEvents);
             }
         }
         const shutdownOnError = (cause) => Effect.gen(function* () {
@@ -160,13 +173,19 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
             connectedClientSessionPullQueues,
             mergeCounterRef,
             mergePayloads,
+            localPushBatchSize,
+            testing: {
+                delay: testing?.delays?.localPushProcessing,
+            },
         }).pipe(Effect.tapCauseLogPretty, Effect.catchAllCause(shutdownOnError), Effect.forkScoped);
         const backendPushingFiberHandle = yield* FiberHandle.make();
-        yield* FiberHandle.run(backendPushingFiberHandle, backgroundBackendPushing({
+        const backendPushingEffect = backgroundBackendPushing({
             syncBackendPushQueue,
             otelSpan,
             devtoolsLatch: ctxRef.current?.devtoolsLatch,
-        }).pipe(Effect.tapCauseLogPretty, Effect.catchAllCause(shutdownOnError)));
+            backendPushBatchSize,
+        }).pipe(Effect.tapCauseLogPretty, Effect.catchAllCause(shutdownOnError));
+        yield* FiberHandle.run(backendPushingFiberHandle, backendPushingEffect);
         yield* backgroundBackendPulling({
             initialBackendHead,
             isClientEvent,
@@ -177,11 +196,7 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
                 yield* BucketQueue.clear(syncBackendPushQueue);
                 yield* BucketQueue.offerAll(syncBackendPushQueue, filteredRebasedPending);
                 // Restart pushing fiber
-                yield* FiberHandle.run(backendPushingFiberHandle, backgroundBackendPushing({
-                    syncBackendPushQueue,
-                    otelSpan,
-                    devtoolsLatch: ctxRef.current?.devtoolsLatch,
-                }).pipe(Effect.tapCauseLogPretty, Effect.catchAllCause(shutdownOnError)));
+                yield* FiberHandle.run(backendPushingFiberHandle, backendPushingEffect);
             }),
             syncStateSref,
             localPushesLatch,
@@ -192,6 +207,7 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
             connectedClientSessionPullQueues,
             mergeCounterRef,
             mergePayloads,
+            advancePushHead,
         }).pipe(Effect.tapCauseLogPretty, Effect.catchAllCause(shutdownOnError), Effect.forkScoped);
         return { initialLeaderHead: initialLocalHead };
     }).pipe(Effect.withSpanScoped('@livestore/common:LeaderSyncProcessor:boot'));
@@ -212,7 +228,7 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
                     return {
                         payload: {
                             _tag: 'upstream-advance',
-                            newEvents: ReadonlyArray.dropWhile(payload.newEvents, (mutationEventEncoded) => EventId.isGreaterThanOrEqual(cursor.eventId, mutationEventEncoded.id)),
+                            newEvents: ReadonlyArray.dropWhile(payload.newEvents, (eventEncoded) => EventId.isGreaterThanOrEqual(cursor.eventId, eventEncoded.id)),
                         },
                         mergeCounter,
                     };
@@ -244,10 +260,12 @@ export const makeLeaderSyncProcessor = ({ schema, dbMutationLogMissing, dbMutati
         getMergeCounter: () => mergeCounterRef.current,
     };
 });
-const backgroundApplyLocalPushes = ({ localPushesLatch, localPushesQueue, pullLatch, syncStateSref, syncBackendPushQueue, schema, isClientEvent, otelSpan, currentLocalPushGenerationRef, connectedClientSessionPullQueues, mergeCounterRef, mergePayloads, }) => Effect.gen(function* () {
+const backgroundApplyLocalPushes = ({ localPushesLatch, localPushesQueue, pullLatch, syncStateSref, syncBackendPushQueue, schema, isClientEvent, otelSpan, currentLocalPushGenerationRef, connectedClientSessionPullQueues, mergeCounterRef, mergePayloads, localPushBatchSize, testing, }) => Effect.gen(function* () {
     while (true) {
-        // TODO make batch size configurable
-        const batchItems = yield* BucketQueue.takeBetween(localPushesQueue, 1, LOCAL_PUSH_BATCH_SIZE);
+        if (testing.delay !== undefined) {
+            yield* testing.delay.pipe(Effect.withSpan('localPushProcessingDelay'));
+        }
+        const batchItems = yield* BucketQueue.takeBetween(localPushesQueue, 1, localPushBatchSize);
         // Wait for the backend pulling to finish
         yield* localPushesLatch.await;
         // Prevent backend pull processing until this local push is finished
@@ -256,7 +274,7 @@ const backgroundApplyLocalPushes = ({ localPushesLatch, localPushesQueue, pullLa
         // It's important that we filter after we got localPushesLatch, otherwise we might filter with the old generation
         const filteredBatchItems = batchItems
             .filter(([_1, _2, generation]) => generation === currentLocalPushGenerationRef.current)
-            .map(([mutationEventEncoded, deferred]) => [mutationEventEncoded, deferred]);
+            .map(([eventEncoded, deferred]) => [eventEncoded, deferred]);
         if (filteredBatchItems.length === 0) {
             // console.log('dropping old-gen batch', currentLocalPushGenerationRef.current)
             // Allow the backend pulling to start
@@ -271,12 +289,12 @@ const backgroundApplyLocalPushes = ({ localPushesLatch, localPushesQueue, pullLa
             syncState,
             payload: { _tag: 'local-push', newEvents },
             isClientEvent,
-            isEqualEvent: MutationEvent.isEqualEncoded,
+            isEqualEvent: LiveStoreEvent.isEqualEncoded,
         });
         const mergeCounter = yield* incrementMergeCounter(mergeCounterRef);
         switch (mergeResult._tag) {
             case 'unexpected-error': {
-                otelSpan?.addEvent(`merge[${mergeCounter}]:local-push:unexpected-error`, {
+                otelSpan?.addEvent(`[${mergeCounter}]:push:unexpected-error`, {
                     batchSize: newEvents.length,
                     newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
                 });
@@ -286,7 +304,7 @@ const backgroundApplyLocalPushes = ({ localPushesLatch, localPushesQueue, pullLa
                 return shouldNeverHappen('The leader thread should never have to rebase due to a local push');
             }
             case 'reject': {
-                otelSpan?.addEvent(`merge[${mergeCounter}]:local-push:reject`, {
+                otelSpan?.addEvent(`[${mergeCounter}]:push:reject`, {
                     batchSize: newEvents.length,
                     mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
                 });
@@ -331,48 +349,48 @@ const backgroundApplyLocalPushes = ({ localPushesLatch, localPushesQueue, pullLa
             mergeCounter,
         });
         mergePayloads.set(mergeCounter, SyncState.PayloadUpstreamAdvance.make({ newEvents: mergeResult.newEvents }));
-        otelSpan?.addEvent(`merge[${mergeCounter}]:local-push:advance`, {
+        otelSpan?.addEvent(`[${mergeCounter}]:push:advance`, {
             batchSize: newEvents.length,
             mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
         });
-        // Don't sync clientOnly mutations
-        const filteredBatch = mergeResult.newEvents.filter((mutationEventEncoded) => {
-            const mutationDef = getMutationDef(schema, mutationEventEncoded.mutation);
-            return mutationDef.options.clientOnly === false;
+        // Don't sync clientOnly events
+        const filteredBatch = mergeResult.newEvents.filter((eventEncoded) => {
+            const eventDef = getEventDef(schema, eventEncoded.name);
+            return eventDef.eventDef.options.clientOnly === false;
         });
         yield* BucketQueue.offerAll(syncBackendPushQueue, filteredBatch);
-        yield* applyMutationsBatch({ batchItems: newEvents, deferreds });
+        yield* applyEventsBatch({ batchItems: mergeResult.newEvents, deferreds });
         // Allow the backend pulling to start
         yield* pullLatch.open;
     }
 });
 // TODO how to handle errors gracefully
-const applyMutationsBatch = ({ batchItems, deferreds }) => Effect.gen(function* () {
-    const { dbReadModel: db, dbMutationLog, applyMutation } = yield* LeaderThreadCtx;
-    // NOTE We always start a transaction to ensure consistency between db and mutation log (even for single-item batches)
+const applyEventsBatch = ({ batchItems, deferreds }) => Effect.gen(function* () {
+    const { dbReadModel: db, dbEventlog, applyEvent } = yield* LeaderThreadCtx;
+    // NOTE We always start a transaction to ensure consistency between db and eventlog (even for single-item batches)
     db.execute('BEGIN TRANSACTION', undefined); // Start the transaction
-    dbMutationLog.execute('BEGIN TRANSACTION', undefined); // Start the transaction
+    dbEventlog.execute('BEGIN TRANSACTION', undefined); // Start the transaction
     yield* Effect.addFinalizer((exit) => Effect.gen(function* () {
         if (Exit.isSuccess(exit))
             return;
         // Rollback in case of an error
         db.execute('ROLLBACK', undefined);
-        dbMutationLog.execute('ROLLBACK', undefined);
+        dbEventlog.execute('ROLLBACK', undefined);
     }));
     for (let i = 0; i < batchItems.length; i++) {
-        const { sessionChangeset } = yield* applyMutation(batchItems[i]);
+        const { sessionChangeset } = yield* applyEvent(batchItems[i]);
         batchItems[i].meta.sessionChangeset = sessionChangeset;
         if (deferreds?.[i] !== undefined) {
             yield* Deferred.succeed(deferreds[i], void 0);
         }
     }
     db.execute('COMMIT', undefined); // Commit the transaction
-    dbMutationLog.execute('COMMIT', undefined); // Commit the transaction
-}).pipe(Effect.uninterruptible, Effect.scoped, Effect.withSpan('@livestore/common:LeaderSyncProcessor:applyMutationItems', {
+    dbEventlog.execute('COMMIT', undefined); // Commit the transaction
+}).pipe(Effect.uninterruptible, Effect.scoped, Effect.withSpan('@livestore/common:LeaderSyncProcessor:applyEventItems', {
     attributes: { batchSize: batchItems.length },
 }), Effect.tapCauseLogPretty, UnexpectedError.mapToUnexpectedError);
-const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBackendPushing, otelSpan, syncStateSref, localPushesLatch, pullLatch, devtoolsLatch, initialBlockingSyncContext, connectedClientSessionPullQueues, mergeCounterRef, mergePayloads, }) => Effect.gen(function* () {
-    const { syncBackend, dbReadModel: db, dbMutationLog, schema } = yield* LeaderThreadCtx;
+const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBackendPushing, otelSpan, syncStateSref, localPushesLatch, pullLatch, devtoolsLatch, initialBlockingSyncContext, connectedClientSessionPullQueues, mergeCounterRef, mergePayloads, advancePushHead, }) => Effect.gen(function* () {
+    const { syncBackend, dbReadModel: db, dbEventlog, schema } = yield* LeaderThreadCtx;
     if (syncBackend === undefined)
         return;
     const onNewPullChunk = (newEvents, remaining) => Effect.gen(function* () {
@@ -392,7 +410,7 @@ const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBa
             syncState,
             payload: SyncState.PayloadUpstreamAdvance.make({ newEvents }),
             isClientEvent,
-            isEqualEvent: MutationEvent.isEqualEncoded,
+            isEqualEvent: LiveStoreEvent.isEqualEncoded,
             ignoreClientEvents: true,
         });
         const mergeCounter = yield* incrementMergeCounter(mergeCounterRef);
@@ -400,28 +418,28 @@ const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBa
             return shouldNeverHappen('The leader thread should never reject upstream advances');
         }
         else if (mergeResult._tag === 'unexpected-error') {
-            otelSpan?.addEvent(`merge[${mergeCounter}]:backend-pull:unexpected-error`, {
+            otelSpan?.addEvent(`[${mergeCounter}]:pull:unexpected-error`, {
                 newEventsCount: newEvents.length,
                 newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
             });
             return yield* Effect.fail(mergeResult.cause);
         }
         const newBackendHead = newEvents.at(-1).id;
-        Mutationlog.updateBackendHead(dbMutationLog, newBackendHead);
+        Eventlog.updateBackendHead(dbEventlog, newBackendHead);
         if (mergeResult._tag === 'rebase') {
-            otelSpan?.addEvent(`merge[${mergeCounter}]:backend-pull:rebase`, {
+            otelSpan?.addEvent(`[${mergeCounter}]:pull:rebase`, {
                 newEventsCount: newEvents.length,
                 newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
                 rollbackCount: mergeResult.rollbackEvents.length,
                 mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
             });
-            const globalRebasedPendingEvents = mergeResult.newSyncState.pending.filter((mutationEvent) => {
-                const mutationDef = getMutationDef(schema, mutationEvent.mutation);
-                return mutationDef.options.clientOnly === false;
+            const globalRebasedPendingEvents = mergeResult.newSyncState.pending.filter((event) => {
+                const eventDef = getEventDef(schema, event.name);
+                return eventDef.eventDef.options.clientOnly === false;
             });
             yield* restartBackendPushing(globalRebasedPendingEvents);
             if (mergeResult.rollbackEvents.length > 0) {
-                yield* rollback({ db, dbMutationLog, eventIdsToRollback: mergeResult.rollbackEvents.map((_) => _.id) });
+                yield* rollback({ db, dbEventlog, eventIdsToRollback: mergeResult.rollbackEvents.map((_) => _.id) });
             }
             yield* connectedClientSessionPullQueues.offer({
                 payload: SyncState.PayloadUpstreamRebase.make({
@@ -436,7 +454,7 @@ const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBa
             }));
         }
         else {
-            otelSpan?.addEvent(`merge[${mergeCounter}]:backend-pull:advance`, {
+            otelSpan?.addEvent(`[${mergeCounter}]:pull:advance`, {
                 newEventsCount: newEvents.length,
                 mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
             });
@@ -448,20 +466,21 @@ const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBa
             if (mergeResult.confirmedEvents.length > 0) {
                 // `mergeResult.confirmedEvents` don't contain the correct sync metadata, so we need to use
                 // `newEvents` instead which we filter via `mergeResult.confirmedEvents`
-                const confirmedNewEvents = newEvents.filter((mutationEvent) => mergeResult.confirmedEvents.some((confirmedEvent) => EventId.isEqual(mutationEvent.id, confirmedEvent.id)));
-                yield* Mutationlog.updateSyncMetadata(confirmedNewEvents);
+                const confirmedNewEvents = newEvents.filter((event) => mergeResult.confirmedEvents.some((confirmedEvent) => EventId.isEqual(event.id, confirmedEvent.id)));
+                yield* Eventlog.updateSyncMetadata(confirmedNewEvents);
             }
         }
         // Removes the changeset rows which are no longer needed as we'll never have to rollback beyond this point
         trimChangesetRows(db, newBackendHead);
-        yield* applyMutationsBatch({ batchItems: mergeResult.newEvents, deferreds: undefined });
+        advancePushHead(mergeResult.newSyncState.localHead);
+        yield* applyEventsBatch({ batchItems: mergeResult.newEvents, deferreds: undefined });
         yield* SubscriptionRef.set(syncStateSref, mergeResult.newSyncState);
         // Allow local pushes to be processed again
         if (remaining === 0) {
             yield* localPushesLatch.open;
         }
     });
-    const cursorInfo = yield* Mutationlog.getSyncBackendCursorInfo(initialBackendHead);
+    const cursorInfo = yield* Eventlog.getSyncBackendCursorInfo(initialBackendHead);
     yield* syncBackend.pull(cursorInfo).pipe(
     // TODO only take from queue while connected
     Stream.tap(({ batch, remaining }) => Effect.gen(function* () {
@@ -471,22 +490,21 @@ const backgroundBackendPulling = ({ initialBackendHead, isClientEvent, restartBa
         //     batch: TRACE_VERBOSE ? batch : undefined,
         //   },
         // })
-        // NOTE we only want to take process mutations when the sync backend is connected
+        // NOTE we only want to take process events when the sync backend is connected
         // (e.g. needed for simulating being offline)
         // TODO remove when there's a better way to handle this in stream above
         yield* SubscriptionRef.waitUntil(syncBackend.isConnected, (isConnected) => isConnected === true);
-        yield* onNewPullChunk(batch.map((_) => MutationEvent.EncodedWithMeta.fromGlobal(_.mutationEventEncoded, _.metadata)), remaining);
+        yield* onNewPullChunk(batch.map((_) => LiveStoreEvent.EncodedWithMeta.fromGlobal(_.eventEncoded, _.metadata)), remaining);
         yield* initialBlockingSyncContext.update({ processed: batch.length, remaining });
     })), Stream.runDrain, Effect.interruptible);
 }).pipe(Effect.withSpan('@livestore/common:LeaderSyncProcessor:backend-pulling'));
-const backgroundBackendPushing = ({ syncBackendPushQueue, otelSpan, devtoolsLatch, }) => Effect.gen(function* () {
+const backgroundBackendPushing = ({ syncBackendPushQueue, otelSpan, devtoolsLatch, backendPushBatchSize, }) => Effect.gen(function* () {
     const { syncBackend } = yield* LeaderThreadCtx;
     if (syncBackend === undefined)
         return;
     while (true) {
         yield* SubscriptionRef.waitUntil(syncBackend.isConnected, (isConnected) => isConnected === true);
-        // TODO make batch size configurable
-        const queueItems = yield* BucketQueue.takeBetween(syncBackendPushQueue, 1, BACKEND_PUSH_BATCH_SIZE);
+        const queueItems = yield* BucketQueue.takeBetween(syncBackendPushQueue, 1, backendPushBatchSize);
         yield* SubscriptionRef.waitUntil(syncBackend.isConnected, (isConnected) => isConnected === true);
         if (devtoolsLatch !== undefined) {
             yield* devtoolsLatch.await;
@@ -550,4 +568,22 @@ const getMergeCounterFromDb = (dbReadModel) => Effect.gen(function* () {
     const result = dbReadModel.select(sql `SELECT mergeCounter FROM ${LEADER_MERGE_COUNTER_TABLE} WHERE id = 0`);
     return result[0]?.mergeCounter ?? 0;
 });
+const validatePushBatch = (batch, pushHead) => Effect.gen(function* () {
+    if (batch.length === 0) {
+        return;
+    }
+    // Make sure batch is monotonically increasing
+    for (let i = 1; i < batch.length; i++) {
+        if (EventId.isGreaterThanOrEqual(batch[i - 1].id, batch[i].id)) {
+            shouldNeverHappen(`Events must be ordered in monotonically ascending order by eventId. Received: [${batch.map((e) => EventId.toString(e.id)).join(', ')}]`);
+        }
+    }
+    // Make sure smallest event id is > pushHead
+    if (EventId.isGreaterThanOrEqual(pushHead, batch[0].id)) {
+        return yield* LeaderAheadError.make({
+            minimumExpectedId: pushHead,
+            providedId: batch[0].id,
+        });
+    }
+});
 //# sourceMappingURL=LeaderSyncProcessor.js.map