@mauroandre/velojs 0.0.18 → 0.0.20

package/README.md

@@ -501,6 +501,200 @@ export const action_login = async ({ body }: { body: LoginBody }) => {
 
 **Error handling**: Actions do NOT throw on server errors. They resolve with `{ error: "message" }`. Always check `result.error` explicitly.
 
+### Shared actions in Layouts
+
+Actions are tied to the module where they're declared — the route is always `/_action/{moduleId}/{actionName}`. Declare an action in a Layout and import it from any child module to share it across multiple pages.
+
+```typescript
+// app/admin/Layout.tsx — action declared once in the layout
+import type { ActionArgs } from "@mauroandre/velojs";
+
+export const action_logout = async ({ c }: ActionArgs) => {
+    const { deleteCookie } = await import("@mauroandre/velojs/cookie");
+    deleteCookie(c!, "session");
+    return { ok: true };
+};
+
+export const Component = ({ children }) => (/* layout with children */);
+```
+
+```typescript
+// app/admin/Dashboard.tsx — imports and uses the action from Layout
+import { action_logout } from "./Layout.js";
+
+export const Component = () => (
+    <button onClick={async () => {
+        await action_logout({});
+        window.location.href = "/login";
+    }}>Logout</button>
+);
+```
+
+The client-side transform rewrites the import to fetch `/_action/admin/Layout/logout`, so the action always points to the correct URL regardless of where it's imported. Middlewares on the Layout apply automatically.
+
+---
+
+## Event Streams
+
+Push real-time updates from server to client via Server-Sent Events (SSE). Live progress, notifications, metrics, log streaming, AI tokens — anything server → client.
+
+Three verbs: `emit`, `close`, `useEventStream`. The framework handles routing, types, listener management, snapshots, lifecycle, reconnection, and cleanup.
+
+### Shortest example
+
+```typescript
+// app/admin/Provision.tsx
+import { createEventStream } from "@mauroandre/velojs";
+import { useEventStream } from "@mauroandre/velojs/hooks";
+
+export const stream_logs = createEventStream<string>();
+
+export const Component = () => {
+    const { snapshot, data, closed } = useEventStream(stream_logs, { channel: sessionId });
+    const lines = [...(snapshot.value ?? []), ...(data.value ? [data.value] : [])];
+    return <pre>{lines.join("\n")}{closed.value && "\n[done]"}</pre>;
+};
+```
+
+```typescript
+// app/admin/provision.service.ts
+import { stream_logs } from "./Provision.js";
+
+export async function provision(sessionId: string) {
+    try {
+        stream_logs.emit(sessionId, "Connecting...", { snapshot: true });
+        // ... real work
+        stream_logs.emit(sessionId, "Worker ready.", { snapshot: true });
+    } finally {
+        stream_logs.close(sessionId);
+    }
+}
+```
+
+One line to declare, three verbs to use. Route at `/_event/admin/Provision/logs` is registered automatically. Middlewares inherited from parent route nodes.
+
+### Two ways to declare
+
+**Convention `stream_*`** (recommended) — for streams logically tied to a page/layout. Path derived from module ID, middlewares inherited.
+
+```typescript
+export const stream_progress = createEventStream<DeployState>();
+```
+
+**Standalone** — for cross-cutting streams (global metrics, notifications). Pass `path` and (if needed) `middlewares` explicitly.
+
+```typescript
+export const containerMetrics = createEventStream<Metric[]>({
+    path: "/api/metrics/containers",
+    middlewares: [authMiddleware],
+});
+```
+
+### Three ways to emit
+
+**Reactive** — call `emit()` from anywhere when something happens. Most common:
+
+```typescript
+stream_logs.emit(sessionId, "Line", { snapshot: true });
+```
+
+**Source-driven** — pass a `source` function. Framework runs it only while subscribed (zero CPU when nobody is watching):
+
+```typescript
+import { poll } from "@mauroandre/velojs";
+
+export const stream_metrics = createEventStream<Metric[]>({
+    source: poll({
+        intervalMs: 3000,
+        tick: async (emit) => emit(await collectMetrics()),
+    }),
+});
+```
+
+**Stateful snapshot** — for state-machine patterns where each emit is the complete current state:
+
+```typescript
+const deploys = new Map<string, DeployState>();
+
+export const stream_deploy = createEventStream<DeployState>({
+    snapshot: (id) => deploys.get(id ?? ""),
+});
+```
+
+### Configuration
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `path` | `string` | (Standalone) Explicit URL path |
+| `channel` | `(c) => string` | Extract channel ID. Default: `?channel=...` query param |
+| `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 |
+| `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 |
+
+### Snapshot mechanisms
+
+Two snapshot patterns for two cases:
+
+**Per-emit `{ snapshot: true }` — append pattern.** Framework keeps a buffer per channel. Late subscribers receive the array.
+
+```typescript
+stream_logs.emit(id, "line 1", { snapshot: true });
+stream_logs.emit(id, "line 2", { snapshot: true });
+// Late subscriber → snapshot.value = ["line 1", "line 2"]
+```
+
+**`snapshot: callback` config — replace pattern.** You return the latest state from your own data structure.
+
+```typescript
+createEventStream({ snapshot: (id) => deploys.get(id ?? "") });
+// Late subscriber → snapshot.value = the latest DeployState
+```
+
+Both survive after `close()` for `retainMs` (default 5 min) so refresh-after-finish still shows final state.
+
+### Closing
+
+Two ways, choose either or both:
+
+```typescript
+// Imperative — call from anywhere
+stream.close(channelId);
+
+// Declarative — predicate on event
+createEventStream({ closeOn: (s) => s.status === "success" });
+```
+
+After close, subsequent `emit()` to that channel is ignored with a warning.
+
+### `useEventStream` hook
+
+```typescript
+const { data, snapshot, closed, error } = useEventStream(stream, {
+    channel: "deploy-123",  // optional
+    enabled: true,          // optional
+});
+```
+
+| Signal | Description |
+|--------|-------------|
+| `data` | Latest event received |
+| `snapshot` | Initial state on connect (buffer or callback) |
+| `closed` | `true` when server closed the stream |
+| `error` | Parse or connection error, if any |
+
+Lifecycle is automatic: opens on mount, closes on unmount, re-opens fresh when `channel` changes.
+
+### `poll` helper
+
+For interval-based polling sources. Wraps your tick function in a loop that respects the `AbortSignal`. Errors in tick are logged but don't stop the loop.
+
+```typescript
+poll({ intervalMs: 3000, tick: async (emit) => emit(await collect()) })
+```
+
 ---
 
 ## Hooks
@@ -511,6 +705,7 @@ All hooks work in both SSR and client (via AsyncLocalStorage on server, wouter/D
 |------|-------------|
 | `useLoader<T>(deps?)` | Loader data with SSR + SPA support. Returns `{ data, loading, refetch }` |
 | `Loader<T>()` | Module-level SSR-only loader. Returns `{ data, loading }` |
+| `useEventStream<T, S>(stream, opts?)` | Subscribe to a server-sent event stream. Returns `{ data, snapshot, closed, error }` |
 | `useParams<T>()` | Route parameters (e.g., `:id`) |
 | `useQuery<T>()` | Query string parameters |
 | `useNavigate()` | Programmatic navigation. Returns `navigate(path)` function |
@@ -701,7 +896,25 @@ export default [
 
 ### Inheritance
 
-Middlewares accumulate from parent to child. In the example above, `/master/workers` runs `authMiddleware` first, then `masterMiddleware`. This applies to both page loads (loaders) and action calls.
+Middlewares accumulate from parent to child and apply to **every nested route**, including:
+
+- **Page routes** (GET) — when loading a page
+- **Action routes** (POST `/_action/...`) — when calling a server action
+- **Data fetches** (GET with `?_data=1`) — during SPA navigation
+
+In the example above, `/master/workers` runs `authMiddleware` first, then `masterMiddleware`. The same applies when calling `action_*` functions from any page under `MasterLayout` — both middlewares run before the action executes.
+
+```typescript
+// This action, defined in app/master/Workers.tsx, is registered as
+// POST /_action/master/Workers/delete
+// with authMiddleware + masterMiddleware applied.
+export const action_delete = async ({ body, c }: ActionArgs<{ id: string }>) => {
+    const user = c!.get("user"); // set by authMiddleware
+    // ...
+};
+```
+
+A middleware on a Layout guards everything underneath it — pages, loaders, and actions — with no extra wiring.
 
 ### Accessing middleware data in loaders and actions
 
@@ -927,10 +1140,11 @@ Hooks (`useParams`, `useQuery`, `usePathname`, `Loader`, `useLoader`) access thi
 
 | Import | Contents |
 |--------|----------|
-| `@mauroandre/velojs` | Types (`AppRoutes`, `ActionArgs`, `LoaderArgs`, `Metadata`), `Scripts`, `Link`, `defineConfig` |
+| `@mauroandre/velojs` | Types (`AppRoutes`, `ActionArgs`, `LoaderArgs`, `Metadata`, `EventStream`, `EventStreamConfig`, `EmitFn`, `EmitOptions`, `SourceFn`), `Scripts`, `Link`, `createEventStream`, `poll`, `defineConfig` |
 | `@mauroandre/velojs/server` | `startServer`, `createApp`, `addRoutes`, `onServer`, `serverDataStorage` |
 | `@mauroandre/velojs/client` | `startClient` |
-| `@mauroandre/velojs/hooks` | `Loader`, `useLoader`, `useParams`, `useQuery`, `useNavigate`, `usePathname`, `touch` |
+| `@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/cookie` | `getCookie`, `setCookie`, `deleteCookie`, `getSignedCookie`, `setSignedCookie` |
 | `@mauroandre/velojs/factory` | `createMiddleware`, `createFactory` |
 | `@mauroandre/velojs/vite` | `veloPlugin` |

package/dist/events.d.ts

@@ -0,0 +1,184 @@
+/**
+ * VeloJS Event Streams
+ * Server-Sent Events (SSE) with snapshot, channels, source-driven emission, and auto-close.
+ *
+ * Two ways to declare:
+ *
+ * 1. Convention `stream_*` (per-page or per-layout, route registered automatically):
+ * ```typescript
+ * // app/admin/Deploy.tsx
+ * export const stream_progress = createEventStream<DeployState>();
+ * ```
+ *
+ * 2. Standalone (cross-cutting streams like global metrics):
+ * ```typescript
+ * export const metricsStream = createEventStream<Metric[]>({
+ *     path: "/api/metrics",
+ *     middlewares: [authMiddleware],
+ * });
+ * ```
+ *
+ * Three ways to emit (server-side):
+ *
+ * - Reactive (call from anywhere when something happens):
+ *   `stream.emit(channelId, value, { snapshot: true })`
+ * - Source-driven (framework runs your producer only when subscribed):
+ *   `createEventStream({ source: poll({ intervalMs, tick }) })`
+ * - Stateful snapshot via callback (for state-machine patterns):
+ *   `createEventStream({ snapshot: (channelId) => activeStates.get(channelId) })`
+ */
+import type { Context, Hono, MiddlewareHandler } from "hono";
+/** Function passed to `source` for emitting values. */
+export type EmitFn<TEvent> = {
+    /** Broadcast emit (no channel) */
+    (event: TEvent, options?: EmitOptions): void;
+    /** Channel-targeted emit */
+    (channel: string, event: TEvent, options?: EmitOptions): void;
+};
+/** Options accepted by `emit()` per call. */
+export interface EmitOptions {
+    /**
+     * If true, the value is appended to the stream's internal buffer for that channel.
+     * Late subscribers receive the full buffer as a snapshot on connect.
+     * Default: false (event is broadcast-only, not retained).
+     */
+    snapshot?: boolean;
+}
+/**
+ * A producer function that runs **only when there are active subscribers**.
+ * The framework passes an `AbortSignal` that fires when the last subscriber disconnects.
+ *
+ * Example (event-driven):
+ * ```typescript
+ * source: async (emit, { abortSignal }) => {
+ *     const handler = (e) => emit(e);
+ *     bus.on("event", handler);
+ *     abortSignal.addEventListener("abort", () => bus.off("event", handler));
+ *     await new Promise(r => abortSignal.addEventListener("abort", r));
+ * }
+ * ```
+ *
+ * For polling, use the `poll` helper instead of writing the loop yourself.
+ *
+ * **Anti-pattern**: ignoring `abortSignal` keeps the source running forever (and leaks
+ * resources). Only do this if the producer is meant to run independently of UI.
+ */
+export type SourceFn<TEvent> = (emit: EmitFn<TEvent>, ctx: {
+    abortSignal: AbortSignal;
+}) => void | Promise<void>;
+export interface EventStreamConfig<TEvent, TSnapshot = TEvent> {
+    /**
+     * Explicit URL path for the SSE endpoint (standalone usage).
+     * When omitted, the path is derived from the module ID at build time
+     * (convention `stream_*`).
+     */
+    path?: string;
+    /**
+     * Channel selector — extracts a channel ID from the request.
+     * Subscribers only receive events emitted to their channel.
+     * When omitted, defaults to `c.req.query("channel") ?? ""` so client-side
+     * `useEventStream(stream, { channel })` works out of the box.
+     */
+    channel?: (c: Context) => string;
+    /**
+     * Returns the current state of a channel for snapshot-on-connect.
+     * Sent before any new events to bring the client up to date.
+     *
+     * Use this for **state-machine patterns** where each emit is a complete state
+     * (deploy progress, migration status). The callback returns the latest state.
+     *
+     * For **append-only patterns** (logs, tokens), prefer `emit(..., { snapshot: true })`
+     * which uses an internal buffer managed by the framework.
+     */
+    snapshot?: (channel: string | undefined) => TSnapshot | undefined | Promise<TSnapshot | undefined>;
+    /**
+     * Returns true when an event marks the end of the stream for that channel.
+     * The server closes the SSE connection after sending such an event.
+     *
+     * For imperative close from anywhere, use `stream.close(channel)` instead.
+     */
+    closeOn?: (event: TEvent) => boolean;
+    /**
+     * Heartbeat interval in milliseconds. Sends `:heartbeat\n\n` to keep
+     * proxies (Cloudflare, Nginx, ALB) from closing idle connections.
+     * Default: 20000 (20s). Set to `false` to disable.
+     */
+    heartbeatMs?: number | false;
+    /**
+     * Middlewares to apply to the SSE route (standalone streams only).
+     * For `stream_*` convention streams, middlewares are inherited from
+     * parent route nodes automatically.
+     */
+    middlewares?: MiddlewareHandler[];
+    /**
+     * Self-running producer that emits values into the stream.
+     * The framework only invokes `source` while there are active subscribers.
+     * When the last subscriber disconnects, the AbortSignal fires.
+     *
+     * Use the `poll` helper for the common interval-based pattern.
+     */
+    source?: SourceFn<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;
+}
+export interface EventStream<TEvent, TSnapshot = TEvent> {
+    /** Broadcast emit (no channel) */
+    emit(event: TEvent, options?: EmitOptions): void;
+    /** Channel-targeted emit */
+    emit(channel: string, event: TEvent, options?: EmitOptions): void;
+    /**
+     * Closes the stream (or a specific channel).
+     * - Notifies current subscribers so their `useEventStream().closed` becomes true.
+     * - Schedules cleanup of the per-channel buffer after `retainMs`.
+     * - Idempotent: calling close on an already-closed channel is a no-op.
+     */
+    close(channel?: string): void;
+    /** Internal: marker for runtime detection */
+    readonly __isVeloEventStream: true;
+    /** Internal: configuration */
+    readonly __config: EventStreamConfig<TEvent, TSnapshot>;
+    /** Internal: registered listeners by channel ("" for broadcast) */
+    readonly __listeners: Map<string, Set<StreamListener<TEvent>>>;
+    /** Internal: per-channel buffer for { snapshot: true } emits */
+    readonly __buffers: Map<string, TEvent[]>;
+    /** Internal: assigned URL path (set by standalone or by stream_* discovery) */
+    __path: string | undefined;
+    /** Internal: source lifecycle hook */
+    __onConnect(channelKey: string, listener: StreamListener<TEvent>): void;
+    /** Internal: source lifecycle hook */
+    __onDisconnect(channelKey: string, listener: StreamListener<TEvent>): void;
+}
+/** Internal listener — receives events and a close signal. */
+interface StreamListener<TEvent> {
+    (event: TEvent): void;
+    close(): void;
+}
+export declare function flushPendingStreamRoutes(app: Hono): void;
+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.
+ * The tick function is wrapped in try/catch — errors are logged but don't stop the loop.
+ *
+ * ```typescript
+ * export const stream_metrics = createEventStream<Metric[]>({
+ *     source: poll({
+ *         intervalMs: 3000,
+ *         tick: async (emit) => emit(await collectMetrics()),
+ *     }),
+ * });
+ * ```
+ */
+export declare function poll<TEvent>(opts: {
+    intervalMs: number;
+    tick: (emit: EmitFn<TEvent>) => void | Promise<void>;
+}): SourceFn<TEvent>;
+/**
+ * Registers a GET SSE route for the given stream at the given path.
+ * Used both by standalone streams and by stream_* discovery.
+ */
+export declare function registerStreamHandler<TEvent, TSnapshot>(app: Hono, path: string, stream: EventStream<TEvent, TSnapshot>, middlewares?: Array<(c: Context, next: () => Promise<void>) => any>): void;
+export {};

package/dist/events.js

@@ -0,0 +1,137 @@
+const p = [];
+function m(t) {
+  for (const r of p) r(t);
+  p.length = 0;
+}
+function C(t = {}) {
+  const r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Map();
+  let u = null, S = 0;
+  const b = () => {
+    t.source && (u || (u = new AbortController(), Promise.resolve(
+      t.source(A, { abortSignal: u.signal })
+    ).catch((e) => {
+      console.error("[velojs] event stream source threw:", e);
+    })));
+  }, h = () => {
+    S > 0 || u && (u.abort(), u = null);
+  };
+  function A(e, i, s) {
+    let o, l, d;
+    if (!!t.channel ? (o = e, l = i, d = s) : (o = "", l = e, d = i), a.has(o)) {
+      console.warn(
+        `[velojs] emit() called on closed channel "${o}" — ignored. Reopen the channel by emitting to a fresh ID, or remove the close() call.`
+      );
+      return;
+    }
+    if (d?.snapshot) {
+      const T = n.get(o) ?? [];
+      T.push(l), n.set(o, T);
+    }
+    const f = r.get(o);
+    if (f)
+      for (const T of f) T(l);
+  }
+  function E(e = "") {
+    if (a.has(e)) return;
+    a.add(e);
+    const i = r.get(e);
+    if (i)
+      for (const l of i) l.close();
+    const s = t.retainMs ?? 3e5, o = _.get(e);
+    o && clearTimeout(o), _.set(
+      e,
+      setTimeout(() => {
+        n.delete(e), _.delete(e), a.delete(e);
+      }, s)
+    );
+  }
+  const c = {
+    emit: A,
+    close: E,
+    __isVeloEventStream: !0,
+    __config: t,
+    __listeners: r,
+    __buffers: n,
+    __path: t.path,
+    __onConnect(e, i) {
+      let s = r.get(e);
+      s || (s = /* @__PURE__ */ new Set(), r.set(e, s)), s.add(i), S++, b();
+    },
+    __onDisconnect(e, i) {
+      const s = r.get(e);
+      s && (s.delete(i), s.size === 0 && r.delete(e), S--, h());
+    }
+  };
+  return t.path && p.push((e) => {
+    v(e, t.path, c, t.middlewares ?? []);
+  }), c;
+}
+function N(t) {
+  return async (r, { abortSignal: n }) => {
+    for (; !n.aborted; ) {
+      try {
+        await t.tick(r);
+      } catch (a) {
+        console.error("[velojs] poll tick threw:", a);
+      }
+      await new Promise((a) => {
+        const _ = setTimeout(a, t.intervalMs);
+        n.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(_), a();
+          },
+          { once: !0 }
+        );
+      });
+    }
+  };
+}
+function g(t) {
+  return t.req.query("channel") ?? "";
+}
+function v(t, r, n, a = []) {
+  const _ = async (u) => {
+    const { streamSSE: S } = await import("hono/streaming"), h = (n.__config.channel ?? g)(u), A = n.__config.heartbeatMs, E = A === !1 ? 0 : A ?? 2e4;
+    return S(u, async (c) => {
+      const e = n.__buffers.get(h);
+      if (e && e.length > 0 && await c.writeSSE({
+        event: "snapshot",
+        data: JSON.stringify(e)
+      }), n.__config.snapshot) {
+        const f = await n.__config.snapshot(
+          h === "" ? void 0 : h
+        );
+        f !== void 0 && await c.writeSSE({
+          event: "snapshot",
+          data: JSON.stringify(f)
+        });
+      }
+      let i;
+      const s = new Promise((f) => {
+        i = f;
+      });
+      let o = !1, l = null;
+      const d = () => {
+        o || (o = !0, l && clearInterval(l), n.__onDisconnect(h, w), i());
+      }, w = ((f) => {
+        o || (c.writeSSE({ data: JSON.stringify(f) }).catch(() => {
+        }), n.__config.closeOn?.(f) && (c.close(), d()));
+      });
+      w.close = () => {
+        o || (c.writeSSE({ event: "close", data: "" }).catch(() => {
+        }), c.close(), d());
+      }, n.__onConnect(h, w), l = E > 0 ? setInterval(() => {
+        o || c.writeSSE({ event: "heartbeat", data: "" }).catch(() => {
+        });
+      }, E) : null, c.onAbort(d), await s;
+    });
+  };
+  a.length > 0 ? t.on(["GET"], [r], ...a, _) : t.on(["GET"], [r], _);
+}
+export {
+  C as createEventStream,
+  m as flushPendingStreamRoutes,
+  N as poll,
+  v as registerStreamHandler
+};

package/dist/hooks.d.ts

@@ -1,4 +1,5 @@
 import { type Signal } from "@preact/signals";
+import type { EventStream } from "./events.js";
 export declare const __veloUpdatePending: Signal<boolean>;
 /**
  * Força o signal a notificar mudanças após mutação de propriedades aninhadas
@@ -118,3 +119,33 @@ export declare function useQuery<T extends Record<string, string> = Record<strin
  * ```
  */
 export declare function usePathname(): string;
+/**
+ * Subscribes to a server event stream (SSE) created with createEventStream.
+ *
+ * Returns:
+ * - `data`: Signal with the latest event received (null until first event)
+ * - `snapshot`: Signal with the initial snapshot if the server provided one
+ * - `closed`: Signal that becomes true when the stream is closed by the server
+ * - `error`: Signal with the connection error, if any
+ *
+ * Usage:
+ * ```tsx
+ * // Per-page stream (stream_* convention)
+ * const { data, snapshot } = useEventStream(stream_progress, { channel: deployId });
+ *
+ * // Standalone stream (no channel)
+ * const { data } = useEventStream(metricsStream);
+ * ```
+ *
+ * The connection closes automatically when the component unmounts or when
+ * the channel changes (re-opens with new channel).
+ */
+export declare function useEventStream<TEvent, TSnapshot = TEvent>(stream: EventStream<TEvent, TSnapshot>, options?: {
+    channel?: string;
+    enabled?: boolean;
+}): {
+    data: Signal<TEvent | null>;
+    snapshot: Signal<TSnapshot | null>;
+    closed: Signal<boolean>;
+    error: Signal<Error | null>;
+};