@nimbus-cqrs/eventsourcingdb 2.1.2 → 2.3.0

package/README.md

@@ -7,9 +7,9 @@
 
 Integration between Nimbus and [EventSourcingDB](https://www.eventsourcingdb.io/). The package wraps the official `eventsourcingdb` client with:
 
--   a **singleton setup** that pings the server, verifies the API token and registers long-running observers in one call,
--   typed **`writeEvents` / `readEvents`** helpers that translate between Nimbus events and EventSourcingDB events while preserving correlation IDs, data schemas and W3C trace context (`traceparent` / `tracestate`),
--   resilient **event observers** with exponential-backoff retries, jitter, position tracking across reconnects and OpenTelemetry span linking back to the original writer.
+- a **singleton setup** that pings the server, verifies the API token and registers long-running observers in one call,
+- typed **`writeEvents` / `readEvents`** helpers that translate between Nimbus events and EventSourcingDB events while preserving correlation IDs, data schemas and W3C trace context (`traceparent` / `tracestate`),
+- resilient **event observers** with exponential-backoff retries, jitter, position tracking across reconnects and OpenTelemetry span linking back to the original writer.
 
 Refer to the [Nimbus main repository](https://github.com/overlap-dev/Nimbus) or the [Nimbus documentation](https://nimbus.overlap.at) for more information about the Nimbus framework.
 
@@ -122,7 +122,7 @@ await writeEvents(
             type: "isSubjectPristine",
             payload: { subject: "/todos/todo-1" },
         },
-    ]
+    ],
 );
 ```
 
@@ -146,11 +146,17 @@ Pass an `AbortSignal` as the third argument if you need to cancel a long-running
 
 ## Event observers
 
-An `EventObserver` is a long-running consumer attached to a subject. `initEventObserver` (or the `eventObservers` array on `setupEventSourcingDBClient`) starts it in the background and keeps it alive: on connection failures it retries with exponential backoff plus jitter (defaults: 3 retries, 3000 ms initial delay) and on every successful event it advances its lower bound, so a reconnection resumes from exactly where it left off — no replays, no gaps.
+An `EventObserver` is a long-running consumer attached to a subject. `initEventObserver` (or the `eventObservers` array on `setupEventSourcingDBClient`) starts it in the background and keeps it alive. Connection and handler failures are retried separately with exponential backoff plus jitter (defaults: 3 retries, 3000 ms initial delay for each):
+
+- **Connection failures** reconnect the observe stream (`connectionRetryOptions`; deprecated alias: `retryOptions`).
+- **Handler failures** are retried in-place without reconnecting (`handlerRetryOptions`). After handler retries are exhausted the event is skipped (optional `onHandlerError`) and observation continues.
+
+On every handled or skipped event the observer advances its lower bound so a reconnection resumes from exactly where it left off — no replays, no gaps.
 
 Each event handler runs inside an OpenTelemetry span. If the source event carries a `traceparent`, that span is linked back to the writer's trace, giving you end-to-end visibility from the command that produced the event to every subscriber that reacted to it.
 
 ```typescript
