opinionated-machine 11.1.0 → 11.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # opinionated-machine
 
+## 11.2.0
+
+### Minor Changes
+
+- 9637451: Add `SSERoomEventPublisher`: fire-and-forget room broadcasting for domain code. It validates a payload against the event's own schema before broadcasting, and broadcasts the parsed value so schema defaults reach the wire. `publish` throws on a payload that violates its schema, since nobody receives that event and a producer should not believe otherwise; `safePublish` returns `Either<InternalError, true>` instead, for a caller that cannot absorb a throw. A failed broadcast is logged by both, as it happens after the call returns. Accepts the caller's context (anything with a `logger`, such as a `RequestContext`) so failures carry a correlation id.
+
 ## 11.1.0
 
 ### Minor Changes

package/README.md

@@ -56,6 +56,7 @@ Very opinionated DI framework for fastify, built on top of awilix
     - [Session Room Operations](#session-room-operations)
     - [Broadcasting to Rooms](#broadcasting-to-rooms)
     - [Room Broadcaster (Decoupled Broadcasting)](#room-broadcaster-decoupled-broadcasting)
+    - [Room Event Publisher (Fire-and-Forget)](#room-event-publisher-fire-and-forget)
     - [Room Name Helpers](#room-name-helpers)
     - [Room Query Methods](#room-query-methods)
     - [Auto-Leave on Disconnect](#auto-leave-on-disconnect)
@@ -2026,6 +2027,103 @@ class MetricsService {
 
 The broadcaster provides `broadcastToRoom()` (with `defineEvent()`-based type safety), `broadcastMessage()` (raw SSEMessage), plus room query methods (`getConnectionsInRoom`, `getConnectionCountInRoom`). Multiple controllers register their `sendEvent` with the same broadcaster — the first to recognize a connection handles delivery.
 
+#### Room Event Publisher (Fire-and-Forget)
+
+`broadcastToRoom()` returns a promise, and most producers of a room event have nothing to do with
+it. An event listener or message queue handler has already committed its primary work by the time
+it broadcasts: it cannot retry a dropped hint, has nowhere to report one, and awaiting the fan-out
+would tie its latency to the number of open connections. `SSERoomEventPublisher` is the broadcaster
+without the promise.
+
+```ts
+import { defineEvent, SSERoomEventPublisher } from 'opinionated-machine'
+import { z } from 'zod'
+
+const metricsUpdateEvent = defineEvent(
+  'metricsUpdate',
+  z.object({ cpu: z.number(), memory: z.number() }),
+)
+
+// Register alongside the broadcaster it wraps; it expects 'sseRoomBroadcaster' and 'logger'
+// in the cradle, so the names must match exactly.
+class DashboardModule extends AbstractModule {
+  resolveDependencies() {
+    return {
+      sseRoomManager: asValue(new SSERoomManager()),
+      sseRoomBroadcaster: asSingletonClass(SSERoomBroadcaster),
+      sseRoomEventPublisher: asSingletonClass(SSERoomEventPublisher),
+      metricsService: asSingletonClass(MetricsService),
+    }
+  }
+}
+
+class MetricsService {
+  private publisher: SSERoomEventPublisher
+
+  constructor(deps: { sseRoomEventPublisher: SSERoomEventPublisher }) {
+    this.publisher = deps.sseRoomEventPublisher
+  }
+
+  onMetricsUpdate(
+    dashboardId: string,
+    metrics: { cpu: number; memory: number },
+    requestContext: RequestContext,
+  ) {
+    // No await: a failure is logged, not returned. The context is passed whole; only its
+    // logger is read, so a dropped event carries the correlation id of whatever produced it.
+    this.publisher.publish(
+      `dashboard:${dashboardId}`,
+      metricsUpdateEvent,
+      metrics,
+      requestContext,
+    )
+  }
+}
+```
+
+The context parameter is typed as `SSELogContext` (`{ logger: SSELogger }`) rather than any
+concrete context type, so `@lokalise/fastify-extras`' `RequestContext` satisfies it structurally
+and this package needs no dependency on it. A job or consumer context of your own works the same
+way, and a caller that has none omits the argument and falls back to the injected logger.
+
+Two things it does beyond hiding the promise:
+
+- **Validates before broadcasting, and throws.** A payload that violates its own event schema is
+  a bug in the producer, and nobody receives the event, so dropping it quietly means believing
+  you published something you did not. Delivery-time validation cannot give you this: it runs
+  once per connection, so it reports the mismatch once per open connection on every node, names
+  the event but not the code that produced it, does not run at all when nobody has joined the
+  room, and by then the call has long returned.
+- **Puts the parsed value on the wire,** so a schema default is filled in once here rather than
+  left to every client. Delivery-time validation discards its own result and serializes what it
+  was handed, so `broadcastToRoom()` sends the unparsed input.
+
+#### `publish` vs `safePublish`
+
+They differ in one thing: what a malformed payload does.
+
+| | malformed payload | failed broadcast |
+| --- | --- | --- |
+| `publish` | throws `InternalError` | logged |
+| `safePublish` | returns `{ error }`, and logs | logged |
+
+Reach for `safePublish` in a producer that cannot absorb a throw: a message handler whose primary
+work has already committed would be retried in full and redo it, and the retry cannot succeed
+anyway, since a malformed payload fails the same way every time. Prefer `publish` everywhere
+else.
+
+```ts
+const outcome = this.publisher.safePublish(room, event, payload, requestContext)
+if (outcome.error) {
+  // decide for yourself: metric, Bugsnag, a compensating write
+}
+```
+
+`{ result: true }` means the payload was validated and handed to the broadcaster. That is
+acceptance, not delivery: the fan-out has not run yet, and neither method reports its outcome,
+because it happens after the call has returned. Use the broadcaster directly when the delivered
+count matters, or when a failed delivery is something the caller can act on.
+
 #### Room Name Helpers
 
 Room names are plain strings (like Socket.IO), but `defineRoom()` adds type-safe resolvers that ensure consistent naming across controllers and domain services:

package/dist/lib/sse/index.d.ts

@@ -4,7 +4,7 @@ export { type BuildFastifySSERoutesReturnType, buildFastifyRoute, buildHandler,
 export { AbstractSSEController, type SSEControllerConfig, type SSEEventSender, type SSELogger, type SSEMessage, } from './AbstractSSEController.js';
 export { defineEvent, type SSEEventDefinition } from './defineEvent.js';
 export { type AsyncEventIdSequence, type CreateEventIdSequenceOptions, compareEventIds, createEventIdSequence, type EventIdSequence, formatEventId, MAX_EVENT_ID_COUNTER, } from './eventIds.js';
-export { defineRoom, InMemoryAdapter, type PreDeliveryFilter, type RoomBroadcastOptions, type RoomNameResolver, type SSERoomAdapter, SSERoomBroadcaster, SSERoomManager, type SSERoomManagerConfig, type SSERoomMessageHandler, type SSERoomOperations, } from './rooms/index.js';
+export { defineRoom, InMemoryAdapter, type PreDeliveryFilter, type RoomBroadcastOptions, type RoomNameResolver, type SSELogContext, type SSERoomAdapter, SSERoomBroadcaster, SSERoomEventPublisher, type SSERoomEventPublisherDependencies, type SSERoomEventPublishOptions, SSERoomManager, type SSERoomManagerConfig, type SSERoomMessageHandler, type SSERoomOperations, } from './rooms/index.js';
 export { type SpiedSSESession, type SSESessionEvent, SSESessionSpy } from './SSESessionSpy.js';
 export { SSE_DIAGNOSTICS_HEADER, type SSEDiagnosticsScope, type SSESendFailure, } from './sseSendDiagnostics.js';
 export { defineEventMetadata, type ExtractMetadata, type FilterVerdict, type IncomingEvent, type MetadataGuard, type MetadataGuards, type PublishResult, type ResolverResult, SSESubscriptionManager, type SSESubscriptionManagerConfig, type SubscriptionContext, type SubscriptionPolicy, type SubscriptionResolver, } from './subscriptions/index.js';

package/dist/lib/sse/index.js

@@ -8,7 +8,7 @@ export { AbstractSSEController, } from './AbstractSSEController.js';
 export { defineEvent } from './defineEvent.js';
 export { compareEventIds, createEventIdSequence, formatEventId, MAX_EVENT_ID_COUNTER, } from './eventIds.js';
 // Re-export room types and classes
-export { defineRoom, InMemoryAdapter, SSERoomBroadcaster, SSERoomManager, } from './rooms/index.js';
+export { defineRoom, InMemoryAdapter, SSERoomBroadcaster, SSERoomEventPublisher, SSERoomManager, } from './rooms/index.js';
 export { SSESessionSpy } from './SSESessionSpy.js';
 export { SSE_DIAGNOSTICS_HEADER, } from './sseSendDiagnostics.js';
 // SSE Subscriptions

package/dist/lib/sse/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/sse/index.ts"],"names":[],"mappings":"AAUA,6EAA6E;AAC7E,+EAA+E;AAC/E,4BAA4B;AAC5B,OAAO,EACL,qBAAqB,EAIrB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,cAAc,GAIf,MAAM,iCAAiC,CAAA;AACxC,2CAA2C;AAC3C,OAAO,EAEL,iBAAiB,EACjB,YAAY,GAUb,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,qBAAqB,GAKtB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,WAAW,EAA2B,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAGL,eAAe,EACf,qBAAqB,EAErB,aAAa,EACb,oBAAoB,GACrB,MAAM,eAAe,CAAA;AACtB,mCAAmC;AACnC,OAAO,EACL,UAAU,EACV,eAAe,EAKf,kBAAkB,EAClB,cAAc,GAIf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA8C,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAC9F,OAAO,EACL,sBAAsB,GAGvB,MAAM,yBAAyB,CAAA;AAChC,oBAAoB;AACpB,OAAO,EACL,mBAAmB,EAQnB,sBAAsB,GAKvB,MAAM,0BAA0B,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/sse/index.ts"],"names":[],"mappings":"AAUA,6EAA6E;AAC7E,+EAA+E;AAC/E,4BAA4B;AAC5B,OAAO,EACL,qBAAqB,EAIrB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,cAAc,GAIf,MAAM,iCAAiC,CAAA;AACxC,2CAA2C;AAC3C,OAAO,EAEL,iBAAiB,EACjB,YAAY,GAUb,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,qBAAqB,GAKtB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,WAAW,EAA2B,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAGL,eAAe,EACf,qBAAqB,EAErB,aAAa,EACb,oBAAoB,GACrB,MAAM,eAAe,CAAA;AACtB,mCAAmC;AACnC,OAAO,EACL,UAAU,EACV,eAAe,EAMf,kBAAkB,EAClB,qBAAqB,EAGrB,cAAc,GAIf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA8C,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAC9F,OAAO,EACL,sBAAsB,GAGvB,MAAM,yBAAyB,CAAA;AAChC,oBAAoB;AACpB,OAAO,EACL,mBAAmB,EAQnB,sBAAsB,GAKvB,MAAM,0BAA0B,CAAA"}

package/dist/lib/sse/rooms/SSERoomEventPublisher.d.ts

@@ -0,0 +1,121 @@
+import { type Either, InternalError } from '@lokalise/node-core';
+import type { z } from 'zod';
+import type { SSEEventDefinition } from '../defineEvent.js';
+import type { SSELogger } from '../sseTypes.js';
+import type { SSERoomBroadcaster } from './SSERoomBroadcaster.js';
+import type { RoomBroadcastOptions } from './types.js';
+export type SSERoomEventPublisherDependencies = {
+    sseRoomBroadcaster: SSERoomBroadcaster;
+    logger: SSELogger;
+};
+/**
+ * Whatever the caller is working on behalf of, narrowed to the one thing the publisher needs
+ * from it. `@lokalise/fastify-extras`' `RequestContext` satisfies this structurally, as does a
+ * job or consumer context of your own, so neither this package nor its callers need an adapter.
+ */
+export type SSELogContext = {
+    logger: SSELogger;
+};
+/**
+ * Everything {@link SSERoomBroadcaster.broadcastToRoom} accepts, so the publisher is not a lossy
+ * wrapper over it.
+ */
+export type SSERoomEventPublishOptions = RoomBroadcastOptions & {
+    /**
+     * The SSE `id:` put on the wire. Defaults to a random UUID. Set it to a value a client can
+     * order, such as the sequence from `createEventIdSequence()`, when consumers deduplicate or
+     * resume by event id.
+     */
+    id?: string;
+    /** The SSE `retry:` hint, in milliseconds: how long a client waits before reconnecting. */
+    retry?: number;
+    /**
+     * Per-broadcast context handed to the pre-delivery filter, and to other nodes alongside the
+     * message. Only a filter reads it (`SSESubscriptionManager` installs one to evaluate its
+     * resolver pipeline), so it is redundant unless one is installed.
+     */
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Fire-and-forget broadcasting for domain code: a room event goes out and the caller does not
+ * await the fan-out.
+ *
+ * The typical producer is an event listener or a message handler whose primary work has already
+ * committed. It cannot retry a dropped hint, and awaiting the fan-out would tie its latency to
+ * the number of open connections. Code that needs the delivered count, or that can act on a
+ * delivery failure, should use {@link SSERoomBroadcaster} directly.
+ *
+ * The two ways publishing fails are treated differently, because they are different kinds of
+ * problem:
+ *
+ * - **A payload that violates its own event schema is a bug in the producer.** Nobody receives
+ *   the event, so swallowing it means believing you published something you did not.
+ *   {@link publish} throws. {@link safePublish} returns the error instead, for a caller that
+ *   cannot absorb a throw.
+ * - **A failed broadcast is the world's problem**, and no caller here can retry it, so both
+ *   methods log it. It also happens after the call has returned, which is why neither method can
+ *   report it in a return value.
+ *
+ * @example
+ * ```typescript
+ * // In your DI module
+ * sseRoomEventPublisher: asSingletonClass(SSERoomEventPublisher),
+ *
+ * // In a listener. `requestContext` is passed straight through: the publisher reads its
+ * // logger, so a dropped event carries the correlation id of whatever produced it.
+ * this.publisher.publish(
+ *   ProjectSse.roomResolver(projectId),
+ *   ProjectSse.events.updated,
+ *   payload,
+ *   requestContext,
+ * )
+ * ```
+ */
+export declare class SSERoomEventPublisher {
+    private readonly sseRoomBroadcaster;
+    private readonly logger;
+    constructor({ sseRoomBroadcaster, logger }: SSERoomEventPublisherDependencies);
+    /**
+     * Validate `data` against the event's own schema and broadcast it to `room`, throwing if it
+     * fails.
+     *
+     * Validating here rather than leaving it to delivery is what makes the throw possible at all.
+     * Delivery-time validation runs once per connection, so it reports a mismatch once per open
+     * connection on every node, names the event but not the code that produced it, and does not
+     * run at all when nobody has joined the room. By then the call has long returned and there is
+     * nothing left to throw to.
+     *
+     * What goes on the wire is the parsed value, so a schema default is filled in once here
+     * instead of being left to every client. Delivery-time validation discards its own result and
+     * serializes what it was handed, so calling {@link SSERoomBroadcaster.broadcastToRoom}
+     * directly sends the unparsed input.
+     *
+     * `context` is whatever the caller is acting on behalf of; only its logger is read, so a
+     * request context goes in as-is. Omit it in a caller that has none and the injected logger is
+     * used, which costs a logged failure its correlation id and nothing else.
+     *
+     * @throws {InternalError} if `data` does not satisfy the event's schema.
+     */
+    publish<T extends z.ZodType>(room: string | string[], event: SSEEventDefinition<string, T>, data: z.input<T>, context?: SSELogContext, options?: SSERoomEventPublishOptions): void;
+    /**
+     * {@link publish}, but a payload that fails its schema comes back as an error instead of being
+     * thrown.
+     *
+     * For a producer that cannot absorb a throw: a message handler whose primary work has already
+     * committed would be retried in full and redo it, and the retry cannot succeed anyway, since a
+     * malformed payload fails the same way every time. Prefer {@link publish} everywhere else.
+     *
+     * The failure is logged as well as returned, so a caller that ignores the result still leaves
+     * a trace rather than silence.
+     *
+     * @returns `{ result: true }` once the payload has been validated and handed to the
+     * broadcaster. That is acceptance, not delivery: the fan-out has not happened yet, and its
+     * own failure is logged rather than returned.
+     */
+    safePublish<T extends z.ZodType>(room: string | string[], event: SSEEventDefinition<string, T>, data: z.input<T>, context?: SSELogContext, options?: SSERoomEventPublishOptions): Either<InternalError, true>;
+    /**
+     * The shared tail of both methods. A failed broadcast is logged rather than surfaced: it
+     * happens after the caller has returned, and none of these callers could retry it anyway.
+     */
+    private broadcast;
+}

package/dist/lib/sse/rooms/SSERoomEventPublisher.js

@@ -0,0 +1,119 @@
+import { InternalError } from '@lokalise/node-core';
+/** The same error either way, so a caller switching between the two methods sees one shape. */
+const validationError = (room, event, error) => new InternalError({
+    message: `SSE event validation failed for event "${event}": ${error.message}`,
+    errorCode: 'SSE_EVENT_VALIDATION_FAILED',
+    details: { room: Array.isArray(room) ? room.join(',') : room, event },
+});
+/**
+ * Fire-and-forget broadcasting for domain code: a room event goes out and the caller does not
+ * await the fan-out.
+ *
+ * The typical producer is an event listener or a message handler whose primary work has already
+ * committed. It cannot retry a dropped hint, and awaiting the fan-out would tie its latency to
+ * the number of open connections. Code that needs the delivered count, or that can act on a
+ * delivery failure, should use {@link SSERoomBroadcaster} directly.
+ *
+ * The two ways publishing fails are treated differently, because they are different kinds of
+ * problem:
+ *
+ * - **A payload that violates its own event schema is a bug in the producer.** Nobody receives
+ *   the event, so swallowing it means believing you published something you did not.
+ *   {@link publish} throws. {@link safePublish} returns the error instead, for a caller that
+ *   cannot absorb a throw.
+ * - **A failed broadcast is the world's problem**, and no caller here can retry it, so both
+ *   methods log it. It also happens after the call has returned, which is why neither method can
+ *   report it in a return value.
+ *
+ * @example
+ * ```typescript
+ * // In your DI module
+ * sseRoomEventPublisher: asSingletonClass(SSERoomEventPublisher),
+ *
+ * // In a listener. `requestContext` is passed straight through: the publisher reads its
+ * // logger, so a dropped event carries the correlation id of whatever produced it.
+ * this.publisher.publish(
+ *   ProjectSse.roomResolver(projectId),
+ *   ProjectSse.events.updated,
+ *   payload,
+ *   requestContext,
+ * )
+ * ```
+ */
+export class SSERoomEventPublisher {
+    sseRoomBroadcaster;
+    logger;
+    constructor({ sseRoomBroadcaster, logger }) {
+        this.sseRoomBroadcaster = sseRoomBroadcaster;
+        this.logger = logger;
+    }
+    /**
+     * Validate `data` against the event's own schema and broadcast it to `room`, throwing if it
+     * fails.
+     *
+     * Validating here rather than leaving it to delivery is what makes the throw possible at all.
+     * Delivery-time validation runs once per connection, so it reports a mismatch once per open
+     * connection on every node, names the event but not the code that produced it, and does not
+     * run at all when nobody has joined the room. By then the call has long returned and there is
+     * nothing left to throw to.
+     *
+     * What goes on the wire is the parsed value, so a schema default is filled in once here
+     * instead of being left to every client. Delivery-time validation discards its own result and
+     * serializes what it was handed, so calling {@link SSERoomBroadcaster.broadcastToRoom}
+     * directly sends the unparsed input.
+     *
+     * `context` is whatever the caller is acting on behalf of; only its logger is read, so a
+     * request context goes in as-is. Omit it in a caller that has none and the injected logger is
+     * used, which costs a logged failure its correlation id and nothing else.
+     *
+     * @throws {InternalError} if `data` does not satisfy the event's schema.
+     */
+    publish(room, event, data, context, options) {
+        const validation = event.schema.safeParse(data);
+        if (!validation.success) {
+            throw validationError(room, event.event, validation.error);
+        }
+        this.broadcast(room, event, validation.data, context, options);
+    }
+    /**
+     * {@link publish}, but a payload that fails its schema comes back as an error instead of being
+     * thrown.
+     *
+     * For a producer that cannot absorb a throw: a message handler whose primary work has already
+     * committed would be retried in full and redo it, and the retry cannot succeed anyway, since a
+     * malformed payload fails the same way every time. Prefer {@link publish} everywhere else.
+     *
+     * The failure is logged as well as returned, so a caller that ignores the result still leaves
+     * a trace rather than silence.
+     *
+     * @returns `{ result: true }` once the payload has been validated and handed to the
+     * broadcaster. That is acceptance, not delivery: the fan-out has not happened yet, and its
+     * own failure is logged rather than returned.
+     */
+    safePublish(room, event, data, context, options) {
+        const validation = event.schema.safeParse(data);
+        if (!validation.success) {
+            const logger = context?.logger ?? this.logger;
+            logger.error({ room, event: event.event, issues: validation.error.issues }, 'Refusing to broadcast an SSE event that fails its own schema');
+            return { error: validationError(room, event.event, validation.error) };
+        }
+        this.broadcast(room, event, validation.data, context, options);
+        return { result: true };
+    }
+    /**
+     * The shared tail of both methods. A failed broadcast is logged rather than surfaced: it
+     * happens after the caller has returned, and none of these callers could retry it anyway.
+     */
+    broadcast(room, event, 
+    // Already schema-valid, so the re-parse at delivery accepts it. The cast below is only
+    // needed because `z.output` is not `z.input` for a schema that defaults or transforms.
+    parsed, context, options) {
+        const logger = context?.logger ?? this.logger;
+        this.sseRoomBroadcaster
+            .broadcastToRoom(room, event, parsed, options)
+            .catch((error) => {
+            logger.error({ error, room, event: event.event }, 'Failed to broadcast SSE event');
+        });
+    }
+}
+//# sourceMappingURL=SSERoomEventPublisher.js.map

package/dist/lib/sse/rooms/SSERoomEventPublisher.js.map

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

package/dist/lib/sse/rooms/index.d.ts

@@ -1,5 +1,6 @@
 export { InMemoryAdapter } from './adapters/InMemoryAdapter.js';
 export { defineRoom } from './defineRoom.js';
 export { SSERoomBroadcaster } from './SSERoomBroadcaster.js';
+export { type SSELogContext, SSERoomEventPublisher, type SSERoomEventPublisherDependencies, type SSERoomEventPublishOptions, } from './SSERoomEventPublisher.js';
 export { SSERoomManager } from './SSERoomManager.js';
 export type { PreDeliveryFilter, RoomBroadcastOptions, RoomNameResolver, SSERoomAdapter, SSERoomManagerConfig, SSERoomMessageHandler, SSERoomOperations, } from './types.js';

package/dist/lib/sse/rooms/index.js

@@ -3,5 +3,6 @@
 export { InMemoryAdapter } from './adapters/InMemoryAdapter.js';
 export { defineRoom } from './defineRoom.js';
 export { SSERoomBroadcaster } from './SSERoomBroadcaster.js';
+export { SSERoomEventPublisher, } from './SSERoomEventPublisher.js';
 export { SSERoomManager } from './SSERoomManager.js';
 //# sourceMappingURL=index.js.map

package/dist/lib/sse/rooms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../lib/sse/rooms/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AAEpB,WAAW;AACX,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../lib/sse/rooms/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AAEpB,WAAW;AACX,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAEL,qBAAqB,GAGtB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opinionated-machine",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "description": "Very opinionated DI framework for fastify, built on top of awilix ",
   "type": "module",
   "license": "MIT",
@@ -48,13 +48,13 @@
     "@types/node": "^22.19.7",
     "@vitest/coverage-v8": "^4.1.11",
     "awilix": "^13.0.0",
-    "awilix-manager": "^7.0.0",
-    "fastify": "^5.7.4",
+    "awilix-manager": "^7.0.1",
+    "fastify": "^5.12.4",
     "fastify-type-provider-zod": "^7.0.0",
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "zod": "^4.5.4",
+    "zod": "^4.6.2",
     "@opinionated-machine/sse-fallback": "0.1.1"
   },
   "private": false,