@rotorsoft/act-http 0.1.0

package/dist/@types/sse/presence.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Generic presence tracker — ref-counted online status per stream per identity.
+ *
+ * Supports multi-tab: each subscribe increments the ref count, each
+ * unsubscribe decrements it. An identity is considered online when
+ * ref count > 0.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const presence = new PresenceTracker();
+ *
+ * // On SSE connect:
+ * presence.add(gameId, playerId);
+ *
+ * // On SSE disconnect:
+ * presence.remove(gameId, playerId);
+ *
+ * // Query:
+ * presence.getOnline(gameId); // Set<string>
+ * ```
+ */
+export declare class PresenceTracker {
+    private streams;
+    /** Increment ref count for an identity on a stream. */
+    add(streamId: string, identityId: string): void;
+    /** Decrement ref count. Removes the identity when count reaches 0. */
+    remove(streamId: string, identityId: string): void;
+    /** Get the set of online identity IDs for a stream. */
+    getOnline(streamId: string): Set<string>;
+    /** Check if a specific identity is online for a stream. */
+    isOnline(streamId: string, identityId: string): boolean;
+}
+//# sourceMappingURL=presence.d.ts.map

package/dist/@types/sse/presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../../../src/sse/presence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAA0C;IAEzD,uDAAuD;IACvD,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAM/C,sEAAsE;IACtE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IASlD,uDAAuD;IACvD,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAKxC,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;CAGxD"}

package/dist/@types/sse/state-cache.d.ts

@@ -0,0 +1,29 @@
+import type { BroadcastState } from "./types.js";
+/**
+ * Generic LRU cache for aggregate state objects.
+ *
+ * Keyed by stream ID. Each entry stores the full state (with `_v` from the
+ * event store). Used as the "previous state" baseline for computing patches,
+ * and as the fast path for reconnects.
+ *
+ * The cache is shared between the broadcast hot path and read queries.
+ * Projections should maintain their own cache to avoid double-apply bugs.
+ */
+export declare class StateCache<S extends BroadcastState = BroadcastState> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    /** Get a cached state, promoting it to MRU position. */
+    get(key: string): S | undefined;
+    /** Set a cached state, evicting the LRU entry if at capacity. */
+    set(key: string, state: S): void;
+    /** Remove a cached entry. */
+    delete(key: string): void;
+    /** Check if a key exists in the cache. */
+    has(key: string): boolean;
+    /** Current number of cached entries. */
+    get size(): number;
+    /** Direct access to the underlying map (for iteration). */
+    entries(): IterableIterator<[string, S]>;
+}
+//# sourceMappingURL=state-cache.d.ts.map

package/dist/@types/sse/state-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-cache.d.ts","sourceRoot":"","sources":["../../../src/sse/state-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;GASG;AACH,qBAAa,UAAU,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc;IAC/D,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,SAAK;IAIxB,wDAAwD;IACxD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAS/B,iEAAiE;IACjE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAQhC,6BAA6B;IAC7B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,0CAA0C;IAC1C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,wCAAwC;IACxC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,2DAA2D;IAC3D,OAAO,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAGzC"}

package/dist/@types/sse/types.d.ts

@@ -0,0 +1,20 @@
+import type { DeepPartial } from "@rotorsoft/act-patch";
+/**
+ * Base constraint for state objects managed by the broadcast system.
+ * Apps extend this with their own domain state shape.
+ */
+export type BroadcastState = Record<string, unknown> & {
+    /** Event store stream version — set by the broadcast layer from snap.event.version */
+    _v: number;
+};
+/**
+ * SSE message: version-keyed domain patches.
+ * Keys are stringified version numbers, values are domain patches (deep partials).
+ * Multi-event commits produce multiple version-keyed entries.
+ */
+export type PatchMessage<S extends BroadcastState = BroadcastState> = Record<number, DeepPartial<S>>;
+/**
+ * Subscriber callback — receives version-keyed patch messages.
+ */
+export type Subscriber<S extends BroadcastState = BroadcastState> = (msg: PatchMessage<S>) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/@types/sse/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sse/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACrD,sFAAsF;IACtF,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,MAAM,CAC1E,MAAM,EACN,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,CAClE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,KACjB,IAAI,CAAC"}

package/dist/@types/webhook/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @packageDocumentation
+ * @module act-http/webhook
+ *
+ * Reaction-handler sugar for POSTing committed events to external URLs.
+ *
+ * Wraps `fetch` with timeouts, automatic `Idempotency-Key` derivation, and
+ * status-classified errors. Designed to be composed with the reaction
+ * options shipped in ACT-601 (`maxRetries`, `blockOnError`, `backoff`):
+ *
+ * ```ts
+ * import { webhook } from "@rotorsoft/act-http/webhook";
+ *
+ * .on("OrderConfirmed")
+ *   .do(
+ *     webhook({
+ *       url: "https://api.example.com/webhooks/orders",
+ *       headers: (e) => ({ Authorization: "Bearer ..." }),
+ *       body: (e) => ({ orderId: e.stream, total: e.data.total }),
+ *       timeoutMs: 5_000,
+ *     }),
+ *     { maxRetries: 5, backoff: { strategy: "exponential", baseMs: 200, maxMs: 30_000 } }
+ *   )
+ *   .to(resolver);
+ * ```
+ */
+import type { ReactionHandler, Schemas } from "@rotorsoft/act";
+import { type WebhookConfig } from "./types.js";
+export type { WebhookConfig, WebhookResolver } from "./types.js";
+export { WebhookError } from "./types.js";
+/**
+ * Build a reaction handler that POSTs each event to an external URL.
+ *
+ * Behavior:
+ *
+ * - Network errors and timeouts throw {@link WebhookError} with
+ *   `status: 0`, `retryable: true`.
+ * - 5xx responses throw with `retryable: true`.
+ * - 4xx responses throw with `retryable: false`.
+ * - 2xx and 3xx return successfully.
+ *
+ * Drain retry behavior follows the reaction's `maxRetries` / `backoff`
+ * options. To skip retries entirely for client errors, set
+ * `maxRetries: 0` on the reaction — both 4xx and 5xx will block on the
+ * first failed attempt.
+ */
+export declare function webhook<TEvents extends Schemas = Schemas>(config: WebhookConfig<TEvents>): ReactionHandler<TEvents, keyof TEvents>;
+//# sourceMappingURL=index.d.ts.map

package/dist/@types/webhook/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webhook/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAa,eAAe,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,KAAK,aAAa,EAAgB,MAAM,YAAY,CAAC;AAE9D,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAsB1C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,OAAO,SAAS,OAAO,GAAG,OAAO,EACvD,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B,eAAe,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,CAqEzC"}

package/dist/@types/webhook/types.d.ts

@@ -0,0 +1,82 @@
+import type { Committed, Schemas } from "@rotorsoft/act";
+/**
+ * Function or static value resolver. Used so callers can pass either a
+ * constant or a per-event function for headers / body / url.
+ *
+ * The static side `T` is constrained to non-function types so that a
+ * passed `(event) => ...` is unambiguously typed as the function variant.
+ */
+export type WebhookResolver<TEvents extends Schemas, T> = T | ((event: Committed<TEvents, keyof TEvents>) => T);
+/**
+ * Plain-data body shape the helper accepts as a static value. Functions
+ * are deliberately excluded so the union with the resolver function is
+ * unambiguous at the call site (TypeScript can discriminate by shape).
+ */
+export type WebhookBody = string | {
+    readonly [k: string]: unknown;
+} | readonly unknown[];
+/**
+ * Configuration for {@link webhook}.
+ *
+ * @template TEvents - Event schemas; resolvers receive the typed committed event.
+ */
+export type WebhookConfig<TEvents extends Schemas = Schemas> = {
+    /** Target URL — static string or per-event function. */
+    readonly url: WebhookResolver<TEvents, string>;
+    /** HTTP method. Defaults to `"POST"`. */
+    readonly method?: "POST" | "PUT" | "PATCH" | "DELETE";
+    /**
+     * Headers to send. Resolver may return a record per event. The
+     * `Content-Type: application/json` and `Idempotency-Key` headers are
+     * applied automatically; both can be overridden by returning a header
+     * with the same name (case-insensitive).
+     */
+    readonly headers?: WebhookResolver<TEvents, Record<string, string>>;
+    /**
+     * Request body. Static plain data (object, array, string) or a
+     * per-event function returning the same. Strings are sent as-is;
+     * anything else is JSON-serialized. Defaults to the committed event
+     * itself.
+     */
+    readonly body?: WebhookBody | ((event: Committed<TEvents, keyof TEvents>) => WebhookBody);
+    /**
+     * Per-request timeout in milliseconds. Defaults to 5000.
+     * The handler throws after the timeout via `AbortController`.
+     */
+    readonly timeoutMs?: number;
+    /**
+     * Override for the auto-generated `Idempotency-Key`. By default, the
+     * helper sends `event.id` (the immutable, monotonic event identifier).
+     * Return a string to override; return `null` to skip the header entirely.
+     */
+    readonly idempotencyKey?: (event: Committed<TEvents, keyof TEvents>) => string | null;
+    /**
+     * Injection point for tests. Defaults to global `fetch`.
+     */
+    readonly fetch?: typeof fetch;
+};
+/**
+ * Error thrown by the webhook handler on network failure, timeout, or
+ * non-2xx response. The `status` field is `0` for network / timeout
+ * errors and the HTTP status code otherwise.
+ *
+ * `retryable` reflects the helper's classification: network errors,
+ * timeouts, and 5xx are flagged retryable; 4xx is not. The current drain
+ * pipeline does not distinguish — both are caught and counted against
+ * `maxRetries`. Callers who want different retry semantics per category
+ * can introspect the error in a wrapping handler or tune `maxRetries` /
+ * `backoff` on the reaction options.
+ */
+export declare class WebhookError extends Error {
+    readonly status: number;
+    readonly retryable: boolean;
+    readonly url: string;
+    readonly responseBody?: string;
+    constructor(message: string, init: {
+        status: number;
+        retryable: boolean;
+        url: string;
+        responseBody?: string;
+    });
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/@types/webhook/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/webhook/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzD;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,CAAC,OAAO,SAAS,OAAO,EAAE,CAAC,IAClD,CAAC,GACD,CAAC,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,MAAM,GACN;IAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GACjC,SAAS,OAAO,EAAE,CAAC;AAEvB;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,OAAO,SAAS,OAAO,GAAG,OAAO,IAAI;IAC7D,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/C,yCAAyC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACtD;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpE;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EACV,WAAW,GACX,CAAC,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,KAAK,WAAW,CAAC,CAAC;IAChE;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CACxB,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,KACrC,MAAM,GAAG,IAAI,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;gBAG7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;QACJ,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,OAAO,CAAC;QACnB,GAAG,EAAE,MAAM,CAAC;QACZ,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;CASJ"}

package/dist/sse/index.cjs

@@ -0,0 +1,204 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sse/index.ts
+var sse_exports = {};
+__export(sse_exports, {
+  BroadcastChannel: () => BroadcastChannel,
+  PresenceTracker: () => PresenceTracker,
+  StateCache: () => StateCache,
+  applyPatchMessage: () => applyPatchMessage,
+  patch: () => import_act_patch3.patch
+});
+module.exports = __toCommonJS(sse_exports);
+var import_act_patch3 = require("@rotorsoft/act-patch");
+
+// src/sse/apply-patch.ts
+var import_act_patch = require("@rotorsoft/act-patch");
+function applyPatchMessage(msg, cached) {
+  const cachedV = cached?._v ?? 0;
+  const versions = Object.keys(msg).map(Number).sort((a, b) => a - b);
+  if (!versions.length) return { ok: false, reason: "stale" };
+  const minV = versions[0];
+  const maxV = versions[versions.length - 1];
+  if (maxV <= cachedV) return { ok: false, reason: "stale" };
+  if (!cached || minV > cachedV + 1) return { ok: false, reason: "behind" };
+  let state = cached;
+  for (const v of versions) {
+    if (v <= cachedV) continue;
+    state = { ...(0, import_act_patch.patch)(state, msg[v]), _v: v };
+  }
+  return { ok: true, state };
+}
+
+// src/sse/broadcast.ts
+var import_act_patch2 = require("@rotorsoft/act-patch");
+
+// src/sse/state-cache.ts
+var StateCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 50) {
+    this.maxSize = maxSize;
+  }
+  /** Get a cached state, promoting it to MRU position. */
+  get(key) {
+    const s = this.cache.get(key);
+    if (s) {
+      this.cache.delete(key);
+      this.cache.set(key, s);
+    }
+    return s;
+  }
+  /** Set a cached state, evicting the LRU entry if at capacity. */
+  set(key, state) {
+    this.cache.delete(key);
+    this.cache.set(key, state);
+    if (this.cache.size > this.maxSize) {
+      this.cache.delete(this.cache.keys().next().value);
+    }
+  }
+  /** Remove a cached entry. */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /** Check if a key exists in the cache. */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /** Current number of cached entries. */
+  get size() {
+    return this.cache.size;
+  }
+  /** Direct access to the underlying map (for iteration). */
+  entries() {
+    return this.cache.entries();
+  }
+};
+
+// src/sse/broadcast.ts
+var BroadcastChannel = class {
+  channels = /* @__PURE__ */ new Map();
+  stateCache;
+  constructor(options) {
+    this.stateCache = new StateCache(options?.cacheSize ?? 50);
+  }
+  /**
+   * Publish domain patches from a commit.
+   * patches[i] corresponds to version baseV + i + 1.
+   *
+   * @param streamId - The event store stream ID
+   * @param state - Full state with `_v` set from `snap.event.version`
+   * @param patches - Array of domain patches, one per emitted event
+   */
+  publish(streamId, state, patches = []) {
+    this.stateCache.set(streamId, state);
+    const baseV = state._v - patches.length;
+    const msg = {};
+    patches.forEach((p, i) => {
+      msg[baseV + i + 1] = p;
+    });
+    const subs = this.channels.get(streamId);
+    if (subs?.size) {
+      for (const cb of subs) cb(msg);
+    }
+    return msg;
+  }
+  /**
+   * Publish a state update that doesn't change the event version
+   * (e.g. presence overlay, computed field refresh).
+   * Uses the same version as the cached state, single entry.
+   */
+  publishOverlay(streamId, overlayPatch) {
+    const prev = this.stateCache.get(streamId);
+    if (!prev) return void 0;
+    const state = (0, import_act_patch2.patch)(prev, overlayPatch);
+    this.stateCache.set(streamId, state);
+    const msg = { [state._v]: overlayPatch };
+    const subs = this.channels.get(streamId);
+    if (subs?.size) {
+      for (const cb of subs) cb(msg);
+    }
+    return msg;
+  }
+  /**
+   * Subscribe to broadcast messages for a stream.
+   * Returns a cleanup function that removes the subscription.
+   */
+  subscribe(streamId, cb) {
+    if (!this.channels.has(streamId)) this.channels.set(streamId, /* @__PURE__ */ new Set());
+    this.channels.get(streamId).add(cb);
+    return () => {
+      this.channels.get(streamId)?.delete(cb);
+      if (this.channels.get(streamId)?.size === 0) {
+        this.channels.delete(streamId);
+      }
+    };
+  }
+  /** Get the number of subscribers for a stream. */
+  getSubscriberCount(streamId) {
+    return this.channels.get(streamId)?.size ?? 0;
+  }
+  /** Get the cached state for a stream (for reconnects / initial SSE yield). */
+  getState(streamId) {
+    return this.stateCache.get(streamId);
+  }
+  /** Direct access to the state cache (for app-specific reads like presence). */
+  get cache() {
+    return this.stateCache;
+  }
+};
+
+// src/sse/presence.ts
+var PresenceTracker = class {
+  streams = /* @__PURE__ */ new Map();
+  /** Increment ref count for an identity on a stream. */
+  add(streamId, identityId) {
+    if (!this.streams.has(streamId)) this.streams.set(streamId, /* @__PURE__ */ new Map());
+    const counts = this.streams.get(streamId);
+    counts.set(identityId, (counts.get(identityId) ?? 0) + 1);
+  }
+  /** Decrement ref count. Removes the identity when count reaches 0. */
+  remove(streamId, identityId) {
+    const counts = this.streams.get(streamId);
+    if (!counts) return;
+    const n = (counts.get(identityId) ?? 1) - 1;
+    if (n <= 0) counts.delete(identityId);
+    else counts.set(identityId, n);
+    if (counts.size === 0) this.streams.delete(streamId);
+  }
+  /** Get the set of online identity IDs for a stream. */
+  getOnline(streamId) {
+    const counts = this.streams.get(streamId);
+    return counts ? new Set(counts.keys()) : /* @__PURE__ */ new Set();
+  }
+  /** Check if a specific identity is online for a stream. */
+  isOnline(streamId, identityId) {
+    return (this.streams.get(streamId)?.get(identityId) ?? 0) > 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BroadcastChannel,
+  PresenceTracker,
+  StateCache,
+  applyPatchMessage,
+  patch
+});
+//# sourceMappingURL=index.cjs.map

package/dist/sse/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/sse/index.ts","../../src/sse/apply-patch.ts","../../src/sse/broadcast.ts","../../src/sse/state-cache.ts","../../src/sse/presence.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * @module act-http/sse\n *\n * Incremental state broadcast over SSE for act event-sourced apps.\n *\n * Server-side broadcast with domain patch forwarding, an LRU state cache,\n * presence tracking, and a client-side patch applicator with version\n * validation and resync detection.\n *\n * ## Architecture\n *\n * ```\n *   app.do() → snapshots (each carries its domain patch)\n *       │\n *       ▼\n *   deriveState(snap)          ← app-specific (overlay presence, deadlines, etc.)\n *   state._v = snap.event.version\n *       │\n *       ▼\n *   broadcast.publish(streamId, state, patches)\n *       │\n *       ├── version-key each patch: { [baseV+1]: patch1, [baseV+2]: patch2 }\n *       └── push to all SSE subscribers\n *       │\n *       ▼\n *   Client: applyPatchMessage(msg, cached)\n *       │\n *       ├── contiguous → deep-merge patches in version order\n *       ├── stale    → skip (client already ahead)\n *       └── behind   → resync (client missed versions)\n * ```\n *\n * ## Version Contract\n *\n * `_v` is always the event store stream version (`snap.event.version`).\n * No separate version counters. The event store is the single source of truth.\n */\n\nexport { patch } from \"@rotorsoft/act-patch\";\nexport type { ApplyResult } from \"./apply-patch.js\";\nexport { applyPatchMessage } from \"./apply-patch.js\";\nexport { BroadcastChannel } from \"./broadcast.js\";\nexport { PresenceTracker } from \"./presence.js\";\nexport { StateCache } from \"./state-cache.js\";\nexport type { BroadcastState, PatchMessage, Subscriber } from \"./types.js\";\n","import { patch as deepMerge } from \"@rotorsoft/act-patch\";\nimport type { BroadcastState, PatchMessage } from \"./types.js\";\n\n/**\n * Result of applying a patch message to cached client state.\n */\nexport type ApplyResult<S extends BroadcastState = BroadcastState> =\n  | { ok: true; state: S }\n  | { ok: false; reason: \"stale\" | \"behind\" };\n\n/**\n * Apply a version-keyed patch message to the client's cached state.\n *\n * ## Version logic\n *\n * - All patches older than cached → \"stale\" (client already ahead)\n * - Gap between cached version and first patch → \"behind\" (client missed versions, must resync)\n * - Contiguous from cached version → apply in order\n *\n * ## Usage (React Query)\n *\n * ```typescript\n * onData: (msg) => {\n *   const cached = utils.getState.getData({ streamId });\n *   const result = applyPatchMessage(msg, cached);\n *   if (result.ok) {\n *     utils.getState.setData({ streamId }, result.state);\n *   } else if (result.reason === \"behind\") {\n *     utils.getState.invalidate({ streamId }); // trigger full refetch\n *   }\n *   // \"stale\" → no-op, client already has newer state\n * }\n * ```\n */\nexport function applyPatchMessage<S extends BroadcastState>(\n  msg: PatchMessage<S>,\n  cached: S | null | undefined\n): ApplyResult<S> {\n  const cachedV = cached?._v ?? 0;\n  const versions = Object.keys(msg)\n    .map(Number)\n    .sort((a, b) => a - b);\n\n  if (!versions.length) return { ok: false, reason: \"stale\" };\n\n  const minV = versions[0];\n  const maxV = versions[versions.length - 1];\n\n  if (maxV <= cachedV) return { ok: false, reason: \"stale\" };\n  if (!cached || minV > cachedV + 1) return { ok: false, reason: \"behind\" };\n\n  let state = cached;\n  for (const v of versions) {\n    if (v <= cachedV) continue;\n    state = { ...deepMerge(state, msg[v]), _v: v } as S;\n  }\n  return { ok: true, state };\n}\n","import { patch as applyPatch } from \"@rotorsoft/act-patch\";\nimport { StateCache } from \"./state-cache.js\";\nimport type { BroadcastState, PatchMessage, Subscriber } from \"./types.js\";\n\n/**\n * Server-side broadcast channel for incremental state sync over SSE.\n *\n * Manages per-stream subscriber sets and an LRU state cache. When state\n * changes, forwards domain patches (from event handlers) to all subscribers\n * as version-keyed messages.\n *\n * ## Usage\n *\n * ```typescript\n * const broadcast = new BroadcastChannel<MyState>();\n *\n * // After every app.do():\n * const snaps = await app.do(...);\n * const patches = snaps.map(s => s.patch).filter(Boolean);\n * const state = deriveState(snaps.at(-1));\n * broadcast.publish(streamId, state, patches);\n *\n * // In SSE subscription:\n * const cleanup = broadcast.subscribe(streamId, (msg) => {\n *   pending = msg;\n *   resolve?.();\n * });\n *\n * // Initial state for reconnects:\n * const cached = broadcast.getState(streamId);\n * ```\n *\n * ## Version Contract\n *\n * The `_v` field on state MUST be set from `snap.event.version` (the event\n * store's monotonic stream version) BEFORE calling `publish()`. This is the\n * single source of truth for ordering — no separate version counters.\n */\nexport class BroadcastChannel<S extends BroadcastState = BroadcastState> {\n  private channels = new Map<string, Set<Subscriber<S>>>();\n  private stateCache: StateCache<S>;\n\n  constructor(options?: { cacheSize?: number }) {\n    this.stateCache = new StateCache<S>(options?.cacheSize ?? 50);\n  }\n\n  /**\n   * Publish domain patches from a commit.\n   * patches[i] corresponds to version baseV + i + 1.\n   *\n   * @param streamId - The event store stream ID\n   * @param state - Full state with `_v` set from `snap.event.version`\n   * @param patches - Array of domain patches, one per emitted event\n   */\n  publish(\n    streamId: string,\n    state: S,\n    patches: Partial<S>[] = []\n  ): PatchMessage<S> {\n    this.stateCache.set(streamId, state);\n\n    const baseV = state._v - patches.length;\n    const msg: PatchMessage<S> = {};\n    patches.forEach((p, i) => {\n      msg[baseV + i + 1] = p;\n    });\n\n    const subs = this.channels.get(streamId);\n    if (subs?.size) {\n      for (const cb of subs) cb(msg);\n    }\n    return msg;\n  }\n\n  /**\n   * Publish a state update that doesn't change the event version\n   * (e.g. presence overlay, computed field refresh).\n   * Uses the same version as the cached state, single entry.\n   */\n  publishOverlay(\n    streamId: string,\n    overlayPatch: Partial<S>\n  ): PatchMessage<S> | undefined {\n    const prev = this.stateCache.get(streamId);\n    if (!prev) return undefined;\n\n    const state = applyPatch(prev, overlayPatch) as S;\n    this.stateCache.set(streamId, state);\n\n    const msg: PatchMessage<S> = { [state._v]: overlayPatch };\n    const subs = this.channels.get(streamId);\n    if (subs?.size) {\n      for (const cb of subs) cb(msg);\n    }\n    return msg;\n  }\n\n  /**\n   * Subscribe to broadcast messages for a stream.\n   * Returns a cleanup function that removes the subscription.\n   */\n  subscribe(streamId: string, cb: Subscriber<S>): () => void {\n    if (!this.channels.has(streamId)) this.channels.set(streamId, new Set());\n    this.channels.get(streamId)!.add(cb);\n    return () => {\n      this.channels.get(streamId)?.delete(cb);\n      if (this.channels.get(streamId)?.size === 0) {\n        this.channels.delete(streamId);\n      }\n    };\n  }\n\n  /** Get the number of subscribers for a stream. */\n  getSubscriberCount(streamId: string): number {\n    return this.channels.get(streamId)?.size ?? 0;\n  }\n\n  /** Get the cached state for a stream (for reconnects / initial SSE yield). */\n  getState(streamId: string): S | undefined {\n    return this.stateCache.get(streamId);\n  }\n\n  /** Direct access to the state cache (for app-specific reads like presence). */\n  get cache(): StateCache<S> {\n    return this.stateCache;\n  }\n}\n","import type { BroadcastState } from \"./types.js\";\n\n/**\n * Generic LRU cache for aggregate state objects.\n *\n * Keyed by stream ID. Each entry stores the full state (with `_v` from the\n * event store). Used as the \"previous state\" baseline for computing patches,\n * and as the fast path for reconnects.\n *\n * The cache is shared between the broadcast hot path and read queries.\n * Projections should maintain their own cache to avoid double-apply bugs.\n */\nexport class StateCache<S extends BroadcastState = BroadcastState> {\n  private cache = new Map<string, S>();\n  private maxSize: number;\n\n  constructor(maxSize = 50) {\n    this.maxSize = maxSize;\n  }\n\n  /** Get a cached state, promoting it to MRU position. */\n  get(key: string): S | undefined {\n    const s = this.cache.get(key);\n    if (s) {\n      this.cache.delete(key);\n      this.cache.set(key, s);\n    }\n    return s;\n  }\n\n  /** Set a cached state, evicting the LRU entry if at capacity. */\n  set(key: string, state: S): void {\n    this.cache.delete(key);\n    this.cache.set(key, state);\n    if (this.cache.size > this.maxSize) {\n      this.cache.delete(this.cache.keys().next().value!);\n    }\n  }\n\n  /** Remove a cached entry. */\n  delete(key: string): void {\n    this.cache.delete(key);\n  }\n\n  /** Check if a key exists in the cache. */\n  has(key: string): boolean {\n    return this.cache.has(key);\n  }\n\n  /** Current number of cached entries. */\n  get size(): number {\n    return this.cache.size;\n  }\n\n  /** Direct access to the underlying map (for iteration). */\n  entries(): IterableIterator<[string, S]> {\n    return this.cache.entries();\n  }\n}\n","/**\n * Generic presence tracker — ref-counted online status per stream per identity.\n *\n * Supports multi-tab: each subscribe increments the ref count, each\n * unsubscribe decrements it. An identity is considered online when\n * ref count > 0.\n *\n * ## Usage\n *\n * ```typescript\n * const presence = new PresenceTracker();\n *\n * // On SSE connect:\n * presence.add(gameId, playerId);\n *\n * // On SSE disconnect:\n * presence.remove(gameId, playerId);\n *\n * // Query:\n * presence.getOnline(gameId); // Set<string>\n * ```\n */\nexport class PresenceTracker {\n  private streams = new Map<string, Map<string, number>>();\n\n  /** Increment ref count for an identity on a stream. */\n  add(streamId: string, identityId: string): void {\n    if (!this.streams.has(streamId)) this.streams.set(streamId, new Map());\n    const counts = this.streams.get(streamId)!;\n    counts.set(identityId, (counts.get(identityId) ?? 0) + 1);\n  }\n\n  /** Decrement ref count. Removes the identity when count reaches 0. */\n  remove(streamId: string, identityId: string): void {\n    const counts = this.streams.get(streamId);\n    if (!counts) return;\n    const n = (counts.get(identityId) ?? 1) - 1;\n    if (n <= 0) counts.delete(identityId);\n    else counts.set(identityId, n);\n    if (counts.size === 0) this.streams.delete(streamId);\n  }\n\n  /** Get the set of online identity IDs for a stream. */\n  getOnline(streamId: string): Set<string> {\n    const counts = this.streams.get(streamId);\n    return counts ? new Set(counts.keys()) : new Set();\n  }\n\n  /** Check if a specific identity is online for a stream. */\n  isOnline(streamId: string, identityId: string): boolean {\n    return (this.streams.get(streamId)?.get(identityId) ?? 0) > 0;\n  }\n}\n"],"mappings":"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","names":["import_act_patch","deepMerge","import_act_patch","applyPatch"]}

