@livestore/common 0.4.0-dev.2 → 0.4.0-dev.20

package/dist/sync/sync.js

@@ -1,28 +1,3 @@
-import { Schema } from '@livestore/utils/effect';
-import * as EventSequenceNumber from "../schema/EventSequenceNumber.js";
-export class IsOfflineError extends Schema.TaggedError()('IsOfflineError', {}) {
-}
-// TODO gt rid of this error in favour of SyncError
-export class InvalidPushError extends Schema.TaggedError()('InvalidPushError', {
-    reason: Schema.Union(Schema.TaggedStruct('Unexpected', {
-        message: Schema.String,
-    }), Schema.TaggedStruct('ServerAhead', {
-        minimumExpectedNum: Schema.Number,
-        providedNum: Schema.Number,
-    })),
-}) {
-}
-// TODO gt rid of this error in favour of SyncError
-export class InvalidPullError extends Schema.TaggedError()('InvalidPullError', {
-    message: Schema.String,
-}) {
-}
-// TODO gt rid of this error in favour of SyncError
-export class LeaderAheadError extends Schema.TaggedError()('LeaderAheadError', {
-    minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
-    providedNum: EventSequenceNumber.EventSequenceNumber,
-    /** Generation number the client session should use for subsequent pushes */
-    // nextGeneration: Schema.Number,
-}) {
-}
+export * from "./errors.js";
+export * as SyncBackend from "./sync-backend.js";
 //# sourceMappingURL=sync.js.map

package/dist/sync/sync.js.map

