@krizaka/realtime 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,116 @@
-# Temporary Holding Version
+# @krizaka/realtime
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Realtime for a Node app, behind **one interface**: a bus (publish / subscribe by channel), presence (who is
+connected, by heartbeat and time-to-live) and Server-Sent Events. The adapter is a deployment choice — memory,
+**PostgreSQL LISTEN/NOTIFY** or **Redis / Valkey** — and the code that publishes and subscribes never knows which.
+
+```bash
+npm install @krizaka/realtime
+npm install pg        # for the PostgreSQL adapter's pgChannel (optional peer)
+npm install ioredis   # for the Redis / Valkey adapter (optional peer)
+```
+
+ESM only, Node ≥ 20. The root entry loads no driver.
+
+## What is in it
+
+| Entry | What | Needs |
+| :-- | :-- | :-- |
+| `@krizaka/realtime` | `RealtimeBus`, `PresenceStore` and their types · `createBus` · `busKind` · `memoryBus` · `postgresBus` · `ReplicatedPresence` · `eventStream`, `sseFrame` | nothing |
+| `@krizaka/realtime/sse` | `eventStream`, `sseFrame` alone (an edge route that only streams) | nothing |
+| `@krizaka/realtime/postgres` | `postgresBus`, `PostgresChannel`, `NOTIFY_LIMIT`, `DEFAULT_CHANNEL` | a `PostgresChannel` |
+| `@krizaka/realtime/pg` | `pgChannel` — a `PostgresChannel` on node-postgres | `pg` |
+| `@krizaka/realtime/redis` | `redisBus`, `RedisPresence`, `DEFAULT_PREFIX` | `ioredis` |
+
+## The contract
+
+- **Best-effort.** `publish` never throws; when the network fails, the event still reaches this instance's
+  subscribers. Durable facts (messages, bids) live in the database and are replayed from it — never from the bus.
+- **Small payloads.** Ids and small facts; PostgreSQL caps a NOTIFY at 8 000 bytes (`NOTIFY_LIMIT` = 7 900 with the
+  envelope).
+- **Presence is never a database write per beat.** A connection beats (`beat`) every third of `ttlMs` (default
+  45 s); a closed one lingers `graceMs` (default 10 s) so a reconnection changes nothing; `settle` after the grace
+  tells whether the person went offline. Every call answers the change it caused, once, so the caller publishes it
+  once — whichever instance noticed it.
+- **Fail loudly on configuration.** `createBus` refuses a bus that cannot work (redis without a URL, postgres without a
+  channel) instead of falling back to memory.
+
+## Wiring it once
+
+```ts
+// lib/realtime.ts — the app's one realtime door
+import { busKind, createBus, eventStream, type RealtimeBus } from "@krizaka/realtime";
+import { pgChannel } from "@krizaka/realtime/pg";
+import { redisBus } from "@krizaka/realtime/redis";
+
+import { pool } from "./db"; // the app's own pool (a transaction pooler is fine for NOTIFY)
+
+let bus: RealtimeBus | undefined;
+export function realtimeBus() {
+  return (bus ??= createBus({
+    kind: busKind(process.env.REALTIME_BUS),               // postgres (default) · redis · memory
+    // LISTEN needs a session: a direct connection, never PgBouncer in transaction mode.
+    postgres: pgChannel({ listen: process.env.DATABASE_DIRECT_URL!, notify: pool }),
+    channel: "myapp_events",                              // one NOTIFY channel per app
+    redisBus,
+    redisUrl: process.env.REDIS_URL,
+    prefix: "myapp:rt:",                                  // one key prefix per app on a shared server
+  }));
+}
+
+// app/api/events/route.ts — a Server-Sent Events stream
+export function GET() {
+  return eventStream({
+    retryMs: 2000,
+    heartbeatMs: 15_000,
+    maxLifetimeMs: 300_000,                               // under the platform's request timeout; the client comes back
+    start: ({ send }) => realtimeBus().subscribe(`user:${userId}`, (event) => send({ data: event })),
+  });
+}
+```
+
+The package reads **no environment variable**: the app decides which URL is the direct one, which channel and which
+prefix are its own. Bring your own `PostgresChannel` (`{ notify, listen }`) if your app already has a LISTEN
+connection; `pgChannel` is only the ready-made one.
+
+## Which adapter
+
+| Adapter | Fan-out | Presence | Choose it when |
+| :-- | :-- | :-- | :-- |
+| `memory` | inside one process | in memory | tests, one instance without a database |
+| `postgres` (default) | `NOTIFY` to every instance's `LISTEN` — every instance receives every event | each instance's memory, replicated over the same channel (changes + a snapshot every 30 s) | one to ~3 instances: no extra service to run or pay for |
+| `redis` | Redis / Valkey pub/sub, one subscription per channel that has a listener on the instance | in Redis, one atomic script per beat, keys that expire by themselves | more instances or many open streams: an event crosses the network only to instances that listen |
+
+Switch to **Redis / Valkey** when the instances multiply (every PostgreSQL instance receives every event and the
+NOTIFY queue is shared with the database), when presence must survive an instance's restart without a 75 s fade, or
+when a managed cache is already there. Switching is a variable and a restart.
+
+### PostgreSQL behind a pooler
+
+`LISTEN` lives as long as its **session**. Behind PgBouncer (or any pooler) in **transaction** mode, the subscription
+is lost between transactions: give `pgChannel` a **direct** connection string for `listen` (DigitalOcean, Supabase,
+Neon and others all offer one next to the pooled one), and pass the app's pooled `pool` as `notify` — a NOTIFY is one
+statement and goes through a transaction pooler. Without `notify`, `pgChannel` opens a pool of two connections on the
+`listen` URL. The LISTEN connection reconnects by itself (1 s, doubling, capped at 30 s); while it is down, the
+instance still publishes to the others and delivers its own events locally (`bus.connected` is `false`).
+
+## How the Krizaka products use it
+
+- **A video platform**: one `user:<id>` topic per account (messages, receipts, typing, notifications), `presence:<id>`
+  delivered only to those allowed to see it, one topic per live auction and per challenge; the chat stream replays
+  missed messages from the database with `Last-Event-ID`, then follows the bus.
+- **A dating app**: the agent's reply streamed as SSE, the events of an account (a batch is ready, a new intro, a
+  message) on `user:<id>`, the messages of an intro on `intro:<id>`.
+
+Both run `postgres` by default and keep `redis` one variable away.
+
+## Tests
+
+`pnpm --filter @krizaka/realtime test` covers every adapter without a server (100 % enforced): the PostgreSQL bus over
+an in-memory channel, `pgChannel` over a fake driver. The contract against real servers — two instances per adapter,
+delivery under a second, order of a burst, presence announced once — runs with `REALTIME_IT=1`
+(`pnpm --filter @krizaka/realtime test:integration`, `DATABASE_URL` and `REDIS_URL`), in CI's "Realtime adapters" job.
+
+## License
+
+Apache-2.0 © Krizaka

