actor-ts 0.9.0

package/dist/persistence/EventDispatcher.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Typed event dispatcher helper (#239) — gives the user a builder that
+ * the compiler refuses to finish until every variant of the event
+ * discriminator union has a handler.
+ *
+ * Today's `PersistentActor.onEvent` is user-defined.  A common pattern
+ * is an if-chain or switch over `event.kind`; both are easy to forget
+ * to update when a new event type is added — the new variant silently
+ * falls through to the default branch (or throws at runtime).
+ *
+ * `eventDispatcher` materialises an `onEvent` from a sequence of
+ * `.on(kind, fn)` calls.  TypeScript prevents `.build()` from being
+ * called until every variant of `Event['kind']` is handled — adding a
+ * new variant to the union surfaces as a compile error on this site.
+ *
+ * Usage:
+ *
+ *   type State = { count: number };
+ *   type Event =
+ *     | { kind: 'incremented'; by: number }
+ *     | { kind: 'decremented'; by: number }
+ *     | { kind: 'reset' };
+ *
+ *   const onEvent = eventDispatcher<State, Event>()
+ *     .on('incremented', (s, e) => ({ count: s.count + e.by }))
+ *     .on('decremented', (s, e) => ({ count: s.count - e.by }))
+ *     .on('reset',       () => ({ count: 0 }))
+ *     .build();
+ *
+ *   class CounterActor extends PersistentActor<Cmd, Event, State> {
+ *     override onEvent = onEvent;
+ *     // ... rest of the actor ...
+ *   }
+ *
+ * Adding a fourth variant to `Event` without an `.on(...)` arm makes
+ * `.build()` a type error.
+ */
+/**
+ * Phantom marker type returned by `.build()` when the builder is
+ * NOT exhaustive.  Has no call signature — using the result as a
+ * function produces a clear TS error like
+ * `"This expression is not callable. Type
+ * 'EventDispatcherIncomplete<\"c\">' has no call signatures."`
+ * The `unhandled` field-name surfaces which kind is missing.
+ */
+export interface EventDispatcherIncomplete<Unhandled extends string> {
+    readonly __unhandled: Unhandled;
+}
+/**
+ * Builder state, parameterised by the kinds that have already been
+ * handled.  Each `.on()` call narrows `Handled`; once `Handled`
+ * covers every kind in the union, `.build()`'s return type becomes a
+ * callable `(state, event) => state` function.  Until then it returns
+ * an `EventDispatcherIncomplete<missing>` that isn't callable, so the
+ * user sees a type error at the call site.
+ */
+export interface EventDispatcherBuilder<S, E extends {
+    readonly kind: string;
+}, Handled extends E['kind']> {
+    /**
+     * Register a handler for `kind`.  Returns a new builder type with
+     * `K` added to the handled set.  Re-registering the same kind is a
+     * compile error (the type-level `Exclude` forbids it).
+     */
+    on<K extends Exclude<E['kind'], Handled>>(kind: K, fn: (state: S, event: Extract<E, {
+        readonly kind: K;
+    }>) => S): EventDispatcherBuilder<S, E, Handled | K>;
+    /**
+     * Materialise the dispatcher as a single function.  Return type is
+     * the callable dispatcher when every variant of `E['kind']` is
+     * registered, otherwise `EventDispatcherIncomplete<missing>`.
+     *
+     * When a variant is missing, calling the result like
+     * `dispatcher(state, event)` produces a TS error naming the missing
+     * `kind` literal in the type.
+     */
+    build(): [Exclude<E['kind'], Handled>] extends [never] ? (state: S, event: E) => S : EventDispatcherIncomplete<Exclude<E['kind'], Handled>>;
+}
+/**
+ * Start a new event-dispatcher builder.  See the module header for
+ * usage.  The two generic parameters `S` (state) and `E` (event
+ * discriminated union) MUST be supplied explicitly — TypeScript can't
+ * infer the union from the first `.on()` call alone.
+ */
+export declare function eventDispatcher<S, E extends {
+    readonly kind: string;
+}>(): EventDispatcherBuilder<S, E, never>;
+//# sourceMappingURL=EventDispatcher.d.ts.map

package/dist/persistence/EventDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDispatcher.d.ts","sourceRoot":"","sources":["../../src/persistence/EventDispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB,CAAC,SAAS,SAAS,MAAM;IACjE,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB,CACrC,CAAC,EACD,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACnC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC;IAEzB;;;;OAIG;IACH,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,EACtC,IAAI,EAAE,CAAC,EACP,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,KAAK,CAAC,GAC3D,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;IAE7C;;;;;;;;OAQG;IACH,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAClD,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GACzB,yBAAyB,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;CAC5D;AAwDD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EACD,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KAChC,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAEvC"}

package/dist/persistence/EventDispatcher.js

@@ -0,0 +1,81 @@
+/**
+ * Typed event dispatcher helper (#239) — gives the user a builder that
+ * the compiler refuses to finish until every variant of the event
+ * discriminator union has a handler.
+ *
+ * Today's `PersistentActor.onEvent` is user-defined.  A common pattern
+ * is an if-chain or switch over `event.kind`; both are easy to forget
+ * to update when a new event type is added — the new variant silently
+ * falls through to the default branch (or throws at runtime).
+ *
+ * `eventDispatcher` materialises an `onEvent` from a sequence of
+ * `.on(kind, fn)` calls.  TypeScript prevents `.build()` from being
+ * called until every variant of `Event['kind']` is handled — adding a
+ * new variant to the union surfaces as a compile error on this site.
+ *
+ * Usage:
+ *
+ *   type State = { count: number };
+ *   type Event =
+ *     | { kind: 'incremented'; by: number }
+ *     | { kind: 'decremented'; by: number }
+ *     | { kind: 'reset' };
+ *
+ *   const onEvent = eventDispatcher<State, Event>()
+ *     .on('incremented', (s, e) => ({ count: s.count + e.by }))
+ *     .on('decremented', (s, e) => ({ count: s.count - e.by }))
+ *     .on('reset',       () => ({ count: 0 }))
+ *     .build();
+ *
+ *   class CounterActor extends PersistentActor<Cmd, Event, State> {
+ *     override onEvent = onEvent;
+ *     // ... rest of the actor ...
+ *   }
+ *
+ * Adding a fourth variant to `Event` without an `.on(...)` arm makes
+ * `.build()` a type error.
+ */
+class EventDispatcherBuilderImpl {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    on(kind, fn) {
+        if (this.handlers.has(kind)) {
+            throw new Error(`eventDispatcher: kind '${kind}' was registered twice — ` +
+                `each kind must have exactly one handler.`);
+        }
+        const next = new Map(this.handlers);
+        next.set(kind, fn);
+        return new EventDispatcherBuilderImpl(next);
+    }
+    build() {
+        // Snapshot handlers into a plain Map so the returned closure
+        // doesn't keep the builder instance alive.
+        const handlers = new Map(this.handlers);
+        const fn = (state, event) => {
+            const handler = handlers.get(event.kind);
+            if (!handler) {
+                // This branch is unreachable if the user types everything
+                // correctly — `.build()`'s return type is non-callable until
+                // all variants are registered.  Kept as a defensive throw in
+                // case the user forces a cast or the event union shifts at
+                // runtime (e.g. legacy persisted events from before a kind
+                // was renamed).
+                throw new Error(`eventDispatcher: no handler registered for event.kind='${event.kind}'.`);
+            }
+            return handler(state, event);
+        };
+        return fn;
+    }
+}
+/**
+ * Start a new event-dispatcher builder.  See the module header for
+ * usage.  The two generic parameters `S` (state) and `E` (event
+ * discriminated union) MUST be supplied explicitly — TypeScript can't
+ * infer the union from the first `.on()` call alone.
+ */
+export function eventDispatcher() {
+    return new EventDispatcherBuilderImpl(new Map());
+}
+//# sourceMappingURL=EventDispatcher.js.map

package/dist/persistence/EventDispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDispatcher.js","sourceRoot":"","sources":["../../src/persistence/EventDispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAmDH,MAAM,0BAA0B;IAMX;IADnB,YACmB,QAGhB;QAHgB,aAAQ,GAAR,QAAQ,CAGxB;IACA,CAAC;IAEJ,EAAE,CACA,IAAO,EACP,EAA4D;QAE5D,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,0BAA0B,IAAI,2BAA2B;gBACzD,0CAA0C,CAC3C,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAoC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAA0C,CAAC,CAAC;QAC3D,OAAO,IAAI,0BAA0B,CAAoB,IAAI,CAAC,CAAC;IACjE,CAAC;IAED,KAAK;QAGH,6DAA6D;QAC7D,2CAA2C;QAC3C,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,MAAM,EAAE,GAAG,CAAC,KAAQ,EAAE,KAAQ,EAAK,EAAE;YACnC,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACzC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,0DAA0D;gBAC1D,6DAA6D;gBAC7D,6DAA6D;gBAC7D,2DAA2D;gBAC3D,2DAA2D;gBAC3D,gBAAgB;gBAChB,MAAM,IAAI,KAAK,CACb,0DAA0D,KAAK,CAAC,IAAI,IAAI,CACzE,CAAC;YACJ,CAAC;YACD,OAAO,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC,CAAC;QACF,OAAO,EAEmD,CAAC;IAC7D,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe;IAI7B,OAAO,IAAI,0BAA0B,CAAc,IAAI,GAAG,EAAE,CAAC,CAAC;AAChE,CAAC"}

package/dist/persistence/Journal.d.ts

@@ -0,0 +1,40 @@
+import type { JournalEventBus } from './JournalEventBus.js';
+import type { PersistentEvent } from './JournalTypes.js';
+/**
+ * Pluggable event journal — the persistence-plugin boundary.  Core ships
+ * with an in-memory reference implementation and a SQLite-based one; the
+ * interface is deliberately narrow so third-party plug-ins (Cassandra,
+ * ScyllaDB, Postgres, …) only have to implement four methods.
+ */
+export interface Journal {
+    /**
+     * Append `events` to the stream of `pid`, enforcing optimistic concurrency:
+     * the current highest sequence number MUST equal `expectedSeq` or the
+     * call throws `JournalConcurrencyError`.  Returns the written events
+     * with their assigned sequence numbers.
+     */
+    append<E = unknown>(pid: string, events: ReadonlyArray<E>, expectedSeq: number, tags?: ReadonlyArray<string>): Promise<PersistentEvent<E>[]>;
+    /**
+     * Return events in `(fromSeq, …, toSeq]` order.  `toSeq` defaults to
+     * the current highest sequence number.  Inclusive bounds — `fromSeq`
+     * is the first event returned, not the "after" cursor.
+     */
+    read<E = unknown>(pid: string, fromSeq: number, toSeq?: number): Promise<PersistentEvent<E>[]>;
+    /** Current highest sequence number for `pid` — 0 if no events exist. */
+    highestSeq(pid: string): Promise<number>;
+    /** Delete events up to and including `toSeq` — used when compacting past a snapshot. */
+    delete(pid: string, toSeq: number): Promise<void>;
+    /** Persistence IDs currently known to the journal (useful for projections). */
+    persistenceIds(): Promise<string[]>;
+    /**
+     * Optional in-process notification bus.  When present, the read-side
+     * query layer subscribes here for sub-poll-interval push delivery
+     * (see `JournalEventBus`).  Journals that span processes (Cassandra,
+     * Postgres) leave it `undefined` — the query layer falls back to
+     * the polling loop.
+     */
+    readonly events?: JournalEventBus;
+    /** Best-effort teardown; idempotent. */
+    close?(): Promise<void>;
+}
+//# sourceMappingURL=Journal.d.ts.map

package/dist/persistence/Journal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Journal.d.ts","sourceRoot":"","sources":["../../src/persistence/Journal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;;OAKG;IACH,MAAM,CAAC,CAAC,GAAG,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAC3B,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAEjC;;;;OAIG;IACH,IAAI,CAAC,CAAC,GAAG,OAAO,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAEjC,wEAAwE;IACxE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzC,wFAAwF;IACxF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElD,+EAA+E;IAC/E,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEpC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;IAElC,wCAAwC;IACxC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB"}

package/dist/persistence/Journal.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Journal.js.map

package/dist/persistence/Journal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Journal.js","sourceRoot":"","sources":["../../src/persistence/Journal.ts"],"names":[],"mappings":""}

package/dist/persistence/JournalEventBus.d.ts

@@ -0,0 +1,47 @@
+import type { PersistentEvent } from './JournalTypes.js';
+/**
+ * Optional in-process notification capability that a `Journal` MAY
+ * expose.  When present, the read-side query layer
+ * (`PersistenceQuery`) subscribes here and emits events the moment
+ * they're appended — no polling latency.  When absent (e.g. for
+ * cross-process backends like Cassandra), the query layer falls
+ * back to its `pollIntervalMs`-driven loop.
+ *
+ * Cross-process delivery is **out of scope** — this bus only
+ * notifies subscribers in the same JS process.  Networked backends
+ * that need cross-process push would layer their own protocol on
+ * top (Postgres LISTEN/NOTIFY, Redis pub/sub, …).
+ */
+export interface JournalEventBus {
+    /**
+     * Notify every subscriber that an event has been appended.  The
+     * journal calls this AFTER the underlying write has succeeded;
+     * subscribers therefore see only events that are durably on disk
+     * (modulo whatever fsync semantics the journal itself promises).
+     */
+    publish(event: PersistentEvent<unknown>): void;
+    /**
+     * Register a handler.  Returns an unsubscribe function — call it
+     * to detach.  Handlers run synchronously inside `publish`; throwing
+     * is caught + logged-to-console-warn so one bad subscriber doesn't
+     * stop deliveries to the rest.
+     */
+    subscribe(listener: (event: PersistentEvent<unknown>) => void): () => void;
+    /** Test hook — current subscriber count.  Useful for asserting that
+     *  cancellation actually detaches.  Not part of the contract that
+     *  custom journals have to honour. */
+    subscriberCount?(): number;
+}
+/**
+ * Reference implementation.  Plain `Set<listener>`; one
+ * try/catch per delivery so a misbehaving subscriber doesn't break
+ * the bus for the others.  Used by every journal implementation
+ * that ships with the framework.
+ */
+export declare class InProcessJournalEventBus implements JournalEventBus {
+    private readonly listeners;
+    publish(event: PersistentEvent<unknown>): void;
+    subscribe(listener: (event: PersistentEvent<unknown>) => void): () => void;
+    subscriberCount(): number;
+}
+//# sourceMappingURL=JournalEventBus.d.ts.map

package/dist/persistence/JournalEventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalEventBus.d.ts","sourceRoot":"","sources":["../../src/persistence/JournalEventBus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAE/C;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAE3E;;0CAEsC;IACtC,eAAe,CAAC,IAAI,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,wBAAyB,YAAW,eAAe;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwD;IAElF,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,IAAI;IAS9C,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAK1E,eAAe,IAAI,MAAM;CAC1B"}

package/dist/persistence/JournalEventBus.js

@@ -0,0 +1,26 @@
+/**
+ * Reference implementation.  Plain `Set<listener>`; one
+ * try/catch per delivery so a misbehaving subscriber doesn't break
+ * the bus for the others.  Used by every journal implementation
+ * that ships with the framework.
+ */
+export class InProcessJournalEventBus {
+    listeners = new Set();
+    publish(event) {
+        for (const l of this.listeners) {
+            try {
+                l(event);
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.warn('JournalEventBus: subscriber threw on publish', err);
+            }
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    subscriberCount() { return this.listeners.size; }
+}
+//# sourceMappingURL=JournalEventBus.js.map

package/dist/persistence/JournalEventBus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalEventBus.js","sourceRoot":"","sources":["../../src/persistence/JournalEventBus.ts"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,MAAM,OAAO,wBAAwB;IAClB,SAAS,GAAG,IAAI,GAAG,EAA6C,CAAC;IAElF,OAAO,CAAC,KAA+B;QACrC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC;gBAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAAC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBAC7B,sCAAsC;gBACtC,OAAO,CAAC,IAAI,CAAC,8CAA8C,EAAE,GAAG,CAAC,CAAC;YACpE,CAAC;QACH,CAAC;IACH,CAAC;IAED,SAAS,CAAC,QAAmD;QAC3D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC;IAED,eAAe,KAAa,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;CAC1D"}

package/dist/persistence/JournalTypes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared types for the persistence pipeline.  Kept separate from Journal.ts
+ * so plug-ins can implement the protocol without importing the default
+ * Journal implementation.
+ */
+/** An event stored in the journal, paired with its positional metadata. */
+export interface PersistentEvent<E = unknown> {
+    /** Entity id this event belongs to ("bank-account-42", "order-7", …). */
+    readonly persistenceId: string;
+    /** 1-based monotonic sequence number within the entity's stream. */
+    readonly sequenceNr: number;
+    /** User-domain event payload. */
+    readonly event: E;
+    /** Wall-clock time the journal persisted the event. */
+    readonly timestamp: number;
+    /** Optional tags that Projections / Persistence-Query can filter on. */
+    readonly tags?: ReadonlyArray<string>;
+}
+/** A snapshot of an entity's state at a given sequence number. */
+export interface Snapshot<S = unknown> {
+    readonly persistenceId: string;
+    /** Events up to and including this seq are reflected in `state`. */
+    readonly sequenceNr: number;
+    readonly state: S;
+    readonly timestamp: number;
+}
+/** Raised when the caller's `expectedSeq` does not match the journal. */
+export declare class JournalConcurrencyError extends Error {
+    readonly persistenceId: string;
+    readonly expectedSeq: number;
+    readonly actualSeq: number;
+    constructor(persistenceId: string, expectedSeq: number, actualSeq: number);
+}
+/** Generic persistence failure, raised by plug-ins that wrap external stores. */
+export declare class JournalError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+//# sourceMappingURL=JournalTypes.d.ts.map

package/dist/persistence/JournalTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalTypes.d.ts","sourceRoot":"","sources":["../../src/persistence/JournalTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,yEAAyE;IACzE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC;AAED,kEAAkE;AAClE,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,yEAAyE;AACzE,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,aAAa,EAAE,MAAM;aACrB,WAAW,EAAE,MAAM;aACnB,SAAS,EAAE,MAAM;gBAFjB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM;CAKpC;AAED,iFAAiF;AACjF,qBAAa,YAAa,SAAQ,KAAK;aACQ,KAAK,CAAC,EAAE,OAAO;gBAAhD,OAAO,EAAE,MAAM,EAAkB,KAAK,CAAC,EAAE,OAAO,YAAA;CAI7D"}

package/dist/persistence/JournalTypes.js

@@ -0,0 +1,28 @@
+/**
+ * Shared types for the persistence pipeline.  Kept separate from Journal.ts
+ * so plug-ins can implement the protocol without importing the default
+ * Journal implementation.
+ */
+/** Raised when the caller's `expectedSeq` does not match the journal. */
+export class JournalConcurrencyError extends Error {
+    persistenceId;
+    expectedSeq;
+    actualSeq;
+    constructor(persistenceId, expectedSeq, actualSeq) {
+        super(`Journal concurrency mismatch for "${persistenceId}": expected ${expectedSeq}, journal has ${actualSeq}`);
+        this.persistenceId = persistenceId;
+        this.expectedSeq = expectedSeq;
+        this.actualSeq = actualSeq;
+        this.name = 'JournalConcurrencyError';
+    }
+}
+/** Generic persistence failure, raised by plug-ins that wrap external stores. */
+export class JournalError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'JournalError';
+    }
+}
+//# sourceMappingURL=JournalTypes.js.map