@@ -1 +1 @@
-{"version":3,"file":"sync.js","sourceRoot":"","sources":["../../src/sync/sync.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAIhD,OAAO,KAAK,mBAAmB,MAAM,kCAAkC,CAAA;AA6EvE,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,WAAW,EAAkB,CAAC,gBAAgB,EAAE,EAAE,CAAC;CAAG;AAEjG,mDAAmD;AACnD,MAAM,OAAO,gBAAiB,SAAQ,MAAM,CAAC,WAAW,EAAoB,CAAC,kBAAkB,EAAE;IAC/F,MAAM,EAAE,MAAM,CAAC,KAAK,CAClB,MAAM,CAAC,YAAY,CAAC,YAAY,EAAE;QAChC,OAAO,EAAE,MAAM,CAAC,MAAM;KACvB,CAAC,EACF,MAAM,CAAC,YAAY,CAAC,aAAa,EAAE;QACjC,kBAAkB,EAAE,MAAM,CAAC,MAAM;QACjC,WAAW,EAAE,MAAM,CAAC,MAAM;KAC3B,CAAC,CACH;CACF,CAAC;CAAG;AAEL,mDAAmD;AACnD,MAAM,OAAO,gBAAiB,SAAQ,MAAM,CAAC,WAAW,EAAoB,CAAC,kBAAkB,EAAE;IAC/F,OAAO,EAAE,MAAM,CAAC,MAAM;CACvB,CAAC;CAAG;AAEL,mDAAmD;AACnD,MAAM,OAAO,gBAAiB,SAAQ,MAAM,CAAC,WAAW,EAAoB,CAAC,kBAAkB,EAAE;IAC/F,kBAAkB,EAAE,mBAAmB,CAAC,mBAAmB;IAC3D,WAAW,EAAE,mBAAmB,CAAC,mBAAmB;IACpD,4EAA4E;IAC5E,iCAAiC;CAClC,CAAC;CAAG"}
+{"version":3,"file":"sync.js","sourceRoot":"","sources":["../../src/sync/sync.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA"}

package/dist/sync/syncstate.d.ts

@@ -1,33 +1,42 @@
 import { Schema } from '@livestore/utils/effect';
-import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts';
+import * as EventSequenceNumber from '../schema/EventSequenceNumber/mod.ts';
+import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts';
 declare const SyncState_base: Schema.Class<SyncState, {
-    pending: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    pending: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** What this node expects the next upstream node to have as its own local head */
     upstreamHead: Schema.Struct<{
         global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
         client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
         rebaseGeneration: typeof Schema.Int;
-    }>;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
     /** Equivalent to `pending.at(-1)?.id` if there are pending events */
     localHead: Schema.Struct<{
         global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
         client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
         rebaseGeneration: typeof Schema.Int;
-    }>;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
 }, Schema.Struct.Encoded<{
-    pending: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    pending: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** What this node expects the next upstream node to have as its own local head */
     upstreamHead: Schema.Struct<{
         global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
         client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
         rebaseGeneration: typeof Schema.Int;
-    }>;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
     /** Equivalent to `pending.at(-1)?.id` if there are pending events */
     localHead: Schema.Struct<{
         global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
         client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
         rebaseGeneration: typeof Schema.Int;
-    }>;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
 }>, never, {
     readonly upstreamHead: {
         readonly global: number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">;
@@ -41,7 +50,7 @@ declare const SyncState_base: Schema.Class<SyncState, {
         readonly rebaseGeneration: number;
     };
 } & {
-    readonly pending: readonly LiveStoreEvent.EncodedWithMeta[];
+    readonly pending: readonly LiveStoreEvent.Client.EncodedWithMeta[];
 }, {}, {}>;
 /**
  * SyncState represents the current sync state of a sync node relative to an upstream node.
@@ -54,7 +63,7 @@ declare const SyncState_base: Schema.Class<SyncState, {
  *                 +------------------------+
  *               ▼                       ▼
  *        Upstream Head             Local Head
- *             (1,0)     (1,1), (1,2), (2,0)
+ *              e1        e1.1, e1.2, e2
  * ```
  *
  * **Pending Events**: Events awaiting acknowledgment from the upstream.
@@ -70,7 +79,7 @@ declare const SyncState_base: Schema.Class<SyncState, {
  * Invariants:
  * 1. **Chain Continuity**: Each event must reference its immediate parent.
  * 2. **Head Ordering**: Upstream Head ≤ Local Head.
- * 3. **Event number sequence**: Must follow the pattern (1,0)→(1,1)→(1,2)→(2,0).
+ * 3. **Event number sequence**: Must follow the pattern e1→e1.1→e1.2→e2.
  *
  * A few further notes to help form an intuition:
  * - The goal is to keep the pending events as small as possible (i.e. to have synced with the next upstream node)
@@ -85,9 +94,9 @@ export declare class SyncState extends SyncState_base {
 }
 declare const PayloadUpstreamRebase_base: Schema.TaggedStruct<"upstream-rebase", {
     /** Events which need to be rolled back */
-    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** Events which need to be applied after the rollback (already rebased by the upstream node) */
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
 }>;
 /**
  * This payload propagates a rebase from the upstream node
@@ -95,12 +104,12 @@ declare const PayloadUpstreamRebase_base: Schema.TaggedStruct<"upstream-rebase",
 export declare class PayloadUpstreamRebase extends PayloadUpstreamRebase_base {
 }
 declare const PayloadUpstreamAdvance_base: Schema.TaggedStruct<"upstream-advance", {
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
 }>;
 export declare class PayloadUpstreamAdvance extends PayloadUpstreamAdvance_base {
 }
 declare const PayloadLocalPush_base: Schema.TaggedStruct<"local-push", {
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
 }>;
 export declare class PayloadLocalPush extends PayloadLocalPush_base {
 }
@@ -119,14 +128,14 @@ declare const MergeContext_base: Schema.Class<MergeContext, {
 }>, never, {
     readonly payload: {
         readonly _tag: "upstream-rebase";
-        readonly rollbackEvents: readonly LiveStoreEvent.EncodedWithMeta[];
-        readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+        readonly rollbackEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
+        readonly newEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
     } | {
         readonly _tag: "upstream-advance";
-        readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+        readonly newEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
     } | {
         readonly _tag: "local-push";
-        readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+        readonly newEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
     };
 } & {
     readonly syncState: SyncState;
@@ -138,27 +147,27 @@ export declare class MergeContext extends MergeContext_base {
 declare const MergeResultAdvance_base: Schema.Class<MergeResultAdvance, {
     _tag: Schema.Literal<["advance"]>;
     newSyncState: typeof SyncState;
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** Events which were previously pending but are now confirmed */
-    confirmedEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    confirmedEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     mergeContext: typeof MergeContext;
 }, Schema.Struct.Encoded<{
     _tag: Schema.Literal<["advance"]>;
     newSyncState: typeof SyncState;
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** Events which were previously pending but are now confirmed */
-    confirmedEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    confirmedEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     mergeContext: typeof MergeContext;
 }>, never, {
     readonly _tag: "advance";
 } & {
-    readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    readonly newEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
 } & {
     readonly newSyncState: SyncState;
 } & {
     readonly mergeContext: MergeContext;
 } & {
-    readonly confirmedEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    readonly confirmedEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
 }, {}, {}>;
 export declare class MergeResultAdvance extends MergeResultAdvance_base {
     toJSON: () => any;
@@ -166,23 +175,23 @@ export declare class MergeResultAdvance extends MergeResultAdvance_base {
 declare const MergeResultRebase_base: Schema.Class<MergeResultRebase, {
     _tag: Schema.Literal<["rebase"]>;
     newSyncState: typeof SyncState;
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** Events which need to be rolled back */
-    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     mergeContext: typeof MergeContext;
 }, Schema.Struct.Encoded<{
     _tag: Schema.Literal<["rebase"]>;
     newSyncState: typeof SyncState;
-    newEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    newEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     /** Events which need to be rolled back */
-    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.EncodedWithMeta>;
+    rollbackEvents: Schema.Array$<typeof LiveStoreEvent.Client.EncodedWithMeta>;
     mergeContext: typeof MergeContext;
 }>, never, {
     readonly _tag: "rebase";
 } & {
-    readonly rollbackEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    readonly rollbackEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
 } & {
-    readonly newEvents: readonly LiveStoreEvent.EncodedWithMeta[];
+    readonly newEvents: readonly LiveStoreEvent.Client.EncodedWithMeta[];
 } & {
     readonly newSyncState: SyncState;
 } & {
@@ -198,7 +207,9 @@ declare const MergeResultReject_base: Schema.Class<MergeResultReject, {
         global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
         client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
         rebaseGeneration: typeof Schema.Int;
-    }>;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
     mergeContext: typeof MergeContext;
 }, Schema.Struct.Encoded<{
     _tag: Schema.Literal<["reject"]>;
@@ -207,7 +218,9 @@ declare const MergeResultReject_base: Schema.Class<MergeResultReject, {
         global: Schema.BrandSchema<number & import("effect/Brand").Brand<"GlobalEventSequenceNumber">, number, never>;
         client: Schema.BrandSchema<number & import("effect/Brand").Brand<"ClientEventSequenceNumber">, number, never>;
         rebaseGeneration: typeof Schema.Int;
-    }>;
+    }> & {
+        make: (seqNum: EventSequenceNumber.Client.CompositeInput) => EventSequenceNumber.Client.Composite;
+    };
     mergeContext: typeof MergeContext;
 }>, never, {
     readonly _tag: "reject";
@@ -223,28 +236,28 @@ declare const MergeResultReject_base: Schema.Class<MergeResultReject, {
 export declare class MergeResultReject extends MergeResultReject_base {
     toJSON: () => any;
 }
-declare const MergeResultUnexpectedError_base: Schema.Class<MergeResultUnexpectedError, {
-    _tag: Schema.Literal<["unexpected-error"]>;
+declare const MergeResultUnknownError_base: Schema.Class<MergeResultUnknownError, {
+    _tag: Schema.Literal<["unknown-error"]>;
     message: typeof Schema.String;
 }, Schema.Struct.Encoded<{
-    _tag: Schema.Literal<["unexpected-error"]>;
+    _tag: Schema.Literal<["unknown-error"]>;
     message: typeof Schema.String;
 }>, never, {
-    readonly _tag: "unexpected-error";
+    readonly _tag: "unknown-error";
 } & {
     readonly message: string;
 }, {}, {}>;
-export declare class MergeResultUnexpectedError extends MergeResultUnexpectedError_base {
+export declare class MergeResultUnknownError extends MergeResultUnknownError_base {
 }
-declare const MergeResult_base: Schema.Union<[typeof MergeResultAdvance, typeof MergeResultRebase, typeof MergeResultReject, typeof MergeResultUnexpectedError]>;
+declare const MergeResult_base: Schema.Union<[typeof MergeResultAdvance, typeof MergeResultRebase, typeof MergeResultReject, typeof MergeResultUnknownError]>;
 export declare class MergeResult extends MergeResult_base {
 }
 export declare const payloadFromMergeResult: (mergeResult: typeof MergeResultAdvance.Type | typeof MergeResultRebase.Type) => typeof PayloadUpstream.Type;
 export declare const merge: ({ syncState, payload, isClientEvent, isEqualEvent, ignoreClientEvents, }: {
     syncState: SyncState;
     payload: typeof Payload.Type;
-    isClientEvent: (event: LiveStoreEvent.EncodedWithMeta) => boolean;
-    isEqualEvent: (a: LiveStoreEvent.EncodedWithMeta, b: LiveStoreEvent.EncodedWithMeta) => boolean;
+    isClientEvent: (event: LiveStoreEvent.Client.EncodedWithMeta) => boolean;
+    isEqualEvent: (a: LiveStoreEvent.Client.EncodedWithMeta, b: LiveStoreEvent.Client.EncodedWithMeta) => boolean;
     /** This is used in the leader which should ignore client events when receiving an upstream-advance payload */
     ignoreClientEvents?: boolean;
 }) => typeof MergeResult.Type;
@@ -253,10 +266,10 @@ export declare const merge: ({ syncState, payload, isClientEvent, isEqualEvent,
  * by comparing each event in `existingEvents` to the corresponding event in `incomingEvents`
  */
 export declare const findDivergencePoint: ({ existingEvents, incomingEvents, isEqualEvent, isClientEvent, ignoreClientEvents, }: {
-    existingEvents: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>;
-    incomingEvents: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>;
-    isEqualEvent: (a: LiveStoreEvent.EncodedWithMeta, b: LiveStoreEvent.EncodedWithMeta) => boolean;
-    isClientEvent: (event: LiveStoreEvent.EncodedWithMeta) => boolean;
+    existingEvents: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>;
+    incomingEvents: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>;
+    isEqualEvent: (a: LiveStoreEvent.Client.EncodedWithMeta, b: LiveStoreEvent.Client.EncodedWithMeta) => boolean;
+    isClientEvent: (event: LiveStoreEvent.Client.EncodedWithMeta) => boolean;
     ignoreClientEvents: boolean;
 }) => number;
 export {};

package/dist/sync/syncstate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncstate.d.ts","sourceRoot":"","sources":["../../src/sync/syncstate.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAGtE,OAAO,KAAK,cAAc,MAAM,6BAA6B,CAAA;;;IAyC3D,kFAAkF;;;;;;IAElF,qEAAqE;;;;;;;;IAFrE,kFAAkF;;;;;;IAElF,qEAAqE;;;;;;;;;;;;;;;;;;;;;AAzCvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,SAAU,SAAQ,cAM7B;IACA,MAAM,QAAO,GAAG,CAId;CACH;;IAMC,0CAA0C;;IAE1C,gGAAgG;;;AANlG;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,0BAKzC;CAAG;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAE1C;CAAG;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAEpC;CAAG;;AAEL,qBAAa,OAAQ,SAAQ,YAA6E;CAAG;;AAE7G,qBAAa,eAAgB,SAAQ,oBAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;AAEnG,uCAAuC;AACvC,qBAAa,YAAa,SAAQ,iBAGhC;IACA,MAAM,QAAO,GAAG,CAqBf;CACF;;;;;IAMC,iEAAiE;;;;;;;IAAjE,iEAAiE;;;;;;;;;;;;;;AAJnE,qBAAa,kBAAmB,SAAQ,uBAOtC;IACA,MAAM,QAAO,GAAG,CAQf;CACF;;;;;IAMC,0CAA0C;;;;;;;IAA1C,0CAA0C;;;;;;;;;;;;;;AAJ5C,qBAAa,iBAAkB,SAAQ,sBAOrC;IACA,MAAM,QAAO,GAAG,CAQf;CACF;;;IAIC,mDAAmD;;;;;;;;;IAAnD,mDAAmD;;;;;;;;;;;;;;;;;;AAFrD,qBAAa,iBAAkB,SAAQ,sBAKrC;IACA,MAAM,QAAO,GAAG,CAMf;CACF;;;;;;;;;;;;AAED,qBAAa,0BAA2B,SAAQ,+BAG9C;CAAG;;AAEL,qBAAa,WAAY,SAAQ,gBAKhC;CAAG;AAEJ,eAAO,MAAM,sBAAsB,GACjC,aAAa,OAAO,kBAAkB,CAAC,IAAI,GAAG,OAAO,iBAAiB,CAAC,IAAI,KAC1E,OAAO,eAAe,CAAC,IAYvB,CAAA;AAkBH,eAAO,MAAM,KAAK,GAAI,0EAMnB;IACD,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC,IAAI,CAAA;IAC5B,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IACjE,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,eAAe,EAAE,CAAC,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IAC/F,8GAA8G;IAC9G,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,KAAG,OAAO,WAAW,CAAC,IAmNtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,sFAMjC;IACD,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,eAAe,CAAC,CAAA;IAC7D,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,eAAe,CAAC,CAAA;IAC7D,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,eAAe,EAAE,CAAC,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IAC/F,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,KAAK,OAAO,CAAA;IACjE,kBAAkB,EAAE,OAAO,CAAA;CAC5B,KAAG,MAyBH,CAAA"}
+{"version":3,"file":"syncstate.d.ts","sourceRoot":"","sources":["../../src/sync/syncstate.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEtE,OAAO,KAAK,mBAAmB,MAAM,sCAAsC,CAAA;AAC3E,OAAO,KAAK,cAAc,MAAM,iCAAiC,CAAA;;;IAyC/D,kFAAkF;;;;;;;;IAElF,qEAAqE;;;;;;;;;;IAFrE,kFAAkF;;;;;;;;IAElF,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;AAzCvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,SAAU,SAAQ,cAM7B;IACA,MAAM,QAAO,GAAG,CAId;CACH;;IAMC,0CAA0C;;IAE1C,gGAAgG;;;AANlG;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,0BAKzC;CAAG;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAE1C;CAAG;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAEpC;CAAG;;AAEL,qBAAa,OAAQ,SAAQ,YAA6E;CAAG;;AAE7G,qBAAa,eAAgB,SAAQ,oBAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;AAEnG,uCAAuC;AACvC,qBAAa,YAAa,SAAQ,iBAGhC;IACA,MAAM,QAAO,GAAG,CAqBf;CACF;;;;;IAMC,iEAAiE;;;;;;;IAAjE,iEAAiE;;;;;;;;;;;;;;AAJnE,qBAAa,kBAAmB,SAAQ,uBAOtC;IACA,MAAM,QAAO,GAAG,CAQf;CACF;;;;;IAMC,0CAA0C;;;;;;;IAA1C,0CAA0C;;;;;;;;;;;;;;AAJ5C,qBAAa,iBAAkB,SAAQ,sBAOrC;IACA,MAAM,QAAO,GAAG,CAQf;CACF;;;IAIC,mDAAmD;;;;;;;;;;;IAAnD,mDAAmD;;;;;;;;;;;;;;;;;;;;AAFrD,qBAAa,iBAAkB,SAAQ,sBAKrC;IACA,MAAM,QAAO,GAAG,CAMf;CACF;;;;;;;;;;;;AAED,qBAAa,uBAAwB,SAAQ,4BAG3C;CAAG;;AAEL,qBAAa,WAAY,SAAQ,gBAKhC;CAAG;AAEJ,eAAO,MAAM,sBAAsB,GACjC,aAAa,OAAO,kBAAkB,CAAC,IAAI,GAAG,OAAO,iBAAiB,CAAC,IAAI,KAC1E,OAAO,eAAe,CAAC,IAYvB,CAAA;AAkBH,eAAO,MAAM,KAAK,GAAI,0EAMnB;IACD,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC,IAAI,CAAA;IAC5B,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,MAAM,CAAC,eAAe,KAAK,OAAO,CAAA;IACxE,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,eAAe,KAAK,OAAO,CAAA;IAC7G,8GAA8G;IAC9G,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,KAAG,OAAO,WAAW,CAAC,IA0NtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,sFAMjC;IACD,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC,eAAe,CAAC,CAAA;IACpE,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC,eAAe,CAAC,CAAA;IACpE,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,eAAe,KAAK,OAAO,CAAA;IAC7G,aAAa,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,MAAM,CAAC,eAAe,KAAK,OAAO,CAAA;IACxE,kBAAkB,EAAE,OAAO,CAAA;CAC5B,KAAG,MAyBH,CAAA"}

package/dist/sync/syncstate.js

@@ -1,7 +1,7 @@
 import { casesHandled, LS_DEV, shouldNeverHappen } from '@livestore/utils';
 import { Match, ReadonlyArray, Schema } from '@livestore/utils/effect';
-import * as EventSequenceNumber from "../schema/EventSequenceNumber.js";
-import * as LiveStoreEvent from "../schema/LiveStoreEvent.js";
+import * as EventSequenceNumber from "../schema/EventSequenceNumber/mod.js";
+import * as LiveStoreEvent from "../schema/LiveStoreEvent/mod.js";
 /**
  * SyncState represents the current sync state of a sync node relative to an upstream node.
  * Events flow from local to upstream, with each state maintaining its own event head.
@@ -13,7 +13,7 @@ import * as LiveStoreEvent from "../schema/LiveStoreEvent.js";
  *                 +------------------------+
  *               ▼                       ▼
  *        Upstream Head             Local Head
- *             (1,0)     (1,1), (1,2), (2,0)
+ *              e1        e1.1, e1.2, e2
  * ```
  *
  * **Pending Events**: Events awaiting acknowledgment from the upstream.
@@ -29,7 +29,7 @@ import * as LiveStoreEvent from "../schema/LiveStoreEvent.js";
  * Invariants:
  * 1. **Chain Continuity**: Each event must reference its immediate parent.
  * 2. **Head Ordering**: Upstream Head ≤ Local Head.
- * 3. **Event number sequence**: Must follow the pattern (1,0)→(1,1)→(1,2)→(2,0).
+ * 3. **Event number sequence**: Must follow the pattern e1→e1.1→e1.2→e2.
  *
  * A few further notes to help form an intuition:
  * - The goal is to keep the pending events as small as possible (i.e. to have synced with the next upstream node)
@@ -40,16 +40,16 @@ import * as LiveStoreEvent from "../schema/LiveStoreEvent.js";
  * handling cases such as upstream rebase, advance and local push.
  */
 export class SyncState extends Schema.Class('SyncState')({
-    pending: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    pending: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
     /** What this node expects the next upstream node to have as its own local head */
-    upstreamHead: EventSequenceNumber.EventSequenceNumber,
+    upstreamHead: EventSequenceNumber.Client.Composite,
     /** Equivalent to `pending.at(-1)?.id` if there are pending events */
-    localHead: EventSequenceNumber.EventSequenceNumber,
+    localHead: EventSequenceNumber.Client.Composite,
 }) {
     toJSON = () => ({
         pending: this.pending.map((e) => e.toJSON()),
-        upstreamHead: EventSequenceNumber.toString(this.upstreamHead),
-        localHead: EventSequenceNumber.toString(this.localHead),
+        upstreamHead: EventSequenceNumber.Client.toString(this.upstreamHead),
+        localHead: EventSequenceNumber.Client.toString(this.localHead),
     });
 }
 /**
@@ -57,17 +57,17 @@ export class SyncState extends Schema.Class('SyncState')({
  */
 export class PayloadUpstreamRebase extends Schema.TaggedStruct('upstream-rebase', {
     /** Events which need to be rolled back */
-    rollbackEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    rollbackEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
     /** Events which need to be applied after the rollback (already rebased by the upstream node) */
-    newEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    newEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
 }) {
 }
 export class PayloadUpstreamAdvance extends Schema.TaggedStruct('upstream-advance', {
-    newEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    newEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
 }) {
 }
 export class PayloadLocalPush extends Schema.TaggedStruct('local-push', {
-    newEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    newEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
 }) {
 }
 export class Payload extends Schema.Union(PayloadUpstreamRebase, PayloadUpstreamAdvance, PayloadLocalPush) {
@@ -100,9 +100,9 @@ export class MergeContext extends Schema.Class('MergeContext')({
 export class MergeResultAdvance extends Schema.Class('MergeResultAdvance')({
     _tag: Schema.Literal('advance'),
     newSyncState: SyncState,
-    newEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    newEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
     /** Events which were previously pending but are now confirmed */
-    confirmedEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    confirmedEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
     mergeContext: MergeContext,
 }) {
     toJSON = () => {
@@ -118,9 +118,9 @@ export class MergeResultAdvance extends Schema.Class('MergeResultAdvance')({
 export class MergeResultRebase extends Schema.Class('MergeResultRebase')({
     _tag: Schema.Literal('rebase'),
     newSyncState: SyncState,
-    newEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    newEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
     /** Events which need to be rolled back */
-    rollbackEvents: Schema.Array(LiveStoreEvent.EncodedWithMeta),
+    rollbackEvents: Schema.Array(LiveStoreEvent.Client.EncodedWithMeta),
     mergeContext: MergeContext,
 }) {
     toJSON = () => {
@@ -136,23 +136,23 @@ export class MergeResultRebase extends Schema.Class('MergeResultRebase')({
 export class MergeResultReject extends Schema.Class('MergeResultReject')({
     _tag: Schema.Literal('reject'),
     /** The minimum id that the new events must have */
-    expectedMinimumId: EventSequenceNumber.EventSequenceNumber,
+    expectedMinimumId: EventSequenceNumber.Client.Composite,
     mergeContext: MergeContext,
 }) {
     toJSON = () => {
         return {
             _tag: this._tag,
-            expectedMinimumId: EventSequenceNumber.toString(this.expectedMinimumId),
+            expectedMinimumId: EventSequenceNumber.Client.toString(this.expectedMinimumId),
             mergeContext: this.mergeContext.toJSON(),
         };
     };
 }
-export class MergeResultUnexpectedError extends Schema.Class('MergeResultUnexpectedError')({
-    _tag: Schema.Literal('unexpected-error'),
+export class MergeResultUnknownError extends Schema.Class('MergeResultUnknownError')({
+    _tag: Schema.Literal('unknown-error'),
     message: Schema.String,
 }) {
 }
-export class MergeResult extends Schema.Union(MergeResultAdvance, MergeResultRebase, MergeResultReject, MergeResultUnexpectedError) {
+export class MergeResult extends Schema.Union(MergeResultAdvance, MergeResultRebase, MergeResultReject, MergeResultUnknownError) {
 }
 export const payloadFromMergeResult = (mergeResult) => Match.value(mergeResult).pipe(Match.tag('advance', (result) => ({
     _tag: 'upstream-advance',
@@ -162,12 +162,12 @@ export const payloadFromMergeResult = (mergeResult) => Match.value(mergeResult).
     newEvents: result.newEvents,
     rollbackEvents: result.rollbackEvents,
 })), Match.exhaustive);
-const unexpectedError = (message) => {
+const unknownError = (message) => {
     if (LS_DEV) {
         // biome-ignore lint/suspicious/noDebugger: debug
         debugger;
     }
-    return MergeResultUnexpectedError.make({ _tag: 'unexpected-error', message });
+    return MergeResultUnknownError.make({ _tag: 'unknown-error', message });
 };
 // TODO Idea: call merge recursively through hierarchy levels
 /*
@@ -220,14 +220,14 @@ export const merge = ({ syncState, payload, isClientEvent, isEqualEvent, ignoreC
             }
             // Validate that newEvents are sorted in ascending order by eventNum
             for (let i = 1; i < payload.newEvents.length; i++) {
-                if (EventSequenceNumber.isGreaterThan(payload.newEvents[i - 1].seqNum, payload.newEvents[i].seqNum)) {
-                    return unexpectedError(`Events must be sorted in ascending order by event number. Received: [${payload.newEvents.map((e) => EventSequenceNumber.toString(e.seqNum)).join(', ')}]`);
+                if (EventSequenceNumber.Client.isGreaterThan(payload.newEvents[i - 1].seqNum, payload.newEvents[i].seqNum)) {
+                    return unknownError(`Events must be sorted in ascending order by event number. Received: [${payload.newEvents.map((e) => EventSequenceNumber.Client.toString(e.seqNum)).join(', ')}]`);
                 }
             }
             // Validate that incoming events are larger than upstream head
-            if (EventSequenceNumber.isGreaterThan(syncState.upstreamHead, payload.newEvents[0].seqNum) ||
-                EventSequenceNumber.isEqual(syncState.upstreamHead, payload.newEvents[0].seqNum)) {
-                return unexpectedError(`Incoming events must be greater than upstream head. Expected greater than: ${EventSequenceNumber.toString(syncState.upstreamHead)}. Received: [${payload.newEvents.map((e) => EventSequenceNumber.toString(e.seqNum)).join(', ')}]`);
+            if (EventSequenceNumber.Client.isGreaterThan(syncState.upstreamHead, payload.newEvents[0].seqNum) ||
+                EventSequenceNumber.Client.isEqual(syncState.upstreamHead, payload.newEvents[0].seqNum)) {
+                return unknownError(`Incoming events must be greater than upstream head. Expected greater than: ${EventSequenceNumber.Client.toString(syncState.upstreamHead)}. Received: [${payload.newEvents.map((e) => EventSequenceNumber.Client.toString(e.seqNum)).join(', ')}]`);
             }
             const newUpstreamHead = payload.newEvents.at(-1).seqNum;
             const divergentPendingIndex = findDivergencePoint({
@@ -263,7 +263,7 @@ export const merge = ({ syncState, payload, isClientEvent, isEqualEvent, ignoreC
                     newSyncState: new SyncState({
                         pending: pendingRemaining,
                         upstreamHead: newUpstreamHead,
-                        localHead: pendingRemaining.at(-1)?.seqNum ?? EventSequenceNumber.max(syncState.localHead, newUpstreamHead),
+                        localHead: pendingRemaining.at(-1)?.seqNum ?? EventSequenceNumber.Client.max(syncState.localHead, newUpstreamHead),
                     }),
                     newEvents,
                     confirmedEvents: pendingMatching,
@@ -310,9 +310,9 @@ export const merge = ({ syncState, payload, isClientEvent, isEqualEvent, ignoreC
                 }));
             }
             const newEventsFirst = payload.newEvents.at(0);
-            const invalidEventSequenceNumber = EventSequenceNumber.isGreaterThan(newEventsFirst.seqNum, syncState.localHead) === false;
+            const invalidEventSequenceNumber = EventSequenceNumber.Client.isGreaterThan(newEventsFirst.seqNum, syncState.localHead) === false;
             if (invalidEventSequenceNumber) {
-                const expectedMinimumId = EventSequenceNumber.nextPair({
+                const expectedMinimumId = EventSequenceNumber.Client.nextPair({
                     seqNum: syncState.localHead,
                     isClient: true,
                 }).seqNum;
@@ -323,12 +323,17 @@ export const merge = ({ syncState, payload, isClientEvent, isEqualEvent, ignoreC
                 }));
             }
             else {
+                const nonClientEvents = ignoreClientEvents
+                    ? payload.newEvents.filter((event) => !isClientEvent(event))
+                    : payload.newEvents;
+                const newPending = [...syncState.pending, ...nonClientEvents];
+                const newLocalHead = newPending.at(-1)?.seqNum ?? EventSequenceNumber.Client.max(syncState.localHead, syncState.upstreamHead);
                 return validateMergeResult(MergeResultAdvance.make({
                     _tag: 'advance',
                     newSyncState: new SyncState({
-                        pending: [...syncState.pending, ...payload.newEvents],
+                        pending: newPending,
                         upstreamHead: syncState.upstreamHead,
-                        localHead: payload.newEvents.at(-1).seqNum,
+                        localHead: newLocalHead,
                     }),
                     newEvents: payload.newEvents,
                     confirmedEvents: [],
@@ -359,7 +364,7 @@ export const findDivergencePoint = ({ existingEvents, incomingEvents, isEqualEve
             return -1;
         const divergencePointEventSequenceNumber = existingEvents[divergencePointWithoutClientEvents].seqNum;
         // Now find the divergence point in the original array
-        return existingEvents.findIndex((event) => EventSequenceNumber.isEqual(event.seqNum, divergencePointEventSequenceNumber));
+        return existingEvents.findIndex((event) => EventSequenceNumber.Client.isEqual(event.seqNum, divergencePointEventSequenceNumber));
     }
     return existingEvents.findIndex((existingEvent, index) => {
         const incomingEvent = incomingEvents[index];
@@ -391,8 +396,8 @@ const rebaseEvents = ({ events, baseEventSequenceNumber, isClientEvent, }) => {
 const _flattenMergeResults = (_updateResults) => { };
 const validatePayload = (payload) => {
     for (let i = 1; i < payload.newEvents.length; i++) {
-        if (EventSequenceNumber.isGreaterThanOrEqual(payload.newEvents[i - 1].seqNum, payload.newEvents[i].seqNum)) {
-            return unexpectedError(`Events must be ordered in monotonically ascending order by eventNum. Received: [${payload.newEvents.map((e) => EventSequenceNumber.toString(e.seqNum)).join(', ')}]`);
+        if (EventSequenceNumber.Client.isGreaterThanOrEqual(payload.newEvents[i - 1].seqNum, payload.newEvents[i].seqNum)) {
+            return unknownError(`Events must be ordered in monotonically ascending order by eventNum. Received: [${payload.newEvents.map((e) => EventSequenceNumber.Client.toString(e.seqNum)).join(', ')}]`);
         }
     }
 };
@@ -402,8 +407,8 @@ const validateSyncState = (syncState) => {
         const nextEvent = syncState.pending[i + 1];
         if (nextEvent === undefined)
             break; // Reached end of chain
-        if (EventSequenceNumber.isGreaterThanOrEqual(event.seqNum, nextEvent.seqNum)) {
-            shouldNeverHappen(`Events must be ordered in monotonically ascending order by eventNum. Received: [${syncState.pending.map((e) => EventSequenceNumber.toString(e.seqNum)).join(', ')}]`, {
+        if (EventSequenceNumber.Client.isGreaterThanOrEqual(event.seqNum, nextEvent.seqNum)) {
+            shouldNeverHappen(`Events must be ordered in monotonically ascending order by eventNum. Received: [${syncState.pending.map((e) => EventSequenceNumber.Client.toString(e.seqNum)).join(', ')}]`, {
                 event,
                 nextEvent,
             });
@@ -412,7 +417,7 @@ const validateSyncState = (syncState) => {
         const globalIdHasIncreased = nextEvent.seqNum.global > event.seqNum.global;
         if (globalIdHasIncreased) {
             if (nextEvent.seqNum.client !== 0) {
-                shouldNeverHappen(`New global events must point to clientId 0 in the parentSeqNum. Received: (${EventSequenceNumber.toString(nextEvent.seqNum)})`, syncState.pending, {
+                shouldNeverHappen(`New global events must point to clientId 0 in the parentSeqNum. Received: (${EventSequenceNumber.Client.toString(nextEvent.seqNum)})`, syncState.pending, {
                     event,
                     nextEvent,
                 });
@@ -420,7 +425,7 @@ const validateSyncState = (syncState) => {
         }
         else {
             // Otherwise, the parentSeqNum must be the same as the previous event's id
-            if (EventSequenceNumber.isEqual(nextEvent.parentSeqNum, event.seqNum) === false) {
+            if (EventSequenceNumber.Client.isEqual(nextEvent.parentSeqNum, event.seqNum) === false) {
                 shouldNeverHappen('Events must be linked in a continuous chain via the parentSeqNum', syncState.pending, {
                     event,
                     nextEvent,
@@ -430,25 +435,25 @@ const validateSyncState = (syncState) => {
     }
 };
 const validateMergeResult = (mergeResult) => {
-    if (mergeResult._tag === 'unexpected-error' || mergeResult._tag === 'reject')
+    if (mergeResult._tag === 'unknown-error' || mergeResult._tag === 'reject')
         return mergeResult;
     validateSyncState(mergeResult.newSyncState);
     // Ensure local head is always greater than or equal to upstream head
-    if (EventSequenceNumber.isGreaterThan(mergeResult.newSyncState.upstreamHead, mergeResult.newSyncState.localHead)) {
+    if (EventSequenceNumber.Client.isGreaterThan(mergeResult.newSyncState.upstreamHead, mergeResult.newSyncState.localHead)) {
         shouldNeverHappen('Local head must be greater than or equal to upstream head', {
             localHead: mergeResult.newSyncState.localHead,
             upstreamHead: mergeResult.newSyncState.upstreamHead,
         });
     }
     // Ensure new local head is greater than or equal to the previous local head
-    if (EventSequenceNumber.isGreaterThanOrEqual(mergeResult.newSyncState.localHead, mergeResult.mergeContext.syncState.localHead) === false) {
+    if (EventSequenceNumber.Client.isGreaterThanOrEqual(mergeResult.newSyncState.localHead, mergeResult.mergeContext.syncState.localHead) === false) {
         shouldNeverHappen('New local head must be greater than or equal to the previous local head', {
             localHead: mergeResult.newSyncState.localHead,
             previousLocalHead: mergeResult.mergeContext.syncState.localHead,
         });
     }
     // Ensure new upstream head is greater than or equal to the previous upstream head
-    if (EventSequenceNumber.isGreaterThanOrEqual(mergeResult.newSyncState.upstreamHead, mergeResult.mergeContext.syncState.upstreamHead) === false) {
+    if (EventSequenceNumber.Client.isGreaterThanOrEqual(mergeResult.newSyncState.upstreamHead, mergeResult.mergeContext.syncState.upstreamHead) === false) {
         shouldNeverHappen('New upstream head must be greater than or equal to the previous upstream head', {
             upstreamHead: mergeResult.newSyncState.upstreamHead,
             previousUpstreamHead: mergeResult.mergeContext.syncState.upstreamHead,