package/dist/chunk-GBVW7BAQ.js

@@ -0,0 +1,90 @@
+// src/sse.ts
+var clean = (value) => value.replace(/[\r\n]/g, " ");
+function sseFrame(frame) {
+  let out = "";
+  if (frame.comment !== void 0) out += `: ${clean(frame.comment)}
+`;
+  if (frame.retry !== void 0) out += `retry: ${Math.max(0, Math.round(frame.retry))}
+`;
+  if (frame.id !== void 0) out += `id: ${clean(frame.id)}
+`;
+  if (frame.event !== void 0) out += `event: ${clean(frame.event)}
+`;
+  if (frame.data !== void 0) out += `data: ${JSON.stringify(frame.data)}
+`;
+  return `${out}
+`;
+}
+function eventStream(options) {
+  const encoder = new TextEncoder();
+  const abort = new AbortController();
+  const cleanups = [];
+  let ended = false;
+  let controllerRef = null;
+  const end = () => {
+    if (ended) return;
+    ended = true;
+    abort.abort();
+    for (const cleanup of cleanups.splice(0).reverse()) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+    try {
+      controllerRef?.close();
+    } catch {
+    }
+  };
+  const send = (frame) => {
+    if (ended || !controllerRef) return;
+    try {
+      controllerRef.enqueue(encoder.encode(sseFrame(frame)));
+    } catch {
+      end();
+    }
+  };
+  const stream = new ReadableStream({
+    async start(controller) {
+      controllerRef = controller;
+      if (options.retryMs) send({ retry: options.retryMs });
+      const heartbeat = setInterval(() => {
+        send({ comment: "heartbeat" });
+        options.onHeartbeat?.();
+      }, options.heartbeatMs ?? 15e3);
+      cleanups.push(() => clearInterval(heartbeat));
+      if (options.maxLifetimeMs) {
+        const lifetime = setTimeout(end, options.maxLifetimeMs);
+        cleanups.push(() => clearTimeout(lifetime));
+      }
+      try {
+        const cleanup = await options.start({ send, close: end, signal: abort.signal });
+        if (cleanup) {
+          if (ended) cleanup();
+          else cleanups.push(cleanup);
+        }
+      } catch (error) {
+        console.warn("[realtime] stream start failed", error.message);
+        end();
+      }
+    },
+    cancel() {
+      end();
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      ...options.headers
+    }
+  });
+}
+
+export {
+  sseFrame,
+  eventStream
+};
+//# sourceMappingURL=chunk-GBVW7BAQ.js.map