package/dist/persistence/JournalTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalTypes.js","sourceRoot":"","sources":["../../src/persistence/JournalTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyBH,yEAAyE;AACzE,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IAE9B;IACA;IACA;IAHlB,YACkB,aAAqB,EACrB,WAAmB,EACnB,SAAiB;QAEjC,KAAK,CAAC,qCAAqC,aAAa,eAAe,WAAW,iBAAiB,SAAS,EAAE,CAAC,CAAC;QAJhG,kBAAa,GAAb,aAAa,CAAQ;QACrB,gBAAW,GAAX,WAAW,CAAQ;QACnB,cAAS,GAAT,SAAS,CAAQ;QAGjC,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AAED,iFAAiF;AACjF,MAAM,OAAO,YAAa,SAAQ,KAAK;IACQ;IAA7C,YAAY,OAAe,EAAkB,KAAe;QAC1D,KAAK,CAAC,OAAO,CAAC,CAAC;QAD4B,UAAK,GAAL,KAAK,CAAU;QAE1D,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF"}

package/dist/persistence/PersistenceExtension.d.ts

@@ -0,0 +1,32 @@
+import type { ActorSystem } from '../ActorSystem.js';
+import { type Extension, type ExtensionId } from '../Extension.js';
+import type { Journal } from './Journal.js';
+import type { SnapshotStore } from './SnapshotStore.js';
+/**
+ * System-wide access point to the currently-configured journal and
+ * snapshot store.  Plug-ins register a new factory through
+ * `registerJournal` / `registerSnapshotStore`; the active plug-in is
+ * chosen by the HOCON config path `actor-ts.persistence.journal.plugin`
+ * (defaults to the in-memory reference implementation).
+ */
+export declare class PersistenceExtension implements Extension {
+    private readonly system;
+    private readonly journalFactories;
+    private readonly snapshotFactories;
+    private _journal;
+    private _snapshotStore;
+    constructor(system: ActorSystem);
+    registerJournal(pluginId: string, factory: (system: ActorSystem) => Journal): void;
+    registerSnapshotStore(pluginId: string, factory: (system: ActorSystem) => SnapshotStore): void;
+    /** Resolve the active journal, instantiating it on first use. */
+    get journal(): Journal;
+    /** Resolve the active snapshot store, instantiating it on first use. */
+    get snapshotStore(): SnapshotStore;
+    /** Replace the active journal in code — useful for tests that need a spy. */
+    setJournal(j: Journal): void;
+    setSnapshotStore(s: SnapshotStore): void;
+    private currentJournalPluginId;
+    private currentSnapshotPluginId;
+}
+export declare const PersistenceExtensionId: ExtensionId<PersistenceExtension>;
+//# sourceMappingURL=PersistenceExtension.d.ts.map

