@floegence/floe-webapp-boot 0.40.3 → 0.40.4

package/dist/index.d.ts

@@ -6,5 +6,7 @@ export type { ArtifactAcquireContext, ArtifactSource } from '@floegence/flowerse
 export { createControlplaneArtifactSource } from '@floegence/flowersec-core/reconnect';
 export type { DirectArtifactReconnectOptions, TunnelArtifactReconnectOptions } from './reconnect';
 export { createArtifactDirectReconnectConfig, createArtifactTunnelReconnectConfig, createProxyRuntimeTunnelReconnectConfig, } from './reconnect';
+export type { FetchServerSentEventsOptions, ServerSentEvent, ServerSentEventStreamErrorCode, } from './server-sent-events';
+export { fetchServerSentEvents, ServerSentEventStreamError, } from './server-sent-events';
 export type { ScopeEnvelope, ScopeResolver, ScopeResolverMap } from './scope';
 export { createBootstrapScopeResolvers, FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS, PROXY_RUNTIME_SCOPE_NAME, validateProxyRuntimeScopeEntry, } from './scope';

package/dist/index.js

@@ -1,25 +1,28 @@
-import { base64UrlToBase64 as r, clearLocationHash as t, parseBase64UrlJsonFromHash as a, parseHashParam as s } from "./index2.js";
-import { postMessageToOrigins as c, waitForMessage as i } from "./index3.js";
-import { getSessionStorage as p, removeSessionStorage as f, setSessionStorage as R } from "./index4.js";
-import { createControlplaneArtifactSource as g } from "@floegence/flowersec-core/reconnect";
-import { createArtifactDirectReconnectConfig as E, createArtifactTunnelReconnectConfig as x, createProxyRuntimeTunnelReconnectConfig as O } from "./index5.js";
-import { FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS as P, PROXY_RUNTIME_SCOPE_NAME as T, createBootstrapScopeResolvers as _, validateProxyRuntimeScopeEntry as u } from "./index6.js";
+import { base64UrlToBase64 as o, clearLocationHash as t, parseBase64UrlJsonFromHash as a, parseHashParam as n } from "./index2.js";
+import { postMessageToOrigins as c, waitForMessage as S } from "./index3.js";
+import { getSessionStorage as f, removeSessionStorage as p, setSessionStorage as m } from "./index4.js";
+import { createControlplaneArtifactSource as R } from "@floegence/flowersec-core/reconnect";
+import { createArtifactDirectReconnectConfig as l, createArtifactTunnelReconnectConfig as x, createProxyRuntimeTunnelReconnectConfig as O } from "./index5.js";
+import { ServerSentEventStreamError as C, fetchServerSentEvents as P } from "./index6.js";
+import { FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS as _, PROXY_RUNTIME_SCOPE_NAME as u, createBootstrapScopeResolvers as A, validateProxyRuntimeScopeEntry as h } from "./index7.js";
 export {
-  P as FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS,
-  T as PROXY_RUNTIME_SCOPE_NAME,
-  r as base64UrlToBase64,
+  _ as FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS,
+  u as PROXY_RUNTIME_SCOPE_NAME,
+  C as ServerSentEventStreamError,
+  o as base64UrlToBase64,
   t as clearLocationHash,
-  E as createArtifactDirectReconnectConfig,
+  l as createArtifactDirectReconnectConfig,
   x as createArtifactTunnelReconnectConfig,
-  _ as createBootstrapScopeResolvers,
-  g as createControlplaneArtifactSource,
+  A as createBootstrapScopeResolvers,
+  R as createControlplaneArtifactSource,
   O as createProxyRuntimeTunnelReconnectConfig,
-  p as getSessionStorage,
+  P as fetchServerSentEvents,
+  f as getSessionStorage,
   a as parseBase64UrlJsonFromHash,
-  s as parseHashParam,
+  n as parseHashParam,
   c as postMessageToOrigins,
-  f as removeSessionStorage,
-  R as setSessionStorage,
-  u as validateProxyRuntimeScopeEntry,
-  i as waitForMessage
+  p as removeSessionStorage,
+  m as setSessionStorage,
+  h as validateProxyRuntimeScopeEntry,
+  S as waitForMessage
 };