package/dist/sse/index.js

@@ -0,0 +1,175 @@
+// src/sse/index.ts
+import { patch } from "@rotorsoft/act-patch";
+
+// src/sse/apply-patch.ts
+import { patch as deepMerge } from "@rotorsoft/act-patch";
+function applyPatchMessage(msg, cached) {
+  const cachedV = cached?._v ?? 0;
+  const versions = Object.keys(msg).map(Number).sort((a, b) => a - b);
+  if (!versions.length) return { ok: false, reason: "stale" };
+  const minV = versions[0];
+  const maxV = versions[versions.length - 1];
+  if (maxV <= cachedV) return { ok: false, reason: "stale" };
+  if (!cached || minV > cachedV + 1) return { ok: false, reason: "behind" };
+  let state = cached;
+  for (const v of versions) {
+    if (v <= cachedV) continue;
+    state = { ...deepMerge(state, msg[v]), _v: v };
+  }
+  return { ok: true, state };
+}
+
+// src/sse/broadcast.ts
+import { patch as applyPatch } from "@rotorsoft/act-patch";
+
+// src/sse/state-cache.ts
+var StateCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 50) {
+    this.maxSize = maxSize;
+  }
+  /** Get a cached state, promoting it to MRU position. */
+  get(key) {
+    const s = this.cache.get(key);
+    if (s) {
+      this.cache.delete(key);
+      this.cache.set(key, s);
+    }
+    return s;
+  }
+  /** Set a cached state, evicting the LRU entry if at capacity. */
+  set(key, state) {
+    this.cache.delete(key);
+    this.cache.set(key, state);
+    if (this.cache.size > this.maxSize) {
+      this.cache.delete(this.cache.keys().next().value);
+    }
+  }
+  /** Remove a cached entry. */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /** Check if a key exists in the cache. */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /** Current number of cached entries. */
+  get size() {
+    return this.cache.size;
+  }
+  /** Direct access to the underlying map (for iteration). */
+  entries() {
+    return this.cache.entries();
+  }
+};
+
+// src/sse/broadcast.ts
+var BroadcastChannel = class {
+  channels = /* @__PURE__ */ new Map();
+  stateCache;
+  constructor(options) {
+    this.stateCache = new StateCache(options?.cacheSize ?? 50);
+  }
+  /**
+   * Publish domain patches from a commit.
+   * patches[i] corresponds to version baseV + i + 1.
+   *
+   * @param streamId - The event store stream ID
+   * @param state - Full state with `_v` set from `snap.event.version`
+   * @param patches - Array of domain patches, one per emitted event
+   */
+  publish(streamId, state, patches = []) {
+    this.stateCache.set(streamId, state);
+    const baseV = state._v - patches.length;
+    const msg = {};
+    patches.forEach((p, i) => {
+      msg[baseV + i + 1] = p;
+    });
+    const subs = this.channels.get(streamId);
+    if (subs?.size) {
+      for (const cb of subs) cb(msg);
+    }
+    return msg;
+  }
+  /**
+   * Publish a state update that doesn't change the event version
+   * (e.g. presence overlay, computed field refresh).
+   * Uses the same version as the cached state, single entry.
+   */
+  publishOverlay(streamId, overlayPatch) {
+    const prev = this.stateCache.get(streamId);
+    if (!prev) return void 0;
+    const state = applyPatch(prev, overlayPatch);
+    this.stateCache.set(streamId, state);
+    const msg = { [state._v]: overlayPatch };
+    const subs = this.channels.get(streamId);
+    if (subs?.size) {
+      for (const cb of subs) cb(msg);
+    }
+    return msg;
+  }
+  /**
+   * Subscribe to broadcast messages for a stream.
+   * Returns a cleanup function that removes the subscription.
+   */
+  subscribe(streamId, cb) {
+    if (!this.channels.has(streamId)) this.channels.set(streamId, /* @__PURE__ */ new Set());
+    this.channels.get(streamId).add(cb);
+    return () => {
+      this.channels.get(streamId)?.delete(cb);
+      if (this.channels.get(streamId)?.size === 0) {
+        this.channels.delete(streamId);
+      }
+    };
+  }
+  /** Get the number of subscribers for a stream. */
+  getSubscriberCount(streamId) {
+    return this.channels.get(streamId)?.size ?? 0;
+  }
+  /** Get the cached state for a stream (for reconnects / initial SSE yield). */
+  getState(streamId) {
+    return this.stateCache.get(streamId);
+  }
+  /** Direct access to the state cache (for app-specific reads like presence). */
+  get cache() {
+    return this.stateCache;
+  }
+};
+
+// src/sse/presence.ts
+var PresenceTracker = class {
+  streams = /* @__PURE__ */ new Map();
+  /** Increment ref count for an identity on a stream. */
+  add(streamId, identityId) {
+    if (!this.streams.has(streamId)) this.streams.set(streamId, /* @__PURE__ */ new Map());
+    const counts = this.streams.get(streamId);
+    counts.set(identityId, (counts.get(identityId) ?? 0) + 1);
+  }
+  /** Decrement ref count. Removes the identity when count reaches 0. */
+  remove(streamId, identityId) {
+    const counts = this.streams.get(streamId);
+    if (!counts) return;
+    const n = (counts.get(identityId) ?? 1) - 1;
+    if (n <= 0) counts.delete(identityId);
+    else counts.set(identityId, n);
+    if (counts.size === 0) this.streams.delete(streamId);
+  }
+  /** Get the set of online identity IDs for a stream. */
+  getOnline(streamId) {
+    const counts = this.streams.get(streamId);
+    return counts ? new Set(counts.keys()) : /* @__PURE__ */ new Set();
+  }
+  /** Check if a specific identity is online for a stream. */
+  isOnline(streamId, identityId) {
+    return (this.streams.get(streamId)?.get(identityId) ?? 0) > 0;
+  }
+};
+export {
+  BroadcastChannel,
+  PresenceTracker,
+  StateCache,
+  applyPatchMessage,
+  patch
+};
+//# sourceMappingURL=index.js.map