package/dist/persistence/PersistenceExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceExtension.d.ts","sourceRoot":"","sources":["../../src/persistence/PersistenceExtension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAe,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,SAAS;IAOxC,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAuD;IACxF,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6D;IAE/F,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,cAAc,CAA8B;gBAEvB,MAAM,EAAE,WAAW;IAMhD,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,GAAG,IAAI;IAMlF,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,GAAG,IAAI;IAK9F,iEAAiE;IACjE,IAAI,OAAO,IAAI,OAAO,CAQrB;IAED,wEAAwE;IACxE,IAAI,aAAa,IAAI,aAAa,CAQjC;IAED,6EAA6E;IAC7E,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI;IAC5B,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI;IAExC,OAAO,CAAC,sBAAsB;IAM9B,OAAO,CAAC,uBAAuB;CAKhC;AAED,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,oBAAoB,CAGpE,CAAC"}

package/dist/persistence/PersistenceExtension.js

@@ -0,0 +1,69 @@
+import { extensionId } from '../Extension.js';
+import { InMemoryJournal } from './journals/InMemoryJournal.js';
+import { InMemorySnapshotStore } from './snapshot-stores/InMemorySnapshotStore.js';
+/**
+ * System-wide access point to the currently-configured journal and
+ * snapshot store.  Plug-ins register a new factory through
+ * `registerJournal` / `registerSnapshotStore`; the active plug-in is
+ * chosen by the HOCON config path `actor-ts.persistence.journal.plugin`
+ * (defaults to the in-memory reference implementation).
+ */
+export class PersistenceExtension {
+    system;
+    journalFactories = new Map();
+    snapshotFactories = new Map();
+    _journal = null;
+    _snapshotStore = null;
+    constructor(system) {
+        this.system = system;
+        // Ship the in-memory reference plug-in out of the box.
+        this.registerJournal('actor-ts.persistence.journal.in-memory', () => new InMemoryJournal());
+        this.registerSnapshotStore('actor-ts.persistence.snapshot-store.in-memory', () => new InMemorySnapshotStore());
+    }
+    registerJournal(pluginId, factory) {
+        this.journalFactories.set(pluginId, factory);
+        // If the active journal changed, force re-lookup.
+        if (this._journal && this.currentJournalPluginId() === pluginId)
+            this._journal = null;
+    }
+    registerSnapshotStore(pluginId, factory) {
+        this.snapshotFactories.set(pluginId, factory);
+        if (this._snapshotStore && this.currentSnapshotPluginId() === pluginId)
+            this._snapshotStore = null;
+    }
+    /** Resolve the active journal, instantiating it on first use. */
+    get journal() {
+        if (!this._journal) {
+            const pluginId = this.currentJournalPluginId();
+            const factory = this.journalFactories.get(pluginId)
+                ?? this.journalFactories.get('actor-ts.persistence.journal.in-memory');
+            this._journal = factory(this.system);
+        }
+        return this._journal;
+    }
+    /** Resolve the active snapshot store, instantiating it on first use. */
+    get snapshotStore() {
+        if (!this._snapshotStore) {
+            const pluginId = this.currentSnapshotPluginId();
+            const factory = this.snapshotFactories.get(pluginId)
+                ?? this.snapshotFactories.get('actor-ts.persistence.snapshot-store.in-memory');
+            this._snapshotStore = factory(this.system);
+        }
+        return this._snapshotStore;
+    }
+    /** Replace the active journal in code — useful for tests that need a spy. */
+    setJournal(j) { this._journal = j; }
+    setSnapshotStore(s) { this._snapshotStore = s; }
+    currentJournalPluginId() {
+        return this.system.config.hasPath('actor-ts.persistence.journal.plugin')
+            ? this.system.config.getString('actor-ts.persistence.journal.plugin')
+            : 'actor-ts.persistence.journal.in-memory';
+    }
+    currentSnapshotPluginId() {
+        return this.system.config.hasPath('actor-ts.persistence.snapshot-store.plugin')
+            ? this.system.config.getString('actor-ts.persistence.snapshot-store.plugin')
+            : 'actor-ts.persistence.snapshot-store.in-memory';
+    }
+}
+export const PersistenceExtensionId = extensionId('PersistenceExtension', (system) => new PersistenceExtension(system));
+//# sourceMappingURL=PersistenceExtension.js.map