package/dist/chunk-GBVW7BAQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sse.ts"],"sourcesContent":["/**\n * Server-Sent Events, framed by hand (the format is four fields). `eventStream` turns a few callbacks into a web\n * `Response` any runtime serves: heartbeats keep proxies from closing an idle stream, `retry` tells the browser how\n * fast to come back, and a maximum lifetime ends the stream cleanly before a platform's own request timeout does\n * (the client reconnects at once, with `Last-Event-ID`).\n */\n\nexport interface SseFrame {\n  /** The event's id: the browser sends the last one back as `Last-Event-ID` when it reconnects. */\n  id?: string;\n  /** A named event (`addEventListener(name)`); absent: `message`. */\n  event?: string;\n  data?: unknown;\n  /** Reconnection delay the client should use (ms). */\n  retry?: number;\n  /** A comment line (heartbeats). */\n  comment?: string;\n}\n\nconst clean = (value: string) => value.replace(/[\\r\\n]/g, \" \");\n\nexport function sseFrame(frame: SseFrame): string {\n  let out = \"\";\n  if (frame.comment !== undefined) out += `: ${clean(frame.comment)}\\n`;\n  if (frame.retry !== undefined) out += `retry: ${Math.max(0, Math.round(frame.retry))}\\n`;\n  if (frame.id !== undefined) out += `id: ${clean(frame.id)}\\n`;\n  if (frame.event !== undefined) out += `event: ${clean(frame.event)}\\n`;\n  if (frame.data !== undefined) out += `data: ${JSON.stringify(frame.data)}\\n`;\n  return `${out}\\n`;\n}\n\nexport interface EventStreamControls {\n  send(frame: SseFrame): void;\n  /** Ends the stream from the server side (the client reconnects). */\n  close(): void;\n  /** Aborted when the client goes away or the stream ends. */\n  signal: AbortSignal;\n}\n\nexport interface EventStreamOptions {\n  /** Runs once the stream is open; returns the cleanup to run when it ends. */\n  start(controls: EventStreamControls): void | (() => void) | Promise<void | (() => void)>;\n  /** Heartbeat period (ms) — below every proxy's idle timeout. */\n  heartbeatMs?: number;\n  /** Called at each heartbeat (presence refreshes its TTL there). */\n  onHeartbeat?: () => void;\n  /** Ends the stream after this long (ms, 0: never) — under a platform's hard request timeout. */\n  maxLifetimeMs?: number;\n  /** Reconnection delay sent to the client (ms). */\n  retryMs?: number;\n  headers?: Record<string, string>;\n}\n\nexport function eventStream(options: EventStreamOptions): Response {\n  const encoder = new TextEncoder();\n  const abort = new AbortController();\n  const cleanups: (() => void)[] = [];\n  let ended = false;\n  let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;\n\n  const end = () => {\n    if (ended) return;\n    ended = true;\n    abort.abort();\n    for (const cleanup of cleanups.splice(0).reverse()) {\n      try {\n        cleanup();\n      } catch {\n        /* keep cleaning */\n      }\n    }\n    try {\n      controllerRef?.close();\n    } catch {\n      /* already closed */\n    }\n  };\n\n  const send = (frame: SseFrame) => {\n    if (ended || !controllerRef) return;\n    try {\n      controllerRef.enqueue(encoder.encode(sseFrame(frame)));\n    } catch {\n      /* v8 ignore next -- defensive: the runtime closed the stream under us (ended guards the known paths) */\n      end();\n    }\n  };\n\n  const stream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      controllerRef = controller;\n      if (options.retryMs) send({ retry: options.retryMs });\n      const heartbeat = setInterval(() => {\n        send({ comment: \"heartbeat\" });\n        options.onHeartbeat?.();\n      }, options.heartbeatMs ?? 15_000);\n      cleanups.push(() => clearInterval(heartbeat));\n      if (options.maxLifetimeMs) {\n        const lifetime = setTimeout(end, options.maxLifetimeMs);\n        cleanups.push(() => clearTimeout(lifetime));\n      }\n      try {\n        const cleanup = await options.start({ send, close: end, signal: abort.signal });\n        if (cleanup) {\n          if (ended) cleanup();\n          else cleanups.push(cleanup);\n        }\n      } catch (error) {\n        console.warn(\"[realtime] stream start failed\", (error as Error).message);\n        end();\n      }\n    },\n    cancel() {\n      end();\n    },\n  });\n\n  return new Response(stream, {\n    headers: {\n      \"Content-Type\": \"text/event-stream; charset=utf-8\",\n      \"Cache-Control\": \"no-cache, no-transform\",\n      Connection: \"keep-alive\",\n      \"X-Accel-Buffering\": \"no\",\n      ...options.headers,\n    },\n  });\n}\n"],"mappings":";AAmBA,IAAM,QAAQ,CAAC,UAAkB,MAAM,QAAQ,WAAW,GAAG;AAEtD,SAAS,SAAS,OAAyB;AAChD,MAAI,MAAM;AACV,MAAI,MAAM,YAAY,OAAW,QAAO,KAAK,MAAM,MAAM,OAAO,CAAC;AAAA;AACjE,MAAI,MAAM,UAAU,OAAW,QAAO,UAAU,KAAK,IAAI,GAAG,KAAK,MAAM,MAAM,KAAK,CAAC,CAAC;AAAA;AACpF,MAAI,MAAM,OAAO,OAAW,QAAO,OAAO,MAAM,MAAM,EAAE,CAAC;AAAA;AACzD,MAAI,MAAM,UAAU,OAAW,QAAO,UAAU,MAAM,MAAM,KAAK,CAAC;AAAA;AAClE,MAAI,MAAM,SAAS,OAAW,QAAO,SAAS,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA;AACxE,SAAO,GAAG,GAAG;AAAA;AACf;AAwBO,SAAS,YAAY,SAAuC;AACjE,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,QAAQ,IAAI,gBAAgB;AAClC,QAAM,WAA2B,CAAC;AAClC,MAAI,QAAQ;AACZ,MAAI,gBAAoE;AAExE,QAAM,MAAM,MAAM;AAChB,QAAI,MAAO;AACX,YAAQ;AACR,UAAM,MAAM;AACZ,eAAW,WAAW,SAAS,OAAO,CAAC,EAAE,QAAQ,GAAG;AAClD,UAAI;AACF,gBAAQ;AAAA,MACV,QAAQ;AAAA,MAER;AAAA,IACF;AACA,QAAI;AACF,qBAAe,MAAM;AAAA,IACvB,QAAQ;AAAA,IAER;AAAA,EACF;AAEA,QAAM,OAAO,CAAC,UAAoB;AAChC,QAAI,SAAS,CAAC,cAAe;AAC7B,QAAI;AACF,oBAAc,QAAQ,QAAQ,OAAO,SAAS,KAAK,CAAC,CAAC;AAAA,IACvD,QAAQ;AAEN,UAAI;AAAA,IACN;AAAA,EACF;AAEA,QAAM,SAAS,IAAI,eAA2B;AAAA,IAC5C,MAAM,MAAM,YAAY;AACtB,sBAAgB;AAChB,UAAI,QAAQ,QAAS,MAAK,EAAE,OAAO,QAAQ,QAAQ,CAAC;AACpD,YAAM,YAAY,YAAY,MAAM;AAClC,aAAK,EAAE,SAAS,YAAY,CAAC;AAC7B,gBAAQ,cAAc;AAAA,MACxB,GAAG,QAAQ,eAAe,IAAM;AAChC,eAAS,KAAK,MAAM,cAAc,SAAS,CAAC;AAC5C,UAAI,QAAQ,eAAe;AACzB,cAAM,WAAW,WAAW,KAAK,QAAQ,aAAa;AACtD,iBAAS,KAAK,MAAM,aAAa,QAAQ,CAAC;AAAA,MAC5C;AACA,UAAI;AACF,cAAM,UAAU,MAAM,QAAQ,MAAM,EAAE,MAAM,OAAO,KAAK,QAAQ,MAAM,OAAO,CAAC;AAC9E,YAAI,SAAS;AACX,cAAI,MAAO,SAAQ;AAAA,cACd,UAAS,KAAK,OAAO;AAAA,QAC5B;AAAA,MACF,SAAS,OAAO;AACd,gBAAQ,KAAK,kCAAmC,MAAgB,OAAO;AACvE,YAAI;AAAA,MACN;AAAA,IACF;AAAA,IACA,SAAS;AACP,UAAI;AAAA,IACN;AAAA,EACF,CAAC;AAED,SAAO,IAAI,SAAS,QAAQ;AAAA,IAC1B,SAAS;AAAA,MACP,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,MACjB,YAAY;AAAA,MACZ,qBAAqB;AAAA,MACrB,GAAG,QAAQ;AAAA,IACb;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-HJCRR3FF.js

