@mauroandre/velojs 0.0.21 → 0.0.23

package/README.md

@@ -629,10 +629,12 @@ export const stream_deploy = createEventStream<DeployState>({
 |--------|------|-------------|
 | `path` | `string` | (Standalone) Explicit URL path |
 | `broadcast` | `boolean` | If true, every emit goes to all subscribers (no channels). Default: false |
-| `channel` | `(c) => string` | Extract channel ID. Default: `?channel=...` query param. Ignored when `broadcast: true` |
+| `channel` | `(c) => string \| null \| Promise<...>` | Resolve channel ID. Sync or async. Return `null`/`undefined` to reject (403). Default: `?channel=...` |
 | `snapshot` | `(channel) => TSnapshot` | Returns current state on connect (state-machine pattern) |
 | `closeOn` | `(event) => boolean` | Closes SSE when matching event is sent (declarative) |
-| `source` | `(emit, { abortSignal }) => Promise<void>` | Self-running producer, only runs while subscribed |
+| `source` | `(emit, { abortSignal }) => Promise<void>` | Stream-wide producer, only runs while subscribed |
+| `perChannelSource` | `(channelKey, emit, { abortSignal }) => Promise<void>` | Per-channel producer. Mutually exclusive with `source` |
+| `bufferSize` | `number` | Max entries kept in snapshot buffer per channel (FIFO). Default `Infinity` |
 | `retainMs` | `number` | Buffer retention after `close()`. Default `300000` (5 min) |
 | `heartbeatMs` | `number \| false` | Heartbeat interval. Default `20000` (20s). `false` to disable |
 | `middlewares` | `MiddlewareHandler[]` | (Standalone) Hono middlewares for the SSE route |
@@ -698,6 +700,53 @@ For interval-based polling sources. Wraps your tick function in a loop that resp
 poll({ intervalMs: 3000, tick: async (emit) => emit(await collect()) })
 ```
 
+### Per-channel sources
+
+Use `perChannelSource` for resources that scale per channel (SSH connections, DB cursors, pub/sub topics). Invoked once per channel on first subscriber, aborted when the last subscriber of that channel leaves.
+
+```typescript
+export const stream_logs = createEventStream<string>({
+    channel: (c) => `${c.req.param("worker")}:${c.req.param("container")}`,
+    bufferSize: 500,
+    perChannelSource: async (key, emit, { abortSignal }) => {
+        const conn = await ssh.connect(...);
+        const stream = conn.exec(`podman logs -f ${key.split(":")[1]}`);
+        stream.on("data", (d) => emit(d.toString(), { snapshot: true }));
+        abortSignal.addEventListener("abort", () => { stream.close(); conn.end(); });
+    },
+});
+```
+
+Mutually exclusive with `source`.
+
+### Async channel resolver (auth + ownership)
+
+The `channel` resolver can be async and reject the connection by returning `null`/`undefined`:
+
+```typescript
+createEventStream({
+    channel: async (c) => {
+        const user = c.get("user");
+        const appId = c.req.query("channel");
+        const app = await getApp({ id: appId });
+        if (app?.owner !== user.id) return null; // → 403
+        return appId;
+    },
+});
+```
+
+Combines auth and channel extraction in one place.
+
+### Buffer size limits
+
+Cap memory usage of long-running log streams via FIFO ring:
+
+```typescript
+createEventStream<string>({ bufferSize: 500 });  // keep last 500 entries per channel
+```
+
+Only affects emits with `{ snapshot: true }`.
+
 ---
 
 ## Hooks
@@ -1139,15 +1188,70 @@ Hooks (`useParams`, `useQuery`, `usePathname`, `Loader`, `useLoader`) access thi
 
 ---
 
+## Testing
+
+VeloJS ships a backend testing toolkit at `@mauroandre/velojs/testing`. Spin up the app in memory, fire HTTP requests against the registered handlers, subscribe to event streams. No socket, no browser, no fragile mocks of framework internals.
+
+```typescript
+import { createTestApp } from "@mauroandre/velojs/testing";
+import { routes } from "../app/routes.js";
+import { stream_progress } from "../app/Deploy.js";
+import { action_startDeploy } from "../app/Deploy.js";
+
+const app = await createTestApp({
+    routes,
+    bootstrap: async () => { await connect(process.env.MONGO_URI!); },
+    getSessionCookie: async ({ user }) => ({ session: await sign(user) }),
+});
+
+// HTTP
+const res = await app.get("/api/health");
+
+// Convention helpers — pass the function, framework resolves the URL
+const data = await app.loader(homeLoader, { params: { id: "abc" } });
+await app.action(action_startDeploy, { body: { appId } });
+
+// Streams — TestSubscription with snapshot, next(), close, etc
+const sub = await app.subscribe(stream_progress, { channel: appId });
+expect(sub.status).toBe(200);
+const event = await sub.next({ timeoutMs: 2000 });
+
+// Auth — sub-client with cookies bound automatically
+const asAlice = app.as({ user: alice });
+await asAlice.subscribe(stream_progress, { channel: appId });
+
+await app.close();
+```
+
+**Prerequisite:** `vitest.config.ts` must include `veloPlugin()` so action/loader/stream metadata is injected.
+
+| API | Purpose |
+|-----|---------|
+| `createTestApp(options)` | Build isolated app with bootstrap + auth callback |
+| `app.get/post/put/patch/delete` | HTTP requests (cookies, headers, query, JSON/FormData body) |
+| `app.action(fn, opts)` | Invoke `action_*` by function reference |
+| `app.loader(fn, opts)` | Invoke `loader` and unwrap response data |
+| `app.subscribe(stream, opts)` | Subscribe to a stream; returns `TestSubscription` with `next/nextN/snapshot/close/closed` |
+| `app.as({ user })` | Sub-client with cookies bound to a user |
+| `app.sessionCookies({ user })` | Build cookies via `getSessionCookie` |
+| `app.mockContext(opts)` | Escape hatch — partial Hono Context for direct invocation |
+| `app.reset()` | Clear stream buffers/listeners between tests |
+| `app.close()` | Tear down everything (zero open handles guaranteed) |
+
+See [Testing docs](https://github.com/mauro-andre/velojs/blob/dev/site/docs/16-testing.md) for the full guide with patterns, isolation, and FAQ.
+
+---
+
 ## Subpath Exports
 
 | Import | Contents |
 |--------|----------|
-| `@mauroandre/velojs` | Types (`AppRoutes`, `ActionArgs`, `LoaderArgs`, `Metadata`, `EventStream`, `EventStreamConfig`, `EmitFn`, `EmitOptions`, `SourceFn`), `Scripts`, `Link`, `createEventStream`, `poll`, `defineConfig` |
+| `@mauroandre/velojs` | Types (`AppRoutes`, `ActionArgs`, `LoaderArgs`, `Metadata`, `EventStream`, `EventStreamConfig`, `EmitFn`, `EmitOptions`, `SourceFn`, `PerChannelSourceFn`, `ChannelResolver`), `Scripts`, `Link`, `createEventStream`, `poll`, `defineConfig` |
 | `@mauroandre/velojs/server` | `startServer`, `createApp`, `addRoutes`, `onServer`, `serverDataStorage` |
 | `@mauroandre/velojs/client` | `startClient` |
 | `@mauroandre/velojs/hooks` | `Loader`, `useLoader`, `useEventStream`, `useParams`, `useQuery`, `useNavigate`, `usePathname`, `touch` |
-| `@mauroandre/velojs/events` | `createEventStream`, `poll`, `EventStream`, `EventStreamConfig`, `EmitFn`, `EmitOptions`, `SourceFn` (also re-exported from root) |
+| `@mauroandre/velojs/events` | `createEventStream`, `poll`, `EventStream`, `EventStreamConfig`, `EmitFn`, `EmitOptions`, `SourceFn`, `PerChannelSourceFn`, `ChannelResolver` (also re-exported from root) |
+| `@mauroandre/velojs/testing` | `createTestApp`, `TestApp`, `TestResponse`, `TestSubscription`, `CreateTestAppOptions`, `MockContextOptions` |
 | `@mauroandre/velojs/cookie` | `getCookie`, `setCookie`, `deleteCookie`, `getSignedCookie`, `setSignedCookie` |
 | `@mauroandre/velojs/factory` | `createMiddleware`, `createFactory` |
 | `@mauroandre/velojs/vite` | `veloPlugin` |

package/dist/app-context.d.ts

@@ -0,0 +1,38 @@
+/**
+ * App context — scoped via a swappable global slot so multiple test apps
+ * can coexist without polluting each other's pending route registrations.
+ *
+ * Production runtime uses a single default context implicitly. Tests create
+ * isolated contexts via `withAppContext()` which swaps the slot for the
+ * duration of the call.
+ *
+ * NOTE: this module is client-safe (no `node:async_hooks` import). Vitest runs
+ * each test file in its own worker, so a simple swappable slot is sufficient
+ * for parallelism between files. Within a single file, tests run sequentially
+ * unless `describe.concurrent`/`it.concurrent` is used.
+ */
+import type { Hono } from "hono";
+type RouteRegisterFn = (app: Hono) => void | Promise<void>;
+type StreamRouteRegisterFn = (app: Hono) => void;
+type ServerCallbackFn = (server: any) => void;
+export interface AppContext {
+    pendingRoutes: RouteRegisterFn[];
+    pendingStreamRoutes: StreamRouteRegisterFn[];
+    serverCallbacks: ServerCallbackFn[];
+    disposers: Set<() => void>;
+}
+export declare function getAppContext(): AppContext;
+/**
+ * Run a function within an isolated app context (for tests).
+ * Restores the previous context after the function resolves/rejects.
+ */
+export declare function withAppContext<T>(ctx: AppContext, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Create a new isolated context. Inherits a SNAPSHOT of the default context
+ * so any addRoutes/onServer/createEventStream calls that happened at top-level
+ * import time are captured.
+ */
+export declare function createIsolatedContext(): AppContext;
+export declare function registerDisposer(dispose: () => void): void;
+export declare function unregisterDisposer(dispose: () => void): void;
+export {};

package/dist/app-context.js

@@ -0,0 +1,43 @@
+function o() {
+  return {
+    pendingRoutes: [],
+    pendingStreamRoutes: [],
+    serverCallbacks: [],
+    disposers: /* @__PURE__ */ new Set()
+  };
+}
+const n = o();
+let e = n;
+function i() {
+  return e;
+}
+async function p(t, s) {
+  const r = e;
+  e = t;
+  try {
+    return await s();
+  } finally {
+    e = r;
+  }
+}
+function u() {
+  return {
+    pendingRoutes: [...n.pendingRoutes],
+    pendingStreamRoutes: [...n.pendingStreamRoutes],
+    serverCallbacks: [...n.serverCallbacks],
+    disposers: /* @__PURE__ */ new Set()
+  };
+}
+function a(t) {
+  e.disposers.add(t);
+}
+function d(t) {
+  e.disposers.delete(t);
+}
+export {
+  u as createIsolatedContext,
+  i as getAppContext,
+  a as registerDisposer,
+  d as unregisterDisposer,
+  p as withAppContext
+};

package/dist/events.d.ts

@@ -66,6 +66,36 @@ export interface EmitOptions {
 export type SourceFn<TEvent> = (emit: EmitFn<TEvent>, ctx: {
     abortSignal: AbortSignal;
 }) => void | Promise<void>;
+/**
+ * A per-channel producer function. Invoked when the **first** subscriber connects
+ * to a specific channel. Aborted when the **last** subscriber of that channel disconnects.
+ *
+ * The provided `emit` function is bound to the current channel — call it with just
+ * the event value (no need to pass the channel ID again).
+ *
+ * Example (per-channel SSH log stream):
+ * ```typescript
+ * perChannelSource: async (channelKey, emit, { abortSignal }) => {
+ *     const conn = await ssh.connect(...);
+ *     const stream = conn.exec(`podman logs -f ${channelKey}`);
+ *     stream.on("data", (d) => emit(d.toString(), { snapshot: true }));
+ *     abortSignal.addEventListener("abort", () => { stream.close(); conn.end(); });
+ * }
+ * ```
+ *
+ * Use this for resources that are **per-channel and expensive** (SSH connections,
+ * DB cursors, external pub/sub subscriptions). Mutually exclusive with `source`.
+ */
+export type PerChannelSourceFn<TEvent> = (channelKey: string, emit: (event: TEvent, options?: EmitOptions) => void, ctx: {
+    abortSignal: AbortSignal;
+}) => void | Promise<void>;
+/**
+ * Async-capable channel resolver. Returns a channel ID, or `null`/`undefined`
+ * to reject the connection (framework responds 403).
+ *
+ * Useful for combining channel extraction with authorization in one place.
+ */
+export type ChannelResolver = (c: Context) => string | null | undefined | Promise<string | null | undefined>;
 export interface EventStreamConfig<TEvent, TSnapshot = TEvent> {
     /**
      * Explicit URL path for the SSE endpoint (standalone usage).
@@ -79,9 +109,12 @@ export interface EventStreamConfig<TEvent, TSnapshot = TEvent> {
      * When omitted, defaults to `c.req.query("channel") ?? ""` so client-side
      * `useEventStream(stream, { channel })` works out of the box.
      *
+     * Can be **async** — return a Promise to perform DB lookups, auth checks, etc.
+     * Return `null` or `undefined` to reject the connection (framework responds 403).
+     *
      * Ignored when `broadcast: true` is set.
      */
-    channel?: (c: Context) => string;
+    channel?: ChannelResolver;
     /**
      * If true, this stream has no channels — every emit goes to all subscribers.
      * - `emit(value, options?)` (no channel arg)
@@ -127,14 +160,37 @@ export interface EventStreamConfig<TEvent, TSnapshot = TEvent> {
      * When the last subscriber disconnects, the AbortSignal fires.
      *
      * Use the `poll` helper for the common interval-based pattern.
+     *
+     * Mutually exclusive with `perChannelSource`.
      */
     source?: SourceFn<TEvent>;
+    /**
+     * Per-channel producer. Invoked when the **first** subscriber of a channel connects.
+     * Aborted when the **last** subscriber of that channel disconnects.
+     *
+     * Use this for resources that scale per channel (SSH connections, DB cursors,
+     * external pub/sub subscriptions). The `emit` provided is bound to the current
+     * channel — call it with just the value.
+     *
+     * Mutually exclusive with `source`.
+     */
+    perChannelSource?: PerChannelSourceFn<TEvent>;
     /**
      * Time (ms) the per-channel snapshot buffer is retained after `close()`.
      * Reconnecting clients within this window still see the final state.
      * Default: 5 * 60 * 1000 (5 minutes).
      */
     retainMs?: number;
+    /**
+     * Maximum number of events kept in the per-channel snapshot buffer
+     * (only applies to `emit(..., { snapshot: true })`).
+     *
+     * When the buffer reaches this size, the oldest entries are dropped (FIFO ring).
+     * Use this to prevent memory growth in long-running log streams.
+     *
+     * Default: `Infinity` (no limit, current behavior).
+     */
+    bufferSize?: number;
 }
 export interface EventStream<TEvent, TSnapshot = TEvent> {
     /**
@@ -165,6 +221,8 @@ export interface EventStream<TEvent, TSnapshot = TEvent> {
     __onConnect(channelKey: string, listener: StreamListener<TEvent>): void;
     /** Internal: source lifecycle hook */
     __onDisconnect(channelKey: string, listener: StreamListener<TEvent>): void;
+    /** @internal Test-only: reset all transient state (buffers, listeners, controllers, timers). */
+    __reset(): void;
 }
 /** Internal listener — receives events and a close signal. */
 interface StreamListener<TEvent> {
@@ -172,6 +230,8 @@ interface StreamListener<TEvent> {
     close(): void;
 }
 export declare function flushPendingStreamRoutes(app: Hono): void;
+/** @internal Used by `@mauroandre/velojs/testing` to reset all streams. */
+export declare function getRegisteredStreams(): ReadonlySet<EventStream<unknown, unknown>>;
 export declare function createEventStream<TEvent, TSnapshot = TEvent>(config?: EventStreamConfig<TEvent, TSnapshot>): EventStream<TEvent, TSnapshot>;
 /**
  * Creates a `source` function that runs `tick` every `intervalMs` while subscribed.

package/dist/events.js

@@ -1,88 +1,130 @@
-const T = [];
-function m(t) {
-  for (const r of T) r(t);
-  T.length = 0;
+import { getAppContext as A } from "./app-context.js";
+const M = 2e4, R = 300 * 1e3, v = "";
+function x(t) {
+  const o = A().pendingStreamRoutes.splice(0);
+  for (const c of o) c(t);
 }
-function N(t = {}) {
-  t.broadcast && t.channel && console.warn(
+const I = /* @__PURE__ */ new Set();
+function y() {
+  return I;
+}
+function L(t = {}) {
+  if (t.broadcast && t.channel && console.warn(
     "[velojs] createEventStream: `broadcast: true` ignores `channel`. Remove one of them — broadcast streams have no channels."
-  );
-  const r = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map();
-  let f = null, A = 0;
-  const d = () => {
-    t.source && (f || (f = new AbortController(), Promise.resolve(
-      t.source(E, { abortSignal: f.signal })
+  ), t.source && t.perChannelSource)
+    throw new Error(
+      "[velojs] createEventStream: `source` and `perChannelSource` are mutually exclusive. Use `source` for stream-wide producers or `perChannelSource` for per-channel resources, not both."
+    );
+  const a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map();
+  let l = null, w = 0;
+  const i = /* @__PURE__ */ new Map(), b = () => {
+    t.source && (l || (l = new AbortController(), Promise.resolve(
+      t.source(p, { abortSignal: l.signal })
     ).catch((e) => {
       console.error("[velojs] event stream source threw:", e);
     })));
-  }, w = () => {
-    A > 0 || f && (f.abort(), f = null);
+  }, m = () => {
+    w > 0 || l && (l.abort(), l = null);
+  }, u = (e) => {
+    if (!t.perChannelSource || i.has(e)) return;
+    const n = new AbortController();
+    i.set(e, n);
+    const s = (r, S) => {
+      h.emit(e, r, S);
+    };
+    Promise.resolve(
+      t.perChannelSource(e, s, { abortSignal: n.signal })
+    ).catch((r) => {
+      console.error(
+        `[velojs] perChannelSource threw for channel "${e}":`,
+        r
+      );
+    });
+  }, d = (e) => {
+    const n = i.get(e);
+    n && (n.abort(), i.delete(e));
   };
-  function E(e, c, n) {
-    let s, l, h;
-    if (!!t.broadcast ? (s = "", l = e, h = c) : (s = e, l = c, h = n), a.has(s)) {
+  function p(e, n, s) {
+    let r, S, E;
+    if (!!t.broadcast ? (r = v, S = e, E = n) : (r = e, S = n, E = s), c.has(r)) {
       console.warn(
-        `[velojs] emit() called on closed channel "${s}" — ignored. Reopen the channel by emitting to a fresh ID, or remove the close() call.`
+        `[velojs] emit() called on closed channel "${r}" — ignored. Reopen the channel by emitting to a fresh ID, or remove the close() call.`
       );
       return;
     }
-    if (h?.snapshot) {
-      const b = o.get(s) ?? [];
-      b.push(l), o.set(s, b);
+    if (E?.snapshot) {
+      const _ = o.get(r) ?? [];
+      _.push(S);
+      const T = t.bufferSize ?? 1 / 0;
+      _.length > T && _.splice(0, _.length - T), o.set(r, _);
     }
-    const v = r.get(s);
-    if (v)
-      for (const b of v) b(l);
+    const C = a.get(r);
+    if (C)
+      for (const _ of C) _(S);
   }
-  function i(e = "") {
-    if (a.has(e)) return;
-    a.add(e);
-    const c = r.get(e);
-    if (c)
-      for (const l of c) l.close();
-    const n = t.retainMs ?? 3e5, s = u.get(e);
-    s && clearTimeout(s), u.set(
+  function g(e = v) {
+    if (c.has(e)) return;
+    c.add(e);
+    const n = a.get(e);
+    if (n)
+      for (const S of n) S.close();
+    const s = t.retainMs ?? R, r = f.get(e);
+    r && clearTimeout(r), f.set(
       e,
       setTimeout(() => {
-        o.delete(e), u.delete(e), a.delete(e);
-      }, n)
+        o.delete(e), f.delete(e), c.delete(e);
+      }, s)
     );
   }
-  const S = {
-    emit: E,
-    close: i,
+  const h = {
+    emit: p,
+    close: g,
     __isVeloEventStream: !0,
     __config: t,
-    __listeners: r,
+    __listeners: a,
     __buffers: o,
     __path: t.path,
-    __onConnect(e, c) {
-      let n = r.get(e);
-      n || (n = /* @__PURE__ */ new Set(), r.set(e, n)), n.add(c), A++, d();
+    __onConnect(e, n) {
+      let s = a.get(e);
+      const r = !s || s.size === 0;
+      s || (s = /* @__PURE__ */ new Set(), a.set(e, s)), s.add(n), w++, b(), r && u(e);
     },
-    __onDisconnect(e, c) {
-      const n = r.get(e);
-      n && (n.delete(c), n.size === 0 && r.delete(e), A--, w());
+    __onDisconnect(e, n) {
+      const s = a.get(e);
+      s && (s.delete(n), s.size === 0 && (a.delete(e), d(e)), w--, m());
+    },
+    __reset() {
+      for (const e of a.values())
+        for (const n of e)
+          try {
+            n.close();
+          } catch {
+          }
+      a.clear(), o.clear(), c.clear();
+      for (const e of f.values()) clearTimeout(e);
+      f.clear(), l && (l.abort(), l = null);
+      for (const e of i.values()) e.abort();
+      i.clear(), w = 0;
     }
   };
-  return t.path && T.push((e) => {
-    g(e, t.path, S, t.middlewares ?? []);
-  }), S;
+  return t.path && A().pendingStreamRoutes.push((e) => {
+    D(e, t.path, h, t.middlewares ?? []);
+  }), I.add(h), h;
 }
-function C(t) {
-  return async (r, { abortSignal: o }) => {
+function B(t) {
+  return async (a, { abortSignal: o }) => {
     for (; !o.aborted; ) {
       try {
-        await t.tick(r);
-      } catch (a) {
-        console.error("[velojs] poll tick threw:", a);
+        await t.tick(a);
+      } catch (c) {
+        console.error("[velojs] poll tick threw:", c);
       }
-      await new Promise((a) => {
-        const u = setTimeout(a, t.intervalMs);
+      await new Promise((c) => {
+        const f = setTimeout(c, t.intervalMs);
         o.addEventListener(
           "abort",
           () => {
-            clearTimeout(u), a();
+            clearTimeout(f), c();
           },
           { once: !0 }
         );
@@ -90,51 +132,68 @@ function C(t) {
     }
   };
 }
-function p(t) {
-  return t.req.query("channel") ?? "";
+function j(t) {
+  return t.req.query("channel") ?? v;
 }
-function g(t, r, o, a = []) {
-  const u = async (f) => {
-    const { streamSSE: A } = await import("hono/streaming"), d = o.__config.broadcast ? "" : (o.__config.channel ?? p)(f), w = o.__config.heartbeatMs, E = w === !1 ? 0 : w ?? 2e4;
-    return A(f, async (i) => {
-      const S = o.__buffers.get(d);
-      if (S && S.length > 0 && await i.writeSSE({
+function D(t, a, o, c = []) {
+  const f = async (l) => {
+    const { streamSSE: w } = await import("hono/streaming");
+    let i;
+    if (o.__config.broadcast)
+      i = v;
+    else {
+      const u = o.__config.channel ?? j;
+      let d;
+      try {
+        d = await u(l);
+      } catch (p) {
+        return console.error("[velojs] channel resolver threw:", p), l.json({ error: "internal" }, 500);
+      }
+      if (d == null)
+        return l.json({ error: "forbidden" }, 403);
+      i = d;
+    }
+    const b = o.__config.heartbeatMs, m = b === !1 ? 0 : b ?? M;
+    return w(l, async (u) => {
+      const d = o.__buffers.get(i);
+      if (d && d.length > 0 && await u.writeSSE({
         event: "snapshot",
-        data: JSON.stringify(S)
+        data: JSON.stringify(d)
       }), o.__config.snapshot) {
-        const _ = await o.__config.snapshot(
-          d === "" ? void 0 : d
+        const r = await o.__config.snapshot(
+          i === v ? void 0 : i
         );
-        _ !== void 0 && await i.writeSSE({
+        r !== void 0 && await u.writeSSE({
           event: "snapshot",
-          data: JSON.stringify(_)
+          data: JSON.stringify(r)
         });
       }
-      let e;
-      const c = new Promise((_) => {
-        e = _;
+      let p;
+      const g = new Promise((r) => {
+        p = r;
       });
-      let n = !1, s = null;
-      const l = () => {
-        n || (n = !0, s && clearInterval(s), o.__onDisconnect(d, h), e());
-      }, h = ((_) => {
-        n || (i.writeSSE({ data: JSON.stringify(_) }).catch(() => {
-        }), o.__config.closeOn?.(_) && (i.close(), l()));
+      let h = !1, e = null;
+      const n = () => {
+        h || (h = !0, e && clearInterval(e), o.__onDisconnect(i, s), p());
+      }, s = ((r) => {
+        h || (u.writeSSE({ data: JSON.stringify(r) }).catch(() => {
+        }), o.__config.closeOn?.(r) && (u.close(), n()));
       });
-      h.close = () => {
-        n || (i.writeSSE({ event: "close", data: "" }).catch(() => {
-        }), i.close(), l());
-      }, o.__onConnect(d, h), s = E > 0 ? setInterval(() => {
-        n || i.writeSSE({ event: "heartbeat", data: "" }).catch(() => {
+      s.close = () => {
+        h || (u.writeSSE({ event: "close", data: "" }).catch(() => {
+        }), u.close(), n());
+      }, o.__onConnect(i, s), e = m > 0 ? setInterval(() => {
+        h || u.writeSSE({ event: "heartbeat", data: "" }).catch(() => {
         });
-      }, E) : null, i.onAbort(l), await c;
+      }, m) : null, u.onAbort(n), await g;
     });
   };
-  a.length > 0 ? t.on(["GET"], [r], ...a, u) : t.on(["GET"], [r], u);
+  c.length > 0 ? t.on(["GET"], [a], ...c, f) : t.on(["GET"], [a], f);
 }
 export {
-  N as createEventStream,
-  m as flushPendingStreamRoutes,
-  C as poll,
-  g as registerStreamHandler
+  L as createEventStream,
+  x as flushPendingStreamRoutes,
+  y as getRegisteredStreams,
+  B as poll,
+  D as registerStreamHandler
 };

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export type { VeloConfig } from "./config.js";
 export { defineConfig } from "./config.js";
 export { Scripts, Link } from "./components.js";
 export { createEventStream, poll } from "./events.js";
-export type { EventStream, EventStreamConfig, EmitFn, EmitOptions, SourceFn, } from "./events.js";
+export type { EventStream, EventStreamConfig, EmitFn, EmitOptions, SourceFn, PerChannelSourceFn, ChannelResolver, } from "./events.js";
 export type { Context, MiddlewareHandler, Next } from "hono";