package/dist/persistence/PersistenceExtension.js.map

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

package/dist/persistence/PersistenceOptions.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Per-call options for any `SnapshotStore` / `DurableStateStore`
+ * operation — primarily a way for an actor to declare its **own**
+ * compression / encryption preferences, overriding any plugin-level
+ * defaults.  Threaded through both write and read paths because
+ * client-side encryption needs the master key on both sides (the store
+ * has no other way to derive the per-pid subkey).  Compression on the
+ * read side is informational only — the body-codec recovers it from the
+ * payload header — and stores ignore it there.
+ *
+ * The two backing types (`CompressionConfig`, `EncryptionConfig`) are
+ * defined here, at the persistence-layer top level, rather than inside
+ * `object-storage/`.  The reason: actors don't know which concrete
+ * store is wired up, and we don't want them to import from a specific
+ * impl directory just to declare their own settings.  Stores that
+ * don't honour these options (in-memory, SQLite, Cassandra) simply
+ * ignore them.
+ */
+/** Compression algorithm choices honoured by stores that compress at rest. */
+export type CompressionAlgo = 'none' | 'gzip' | 'zstd';
+/** Compression directive — what algorithm a single write should use. */
+export interface CompressionConfig {
+    readonly algorithm: CompressionAlgo;
+}
+/**
+ * One entry in a versioned master-key ring used by client-side
+ * AES-256-GCM (#8 — master-key rotation).  Versions are 0..255 — a
+ * single byte of version travels in the body's manifest so decrypt
+ * can pick the matching master at read time.
+ *
+ * **Why versions?**  Rotation is a fact of life — the operator wants
+ * to retire an old key without re-encrypting every blob in the bucket
+ * at once.  The keyring lets a deployment carry the new key
+ * (`active`) **plus** every old key (`retired`) it might still need
+ * to decrypt; new writes use `active`, reads dispatch on the
+ * version byte the manifest carries.  Once every blob has been
+ * re-encrypted at the new version (e.g. via a re-encryption sweep),
+ * the corresponding `retired` entry can be dropped.
+ */
+export interface MasterKeyRingEntry {
+    /** 0..255 — embedded in the body manifest by `BodyCodec`. */
+    readonly version: number;
+    /** 32 bytes (AES-256). */
+    readonly key: Uint8Array;
+}
+export interface MasterKeyRing {
+    /** Currently-active key — every new write encrypts under this one. */
+    readonly active: MasterKeyRingEntry;
+    /**
+     * Older keys still used for decryption of historical blobs.  Every
+     * version a manifest may reference must appear here OR as `active`.
+     */
+    readonly retired?: ReadonlyArray<MasterKeyRingEntry>;
+}
+/**
+ * Encryption directive — supports server-side modes (handed to the
+ * backend as a header / param) and client-side AES-256-GCM with a
+ * 32-byte master key from which a per-pid subkey is derived via HKDF.
+ *
+ * The client-side variant accepts either a single `masterKey` (legacy,
+ * implicitly version 0 — backwards compatible with bodies written
+ * before rotation support landed) or a `masterKeys` ring with one
+ * `active` entry plus optional `retired` entries (#8).
+ */
+export type EncryptionConfig = {
+    readonly mode: 'none';
+} | {
+    readonly mode: 'sse-s3';
+} | {
+    readonly mode: 'sse-kms';
+    readonly kmsKeyId: string;
+} | {
+    readonly mode: 'client-aes256-gcm';
+    readonly masterKey: Uint8Array;
+    readonly info?: string;
+} | {
+    readonly mode: 'client-aes256-gcm';
+    readonly masterKeys: MasterKeyRing;
+    readonly info?: string;
+};
+/**
+ * Bag of per-call options that any persistence store may accept.  All
+ * fields optional — when omitted, the store falls back to its own
+ * configuration (e.g. plugin defaults / per-pid resolver).
+ */
+export interface PersistenceOptions {
+    readonly compression?: CompressionConfig;
+    readonly encryption?: EncryptionConfig;
+}
+/**
+ * @deprecated Use `PersistenceOptions` — kept as an alias so the older
+ * name doesn't break downstream typings.
+ */
+export type PersistenceWriteOptions = PersistenceOptions;
+//# sourceMappingURL=PersistenceOptions.d.ts.map