@@ -0,0 +1,194 @@
+// src/types.ts
+var DEFAULT_PRESENCE = { ttlMs: 45e3, graceMs: 1e4 };
+var rank = (state) => state === "online" ? 2 : state === "away" ? 1 : 0;
+
+// src/presence.ts
+var MAX_LAST_SEEN = 1e5;
+var ReplicatedPresence = class {
+  constructor(config) {
+    this.config = config;
+    this.options = { ...DEFAULT_PRESENCE, ...config };
+    this.snapshotTtlMs = config.snapshotTtlMs ?? 75e3;
+    this.snapshotPage = config.snapshotPage ?? 150;
+  }
+  config;
+  options;
+  local = /* @__PURE__ */ new Map();
+  remote = /* @__PURE__ */ new Map();
+  announced = /* @__PURE__ */ new Map();
+  /** The local view last told to the other instances. */
+  told = /* @__PURE__ */ new Map();
+  lastSeen = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  snapshotTtlMs;
+  snapshotPage;
+  /** This instance's view of one person: the best of its live connections (expired ones are dropped). */
+  localState(userId, now) {
+    const conns = this.local.get(userId);
+    if (!conns) return "offline";
+    let best = "offline";
+    for (const [id, conn] of conns) {
+      if (conn.expiresAt <= now) conns.delete(id);
+      else if (rank(conn.state) > rank(best)) best = conn.state;
+    }
+    if (conns.size === 0) this.local.delete(userId);
+    return best;
+  }
+  remoteState(userId, now) {
+    const views = this.remote.get(userId);
+    if (!views) return "offline";
+    let best = "offline";
+    for (const [instance, view] of views) {
+      if (view.expiresAt <= now) views.delete(instance);
+      else if (rank(view.state) > rank(best)) best = view.state;
+    }
+    if (views.size === 0) this.remote.delete(userId);
+    return best;
+  }
+  state(userId, now) {
+    const a = this.localState(userId, now);
+    const b = this.remoteState(userId, now);
+    return rank(a) >= rank(b) ? a : b;
+  }
+  /**
+   * Compares with what was announced; records and returns the change. A change caused by another instance's report is
+   * returned only when it is an offline the reporter may not have seen (both instances lost the person at once): the
+   * instance with the greater id announces it — at most a duplicate, never a person left online forever.
+   */
+  evaluate(userId, now, own, reporter) {
+    const local = this.localState(userId, now);
+    if ((this.told.get(userId) ?? "offline") !== local) {
+      if (local === "offline") this.told.delete(userId);
+      else this.told.set(userId, local);
+      this.config.broadcast?.({ t: "d", i: this.config.instanceId, u: userId, s: local, at: now });
+    }
+    const next = this.state(userId, now);
+    const previous = this.announced.get(userId) ?? "offline";
+    if (next === "offline") {
+      this.announced.delete(userId);
+      if (previous !== "offline") this.see(userId, now);
+    } else {
+      this.announced.set(userId, next);
+      this.see(userId, now);
+    }
+    if (next === previous) return null;
+    if (own) return { userId, state: next, at: now };
+    if (next === "offline" && reporter !== void 0 && this.config.instanceId > reporter) return { userId, state: next, at: now };
+    return null;
+  }
+  see(userId, at) {
+    if (this.lastSeen.size >= MAX_LAST_SEEN && !this.lastSeen.has(userId)) this.lastSeen.clear();
+    this.lastSeen.set(userId, at);
+  }
+  async beat(userId, connectionId, state, now = Date.now()) {
+    let conns = this.local.get(userId);
+    if (!conns) this.local.set(userId, conns = /* @__PURE__ */ new Map());
+    conns.set(connectionId, { state, expiresAt: now + this.options.ttlMs });
+    return this.evaluate(userId, now, true);
+  }
+  async leave(userId, connectionId, now = Date.now()) {
+    const conn = this.local.get(userId)?.get(connectionId);
+    if (conn) conn.expiresAt = Math.min(conn.expiresAt, now + this.options.graceMs);
+    return this.evaluate(userId, now, true);
+  }
+  async settle(userId, now = Date.now()) {
+    return this.evaluate(userId, now, true);
+  }
+  async get(userIds, now = Date.now()) {
+    const out = /* @__PURE__ */ new Map();
+    for (const id of userIds) {
+      const state = this.state(id, now);
+      out.set(id, { state, lastSeenAt: state === "offline" ? this.lastSeen.get(id) ?? null : now });
+    }
+    return out;
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => void this.listeners.delete(listener);
+  }
+  /** Another instance spoke (ignored when it is this one). */
+  receive(replica, now = Date.now()) {
+    if (replica.i === this.config.instanceId) return;
+    const expiresAt = now + this.snapshotTtlMs;
+    const apply = (userId, state) => {
+      let views = this.remote.get(userId);
+      if (state === "offline") {
+        views?.delete(replica.i);
+        if (views && views.size === 0) this.remote.delete(userId);
+      } else {
+        if (!views) this.remote.set(userId, views = /* @__PURE__ */ new Map());
+        views.set(replica.i, { state, expiresAt });
+      }
+      const change = this.evaluate(userId, now, false, replica.i);
+      if (change) for (const listener of this.listeners) listener(change);
+    };
+    if (replica.t === "d") apply(replica.u, replica.s);
+    else for (const [userId, state] of replica.users) apply(userId, state);
+  }
+  /** This instance's connected people, in pages small enough for the bus (sent at a regular pace). */
+  snapshot(now = Date.now()) {
+    const users = [];
+    for (const userId of [...this.local.keys()]) {
+      const state = this.localState(userId, now);
+      if (state !== "offline") users.push([userId, state]);
+    }
+    const pages = [];
+    for (let i = 0; i < users.length; i += this.snapshotPage) {
+      pages.push({ t: "s", i: this.config.instanceId, at: now, users: users.slice(i, i + this.snapshotPage) });
+    }
+    return pages;
+  }
+  /** How many connections this instance holds (metrics, tests). */
+  get connections() {
+    let n = 0;
+    for (const conns of this.local.values()) n += conns.size;
+    return n;
+  }
+};
+
+// src/memory.ts
+import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
+function localEmitter() {
+  const emitter = new EventEmitter();
+  emitter.setMaxListeners(0);
+  return emitter;
+}
+function emitSafely(emitter, channel, event) {
+  for (const listener of emitter.listeners(channel)) {
+    try {
+      listener(event);
+    } catch (error) {
+      console.warn(`[realtime] a subscriber of ${channel} failed`, error.message);
+    }
+  }
+}
+function memoryBus(options = {}) {
+  const emitter = localEmitter();
+  const presence = new ReplicatedPresence({ instanceId: randomUUID(), ...options });
+  return {
+    kind: "memory",
+    connected: true,
+    presence,
+    async publish(channel, event) {
+      emitSafely(emitter, channel, event);
+    },
+    subscribe(channel, handler) {
+      emitter.on(channel, handler);
+      return () => void emitter.off(channel, handler);
+    },
+    async close() {
+      emitter.removeAllListeners();
+    }
+  };
+}
+
+export {
+  DEFAULT_PRESENCE,
+  rank,
+  ReplicatedPresence,
+  localEmitter,
+  emitSafely,
+  memoryBus
+};
+//# sourceMappingURL=chunk-HJCRR3FF.js.map

