actor-ts 0.9.0

package/dist/persistence/query/PersistenceQuery.d.ts

@@ -0,0 +1,162 @@
+import type { PersistentEvent } from '../JournalTypes.js';
+/**
+ * Read-side query layer for the journal.  Designed for projections —
+ * processes that materialise a read-model by sweeping events out of
+ * the write-side journal and feeding them into a user handler.
+ *
+ * Two flavours of query:
+ *
+ *   - **`current*`** — one-shot snapshot of events currently in the
+ *     journal at call time.  Resolves to a Promise.  Use this for a
+ *     batch backfill or a self-contained report.
+ *   - **`events*`** — continuous live stream.  Polls the journal at
+ *     `pollIntervalMs` for new events.  Yields an `AsyncIterable` so
+ *     consumers can `for await (const ev of stream) ...`.  The stream
+ *     stays open until the consumer breaks out of the loop or calls
+ *     `return()` on the iterator.
+ *
+ * **Delivery guarantees:** at-least-once.  A projection that fails
+ * mid-event must accept that the event will be redelivered after
+ * restart.  Handlers therefore have to be idempotent.
+ *
+ * **Pull-only.**  The first iteration polls.  Push-based subscribe
+ * (via the system's `EventStream`) is intentionally deferred — see
+ * issue #36 / the roadmap plan.
+ */
+export interface PersistenceQuery {
+    /**
+     * Live stream of every event for `persistenceId` whose
+     * `sequenceNr >= fromSeq`.  Past events are emitted first
+     * (chronological by `sequenceNr`), then new events as they are
+     * appended.  The stream never completes on its own — break out of
+     * the loop or call `return()` on the iterator to stop polling.
+     */
+    eventsByPersistenceId<E>(persistenceId: string, fromSeq: number, options?: LiveQueryOptions): AsyncIterable<PersistentEvent<E>>;
+    /**
+     * One-shot read of every event for `persistenceId` whose
+     * `sequenceNr >= fromSeq` (and `<= toSeq` if given).  Resolves
+     * once with the events known at call time.
+     */
+    currentEventsByPersistenceId<E>(persistenceId: string, fromSeq: number, toSeq?: number): Promise<PersistentEvent<E>[]>;
+    /**
+     * Live stream of every event matching `filter` whose offset is
+     * `>= fromOffset`.  Yields events ordered by `(timestamp,
+     * persistenceId, sequenceNr)`.  See {@link Offset} for offset
+     * semantics — the stream emits the offset alongside the event so
+     * the consumer can persist progress.
+     *
+     * `filter` accepts either a single tag string (back-compat shortcut
+     * for `{ all: [tag] }`) or a {@link TagFilter} object that combines
+     * `all` (intersect), `any` (union), and `not` (exclusion) operators.
+     */
+    eventsByTag<E>(filter: TagFilter, fromOffset: Offset, options?: LiveQueryOptions): AsyncIterable<TaggedEvent<E>>;
+    /**
+     * One-shot read of every event matching `filter` whose offset is
+     * `>= fromOffset`.  See {@link TagFilter} for the operator semantics.
+     */
+    currentEventsByTag<E>(filter: TagFilter, fromOffset: Offset): Promise<TaggedEvent<E>[]>;
+    /**
+     * Snapshot of every persistence id known to the journal.  Resolves
+     * once.  Useful for fan-out projections that subscribe to one
+     * stream per id; pair with `eventsByPersistenceId` for the
+     * continuous read.
+     */
+    currentPersistenceIds(): Promise<string[]>;
+}
+/**
+ * Tunables for a live query.  The defaults are deliberately
+ * conservative — projections are I/O-bound, not latency-critical.
+ */
+export interface LiveQueryOptions {
+    /** Poll interval in ms.  Default: `1_000` (1 second). */
+    readonly pollIntervalMs?: number;
+    /** Max events to buffer per poll.  Default: `100`. */
+    readonly batchSize?: number;
+    /**
+     * Optional clock — useful for tests that want to control
+     * time-based offset progression.  Defaults to `Date.now`.
+     */
+    readonly clock?: () => number;
+}
+/**
+ * Cursor used by tag queries.  Composite by design so two events that
+ * share a `timestamp` (which happens whenever a batch of events is
+ * persisted in the same `Date.now()` tick) still have a deterministic
+ * order — `(timestamp, persistenceId, sequenceNr)` is unique per event.
+ *
+ * Compare via {@link offsetGreaterOrEqual} / {@link offsetCompare} —
+ * the tuple structure makes naive `>=` comparison wrong.
+ */
+export interface Offset {
+    /** Wall-clock time of the event's persist call. */
+    readonly timestamp: number;
+    /**
+     * Tiebreaker when two events share `timestamp`.  Set to the empty
+     * string for the "from-the-beginning" sentinel; the comparator
+     * treats `''` as "before any real persistence id".
+     */
+    readonly persistenceId: string;
+    /** Tiebreaker within a persistence id when timestamps collide. */
+    readonly sequenceNr: number;
+}
+/** Sentinel: read every event from the start of recorded history. */
+export declare const offsetStart: Offset;
+export declare function offsetCompare(a: Offset, b: Offset): number;
+export declare function offsetGreaterOrEqual(a: Offset, b: Offset): boolean;
+export declare function offsetGreater(a: Offset, b: Offset): boolean;
+/** Build an offset from an event — the event's "natural" position. */
+export declare function offsetOfEvent<E>(ev: PersistentEvent<E>): Offset;
+/**
+ * Event paired with the {@link Offset} a consumer must persist to
+ * resume after a crash.  See `eventsByTag`.
+ */
+export interface TaggedEvent<E = unknown> {
+    readonly event: PersistentEvent<E>;
+    readonly offset: Offset;
+}
+/**
+ * Tag-filter spec for `eventsByTag` / `currentEventsByTag`.  A bare
+ * string is shorthand for `{ all: [tag] }`; the object form combines
+ * three operators that all apply to the same query:
+ *
+ *   - `all`  — intersection: every listed tag must appear on the event.
+ *   - `any`  — union:        at least one listed tag must appear.
+ *   - `not`  — exclusion:    no listed tag may appear on the event.
+ *
+ * **Empty-list semantics (∀ / ∃ / ∄ over the given list):**
+ *
+ *   - `all: []` and `not: []` impose no constraint (vacuously true).
+ *   - `any: []` matches **nothing** (no event has a tag in the empty
+ *     set) — the only "footgun" worth calling out.
+ *
+ * Operators compose by AND: `{ all: ['type:Order'], not: ['archived'] }`
+ * matches order events that are not archived.  Backends that ship a
+ * tag index (SQLite, Cassandra) push as much of the filter as they
+ * can into the storage layer and JS-refine the rest; the InMemory
+ * reference does the whole match in JS.
+ */
+export type TagFilter = string | TagFilterSpec;
+/**
+ * Object form of {@link TagFilter}.  Each operator is optional; an
+ * empty `{}` matches every event.  See `TagFilter` for the empty-list
+ * semantics.
+ */
+export interface TagFilterSpec {
+    readonly all?: ReadonlyArray<string>;
+    readonly any?: ReadonlyArray<string>;
+    readonly not?: ReadonlyArray<string>;
+}
+/**
+ * Normalise a {@link TagFilter} into the canonical {@link TagFilterSpec}
+ * form.  A bare string `t` becomes `{ all: [t] }`; an object is
+ * shallow-copied so callers can't mutate it after the fact.
+ */
+export declare function normalizeTagFilter(filter: TagFilter): TagFilterSpec;
+/**
+ * Test whether `eventTags` satisfies `filter`.  Used by every
+ * `PersistenceQuery` implementation as the in-memory refinement step
+ * after the storage layer's coarse pre-filter.  Empty `all` / `not`
+ * are no-ops; empty `any` matches nothing (see {@link TagFilter}).
+ */
+export declare function eventMatchesTagFilter(eventTags: ReadonlyArray<string> | undefined, filter: TagFilterSpec): boolean;
+//# sourceMappingURL=PersistenceQuery.d.ts.map

