stitchkit 0.60.1 → 0.61.0

package/dist/server/index.js

@@ -7,7 +7,7 @@ import {
   parseMultipart,
   socketIoLane,
   webSocketLane
-} from "../index-2cgbdckv.js";
+} from "../index-s1tywej8.js";
 import {
   composeAuthHooks,
   createAuthHook,
@@ -973,9 +973,11 @@ function streamSSE(generator) {
         controller.close();
       }
     },
-    async cancel() {
+    cancel() {
       cancelled = true;
-      await generator.return(undefined);
+      generator.return(undefined).catch(() => {
+        return;
+      });
     }
   });
   return new Response(stream, {
@@ -1019,10 +1021,198 @@ async function* parseSSE(response, options) {
     reader.releaseLock();
   }
 }
+// src/server/streaming-route.ts
+var DEFAULT_STREAM_HEARTBEAT_MS = 5000;
+var FRAMINGS = {
+  ndjson: {
+    contentType: "application/x-ndjson",
+    keepAlive: `
+`,
+    frame: (value) => `${JSON.stringify(value)}
+`
+  },
+  sse: {
+    contentType: "text/event-stream",
+    keepAlive: `: keep-alive
+
+`,
+    frame: (value) => `data: ${JSON.stringify(value)}
+
+`,
+    done: `data: [DONE]
+
+`
+  }
+};
+function applyIdleTimeout(server, request, seconds) {
+  if (typeof server !== "object" || server === null)
+    return;
+  const timeout = Reflect.get(server, "timeout");
+  if (typeof timeout !== "function")
+    return;
+  try {
+    Reflect.apply(timeout, server, [request, seconds]);
+  } catch {}
+}
+function unrefTimer(timer) {
+  if (typeof timer !== "object" || timer === null)
+    return;
+  const unref = Reflect.get(timer, "unref");
+  if (typeof unref === "function")
+    Reflect.apply(unref, timer, []);
+}
+var MAX_BUFFERED_FRAMES = 16;
+function responseHeaders(framing, extra) {
+  const headers = new Headers(extra);
+  headers.set("Content-Type", framing.contentType);
+  headers.set("Cache-Control", "no-cache");
+  headers.set("Connection", "keep-alive");
+  headers.set("X-Accel-Buffering", "no");
+  return headers;
+}
+function streamingRoute(options) {
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STREAM_HEARTBEAT_MS;
+  if (!Number.isFinite(heartbeatMs) || heartbeatMs <= 0) {
+    throw new TypeError("heartbeatMs must be a finite positive number of milliseconds");
+  }
+  const idleTimeoutSeconds = options.idleTimeoutSeconds ?? 0;
+  if (!Number.isInteger(idleTimeoutSeconds) || idleTimeoutSeconds < 0) {
+    throw new TypeError("idleTimeoutSeconds must be a non-negative integer");
+  }
+  const framing = FRAMINGS[options.format ?? "ndjson"];
+  return {
+    method: options.method ?? "GET",
+    path: options.path,
+    handler: async (request, context) => {
+      applyIdleTimeout(context.server, request, idleTimeoutSeconds);
+      const departed = new AbortController;
+      const iterable = await options.source(request, { ...context, signal: departed.signal });
+      const iterator = iterable[Symbol.asyncIterator]();
+      const encoder = new TextEncoder;
+      let heartbeat = null;
+      let closed = false;
+      const stopHeartbeat = () => {
+        if (heartbeat === null)
+          return;
+        clearInterval(heartbeat);
+        heartbeat = null;
+      };
+      const release = () => {
+        if (closed)
+          return;
+        closed = true;
+        try {
+          stopHeartbeat();
+          signalDemand();
+          departed.abort();
+          Promise.resolve(iterator.return?.(undefined)).catch(() => {
+            return;
+          });
+        } catch {}
+      };
+      let demand = null;
+      const signalDemand = () => {
+        const resolve2 = demand;
+        demand = null;
+        resolve2?.();
+      };
+      const stream = new ReadableStream({
+        start(controller) {
+          const send = (text) => {
+            if (closed)
+              return false;
+            try {
+              controller.enqueue(encoder.encode(text));
+              return true;
+            } catch {
+              release();
+              return false;
+            }
+          };
+          const finish = () => {
+            try {
+              controller.close();
+            } catch {}
+          };
+          if (request.signal.aborted) {
+            release();
+            finish();
+            return;
+          }
+          request.signal.addEventListener("abort", () => {
+            release();
+            finish();
+          });
+          send(framing.keepAlive);
+          heartbeat = setInterval(() => {
+            if ((controller.desiredSize ?? 1) > 0)
+              send(framing.keepAlive);
+          }, heartbeatMs);
+          unrefTimer(heartbeat);
+          const awaitDemand = async () => {
+            while (!closed && (controller.desiredSize ?? 1) <= 0) {
+              await new Promise((resolve2) => {
+                demand = resolve2;
+              });
+            }
+          };
+          let sinceYield = 0;
+          (async () => {
+            try {
+              for (;; ) {
+                await awaitDemand();
+                if (closed)
+                  return;
+                const next = await iterator.next();
+                if (closed)
+                  return;
+                if (next.done)
+                  break;
+                if (!send(framing.frame(next.value)))
+                  return;
+                sinceYield += 1;
+                if (sinceYield >= MAX_BUFFERED_FRAMES) {
+                  sinceYield = 0;
+                  await new Promise((resolve2) => {
+                    setTimeout(resolve2, 0);
+                  });
+                  if (closed)
+                    return;
+                }
+              }
+              if (framing.done)
+                send(framing.done);
+            } catch (error) {
+              if (!closed)
+                send(framing.frame(normalizeError(error).toJSON()));
+            } finally {
+              release();
+              finish();
+            }
+          })();
+        },
+        pull() {
+          signalDemand();
+        },
+        cancel() {
+          release();
+        }
+      }, { highWaterMark: MAX_BUFFERED_FRAMES });
+      return new Response(stream, { headers: responseHeaders(framing, options.headers) });
+    }
+  };
+}
+function ndjsonRoute(options) {
+  return streamingRoute({ ...options, format: "ndjson" });
+}
+function sseRoute(options) {
+  return streamingRoute({ ...options, format: "sse" });
+}
 export {
   AppError,
   DEFAULT_CORS_ALLOW_HEADERS,
   DEFAULT_CORS_EXPOSE_HEADERS,
+  DEFAULT_STREAM_HEARTBEAT_MS,
   STITCH_ERROR_STATUS,
   ShutdownOptionsSchema,
   ShutdownResultSchema,
@@ -1069,6 +1259,7 @@ export {
   implementRegistry,
   isStitchErrorCode,
   isWithinDir,
+  ndjsonRoute,
   normalizeError,
   notFound,
   openApiRoute,
@@ -1085,8 +1276,10 @@ export {
   serveFile,
   signJwt,
   socketIoLane,
+  sseRoute,
   staticRoute,
   streamSSE,
+  streamingRoute,
   unauthorized,
   verifyJwt,
   verifyPkce,

package/dist/server/socket-io.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket-io.d.ts","sourceRoot":"","sources":["../../src/server/socket-io.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,KAAK,EACV,MAAM,IAAI,SAAS,EAEpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EACV,gBAAgB,EAChB,MAAM,IAAI,cAAc,EAGzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAA2B,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,aAAa,CAAC;AAc/D,YAAY,EACV,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,SAAS,EAAE,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACzD;;;;;OAKG;IACH,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,6EAA6E;IAC7E,aAAa,IAAI,IAAI,CAAC;IACtB,8EAA8E;IAC9E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,sEAAsE;IACtE,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB,CACnC,aAAa,SAAS,cAAc,EACpC,aAAa,SAAS,cAAc,EACpC,KAAK,GAAG,GAAG,CACX,SAAQ,uBAAuB;IAC/B,+EAA+E;IAC/E,EAAE,EAAE,cAAc,CAAC,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;CAC3E;AA0ID,wBAAsB,oBAAoB,CACxC,aAAa,SAAS,cAAc,EACpC,aAAa,SAAS,cAAc,EAKpC,OAAO,GAAG,GAAG,EACb,KAAK,GAAG,OAAO,EAEf,MAAM,EAAE,oBAAoB,CAAC,OAAO,EAAE,KAAK,CAAC,GAC3C,OAAO,CAAC,oBAAoB,CAAC,aAAa,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC,CAmKpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,oBAAoB,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,WAAW,CAAC,GAC3E,YAAY,CAMd"}
+{"version":3,"file":"socket-io.d.ts","sourceRoot":"","sources":["../../src/server/socket-io.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,KAAK,EACV,MAAM,IAAI,SAAS,EAEpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EACV,gBAAgB,EAChB,MAAM,IAAI,cAAc,EAGzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAA2B,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,aAAa,CAAC;AAc/D,YAAY,EACV,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,SAAS,EAAE,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACzD;;;;;OAKG;IACH,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,6EAA6E;IAC7E,aAAa,IAAI,IAAI,CAAC;IACtB,8EAA8E;IAC9E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,sEAAsE;IACtE,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB,CACnC,aAAa,SAAS,cAAc,EACpC,aAAa,SAAS,cAAc,EACpC,KAAK,GAAG,GAAG,CACX,SAAQ,uBAAuB;IAC/B,+EAA+E;IAC/E,EAAE,EAAE,cAAc,CAAC,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;CAC3E;AA8HD,wBAAsB,oBAAoB,CACxC,aAAa,SAAS,cAAc,EACpC,aAAa,SAAS,cAAc,EAKpC,OAAO,GAAG,GAAG,EACb,KAAK,GAAG,OAAO,EAEf,MAAM,EAAE,oBAAoB,CAAC,OAAO,EAAE,KAAK,CAAC,GAC3C,OAAO,CAAC,oBAAoB,CAAC,aAAa,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC,CAmKpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,oBAAoB,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,WAAW,CAAC,GAC3E,YAAY,CAMd"}

package/dist/server/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/server/stream.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,QAAQ,CAmCtE;AAED,8BAA8B;AAC9B,MAAM,WAAW,eAAe;IAC9B,sFAAsF;IACtF,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpD;AAED;;;;GAIG;AACH,wBAAuB,QAAQ,CAAC,CAAC,EAC/B,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CAAC,CAAC,CAAC,CAmCnB"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/server/stream.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,QAAQ,CA2CtE;AAED,8BAA8B;AAC9B,MAAM,WAAW,eAAe;IAC9B,sFAAsF;IACtF,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpD;AAED;;;;GAIG;AACH,wBAAuB,QAAQ,CAAC,CAAC,EAC/B,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CAAC,CAAC,CAAC,CAmCnB"}

package/dist/server/streaming-route.d.ts

@@ -0,0 +1,130 @@
+/**
+ * A long-lived response, with the three things everyone has to remember.
+ *
+ * `RawRoute` + `ctx.server` already gave every capability needed to serve a
+ * continuing NDJSON or SSE body. The problem was never capability — it was that
+ * the author of each such route had to independently remember three unrelated
+ * things, and forgetting any one of them breaks the stream **silently**:
+ *
+ * 1. **Clear the generic HTTP idle timeout.** Without `server.timeout(req, 0)`
+ *    Bun resets the connection after ten seconds. For a stream whose normal
+ *    state is silence — a subscription to a rare event, the log of an idle
+ *    process — that is a healthy connection being severed on a schedule.
+ * 2. **Send a heartbeat.** Even with the timeout cleared, intermediate proxies
+ *    and client stacks are under no obligation to hold a connection carrying no
+ *    bytes.
+ * 3. **Flush the headers at open.** A runtime does not send the response until
+ *    the body produces something, so the consumer's `fetch` does not return
+ *    until the first frame. On a quiet stream "subscribed and silent" becomes
+ *    indistinguishable from "not answering" — and there is nothing to inspect,
+ *    because there is no response yet.
+ *
+ * Each is obvious alone. Together they are a checklist that lived in the head
+ * of whoever wrote the route rather than in the types — and a route written
+ * later, doing the same job for another plane, got none of the three. Reviews
+ * did not catch it and neither did the tests, because every test published an
+ * event immediately and never lived long enough to reach the threshold. The
+ * shape of the defect is the point: not "done wrong", but "done incompletely,
+ * and the incompleteness is invisible".
+ *
+ * They are not independent, and the measurement is worth keeping: with a
+ * heartbeat under the threshold, point 1 does not change the outcome in
+ * process — either measure alone kept a connection alive through twelve
+ * seconds of silence, and only dropping both killed it. Point 1 earns its place
+ * against what a heartbeat cannot reach: a proxy or a client stack applying its
+ * own idle rule. Points 2 and 3 are each load-bearing on their own.
+ *
+ * A fourth thing is handled here that is easy to not even think of:
+ * **cancellation reaches the source.** When the consumer goes away, the async
+ * iterable is returned, so a departed subscriber does not leave live work
+ * running on the server.
+ */
+import type { HttpMethod } from '../contract/define';
+import type { RawRoute, RawRouteContext } from './types';
+/** How a value becomes bytes on the wire. The only thing the two formats differ in. */
+export type StreamingFormat = 'ndjson' | 'sse';
+/**
+ * Default heartbeat, deliberately well under Bun's ten-second idle threshold.
+ *
+ * A default at or near the threshold does not protect anything: the first
+ * pulse would arrive at about the moment the connection was already being
+ * dropped, so the option would look configured and do nothing.
+ */
+export declare const DEFAULT_STREAM_HEARTBEAT_MS = 5000;
+export interface StreamingRouteOptions<TServer = unknown> {
+    path: string;
+    /** Default `GET` — a subscription is a read. */
+    method?: HttpMethod | 'ALL';
+    /** Wire framing. Default `ndjson`. */
+    format?: StreamingFormat;
+    /**
+     * Interval between keep-alive frames while the source is silent. Default
+     * `DEFAULT_STREAM_HEARTBEAT_MS`. Must be finite and positive.
+     */
+    heartbeatMs?: number;
+    /**
+     * Per-request idle timeout in **seconds**, applied through the runtime's own
+     * per-request control where it has one (Bun). Default `0` — no timeout.
+     *
+     * Zero by default and not by accident. The generic timeout exists to reap
+     * connections whose peer has gone quiet, and a stream whose normal state is
+     * silence is the one case where that inference is wrong — which is the reason
+     * this primitive is being reached for at all. It is still a field, because
+     * removing a general limit is a decision worth being able to see and to
+     * override.
+     */
+    idleTimeoutSeconds?: number;
+    /**
+     * The frames. Returned as an async iterable so a generator is the natural
+     * way to write one.
+     *
+     * **A source that waits must honour `context.signal`.** See
+     * `StreamingSourceContext` — this is the one part of cancellation the
+     * primitive cannot do on the source's behalf.
+     */
+    source: (request: Request, context: StreamingSourceContext<TServer>) => AsyncIterable<unknown> | Promise<AsyncIterable<unknown>>;
+    /** Extra response headers. The framing headers below cannot be overridden. */
+    headers?: Record<string, string>;
+}
+/**
+ * What a source is given, and the reason the signal is not optional.
+ *
+ * Closing an async iterator is not enough to stop a source, and the mechanism
+ * is worth stating because the failure is silent. An async generator serialises
+ * its requests: `return()` issued while a `next()` is still in flight is
+ * QUEUED behind it. A subscription source's `next()` is in flight almost all
+ * the time — that is what a subscription is — so the return is queued behind a
+ * promise that will only settle when the next event arrives, which for a quiet
+ * plane may be never. `iterator.return()` is still called, because it does
+ * close a source suspended at a `yield`; it simply cannot interrupt one that is
+ * waiting.
+ *
+ * The signal is what can. It is aborted the moment the consumer goes away —
+ * through either route, a request abort or a stream cancel, which are not the
+ * same event — and a source that awaits on it stops immediately:
+ *
+ * ```ts
+ * ndjsonRoute({
+ *   path: '/events/subscribe',
+ *   source: async function* (request, { signal }) {
+ *     for await (const event of subscribe({ signal })) yield event
+ *   },
+ * })
+ * ```
+ */
+export interface StreamingSourceContext<TServer = unknown> extends RawRouteContext<TServer> {
+    /** Aborted when the consumer goes away. A waiting source must honour it. */
+    signal: AbortSignal;
+}
+/**
+ * A `RawRoute` serving a continuing body.
+ *
+ * @see ndjsonRoute
+ * @see sseRoute
+ */
+export declare function streamingRoute<TServer = unknown>(options: StreamingRouteOptions<TServer>): RawRoute<TServer>;
+/** A `streamingRoute` framed as newline-delimited JSON. Keep-alive is a blank line. */
+export declare function ndjsonRoute<TServer = unknown>(options: Omit<StreamingRouteOptions<TServer>, 'format'>): RawRoute<TServer>;
+/** A `streamingRoute` framed as Server-Sent Events — readable by `parseSSE`. */
+export declare function sseRoute<TServer = unknown>(options: Omit<StreamingRouteOptions<TServer>, 'format'>): RawRoute<TServer>;
+//# sourceMappingURL=streaming-route.d.ts.map

package/dist/server/streaming-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-route.d.ts","sourceRoot":"","sources":["../../src/server/streaming-route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEzD,uFAAuF;AACvF,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,OAAQ,CAAC;AAEjD,MAAM,WAAW,qBAAqB,CAAC,OAAO,GAAG,OAAO;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,MAAM,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC;IAC5B,sCAAsC;IACtC,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,MAAM,EAAE,CACN,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,sBAAsB,CAAC,OAAO,CAAC,KACrC,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9D,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,sBAAsB,CAAC,OAAO,GAAG,OAAO,CAAE,SAAQ,eAAe,CAAC,OAAO,CAAC;IACzF,4EAA4E;IAC5E,MAAM,EAAE,WAAW,CAAC;CACrB;AAiGD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAG,OAAO,EAC9C,OAAO,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACtC,QAAQ,CAAC,OAAO,CAAC,CAgNnB;AAED,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,OAAO,GAAG,OAAO,EAC3C,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,GACtD,QAAQ,CAAC,OAAO,CAAC,CAEnB;AAED,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,OAAO,GAAG,OAAO,EACxC,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,GACtD,QAAQ,CAAC,OAAO,CAAC,CAEnB"}

package/dist/testing.js

@@ -4,7 +4,7 @@ import {
 } from "./index-vtjgx3vv.js";
 import {
   createApplication
-} from "./index-82e74yfx.js";
+} from "./index-eabpd4tb.js";
 import"./index-8eywc9zv.js";
 import {
   RealtimeRequestDisconnectedError,