package/dist/chunk-HJCRR3FF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/presence.ts","../src/memory.ts"],"sourcesContent":["/**\n * The realtime contract. Application code knows these interfaces only; which adapter carries them (memory, PostgreSQL\n * LISTEN/NOTIFY, Redis / Valkey) is a deployment choice (`createBus`).\n */\n\nexport type Unsubscribe = () => void;\n\n/** What a connection says about its person: in front of the screen, or connected but idle / hidden. */\nexport type ConnectionState = \"online\" | \"away\";\n/** A person's presence: the best state among their connections, `offline` when none is left. */\nexport type PresenceState = ConnectionState | \"offline\";\n\nexport interface PresenceInfo {\n  state: PresenceState;\n  /** Epoch ms the person was last connected (null: never seen by this store — the caller may know better). */\n  lastSeenAt: number | null;\n}\n\n/** A person's presence changed (the store announces each change once, whichever instance noticed it). */\nexport interface PresenceChange {\n  userId: string;\n  state: PresenceState;\n  at: number;\n}\n\nexport interface PresenceOptions {\n  /** How long a connection counts without a new beat (ms). Beats come at a third of it. */\n  ttlMs: number;\n  /** How long a closed connection still counts (ms): a reconnection inside it changes nothing (no offline flicker). */\n  graceMs: number;\n}\n\n/**\n * Who is connected, kept by heartbeat and time-to-live — never a database write per beat. Every method answers the\n * change it caused, if any, so the caller publishes it once.\n */\nexport interface PresenceStore {\n  /** A connection is (still) there, in this state: opens it or refreshes its TTL. */\n  beat(userId: string, connectionId: string, state: ConnectionState, now?: number): Promise<PresenceChange | null>;\n  /** A connection closed: it lingers `graceMs`, then the person may be offline — `settle` tells. */\n  leave(userId: string, connectionId: string, now?: number): Promise<PresenceChange | null>;\n  /** Re-evaluates a person after expiries (the caller runs it once the grace has passed). */\n  settle(userId: string, now?: number): Promise<PresenceChange | null>;\n  /** The presence of these people (absent from the store: offline, last seen unknown). */\n  get(userIds: string[], now?: number): Promise<Map<string, PresenceInfo>>;\n  /**\n   * Changes this instance discovers on its own rather than as the answer to a call (another instance's report that\n   * makes a person offline). Announce them like the others. Returns the unsubscribe function.\n   */\n  onChange(listener: (change: PresenceChange) => void): Unsubscribe;\n}\n\nexport type BusKind = \"memory\" | \"postgres\" | \"redis\";\n\n/**\n * The bus: events by channel to every subscriber of every instance, and presence. Best-effort by design — a publish\n * never throws; durable facts (messages) live in the database and are replayed from it, never from the bus.\n */\nexport interface RealtimeBus {\n  readonly kind: BusKind;\n  /** True while events published by other instances reach this one (always true for `memory`). */\n  readonly connected: boolean;\n  readonly presence: PresenceStore;\n  publish(channel: string, event: unknown): Promise<void>;\n  subscribe(channel: string, handler: (event: unknown) => void): Unsubscribe;\n  close(): Promise<void>;\n}\n\nexport const DEFAULT_PRESENCE: PresenceOptions = { ttlMs: 45_000, graceMs: 10_000 };\n\n/** The rank of a state: a person is as present as their most present connection. */\nexport const rank = (state: PresenceState) => (state === \"online\" ? 2 : state === \"away\" ? 1 : 0);\n","import { type ConnectionState, DEFAULT_PRESENCE, type PresenceChange, type PresenceInfo, type PresenceOptions, type PresenceState, type PresenceStore,rank } from \"./types\";\n\n/**\n * Presence in this process's memory, optionally replicated between instances through the bus that carries it\n * (PostgreSQL LISTEN/NOTIFY). Each instance keeps its own connections (heartbeat + TTL) and tells the others its\n * *local* view of a person when it changes, plus a snapshot of everyone connected to it at a regular pace; a person's\n * presence is the best of the local view and the views of the other instances still heard from.\n *\n * Changes are announced once: by the instance where the event happened (a remote report only updates what this\n * instance believes was announced). An instance that dies stops refreshing its snapshot: its people fade out after\n * `snapshotTtlMs` (no event — clients refresh presence on a slow poll as a fallback).\n */\n\n/** What an instance tells the others: one person's local state (`d` = delta), or a page of its connected people. */\nexport type PresenceReplica =\n  | { t: \"d\"; i: string; u: string; s: PresenceState; at: number }\n  | { t: \"s\"; i: string; at: number; users: [string, ConnectionState][] };\n\ninterface Conn {\n  state: ConnectionState;\n  expiresAt: number;\n}\n\nexport interface ReplicatedPresenceOptions extends Partial<PresenceOptions> {\n  /** This instance's id (random per process). */\n  instanceId: string;\n  /** Sends a replica to the other instances (absent: a single instance). */\n  broadcast?: (replica: PresenceReplica) => void;\n  /** How long another instance's snapshot counts (ms) — about 2.5 snapshot intervals. */\n  snapshotTtlMs?: number;\n  /** The most people a snapshot page carries (a PostgreSQL NOTIFY payload stays under 8 KB). */\n  snapshotPage?: number;\n}\n\nconst MAX_LAST_SEEN = 100_000;\n\nexport class ReplicatedPresence implements PresenceStore {\n  readonly options: PresenceOptions;\n  private readonly local = new Map<string, Map<string, Conn>>();\n  private readonly remote = new Map<string, Map<string, { state: ConnectionState; expiresAt: number }>>();\n  private readonly announced = new Map<string, PresenceState>();\n  /** The local view last told to the other instances. */\n  private readonly told = new Map<string, PresenceState>();\n  private readonly lastSeen = new Map<string, number>();\n  private readonly listeners = new Set<(change: PresenceChange) => void>();\n  private readonly snapshotTtlMs: number;\n  private readonly snapshotPage: number;\n\n  constructor(private readonly config: ReplicatedPresenceOptions) {\n    this.options = { ...DEFAULT_PRESENCE, ...config };\n    this.snapshotTtlMs = config.snapshotTtlMs ?? 75_000;\n    this.snapshotPage = config.snapshotPage ?? 150;\n  }\n\n  /** This instance's view of one person: the best of its live connections (expired ones are dropped). */\n  private localState(userId: string, now: number): PresenceState {\n    const conns = this.local.get(userId);\n    if (!conns) return \"offline\";\n    let best: PresenceState = \"offline\";\n    for (const [id, conn] of conns) {\n      if (conn.expiresAt <= now) conns.delete(id);\n      else if (rank(conn.state) > rank(best)) best = conn.state;\n    }\n    if (conns.size === 0) this.local.delete(userId);\n    return best;\n  }\n\n  private remoteState(userId: string, now: number): PresenceState {\n    const views = this.remote.get(userId);\n    if (!views) return \"offline\";\n    let best: PresenceState = \"offline\";\n    for (const [instance, view] of views) {\n      if (view.expiresAt <= now) views.delete(instance);\n      else if (rank(view.state) > rank(best)) best = view.state;\n    }\n    if (views.size === 0) this.remote.delete(userId);\n    return best;\n  }\n\n  private state(userId: string, now: number): PresenceState {\n    const a = this.localState(userId, now);\n    const b = this.remoteState(userId, now);\n    return rank(a) >= rank(b) ? a : b;\n  }\n\n  /**\n   * Compares with what was announced; records and returns the change. A change caused by another instance's report is\n   * returned only when it is an offline the reporter may not have seen (both instances lost the person at once): the\n   * instance with the greater id announces it — at most a duplicate, never a person left online forever.\n   */\n  private evaluate(userId: string, now: number, own: boolean, reporter?: string): PresenceChange | null {\n    const local = this.localState(userId, now);\n    if ((this.told.get(userId) ?? \"offline\") !== local) {\n      if (local === \"offline\") this.told.delete(userId);\n      else this.told.set(userId, local);\n      this.config.broadcast?.({ t: \"d\", i: this.config.instanceId, u: userId, s: local, at: now });\n    }\n    const next = this.state(userId, now);\n    const previous = this.announced.get(userId) ?? \"offline\";\n    if (next === \"offline\") {\n      this.announced.delete(userId);\n      if (previous !== \"offline\") this.see(userId, now);\n    } else {\n      this.announced.set(userId, next);\n      this.see(userId, now);\n    }\n    if (next === previous) return null;\n    if (own) return { userId, state: next, at: now };\n    if (next === \"offline\" && reporter !== undefined && this.config.instanceId > reporter) return { userId, state: next, at: now };\n    return null;\n  }\n\n  private see(userId: string, at: number) {\n    if (this.lastSeen.size >= MAX_LAST_SEEN && !this.lastSeen.has(userId)) this.lastSeen.clear();\n    this.lastSeen.set(userId, at);\n  }\n\n  async beat(userId: string, connectionId: string, state: ConnectionState, now = Date.now()) {\n    let conns = this.local.get(userId);\n    if (!conns) this.local.set(userId, (conns = new Map()));\n    conns.set(connectionId, { state, expiresAt: now + this.options.ttlMs });\n    return this.evaluate(userId, now, true);\n  }\n\n  async leave(userId: string, connectionId: string, now = Date.now()) {\n    const conn = this.local.get(userId)?.get(connectionId);\n    // The connection lingers for the grace period: a reconnection inside it changes nothing.\n    if (conn) conn.expiresAt = Math.min(conn.expiresAt, now + this.options.graceMs);\n    return this.evaluate(userId, now, true);\n  }\n\n  async settle(userId: string, now = Date.now()) {\n    return this.evaluate(userId, now, true);\n  }\n\n  async get(userIds: string[], now = Date.now()) {\n    const out = new Map<string, PresenceInfo>();\n    for (const id of userIds) {\n      const state = this.state(id, now);\n      out.set(id, { state, lastSeenAt: state === \"offline\" ? (this.lastSeen.get(id) ?? null) : now });\n    }\n    return out;\n  }\n\n  onChange(listener: (change: PresenceChange) => void) {\n    this.listeners.add(listener);\n    return () => void this.listeners.delete(listener);\n  }\n\n  /** Another instance spoke (ignored when it is this one). */\n  receive(replica: PresenceReplica, now = Date.now()) {\n    if (replica.i === this.config.instanceId) return;\n    const expiresAt = now + this.snapshotTtlMs;\n    const apply = (userId: string, state: PresenceState) => {\n      let views = this.remote.get(userId);\n      if (state === \"offline\") {\n        views?.delete(replica.i);\n        if (views && views.size === 0) this.remote.delete(userId);\n      } else {\n        if (!views) this.remote.set(userId, (views = new Map()));\n        views.set(replica.i, { state, expiresAt });\n      }\n      const change = this.evaluate(userId, now, false, replica.i);\n      if (change) for (const listener of this.listeners) listener(change);\n    };\n    if (replica.t === \"d\") apply(replica.u, replica.s);\n    else for (const [userId, state] of replica.users) apply(userId, state);\n  }\n\n  /** This instance's connected people, in pages small enough for the bus (sent at a regular pace). */\n  snapshot(now = Date.now()): PresenceReplica[] {\n    const users: [string, ConnectionState][] = [];\n    for (const userId of [...this.local.keys()]) {\n      const state = this.localState(userId, now);\n      if (state !== \"offline\") users.push([userId, state]);\n    }\n    const pages: PresenceReplica[] = [];\n    for (let i = 0; i < users.length; i += this.snapshotPage) {\n      pages.push({ t: \"s\", i: this.config.instanceId, at: now, users: users.slice(i, i + this.snapshotPage) });\n    }\n    return pages;\n  }\n\n  /** How many connections this instance holds (metrics, tests). */\n  get connections(): number {\n    let n = 0;\n    for (const conns of this.local.values()) n += conns.size;\n    return n;\n  }\n}\n","import { randomUUID } from \"node:crypto\";\nimport { EventEmitter } from \"node:events\";\n\nimport { ReplicatedPresence } from \"./presence\";\nimport type { PresenceOptions, RealtimeBus } from \"./types\";\n\n/**\n * One process, no network: events go from publisher to subscribers through an EventEmitter. For tests and a single\n * instance without a database; it is also the local fan-out every other adapter uses inside an instance.\n */\nexport function localEmitter(): EventEmitter {\n  const emitter = new EventEmitter();\n  emitter.setMaxListeners(0);\n  return emitter;\n}\n\n/** Hands an event to a channel's local subscribers; a failing subscriber never stops the others. */\nexport function emitSafely(emitter: EventEmitter, channel: string, event: unknown) {\n  for (const listener of emitter.listeners(channel)) {\n    try {\n      (listener as (e: unknown) => void)(event);\n    } catch (error) {\n      console.warn(`[realtime] a subscriber of ${channel} failed`, (error as Error).message);\n    }\n  }\n}\n\nexport function memoryBus(options: Partial<PresenceOptions> = {}): RealtimeBus {\n  const emitter = localEmitter();\n  const presence = new ReplicatedPresence({ instanceId: randomUUID(), ...options });\n  return {\n    kind: \"memory\",\n    connected: true,\n    presence,\n    async publish(channel, event) {\n      emitSafely(emitter, channel, event);\n    },\n    subscribe(channel, handler) {\n      emitter.on(channel, handler);\n      return () => void emitter.off(channel, handler);\n    },\n    async close() {\n      emitter.removeAllListeners();\n    },\n  };\n}\n"],"mappings":"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","names":[]}