package/dist/index5.js

@@ -1,4 +1,4 @@
-import { createBootstrapScopeResolvers as n } from "./index6.js";
+import { createBootstrapScopeResolvers as n } from "./index7.js";
 function r(e) {
   return {
     source: e.source,

package/dist/index6.js

@@ -1,22 +1,150 @@
-import { assertProxyRuntimeScopeV1 as t } from "@floegence/flowersec-core/proxy";
-const o = "proxy.runtime";
-function r(e) {
-  if (e.scope_version !== 1)
-    throw new Error(`unsupported ${o} scope_version: ${e.scope_version}`);
-  t(e.payload);
+class i extends Error {
+  code;
+  status;
+  retryAfter;
+  constructor(d, m, c = {}) {
+    super(m, c), this.name = "ServerSentEventStreamError", this.code = d, c.status !== void 0 && (this.status = c.status), c.retryAfter !== void 0 && (this.retryAfter = c.retryAfter);
+  }
 }
-const n = Object.freeze({
-  [o]: r
-});
-function c(e) {
-  return e ? Object.freeze({
-    ...e,
-    [o]: r
-  }) : n;
+const U = 1024 * 1024, N = 2 * 1024 * 1024;
+function T(n, d) {
+  if (n === void 0) return d;
+  if (!Number.isSafeInteger(n) || n <= 0)
+    throw new TypeError("server-sent event byte limits must be positive safe integers");
+  return n;
+}
+function R(n) {
+  return n.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === "text/event-stream";
+}
+async function A(n) {
+  try {
+    await n.body?.cancel();
+  } catch {
+  }
+}
+async function* O(n, d = {}) {
+  const {
+    fetch: m = globalThis.fetch,
+    maxFrameBytes: c,
+    maxBufferBytes: F,
+    onActivity: x,
+    signal: L,
+    ...k
+  } = d, M = T(c, U), D = T(F, N);
+  let a;
+  try {
+    a = await m(n, { ...k, signal: L });
+  } catch (e) {
+    throw new i("transport", "failed to open server-sent event stream", { cause: e });
+  }
+  if (!a.ok) {
+    const e = a.headers.get("retry-after") ?? void 0;
+    throw await A(a), new i(
+      "unexpected_status",
+      `server-sent event request returned HTTP ${a.status}`,
+      { status: a.status, retryAfter: e }
+    );
+  }
+  if (!R(a))
+    throw await A(a), new i(
+      "unsupported_content_type",
+      "server-sent event response must use text/event-stream"
+    );
+  if (a.body === null)
+    throw new i("malformed_frame", "server-sent event response has no body");
+  const y = a.body.getReader(), B = new TextDecoder("utf-8", { fatal: !0 }), E = new TextEncoder();
+  let s = "", h = 0, w = [], l, b, u, p = !1, g = !1;
+  const _ = () => {
+    h = 0, w = [], l = void 0, u = void 0, p = !1;
+  }, I = (e, o) => {
+    if (h += E.encode(e).byteLength + o, h > M)
+      throw new i("oversized_frame", "server-sent event frame exceeds its byte limit");
+    if (e === "") {
+      if (!p) {
+        _();
+        return;
+      }
+      const f = {
+        data: w.join(`
+`),
+        ...l === void 0 ? {} : { event: l },
+        ...b === void 0 ? {} : { id: b },
+        ...u === void 0 ? {} : { retry: u }
+      };
+      return _(), f;
+    }
+    if (e.startsWith(":")) {
+      x?.();
+      return;
+    }
+    const r = e.indexOf(":"), v = r < 0 ? e : e.slice(0, r);
+    let t = r < 0 ? "" : e.slice(r + 1);
+    switch (t.startsWith(" ") && (t = t.slice(1)), v) {
+      case "data":
+        p = !0, w.push(t);
+        break;
+      case "event":
+        l = t;
+        break;
+      case "id":
+        t.includes("\0") || (b = t);
+        break;
+      case "retry":
+        if (/^[0-9]+$/u.test(t)) {
+          const f = Number(t);
+          Number.isSafeInteger(f) && (u = f);
+        }
+        break;
+    }
+  };
+  try {
+    for (; ; ) {
+      let e;
+      try {
+        e = await y.read();
+      } catch (r) {
+        throw new i("transport", "failed while reading server-sent event stream", { cause: r });
+      }
+      if (e.value !== void 0) {
+        x?.();
+        try {
+          s += B.decode(e.value, { stream: !e.done });
+        } catch (r) {
+          throw new i("malformed_frame", "server-sent event stream is not valid UTF-8", { cause: r });
+        }
+      } else if (e.done)
+        try {
+          s += B.decode();
+        } catch (r) {
+          throw new i("malformed_frame", "server-sent event stream ends with invalid UTF-8", { cause: r });
+        }
+      let o = 0;
+      for (; o < s.length; ) {
+        const r = s.indexOf(`
+`, o), v = s.indexOf("\r", o);
+        let t = -1;
+        if (r >= 0 && v >= 0 ? t = Math.min(r, v) : t = Math.max(r, v), t < 0 || s[t] === "\r" && t + 1 === s.length && !e.done) break;
+        const f = s[t] === "\r" && s[t + 1] === `
+` ? 2 : 1, S = I(s.slice(o, t), f);
+        o = t + f, S !== void 0 && (yield S);
+      }
+      if (s = s.slice(o), E.encode(s).byteLength > D)
+        throw new i("oversized_buffer", "server-sent event pending buffer exceeds its byte limit");
+      if (e.done) {
+        g = !0;
+        return;
+      }
+    }
+  } finally {
+    if (!g)
+      try {
+        await y.cancel();
+      } catch {
+      }
+    y.releaseLock();
+  }
 }
 export {
-  n as FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS,
-  o as PROXY_RUNTIME_SCOPE_NAME,
-  c as createBootstrapScopeResolvers,
-  r as validateProxyRuntimeScopeEntry
+  i as ServerSentEventStreamError,
+  O as fetchServerSentEvents
 };

package/dist/index7.js

@@ -0,0 +1,22 @@
+import { assertProxyRuntimeScopeV1 as t } from "@floegence/flowersec-core/proxy";
+const o = "proxy.runtime";
+function r(e) {
+  if (e.scope_version !== 1)
+    throw new Error(`unsupported ${o} scope_version: ${e.scope_version}`);
+  t(e.payload);
+}
+const n = Object.freeze({
+  [o]: r
+});
+function c(e) {
+  return e ? Object.freeze({
+    ...e,
+    [o]: r
+  }) : n;
+}
+export {
+  n as FLOWERSEC_BOOTSTRAP_SCOPE_RESOLVERS,
+  o as PROXY_RUNTIME_SCOPE_NAME,
+  c as createBootstrapScopeResolvers,
+  r as validateProxyRuntimeScopeEntry
+};

package/dist/server-sent-events.d.ts

@@ -0,0 +1,24 @@
+export type ServerSentEventStreamErrorCode = 'transport' | 'unexpected_status' | 'unsupported_content_type' | 'malformed_frame' | 'oversized_frame' | 'oversized_buffer';
+export declare class ServerSentEventStreamError extends Error {
+    readonly code: ServerSentEventStreamErrorCode;
+    readonly status?: number;
+    readonly retryAfter?: string;
+    constructor(code: ServerSentEventStreamErrorCode, message: string, options?: ErrorOptions & Readonly<{
+        status?: number;
+        retryAfter?: string;
+    }>);
+}
+export type ServerSentEvent = Readonly<{
+    data: string;
+    event?: string;
+    id?: string;
+    retry?: number;
+}>;
+export type FetchServerSentEventsOptions = Omit<RequestInit, 'signal'> & Readonly<{
+    signal?: AbortSignal;
+    fetch?: typeof globalThis.fetch;
+    maxFrameBytes?: number;
+    maxBufferBytes?: number;
+    onActivity?: () => void;
+}>;
+export declare function fetchServerSentEvents(input: RequestInfo | URL, options?: FetchServerSentEventsOptions): AsyncGenerator<ServerSentEvent, void, undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-boot",
-  "version": "0.40.3",
+  "version": "0.40.4",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",