package/dist/persistence/query/PersistenceQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceQuery.d.ts","sourceRoot":"","sources":["../../../src/persistence/query/PersistenceQuery.ts"],"names":[],"mappings":"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"}

package/dist/persistence/query/PersistenceQuery.js

@@ -0,0 +1,78 @@
+/** Sentinel: read every event from the start of recorded history. */
+export const offsetStart = {
+    timestamp: 0,
+    persistenceId: '',
+    sequenceNr: 0,
+};
+export function offsetCompare(a, b) {
+    if (a.timestamp !== b.timestamp)
+        return a.timestamp - b.timestamp;
+    if (a.persistenceId !== b.persistenceId) {
+        return a.persistenceId < b.persistenceId ? -1 : 1;
+    }
+    return a.sequenceNr - b.sequenceNr;
+}
+export function offsetGreaterOrEqual(a, b) {
+    return offsetCompare(a, b) >= 0;
+}
+export function offsetGreater(a, b) {
+    return offsetCompare(a, b) > 0;
+}
+/** Build an offset from an event — the event's "natural" position. */
+export function offsetOfEvent(ev) {
+    return {
+        timestamp: ev.timestamp,
+        persistenceId: ev.persistenceId,
+        sequenceNr: ev.sequenceNr,
+    };
+}
+/**
+ * Normalise a {@link TagFilter} into the canonical {@link TagFilterSpec}
+ * form.  A bare string `t` becomes `{ all: [t] }`; an object is
+ * shallow-copied so callers can't mutate it after the fact.
+ */
+export function normalizeTagFilter(filter) {
+    if (typeof filter === 'string')
+        return { all: [filter] };
+    return {
+        all: filter.all,
+        any: filter.any,
+        not: filter.not,
+    };
+}
+/**
+ * Test whether `eventTags` satisfies `filter`.  Used by every
+ * `PersistenceQuery` implementation as the in-memory refinement step
+ * after the storage layer's coarse pre-filter.  Empty `all` / `not`
+ * are no-ops; empty `any` matches nothing (see {@link TagFilter}).
+ */
+export function eventMatchesTagFilter(eventTags, filter) {
+    const tags = eventTags ?? [];
+    if (filter.all && filter.all.length > 0) {
+        for (const t of filter.all) {
+            if (!tags.includes(t))
+                return false;
+        }
+    }
+    if (filter.any !== undefined) {
+        if (filter.any.length === 0)
+            return false; // ∃ over ∅ ≡ false
+        let anyMatch = false;
+        for (const t of filter.any) {
+            if (tags.includes(t)) {
+                anyMatch = true;
+                break;
+            }
+        }
+        if (!anyMatch)
+            return false;
+    }
+    if (filter.not && filter.not.length > 0) {
+        for (const t of filter.not) {
+            if (tags.includes(t))
+                return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=PersistenceQuery.js.map

package/dist/persistence/query/PersistenceQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceQuery.js","sourceRoot":"","sources":["../../../src/persistence/query/PersistenceQuery.ts"],"names":[],"mappings":"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"}

package/dist/persistence/query/SqliteQuery.d.ts

@@ -0,0 +1,58 @@
+import type { SqliteJournal } from '../journals/SqliteJournal.js';
+import { InMemoryQuery } from './InMemoryQuery.js';
+import { type Offset, type TagFilter, type TaggedEvent } from './PersistenceQuery.js';
+/**
+ * SQLite-backed query.  Inherits the per-pid read path from
+ * {@link InMemoryQuery} (which delegates straight to `Journal.read`)
+ * and overrides the tag path with an indexed JOIN against the
+ * `${eventsTable}_tags` join table that `SqliteJournal` maintains.
+ *
+ * **Index shape.**  The journal's tags table has primary key
+ * `(tag, timestamp, persistence_id, sequence_nr)`, so a
+ * `WHERE tag = ? AND timestamp >= ?` filter walks a contiguous
+ * range of the index — bounded cost per query no matter how big
+ * the events table grows.  We then JOIN to `events` to pull the
+ * payload + the original CSV tags column.
+ *
+ * **Backwards-compat.**  `SqliteJournal` upgrades existing v0
+ * databases (CSV-only, no join table) by backfilling the join
+ * table on `init()` — see `SqliteJournal.backfillTagsTableIfNeeded`.
+ * From the query layer's POV the table is always present once the
+ * journal is open.
+ *
+ * **Multi-tag filters.**  The `TagFilter` operators (`all` / `any` /
+ * `not`) are pushed into SQL with one of three strategies:
+ *
+ *   - At least one `all` tag → walk the join-table for `all[0]`,
+ *     JS-refine the rest of the filter against `events.tags`.  The
+ *     SQL is the same as the single-tag fast path; only the JS step
+ *     is wider.
+ *   - No `all`, but `any` is non-empty → walk the join-table with
+ *     `t.tag IN (?, ?, …)` (DISTINCT to dedupe events tagged with
+ *     more than one of the listed values), JS-refine for `not`.
+ *   - Only `not` (or empty filter) → fall back to the inherited
+ *     {@link InMemoryQuery} scan path, which iterates persistence ids
+ *     and reads each one.  Less efficient, but only-`not` queries
+ *     don't have a selective index to use anyway.
+ */
+export declare class SqliteQuery extends InMemoryQuery {
+    private readonly sqlite;
+    /**
+     * Cache for the single-tag fetch statement (also used as the
+     * `all[0]` pre-filter).  Subsequent polls reuse the same prepared
+     * statement via the SQLite driver's plan cache.
+     */
+    private cachedSingleTag;
+    /**
+     * `IN (?, ?, …)` pre-filter statements keyed by the number of
+     * placeholders — re-prepared the first time a query of that shape
+     * runs, then reused.
+     */
+    private readonly cachedAnyByArity;
+    constructor(sqlite: SqliteJournal);
+    currentEventsByTag<E>(filter: TagFilter, fromOffset: Offset): Promise<TaggedEvent<E>[]>;
+    private ensureSingleTagStmts;
+    private ensureAnyStmts;
+    private openInternals;
+}
+//# sourceMappingURL=SqliteQuery.d.ts.map

package/dist/persistence/query/SqliteQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteQuery.d.ts","sourceRoot":"","sources":["../../../src/persistence/query/SqliteQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAKL,KAAK,MAAM,EACX,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,WAAY,SAAQ,aAAa;IAehC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAdnC;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAAyB;IAEhD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA+B;gBAEnC,MAAM,EAAE,aAAa;IAInC,kBAAkB,CAAC,CAAC,EACjC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GACpC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;YAqCd,oBAAoB;YAmBpB,cAAc;YAsBd,aAAa;CAoB5B"}

package/dist/persistence/query/SqliteQuery.js

@@ -0,0 +1,173 @@
+import { JournalError } from '../JournalTypes.js';
+import { InMemoryQuery } from './InMemoryQuery.js';
+import { eventMatchesTagFilter, normalizeTagFilter, offsetCompare, offsetOfEvent, } from './PersistenceQuery.js';
+/**
+ * SQLite-backed query.  Inherits the per-pid read path from
+ * {@link InMemoryQuery} (which delegates straight to `Journal.read`)
+ * and overrides the tag path with an indexed JOIN against the
+ * `${eventsTable}_tags` join table that `SqliteJournal` maintains.
+ *
+ * **Index shape.**  The journal's tags table has primary key
+ * `(tag, timestamp, persistence_id, sequence_nr)`, so a
+ * `WHERE tag = ? AND timestamp >= ?` filter walks a contiguous
+ * range of the index — bounded cost per query no matter how big
+ * the events table grows.  We then JOIN to `events` to pull the
+ * payload + the original CSV tags column.
+ *
+ * **Backwards-compat.**  `SqliteJournal` upgrades existing v0
+ * databases (CSV-only, no join table) by backfilling the join
+ * table on `init()` — see `SqliteJournal.backfillTagsTableIfNeeded`.
+ * From the query layer's POV the table is always present once the
+ * journal is open.
+ *
+ * **Multi-tag filters.**  The `TagFilter` operators (`all` / `any` /
+ * `not`) are pushed into SQL with one of three strategies:
+ *
+ *   - At least one `all` tag → walk the join-table for `all[0]`,
+ *     JS-refine the rest of the filter against `events.tags`.  The
+ *     SQL is the same as the single-tag fast path; only the JS step
+ *     is wider.
+ *   - No `all`, but `any` is non-empty → walk the join-table with
+ *     `t.tag IN (?, ?, …)` (DISTINCT to dedupe events tagged with
+ *     more than one of the listed values), JS-refine for `not`.
+ *   - Only `not` (or empty filter) → fall back to the inherited
+ *     {@link InMemoryQuery} scan path, which iterates persistence ids
+ *     and reads each one.  Less efficient, but only-`not` queries
+ *     don't have a selective index to use anyway.
+ */
+export class SqliteQuery extends InMemoryQuery {
+    sqlite;
+    /**
+     * Cache for the single-tag fetch statement (also used as the
+     * `all[0]` pre-filter).  Subsequent polls reuse the same prepared
+     * statement via the SQLite driver's plan cache.
+     */
+    cachedSingleTag = null;
+    /**
+     * `IN (?, ?, …)` pre-filter statements keyed by the number of
+     * placeholders — re-prepared the first time a query of that shape
+     * runs, then reused.
+     */
+    cachedAnyByArity = new Map();
+    constructor(sqlite) {
+        super(sqlite);
+        this.sqlite = sqlite;
+    }
+    async currentEventsByTag(filter, fromOffset) {
+        const spec = normalizeTagFilter(filter);
+        const allTags = spec.all ?? [];
+        const anyTags = spec.any ?? [];
+        // Strategy 1: walk the join table on the first `all` tag, JS-
+        // refine for the remaining `all` / `any` / `not` constraints.
+        if (allTags.length > 0) {
+            const stmts = await this.ensureSingleTagStmts();
+            let rows;
+            try {
+                rows = stmts.fetchByTag.all(allTags[0], fromOffset.timestamp);
+            }
+            catch (e) {
+                throw new JournalError(`SqliteQuery.currentEventsByTag failed: ${e.message}`, e);
+            }
+            return refineAndSort(rows, spec, fromOffset);
+        }
+        // Strategy 2: any-only — walk the join table on `t.tag IN (...)`,
+        // DISTINCT-dedupe events that match more than one tag in the set.
+        if (anyTags.length > 0) {
+            const stmts = await this.ensureAnyStmts(anyTags.length);
+            let rows;
+            try {
+                rows = stmts.fetchByAny.all(...anyTags, fromOffset.timestamp);
+            }
+            catch (e) {
+                throw new JournalError(`SqliteQuery.currentEventsByTag failed: ${e.message}`, e);
+            }
+            return refineAndSort(rows, spec, fromOffset);
+        }
+        // Strategy 3: only `not` (or fully empty filter) — fall back to
+        // the journal-walking scan in the base class.  We still pass the
+        // full filter so the not-clause is applied.
+        return super.currentEventsByTag(spec, fromOffset);
+    }
+    async ensureSingleTagStmts() {
+        if (this.cachedSingleTag)
+            return this.cachedSingleTag;
+        const { db, eventsTable, tagsTable } = await this.openInternals();
+        this.cachedSingleTag = {
+            fetchByTag: db.prepare(
+            // Walk the tags-table PK range for the given tag, JOIN to
+            // events to fetch payload + CSV tags column.  ORDER matches
+            // the index PK so SQLite doesn't have to sort separately.
+            `SELECT e.persistence_id, e.sequence_nr, e.payload, e.tags, e.timestamp
+           FROM ${tagsTable} t
+           JOIN ${eventsTable} e
+             ON e.persistence_id = t.persistence_id AND e.sequence_nr = t.sequence_nr
+          WHERE t.tag = ? AND t.timestamp >= ?
+          ORDER BY t.timestamp ASC, t.persistence_id ASC, t.sequence_nr ASC`),
+        };
+        return this.cachedSingleTag;
+    }
+    async ensureAnyStmts(arity) {
+        const cached = this.cachedAnyByArity.get(arity);
+        if (cached)
+            return cached;
+        const { db, eventsTable, tagsTable } = await this.openInternals();
+        const placeholders = new Array(arity).fill('?').join(', ');
+        const stmts = {
+            fetchByAny: db.prepare(
+            // DISTINCT collapses an event that matches multiple `any`
+            // tags into a single row.  ORDER follows the same composite
+            // key so the JS-side refinement keeps the global ordering.
+            `SELECT DISTINCT e.persistence_id, e.sequence_nr, e.payload, e.tags, e.timestamp
+           FROM ${tagsTable} t
+           JOIN ${eventsTable} e
+             ON e.persistence_id = t.persistence_id AND e.sequence_nr = t.sequence_nr
+          WHERE t.tag IN (${placeholders}) AND t.timestamp >= ?
+          ORDER BY e.timestamp ASC, e.persistence_id ASC, e.sequence_nr ASC`),
+        };
+        this.cachedAnyByArity.set(arity, stmts);
+        return stmts;
+    }
+    async openInternals() {
+        // Force the journal to open + create its tables so we can prepare.
+        await this.sqlite.persistenceIds();
+        const internal = this.sqlite;
+        if (!internal.db) {
+            throw new JournalError('SqliteQuery: underlying SqliteJournal is not open');
+        }
+        return {
+            db: internal.db,
+            eventsTable: internal.table,
+            tagsTable: `${internal.table}_tags`,
+        };
+    }
+}
+/**
+ * Translate driver rows into `TaggedEvent`s, JS-refine against the
+ * full filter (the SQL only saw the pre-filter strategy), and sort.
+ * Shared by both the all-pre-filter and any-pre-filter paths.
+ */
+function refineAndSort(rows, spec, fromOffset) {
+    const out = [];
+    for (const r of rows) {
+        const tags = r.tags ? r.tags.split(',') : undefined;
+        if (!eventMatchesTagFilter(tags, spec))
+            continue;
+        const event = {
+            persistenceId: r.persistence_id,
+            sequenceNr: r.sequence_nr,
+            event: JSON.parse(r.payload),
+            timestamp: r.timestamp,
+            tags,
+        };
+        // The SQL `timestamp >= ?` filter is a coarse cut, but the
+        // (persistence_id, sequence_nr) tiebreakers in `Offset` mean
+        // we still need a precise compare per row.
+        const offset = offsetOfEvent(event);
+        if (offsetCompare(offset, fromOffset) < 0)
+            continue;
+        out.push({ event, offset });
+    }
+    out.sort((a, b) => offsetCompare(a.offset, b.offset));
+    return out;
+}
+//# sourceMappingURL=SqliteQuery.js.map

package/dist/persistence/query/SqliteQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteQuery.js","sourceRoot":"","sources":["../../../src/persistence/query/SqliteQuery.ts"],"names":[],"mappings":"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"}

package/dist/persistence/replicated/ConflictResolver.d.ts

@@ -0,0 +1,70 @@
+import type { ReplicaId } from '../../crdt/Crdt.js';
+import type { VectorClock } from './VectorClock.js';
+/**
+ * Resolution strategy for two events that {@link VectorClock} flags
+ * as concurrent — neither happens-before the other.  The replicated-
+ * event-sourced actor consults this when merging divergent histories
+ * so every replica converges to the same state.
+ *
+ * Two contracts:
+ *   - The resolver is deterministic for a given `(a, b)` pair —
+ *     given the same inputs, every replica must pick the same
+ *     winner / merge result.
+ *   - The resolver MUST be commutative: `resolve(a, b) === resolve(b, a)`.
+ *     Otherwise different replicas would diverge based on which
+ *     event arrived first.
+ *
+ * The simplest deterministic resolver is **last-writer-wins** (LWW)
+ * keyed on `(timestamp, replicaId)` — that's what we ship as the
+ * default.  Domain-aware resolvers can do something smarter
+ * (e.g. additive merge for counters, set union for tag sets).
+ */
+export interface ConflictResolver<E> {
+    /**
+     * Pick a single event from a concurrent pair.  Implementations
+     * MUST be commutative — `resolve(a, b)` must equal `resolve(b, a)`.
+     * Return one of the inputs, or a synthesised merge of both —
+     * either is fine as long as the result is deterministic across
+     * replicas.
+     */
+    resolve(a: ConflictCandidate<E>, b: ConflictCandidate<E>): E;
+}
+/** Event paired with the metadata a resolver needs to break ties. */
+export interface ConflictCandidate<E> {
+    /** The user-domain event payload. */
+    readonly event: E;
+    /** Wall-clock timestamp at the originating replica. */
+    readonly timestamp: number;
+    /** Originating replica id (typically `cluster.selfAddress.toString()`). */
+    readonly replica: ReplicaId;
+    /** Vector clock at persist time. */
+    readonly vc: VectorClock;
+}
+/**
+ * Last-writer-wins on `(timestamp, replicaId)`.  Higher timestamp
+ * wins; on ties the higher (lexicographic) replicaId wins so every
+ * replica converges deterministically.
+ *
+ * Caveat: relies on wall-clock timestamps being roughly comparable
+ * across replicas.  Same trade-off as `LWWRegister`.
+ */
+export declare class LastWriterWinsResolver<E> implements ConflictResolver<E> {
+    resolve(a: ConflictCandidate<E>, b: ConflictCandidate<E>): E;
+}
+/**
+ * Wraps a user-provided commutative merge function.  Use this when
+ * you have domain knowledge that LWW doesn't capture — e.g. the
+ * conflicting events are both "deposit X" and you can simply add
+ * the amounts.
+ *
+ *   new CustomMergeResolver<Event>((a, b) => ({
+ *     kind: 'merged',
+ *     amount: a.event.amount + b.event.amount,
+ *   }));
+ */
+export declare class CustomMergeResolver<E> implements ConflictResolver<E> {
+    private readonly merge;
+    constructor(merge: (a: E, b: E) => E);
+    resolve(a: ConflictCandidate<E>, b: ConflictCandidate<E>): E;
+}
+//# sourceMappingURL=ConflictResolver.d.ts.map

package/dist/persistence/replicated/ConflictResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConflictResolver.d.ts","sourceRoot":"","sources":["../../../src/persistence/replicated/ConflictResolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CAC9D;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,oCAAoC;IACpC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;CAC1B;AAID;;;;;;;GAOG;AACH,qBAAa,sBAAsB,CAAC,CAAC,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IACnE,OAAO,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC;CAM7D;AAID;;;;;;;;;;GAUG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC;IACrD,OAAO,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC;CAS7D"}

package/dist/persistence/replicated/ConflictResolver.js

@@ -0,0 +1,47 @@
+/* ============================== built-in: LWW ============================ */
+/**
+ * Last-writer-wins on `(timestamp, replicaId)`.  Higher timestamp
+ * wins; on ties the higher (lexicographic) replicaId wins so every
+ * replica converges deterministically.
+ *
+ * Caveat: relies on wall-clock timestamps being roughly comparable
+ * across replicas.  Same trade-off as `LWWRegister`.
+ */
+export class LastWriterWinsResolver {
+    resolve(a, b) {
+        if (a.timestamp > b.timestamp)
+            return a.event;
+        if (b.timestamp > a.timestamp)
+            return b.event;
+        // Tie on timestamp — break by replica id.
+        return a.replica > b.replica ? a.event : b.event;
+    }
+}
+/* ============================== built-in: Custom ======================== */
+/**
+ * Wraps a user-provided commutative merge function.  Use this when
+ * you have domain knowledge that LWW doesn't capture — e.g. the
+ * conflicting events are both "deposit X" and you can simply add
+ * the amounts.
+ *
+ *   new CustomMergeResolver<Event>((a, b) => ({
+ *     kind: 'merged',
+ *     amount: a.event.amount + b.event.amount,
+ *   }));
+ */
+export class CustomMergeResolver {
+    merge;
+    constructor(merge) {
+        this.merge = merge;
+    }
+    resolve(a, b) {
+        // We sort the two candidates by replica id so the user's merge
+        // function gets a deterministic argument order even if it isn't
+        // strictly commutative.  The contract still says "be
+        // commutative", but this guards the common case where the user
+        // accidentally wrote a `(left, right)`-asymmetric merge.
+        const [first, second] = a.replica <= b.replica ? [a, b] : [b, a];
+        return this.merge(first.event, second.event);
+    }
+}
+//# sourceMappingURL=ConflictResolver.js.map

package/dist/persistence/replicated/ConflictResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConflictResolver.js","sourceRoot":"","sources":["../../../src/persistence/replicated/ConflictResolver.ts"],"names":[],"mappings":"AA6CA,+EAA+E;AAE/E;;;;;;;GAOG;AACH,MAAM,OAAO,sBAAsB;IACjC,OAAO,CAAC,CAAuB,EAAE,CAAuB;QACtD,IAAI,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS;YAAE,OAAO,CAAC,CAAC,KAAK,CAAC;QAC9C,IAAI,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS;YAAE,OAAO,CAAC,CAAC,KAAK,CAAC;QAC9C,0CAA0C;QAC1C,OAAO,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACnD,CAAC;CACF;AAED,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,OAAO,mBAAmB;IACD;IAA7B,YAA6B,KAAwB;QAAxB,UAAK,GAAL,KAAK,CAAmB;IAAG,CAAC;IACzD,OAAO,CAAC,CAAuB,EAAE,CAAuB;QACtD,+DAA+D;QAC/D,gEAAgE;QAChE,qDAAqD;QACrD,+DAA+D;QAC/D,yDAAyD;QACzD,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;CACF"}