package/dist/persistence/PersistenceOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceOptions.d.ts","sourceRoot":"","sources":["../../src/persistence/PersistenceOptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,8EAA8E;AAC9E,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvD,wEAAwE;AACxE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;CACrC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0BAA0B;IAC1B,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CACtD;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEN;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,CAAC"}

package/dist/persistence/PersistenceOptions.js

@@ -0,0 +1,20 @@
+/**
+ * Per-call options for any `SnapshotStore` / `DurableStateStore`
+ * operation — primarily a way for an actor to declare its **own**
+ * compression / encryption preferences, overriding any plugin-level
+ * defaults.  Threaded through both write and read paths because
+ * client-side encryption needs the master key on both sides (the store
+ * has no other way to derive the per-pid subkey).  Compression on the
+ * read side is informational only — the body-codec recovers it from the
+ * payload header — and stores ignore it there.
+ *
+ * The two backing types (`CompressionConfig`, `EncryptionConfig`) are
+ * defined here, at the persistence-layer top level, rather than inside
+ * `object-storage/`.  The reason: actors don't know which concrete
+ * store is wired up, and we don't want them to import from a specific
+ * impl directory just to declare their own settings.  Stores that
+ * don't honour these options (in-memory, SQLite, Cassandra) simply
+ * ignore them.
+ */
+export {};
+//# sourceMappingURL=PersistenceOptions.js.map

package/dist/persistence/PersistenceOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistenceOptions.js","sourceRoot":"","sources":["../../src/persistence/PersistenceOptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG"}