+import { getLogger } from "@nimbus-cqrs/core";
 import { initEventObserver } from "@nimbus-cqrs/eventsourcingdb";
 
 initEventObserver({
@@ -166,10 +172,21 @@ initEventObserver({
             // ...update a read model, send a notification, ...
         }
     },
-    retryOptions: {
+    connectionRetryOptions: {
         maxRetries: 5,
         initialRetryDelayMs: 1000,
     },
+    handlerRetryOptions: {
+        maxRetries: 3,
+        initialRetryDelayMs: 1000,
+    },
+    onHandlerError: (error, event) => {
+        getLogger().error({
+            category: "EventObserver",
+            message: `Skipping event after handler retries: ${event.id}`,
+            error,
+        });
+    },
 });
 ```
 
@@ -201,9 +218,9 @@ import {
 } from "@nimbus-cqrs/eventsourcingdb";
 ```
 
--   `nimbusEventToEventSourcingDBEventCandidate(event)` — manual conversion, e.g. when batching with the raw client.
--   `eventSourcingDBEventToNimbusEvent<TEvent>(event)` — typed conversion when reading or observing.
--   `isEventData(value)` — type guard to detect the Nimbus envelope on arbitrary stored data.
+- `nimbusEventToEventSourcingDBEventCandidate(event)` — manual conversion, e.g. when batching with the raw client.
+- `eventSourcingDBEventToNimbusEvent<TEvent>(event)` — typed conversion when reading or observing.
+- `isEventData(value)` — type guard to detect the Nimbus envelope on arbitrary stored data.
 
 # License
 

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,7 @@
+declare global {
+    interface Error {
+        cause?: unknown;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,KAAK;QACb,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CACF;AAED,OAAO,EAAE,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1 @@
+export {};

package/esm/index.d.ts

@@ -1,3 +1,4 @@
+import "./_dnt.polyfills.js";
 export * from './lib/client.js';
 export * from './lib/eventMapping.js';
 export * from './lib/eventObserver.js';

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC"}

package/esm/index.js

@@ -1,3 +1,4 @@
+import "./_dnt.polyfills.js";
 export * from './lib/client.js';
 export * from './lib/eventMapping.js';
 export * from './lib/eventObserver.js';

package/esm/lib/client.d.ts

@@ -59,7 +59,11 @@ export type SetupEventSourcingDBClientInput = {
  *             eventHandler: async (event: Event) => {
  *                 console.log('Received event:', event);
  *             },
- *             retryOptions: {
+ *             connectionRetryOptions: {
+ *                 maxRetries: 3,
+ *                 initialRetryDelayMs: 3000,
+ *             },
+ *             handlerRetryOptions: {
  *                 maxRetries: 3,
  *                 initialRetryDelayMs: 3000,
  *             },

package/esm/lib/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lib/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,KAAK,aAAa,EAAqB,MAAM,oBAAoB,CAAC;AAI3E;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC1C;;OAEG;IACH,GAAG,EAAE,GAAG,CAAC;IACT;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;CACpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,0BAA0B,GACnC,mCAAmC,+BAA+B,KACnE,OAAO,CAAC,IAAI,CA0Cd,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAQ3C,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lib/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,KAAK,aAAa,EAAqB,MAAM,oBAAoB,CAAC;AAI3E;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC1C;;OAEG;IACH,GAAG,EAAE,GAAG,CAAC;IACT;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;CACpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,0BAA0B,GACnC,mCAAmC,+BAA+B,KACnE,OAAO,CAAC,IAAI,CA0Cd,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAQ3C,CAAC"}

package/esm/lib/client.js

@@ -44,7 +44,11 @@ let eventSourcingDBClient = null;
  *             eventHandler: async (event: Event) => {
  *                 console.log('Received event:', event);
  *             },
- *             retryOptions: {
+ *             connectionRetryOptions: {
+ *                 maxRetries: 3,
+ *                 initialRetryDelayMs: 3000,
+ *             },
+ *             handlerRetryOptions: {
  *                 maxRetries: 3,
  *                 initialRetryDelayMs: 3000,
  *             },

package/esm/lib/eventMapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eventMapping.d.ts","sourceRoot":"","sources":["../../src/lib/eventMapping.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,qDAAqD,CAAC;AAE9F,OAAO,KAAK,EACR,KAAK,IAAI,oBAAoB,EAC7B,cAAc,EACjB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,UAAU,EAAE,mBAAmB,CAAC;CACnC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,KAAG,IAAI,IAAI,SAOnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0CAA0C,GACnD,OAAO,KAAK,EACZ,cAAc,MAAM,EACpB,aAAa,MAAM,KACpB,cAeF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,MAAM,SAAS,KAAK,EAClE,sBAAsB,oBAAoB,KAC3C,MAwBF,CAAC"}
+{"version":3,"file":"eventMapping.d.ts","sourceRoot":"","sources":["../../src/lib/eventMapping.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,KAAK,EACb,MAAM,qDAAqD,CAAC;AAE7D,OAAO,KAAK,EACR,KAAK,IAAI,oBAAoB,EAC7B,cAAc,EACjB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,UAAU,EAAE,mBAAmB,CAAC;CACnC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,KAAG,IAAI,IAAI,SAOnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0CAA0C,GACnD,OAAO,KAAK,EACZ,cAAc,MAAM,EACpB,aAAa,MAAM,KACpB,cAeF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,MAAM,SAAS,KAAK,EAClE,sBAAsB,oBAAoB,KAC3C,MAwBF,CAAC"}

package/esm/lib/eventMapping.js

@@ -1,4 +1,4 @@
-import { createEvent } from '@nimbus-cqrs/core';
+import { createEvent, } from '@nimbus-cqrs/core';
 import { ulid } from '../deps/jsr.io/@std/ulid/1.0.0/mod.js';
 /**
  * Type guard that checks whether the given value conforms to the {@link EventData} structure

package/esm/lib/eventObserver.d.ts

@@ -10,8 +10,8 @@ type ObserveFromLatestEvent = {
 };
 export type RetryOptions = {
     /**
-     * The maximum number of retry attempts before giving up.
-     * Defaults to 3.
+     * The maximum number of retries after the initial attempt
+     * before giving up. Defaults to 3 (4 failed attempts total).
      */
     maxRetries: number;
     /**
@@ -55,11 +55,33 @@ export type EventObserver = {
      */
     eventHandler: (event: EventSourcingDBEvent) => Promise<void> | void;
     /**
-     * Options for retry behavior when the connection fails.
-     * Uses exponential backoff with jitter between retries.
+     * Options for retry behavior when the observe stream / connection fails.
+     * Uses exponential backoff with jitter between reconnects.
      * Defaults to { maxRetries: 3, initialRetryDelayMs: 3000 }.
      */
+    connectionRetryOptions?: RetryOptions;
+    /**
+     * Options for retry behavior when {@link eventHandler} throws.
+     * Handler retries happen in-place without reconnecting the stream.
+     * Defaults to { maxRetries: 3, initialRetryDelayMs: 3000 }.
+     */
+    handlerRetryOptions?: RetryOptions;
+    /**
+     * @deprecated Use {@link connectionRetryOptions} instead.
+     *
+     * Options for retry behavior when the observe stream / connection fails.
+     * Ignored when {@link connectionRetryOptions} is set.
+     */
     retryOptions?: RetryOptions;
+    /**
+     * Called when {@link eventHandler} keeps failing after all handler
+     * retries are exhausted. The event is then skipped and observation
+     * continues. When omitted, a critical log entry is emitted instead.
+     *
+     * @param error - The last error thrown by the handler.
+     * @param event - The event that could not be handled.
+     */
+    onHandlerError?: (error: Error, event: EventSourcingDBEvent) => Promise<void> | void;
 };
 /**
  * Calculates an exponential backoff delay with jitter for a given
@@ -70,13 +92,39 @@ export type EventObserver = {
  *   exponential scaling.
  * @param attempt - The zero-based retry attempt number.
  * @returns The backoff delay in milliseconds.
+ *
+ * @deprecated Import {@link calculateBackoffDelay} from
+ *   `@nimbus-cqrs/core` instead. This wrapper keeps the historical
+ *   30% jitter default used by EventSourcingDB observers.
  */
 export declare const calculateBackoffDelay: (initialDelayMs: number, attempt: number) => number;
+/**
+ * Starts observing events for the given {@link EventObserver} with
+ * automatic reconnection on stream failure and separate in-place
+ * retries for handler failures.
+ *
+ * Events are consumed from the stream and each one is passed to the
+ * observer's event handler inside an OpenTelemetry span. If the event
+ * carries a `traceparent`, the span is linked to the original writer's
+ * trace for end-to-end distributed tracing.
+ *
+ * Handler failures are retried without reconnecting. After handler
+ * retries are exhausted the event is skipped (lower bound advanced)
+ * so observation can continue. When the connection drops, exponential
+ * backoff with jitter is applied up to the configured maximum number
+ * of connection retries.
+ *
+ * @param eventObserver - The event observer configuration.
+ * @returns A promise that resolves when the observe stream ends or
+ *   connection retries are exhausted.
+ */
+export declare const observeWithRetry: (eventObserver: EventObserver) => Promise<void>;
 /**
  * Initializes an event observer by starting the observation loop in
  * the background (non-blocking). The observer will keep running and
- * reconnecting according to its retry options until the stream ends
- * or retries are exhausted.
+ * reconnecting according to its connection retry options until the
+ * stream ends or connection retries are exhausted. Handler failures
+ * are retried separately and do not stop the observer.
  *
  * @param eventObserver - The event observer configuration.
  */

package/esm/lib/eventObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eventObserver.d.ts","sourceRoot":"","sources":["../../src/lib/eventObserver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,IAAI,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAIrE,KAAK,KAAK,GAAG;IACT,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;CACnC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACvB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IACxB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB;;;OAGG;IACH,eAAe,CAAC,EAAE,sBAAsB,CAAC;IACzC;;;;;OAKG;IACH,YAAY,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpE;;;;OAIG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC/B,CAAC;AAQF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAC9B,gBAAgB,MAAM,EACtB,SAAS,MAAM,KAChB,MAOF,CAAC;AA8KF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,eAAe,aAAa,KAAG,IAEhE,CAAC"}
+{"version":3,"file":"eventObserver.d.ts","sourceRoot":"","sources":["../../src/lib/eventObserver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,IAAI,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAarE,KAAK,KAAK,GAAG;IACT,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;CACnC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACvB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAOF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IACxB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB;;;OAGG;IACH,eAAe,CAAC,EAAE,sBAAsB,CAAC;IACzC;;;;;OAKG;IACH,YAAY,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpE;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,YAAY,CAAC;IACtC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,YAAY,CAAC;IACnC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,CACb,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,oBAAoB,KAC1B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC7B,CAAC;AAQF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAC9B,gBAAgB,MAAM,EACtB,SAAS,MAAM,KAChB,MAIG,CAAC;AAgPP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,GACzB,eAAe,aAAa,KAC7B,OAAO,CAAC,IAAI,CAiGd,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAAI,eAAe,aAAa,KAAG,IAEhE,CAAC"}

package/esm/lib/eventObserver.js

@@ -1,6 +1,12 @@
-import { getLogger } from '@nimbus-cqrs/core';
+import { calculateBackoffDelay as coreCalculateBackoffDelay, getLogger, withRetry, } from '@nimbus-cqrs/core';
+import { SpanStatusCode } from '@opentelemetry/api';
 import { getEventSourcingDBClient } from './client.js';
-import { withSpan } from './tracing.js';
+import { isEventData } from './eventMapping.js';
+import { observerConnectionReconnectsCounter, observerConnectionRetryAttemptsCounter, observerEventsHandledCounter, observerHandlerRetryAttemptsCounter, observerHandlingDuration, withObserveEventSpan, } from './tracing.js';
+const DEFAULT_RETRY_OPTIONS = {
+    maxRetries: 3,
+    initialRetryDelayMs: 3000,
+};
 /**
  * Returns a promise that resolves after the given number of milliseconds.
  */
@@ -14,13 +20,37 @@ const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  *   exponential scaling.
  * @param attempt - The zero-based retry attempt number.
  * @returns The backoff delay in milliseconds.
+ *
+ * @deprecated Import {@link calculateBackoffDelay} from
+ *   `@nimbus-cqrs/core` instead. This wrapper keeps the historical
+ *   30% jitter default used by EventSourcingDB observers.
  */
-export const calculateBackoffDelay = (initialDelayMs, attempt) => {
-    const baseDelay = initialDelayMs * Math.pow(2, attempt);
-    // Add jitter: random value between 0 and 30% of the base delay
-    const jitter = Math.random() * baseDelay * 0.3;
-    return Math.floor(baseDelay + jitter);
-};
+export const calculateBackoffDelay = (initialDelayMs, attempt) => coreCalculateBackoffDelay(initialDelayMs, attempt, {
+    jitterFactor: 0.3,
+    maxDelayMs: Infinity,
+});
+/**
+ * Resolves connection retry options, preferring
+ * {@link EventObserver.connectionRetryOptions} over the deprecated
+ * {@link EventObserver.retryOptions}.
+ */
+const resolveConnectionRetryOptions = (eventObserver) => ({
+    maxRetries: eventObserver.connectionRetryOptions?.maxRetries ??
+        eventObserver.retryOptions?.maxRetries ??
+        DEFAULT_RETRY_OPTIONS.maxRetries,
+    initialRetryDelayMs: eventObserver.connectionRetryOptions?.initialRetryDelayMs ??
+        eventObserver.retryOptions?.initialRetryDelayMs ??
+        DEFAULT_RETRY_OPTIONS.initialRetryDelayMs,
+});
+/**
+ * Resolves handler retry options from {@link EventObserver.handlerRetryOptions}.
+ */
+const resolveHandlerRetryOptions = (eventObserver) => ({
+    maxRetries: eventObserver.handlerRetryOptions?.maxRetries ??
+        DEFAULT_RETRY_OPTIONS.maxRetries,
+    initialRetryDelayMs: eventObserver.handlerRetryOptions?.initialRetryDelayMs ??
+        DEFAULT_RETRY_OPTIONS.initialRetryDelayMs,
+});
 /**
  * Logs an informational message when an event observer connects or
  * reconnects to EventSourcingDB. When {@link retryCount} is greater
@@ -39,10 +69,10 @@ const logObserverConnection = (subject, retryCount, data) => {
     getLogger().info({ category: 'Nimbus', message, data });
 };
 /**
- * Handles an observer error by logging it and waiting with exponential
- * backoff before the next retry attempt. When the maximum number of
- * retries is exceeded a critical log entry is emitted and no further
- * retries are attempted.
+ * Handles a connection / stream error by logging it and waiting with
+ * exponential backoff before the next reconnect attempt. When the
+ * maximum number of retries is exceeded a critical log entry is
+ * emitted and no further retries are attempted.
  *
  * @param error - The error that caused the observer to disconnect.
  * @param subject - The observed subject.
@@ -53,7 +83,7 @@ const logObserverConnection = (subject, retryCount, data) => {
  * @returns `true` if the observer should retry, `false` if retries
  *   are exhausted.
  */
-const handleObserverError = async (error, subject, retryCount, maxRetries, initialRetryDelayMs) => {
+const handleConnectionError = async (error, subject, retryCount, maxRetries, initialRetryDelayMs) => {
     if (retryCount > maxRetries) {
         getLogger().critical({
             category: 'Nimbus',
@@ -61,6 +91,7 @@ const handleObserverError = async (error, subject, retryCount, maxRetries, initi
         });
         return false;
     }
+    observerConnectionRetryAttemptsCounter.add(1, { subject });
     const backoffDelay = calculateBackoffDelay(initialRetryDelayMs, retryCount - 1);
     getLogger().error({
         category: 'Nimbus',
@@ -70,32 +101,130 @@ const handleObserverError = async (error, subject, retryCount, maxRetries, initi
     await delay(backoffDelay);
     return true;
 };
+const recordHandlerMetrics = (metricLabels, status, startTime) => {
+    observerEventsHandledCounter.add(1, { ...metricLabels, status });
+    observerHandlingDuration.record((performance.now() - startTime) / 1000, metricLabels);
+};
+/**
+ * Invokes the event handler with in-place retries. Does not reconnect
+ * the observe stream. When all retries are exhausted, calls
+ * {@link EventObserver.onHandlerError} or logs critically, then
+ * returns without throwing so the observer can skip the event.
+ */
+const handleEventWithRetry = async (eventObserver, event, handlerRetryOptions, span, startTime) => {
+    const { maxRetries, initialRetryDelayMs } = handlerRetryOptions;
+    const metricLabels = {
+        subject: eventObserver.subject,
+        event_type: event.type,
+    };
+    try {
+        await withRetry(() => eventObserver.eventHandler(event), {
+            maxRetries,
+            initialDelayMs: initialRetryDelayMs,
+            maxDelayMs: Infinity,
+            jitterFactor: 0.3,
+            onRetry: ({ error, attempt, delayMs }) => {
+                observerHandlerRetryAttemptsCounter.add(1, metricLabels);
+                span.addEvent('retry', {
+                    attempt,
+                    delay_ms: delayMs,
+                });
+                getLogger().error({
+                    category: 'Nimbus',
+                    message: `Error handling event "${event.id}" (${event.type}) for subject "${eventObserver.subject}" (retry ${attempt}/${maxRetries}), retrying in ${delayMs}ms`,
+                    error,
+                    ...(isEventData(event.data)
+                        ? {
+                            correlationId: event.data.nimbusMeta.correlationid,
+                        }
+                        : {}),
+                });
+            },
+        });
+        recordHandlerMetrics(metricLabels, 'success', startTime);
+    }
+    catch (error) {
+        const handlerError = error instanceof Error
+            ? error
+            : new Error(String(error));
+        recordHandlerMetrics(metricLabels, 'skipped', startTime);
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: handlerError.message,
+        });
+        span.recordException(handlerError);
+        await handleHandlerExhausted(eventObserver, event, handlerError, maxRetries);
+    }
+};
+/**
+ * Handles exhausted handler retries by invoking
+ * {@link EventObserver.onHandlerError} or emitting a critical log.
+ */
+const handleHandlerExhausted = async (eventObserver, event, handlerError, maxRetries) => {
+    if (eventObserver.onHandlerError) {
+        try {
+            await eventObserver.onHandlerError(handlerError, event);
+        }
+        catch (err) {
+            // Isolate user callback failures so the poison
+            // event is still skipped and observation continues.
+            const callbackError = err instanceof Error
+                ? err
+                : new Error(String(err));
+            getLogger().critical({
+                category: 'Nimbus',
+                message: `onHandlerError failed for event "${event.id}" (${event.type}) for subject "${eventObserver.subject}". Skipping event.`,
+                error: callbackError,
+                ...(isEventData(event.data)
+                    ? {
+                        correlationId: event.data.nimbusMeta.correlationid,
+                    }
+                    : {}),
+            });
+        }
+        return;
+    }
+    getLogger().critical({
+        category: 'Nimbus',
+        message: `Failed to handle event "${event.id}" (${event.type}) for subject "${eventObserver.subject}" after ${maxRetries} ${maxRetries === 1 ? 'retry' : 'retries'}. Skipping event.`,
+        error: handlerError,
+        ...(isEventData(event.data)
+            ? {
+                correlationId: event.data.nimbusMeta.correlationid,
+            }
+            : {}),
+    });
+};
 /**
  * Starts observing events for the given {@link EventObserver} with
- * automatic reconnection on failure.
- *
- * On each connection attempt the EventSourcingDB server is pinged
- * first. Events are then consumed from the stream and each one is
- * passed to the observer's event handler inside an OpenTelemetry
- * span. If the event carries a `traceparent`, the span is linked to
- * the original writer's trace for end-to-end distributed tracing.
+ * automatic reconnection on stream failure and separate in-place
+ * retries for handler failures.
  *
- * After every successfully handled event the lower bound is advanced
- * so that a reconnection resumes from the last processed position.
+ * Events are consumed from the stream and each one is passed to the
+ * observer's event handler inside an OpenTelemetry span. If the event
+ * carries a `traceparent`, the span is linked to the original writer's
+ * trace for end-to-end distributed tracing.
  *
- * When the connection drops, exponential backoff with jitter is
- * applied up to the configured maximum number of retries.
+ * Handler failures are retried without reconnecting. After handler
+ * retries are exhausted the event is skipped (lower bound advanced)
+ * so observation can continue. When the connection drops, exponential
+ * backoff with jitter is applied up to the configured maximum number
+ * of connection retries.
  *
  * @param eventObserver - The event observer configuration.
+ * @returns A promise that resolves when the observe stream ends or
+ *   connection retries are exhausted.
  */
-const observeWithRetry = async (eventObserver) => {
-    const eventSourcingDBClient = getEventSourcingDBClient();
-    const maxRetries = eventObserver.retryOptions?.maxRetries ?? 3;
-    const initialRetryDelayMs = eventObserver.retryOptions?.initialRetryDelayMs ?? 3000;
-    let retryCount = 0;
+export const observeWithRetry = async (eventObserver) => {
+    const connectionRetryOptions = resolveConnectionRetryOptions(eventObserver);
+    const handlerRetryOptions = resolveHandlerRetryOptions(eventObserver);
+    let connectionRetryCount = 0;
     let lastProcessedEventId;
     while (true) {
         try {
+            // Resolve the client on every attempt so a re-initialized
+            // singleton is picked up after reconnecting to EventSourcingDB.
+            const eventSourcingDBClient = getEventSourcingDBClient();
             // Once we have a concrete position, use it as lower bound and
             // drop fromLatestEvent; otherwise fall back to the original options.
             const lowerBound = lastProcessedEventId
@@ -104,7 +233,7 @@ const observeWithRetry = async (eventObserver) => {
             const fromLatestEvent = lastProcessedEventId
                 ? undefined
                 : eventObserver.fromLatestEvent;
-            logObserverConnection(eventObserver.subject, retryCount, {
+            logObserverConnection(eventObserver.subject, connectionRetryCount, {
                 recursive: eventObserver.recursive ?? false,
                 lowerBound,
                 fromLatestEvent,
@@ -114,26 +243,34 @@ const observeWithRetry = async (eventObserver) => {
                 ...(lowerBound ? { lowerBound } : {}),
                 ...(fromLatestEvent ? { fromLatestEvent } : {}),
             })) {
-                // Reset the retry count as soon as we successfully receive an event
-                retryCount = 0;
+                // Stream is healthy once events flow again. Count a successful
+                // reconnect only here so failed reconnect attempts are excluded.
+                if (connectionRetryCount > 0) {
+                    observerConnectionReconnectsCounter.add(1, {
+                        subject: eventObserver.subject,
+                    });
+                }
+                connectionRetryCount = 0;
                 const traceContext = event.traceparent
                     ? {
                         traceparent: event.traceparent,
                         tracestate: event.tracestate,
                     }
                     : undefined;
-                await withSpan('observeEvent', async () => {
-                    await eventObserver.eventHandler(event);
-                }, traceContext);
-                // Track last processed position so retries resume from here
+                const startTime = performance.now();
+                await withObserveEventSpan(event, eventObserver.subject, traceContext, async (span) => {
+                    await handleEventWithRetry(eventObserver, event, handlerRetryOptions, span, startTime);
+                });
+                // Advance after success or skip so poison events do not block
+                // the stream and reconnects resume past the last attempted event.
                 lastProcessedEventId = event.id;
             }
             // If the loop completes normally (stream ended), we're done
             return;
         }
         catch (error) {
-            retryCount++;
-            const shouldRetry = await handleObserverError(error, eventObserver.subject, retryCount, maxRetries, initialRetryDelayMs);
+            connectionRetryCount++;
+            const shouldRetry = await handleConnectionError(error, eventObserver.subject, connectionRetryCount, connectionRetryOptions.maxRetries, connectionRetryOptions.initialRetryDelayMs);
             if (!shouldRetry) {
                 return;
             }
@@ -143,8 +280,9 @@ const observeWithRetry = async (eventObserver) => {
 /**
  * Initializes an event observer by starting the observation loop in
  * the background (non-blocking). The observer will keep running and
- * reconnecting according to its retry options until the stream ends
- * or retries are exhausted.
+ * reconnecting according to its connection retry options until the
+ * stream ends or connection retries are exhausted. Handler failures
+ * are retried separately and do not stop the observer.
  *
  * @param eventObserver - The event observer configuration.
  */

package/esm/lib/tracing.d.ts

@@ -1,5 +1,31 @@
+import { type Span } from '@opentelemetry/api';
 export declare const tracer: import("@opentelemetry/api").Tracer;
 export declare const DB_SYSTEM = "eventsourcingdb";
+/**
+ * Histogram of serialized Nimbus event sizes written via writeEvents.
+ */
+export declare const eventSizeBytes: import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
+/**
+ * Counter of events handled by an event observer, labeled with
+ * `status: success|skipped`.
+ */
+export declare const observerEventsHandledCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
+/**
+ * Histogram of observer handler duration in seconds (includes retries).
+ */
+export declare const observerHandlingDuration: import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
+/**
+ * Counter of in-place handler retry attempts for event observers.
+ */
+export declare const observerHandlerRetryAttemptsCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
+/**
+ * Counter of connection reconnect attempts scheduled after stream failure.
+ */
+export declare const observerConnectionRetryAttemptsCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
+/**
+ * Counter of successful reconnects after one or more connection retries.
+ */
+export declare const observerConnectionReconnectsCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
 /**
  * Trace context extracted from an EventSourcingDB event, used to link
  * the processing span to the span that originally wrote the event.
@@ -22,6 +48,20 @@ export type TraceContext = {
  * @returns The result of the async function
  */
 export declare const withSpan: <T>(operation: string, fn: () => Promise<T>, traceContext?: TraceContext) => Promise<T>;
+/**
+ * Starts a consumer span for observing a single EventSourcingDB event,
+ * optionally linked to the writer's trace via {@link TraceContext}.
+ *
+ * @param event - The observed EventSourcingDB event.
+ * @param observerSubject - The observer's configured subject.
+ * @param traceContext - Optional writer trace context from the event.
+ * @param fn - Work to run inside the active span.
+ */
+export declare const withObserveEventSpan: <T>(event: {
+    id: string;
+    type: string;
+    subject: string;
+}, observerSubject: string, traceContext: TraceContext | undefined, fn: (span: Span) => Promise<T>) => Promise<T>;
 /**
  * Wraps an async generator with OpenTelemetry tracing and metrics.
  *

package/esm/lib/tracing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/lib/tracing.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,MAAM,qCAA4B,CAAC;AAEhD,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAmB3C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACtB,WAAW,MAAM,EACjB,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,eAAe,YAAY,KAC5B,OAAO,CAAC,CAAC,CA6DX,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAuB,sBAAsB,CAAC,CAAC,EAC3C,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GACxC,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CA0C/B"}
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/lib/tracing.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,IAAI,EAIZ,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,MAAM,qCAA4B,CAAC;AAEhD,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAmB3C;;GAEG;AACH,eAAO,MAAM,cAAc,iFAM1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,+EAMxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,iFAOpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mCAAmC,+EAM/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sCAAsC,+EAMlD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mCAAmC,+EAM/C,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACtB,WAAW,MAAM,EACjB,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,eAAe,YAAY,KAC5B,OAAO,CAAC,CAAC,CA6DX,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAClC,OAAO;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EACpD,iBAAiB,MAAM,EACvB,cAAc,YAAY,GAAG,SAAS,EACtC,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,CAAC,CA8BX,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAuB,sBAAsB,CAAC,CAAC,EAC3C,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GACxC,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CA0C/B"}

package/esm/lib/tracing.js

@@ -9,6 +9,45 @@ const operationDuration = meter.createHistogram('eventsourcingdb_operation_durat
     description: 'Duration of EventSourcingDB operations in seconds',
     unit: 's',
 });
+/**
+ * Histogram of serialized Nimbus event sizes written via writeEvents.
+ */
+export const eventSizeBytes = meter.createHistogram('eventsourcingdb_event_size_bytes', {
+    description: 'Size of events written to EventSourcingDB in bytes',
+    unit: 'By',
+});
+/**
+ * Counter of events handled by an event observer, labeled with
+ * `status: success|skipped`.
+ */
+export const observerEventsHandledCounter = meter.createCounter('eventsourcingdb_observer_events_handled_total', {
+    description: 'Total number of events handled by EventSourcingDB observers',
+});
+/**
+ * Histogram of observer handler duration in seconds (includes retries).
+ */
+export const observerHandlingDuration = meter.createHistogram('eventsourcingdb_observer_handling_duration_seconds', {
+    description: 'Duration of EventSourcingDB observer event handling in seconds',
+    unit: 's',
+});
+/**
+ * Counter of in-place handler retry attempts for event observers.
+ */
+export const observerHandlerRetryAttemptsCounter = meter.createCounter('eventsourcingdb_observer_handler_retry_attempts_total', {
+    description: 'Total number of handler retry attempts for EventSourcingDB observers',
+});
+/**
+ * Counter of connection reconnect attempts scheduled after stream failure.
+ */
+export const observerConnectionRetryAttemptsCounter = meter.createCounter('eventsourcingdb_observer_connection_retry_attempts_total', {
+    description: 'Total number of connection retry attempts for EventSourcingDB observers',
+});
+/**
+ * Counter of successful reconnects after one or more connection retries.
+ */
+export const observerConnectionReconnectsCounter = meter.createCounter('eventsourcingdb_observer_connection_reconnects_total', {
+    description: 'Total number of successful connection reconnects for EventSourcingDB observers',
+});
 /**
  * Wraps an async function with OpenTelemetry tracing and metrics.
  *
@@ -68,6 +107,41 @@ export const withSpan = (operation, fn, traceContext) => {
         }
     });
 };
+/**
+ * Starts a consumer span for observing a single EventSourcingDB event,
+ * optionally linked to the writer's trace via {@link TraceContext}.
+ *
+ * @param event - The observed EventSourcingDB event.
+ * @param observerSubject - The observer's configured subject.
+ * @param traceContext - Optional writer trace context from the event.
+ * @param fn - Work to run inside the active span.
+ */
+export const withObserveEventSpan = (event, observerSubject, traceContext, fn) => {
+    const parentContext = traceContext
+        ? propagation.extract(otelContext.active(), traceContext)
+        : otelContext.active();
+    return tracer.startActiveSpan('eventsourcingdb.observeEvent', {
+        kind: SpanKind.CONSUMER,
+        attributes: {
+            'db.system': DB_SYSTEM,
+            'db.operation': 'observeEvent',
+            'messaging.system': 'eventsourcingdb',
+            'messaging.operation': 'process',
+            'messaging.destination': event.type,
+            'cloudevents.event_id': event.id,
+            'cloudevents.event_type': event.type,
+            'cloudevents.event_subject': event.subject,
+            'eventsourcingdb.observer.subject': observerSubject,
+        },
+    }, parentContext, async (span) => {
+        try {
+            return await fn(span);
+        }
+        finally {
+            span.end();
+        }
+    });
+};
 /**
  * Wraps an async generator with OpenTelemetry tracing and metrics.
  *

package/esm/lib/writeEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeEvents.d.ts","sourceRoot":"","sources":["../../src/lib/writeEvents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qDAAqD,CAAC;AAEjF,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKpE;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACpB,QAAQ,KAAK,EAAE,EACf,gBAAgB,YAAY,EAAE,KAC/B,OAAO,CAAC,IAAI,CAoBd,CAAC"}
+{"version":3,"file":"writeEvents.d.ts","sourceRoot":"","sources":["../../src/lib/writeEvents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qDAAqD,CAAC;AAEjF,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAapE;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACpB,QAAQ,KAAK,EAAE,EACf,gBAAgB,YAAY,EAAE,KAC/B,OAAO,CAAC,IAAI,CAyBd,CAAC"}

package/esm/lib/writeEvents.js

@@ -1,7 +1,12 @@
 import { context, propagation } from '@opentelemetry/api';
 import { getEventSourcingDBClient } from './client.js';
 import { nimbusEventToEventSourcingDBEventCandidate } from './eventMapping.js';
-import { withSpan } from './tracing.js';
+import { eventSizeBytes, withSpan } from './tracing.js';
+const textEncoder = new TextEncoder();
+/**
+ * Returns the UTF-8 byte length of a serialized Nimbus event.
+ */
+const getEventSizeBytes = (event) => textEncoder.encode(JSON.stringify(event)).length;
 /**
  * Writes one or more Nimbus events to EventSourcingDB. Each event is
  * converted into an EventSourcingDB event candidate before being persisted.
@@ -14,7 +19,13 @@ export const writeEvents = (events, preconditions) => {
         const eventSourcingDBClient = getEventSourcingDBClient();
         const carrier = {};
         propagation.inject(context.active(), carrier);
-        const eventCandidates = events.map((event) => nimbusEventToEventSourcingDBEventCandidate(event, carrier['traceparent'], carrier['tracestate']));
+        const eventCandidates = events.map((event) => {
+            eventSizeBytes.record(getEventSizeBytes(event), {
+                subject: event.subject,
+                event_type: event.type,
+            });
+            return nimbusEventToEventSourcingDBEventCandidate(event, carrier['traceparent'], carrier['tracestate']);
+        });
         await eventSourcingDBClient.writeEvents(eventCandidates, preconditions);
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-cqrs/eventsourcingdb",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "description": "Simplify Event-Driven Applications - EventSourcingDB integration for the Nimbus framework.",
   "keywords": [
     "nimbus",
@@ -35,9 +35,9 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "eventsourcingdb": "^1.8.1",
-    "zod": "^4.3.6",
-    "@nimbus-cqrs/core": "^2.1.2"
+    "eventsourcingdb": "^1.8.2",
+    "zod": "^4.4.3",
+    "@nimbus-cqrs/core": "^2.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0"