dynamodb-reactive 0.2.4 → 0.4.0

package/dist/cloudflare.d.cts

@@ -0,0 +1,95 @@
+import { SubscribeRequest, SnapshotResponse, UnsubscribeRequest, JsonPatch } from './cluster.cjs';
+import { HubSocket, HubPaths } from './hub.cjs';
+
+/**
+ * Cloudflare Durable Object shell for the reactive hub. It is structural: it
+ * takes the Durable Object's `ctx` instead of extending `DurableObject`, so this
+ * entry imports nothing from `cloudflare:workers` and builds like every other
+ * entry. Your Durable Object class owns its name and migrations and delegates
+ * `fetch`, `webSocketMessage`, `webSocketClose` and `webSocketError` to it.
+ */
+/** Set by the route handler on requests it forwards to the hub; never trusted from clients. */
+declare const HUB_PRINCIPAL_HEADER = "x-reactive-principal";
+/** A hibernatable Workers WebSocket, as far as the hub needs it. */
+interface DurableObjectWebSocket extends HubSocket {
+    close(code?: number, reason?: string): void;
+}
+/** The parts of `DurableObjectState` the hub uses. */
+interface DurableObjectStateLike {
+    acceptWebSocket(socket: DurableObjectWebSocket, tags?: string[]): void;
+    getWebSockets(tag?: string): DurableObjectWebSocket[];
+    setWebSocketAutoResponse?(pair?: unknown): void;
+    storage: {
+        get<T>(key: string): Promise<T | undefined>;
+        put<T>(key: string, value: T): Promise<void>;
+    };
+}
+/** Anything with a Durable Object stub's `fetch`. */
+interface HubStub {
+    fetch(request: Request): Promise<Response>;
+}
+type WebSocketPairConstructor = new () => {
+    0: DurableObjectWebSocket;
+    1: DurableObjectWebSocket;
+};
+interface DurableObjectHubOptions {
+    paths: HubPaths;
+    /** Storage key for a path's version. Defaults to `version:<path>`. */
+    versionKey?: (path: string) => string;
+    maxAttachmentBytes?: number;
+    /**
+     * Answers the client's `ping` with `pong` without waking the Durable Object.
+     * Defaults to true.
+     */
+    autoPong?: boolean;
+    /** Workers' `WebSocketPair`; injectable for tests. */
+    WebSocketPair?: WebSocketPairConstructor;
+    /** Creates a connection id; injectable for tests. */
+    randomId?: () => string;
+}
+/** Wires the hub core to a Durable Object's hibernatable WebSockets and storage. */
+declare function createDurableObjectHub(ctx: DurableObjectStateLike, options: DurableObjectHubOptions): {
+    hub: {
+        message(socket: HubSocket, raw: string): void;
+        subscribe(request: SubscribeRequest, principal: string): Promise<SnapshotResponse>;
+        unsubscribe(request: UnsubscribeRequest, principal: string): void;
+        notify(path: string): Promise<void>;
+        publish(path: string, patches: JsonPatch[]): Promise<void>;
+    };
+    /** The Durable Object's `fetch`: WebSocket upgrades and actions from `hubClient`. */
+    fetch(request: Request): Promise<Response>;
+    webSocketMessage(socket: DurableObjectWebSocket, message: string | ArrayBuffer): void;
+    webSocketClose(socket: DurableObjectWebSocket, code: number): void;
+    webSocketError(socket: DurableObjectWebSocket): void;
+};
+type DurableObjectHub = ReturnType<typeof createDurableObjectHub>;
+/** Calls a hub Durable Object from the Worker. */
+declare function hubClient(stub: HubStub): {
+    /** Forwards a reactive HTTP request and returns the hub's response unchanged. */
+    request: (body: SubscribeRequest | UnsubscribeRequest, principal: string) => Promise<Response>;
+    notify: (path: string) => Promise<void>;
+    publish: (path: string, patches: JsonPatch[]) => Promise<void>;
+};
+interface ReactiveRoutes {
+    /** `POST` exchanges a credential for a signed ticket. */
+    ticket: string;
+    /** WebSocket upgrade, authenticated by the ticket in the `token` query parameter. */
+    socket: string;
+    /** Reactive HTTP subscribe and unsubscribe, authenticated by the ticket as a bearer token. */
+    reactive: string;
+}
+interface ReactiveRoutesOptions {
+    routes: ReactiveRoutes;
+    /** Ticket signing secret. Requests get 503 when it is not configured. */
+    secret: string | undefined;
+    /** The hub Durable Object stub that serves these routes. */
+    hub: () => HubStub;
+    /** Returns the principal for a ticket request, or undefined to answer 401. */
+    authenticate(request: Request): string | undefined | Promise<string | undefined>;
+    ticketLifetimeSeconds?: number;
+}
+/** Serves the ticket, socket and reactive HTTP routes; `undefined` for any other path. */
+declare function handleReactiveRoutes(request: Request, options: ReactiveRoutesOptions): Promise<Response | undefined>;
+
+export { HUB_PRINCIPAL_HEADER, createDurableObjectHub, handleReactiveRoutes, hubClient };
+export type { DurableObjectHub, DurableObjectHubOptions, DurableObjectStateLike, DurableObjectWebSocket, HubStub, ReactiveRoutes, ReactiveRoutesOptions };

package/dist/cloudflare.d.ts

@@ -0,0 +1,95 @@
+import { SubscribeRequest, SnapshotResponse, UnsubscribeRequest, JsonPatch } from './cluster.js';
+import { HubSocket, HubPaths } from './hub.js';
+
+/**
+ * Cloudflare Durable Object shell for the reactive hub. It is structural: it
+ * takes the Durable Object's `ctx` instead of extending `DurableObject`, so this
+ * entry imports nothing from `cloudflare:workers` and builds like every other
+ * entry. Your Durable Object class owns its name and migrations and delegates
+ * `fetch`, `webSocketMessage`, `webSocketClose` and `webSocketError` to it.
+ */
+/** Set by the route handler on requests it forwards to the hub; never trusted from clients. */
+declare const HUB_PRINCIPAL_HEADER = "x-reactive-principal";
+/** A hibernatable Workers WebSocket, as far as the hub needs it. */
+interface DurableObjectWebSocket extends HubSocket {
+    close(code?: number, reason?: string): void;
+}
+/** The parts of `DurableObjectState` the hub uses. */
+interface DurableObjectStateLike {
+    acceptWebSocket(socket: DurableObjectWebSocket, tags?: string[]): void;
+    getWebSockets(tag?: string): DurableObjectWebSocket[];
+    setWebSocketAutoResponse?(pair?: unknown): void;
+    storage: {
+        get<T>(key: string): Promise<T | undefined>;
+        put<T>(key: string, value: T): Promise<void>;
+    };
+}
+/** Anything with a Durable Object stub's `fetch`. */
+interface HubStub {
+    fetch(request: Request): Promise<Response>;
+}
+type WebSocketPairConstructor = new () => {
+    0: DurableObjectWebSocket;
+    1: DurableObjectWebSocket;
+};
+interface DurableObjectHubOptions {
+    paths: HubPaths;
+    /** Storage key for a path's version. Defaults to `version:<path>`. */
+    versionKey?: (path: string) => string;
+    maxAttachmentBytes?: number;
+    /**
+     * Answers the client's `ping` with `pong` without waking the Durable Object.
+     * Defaults to true.
+     */
+    autoPong?: boolean;
+    /** Workers' `WebSocketPair`; injectable for tests. */
+    WebSocketPair?: WebSocketPairConstructor;
+    /** Creates a connection id; injectable for tests. */
+    randomId?: () => string;
+}
+/** Wires the hub core to a Durable Object's hibernatable WebSockets and storage. */
+declare function createDurableObjectHub(ctx: DurableObjectStateLike, options: DurableObjectHubOptions): {
+    hub: {
+        message(socket: HubSocket, raw: string): void;
+        subscribe(request: SubscribeRequest, principal: string): Promise<SnapshotResponse>;
+        unsubscribe(request: UnsubscribeRequest, principal: string): void;
+        notify(path: string): Promise<void>;
+        publish(path: string, patches: JsonPatch[]): Promise<void>;
+    };
+    /** The Durable Object's `fetch`: WebSocket upgrades and actions from `hubClient`. */
+    fetch(request: Request): Promise<Response>;
+    webSocketMessage(socket: DurableObjectWebSocket, message: string | ArrayBuffer): void;
+    webSocketClose(socket: DurableObjectWebSocket, code: number): void;
+    webSocketError(socket: DurableObjectWebSocket): void;
+};
+type DurableObjectHub = ReturnType<typeof createDurableObjectHub>;
+/** Calls a hub Durable Object from the Worker. */
+declare function hubClient(stub: HubStub): {
+    /** Forwards a reactive HTTP request and returns the hub's response unchanged. */
+    request: (body: SubscribeRequest | UnsubscribeRequest, principal: string) => Promise<Response>;
+    notify: (path: string) => Promise<void>;
+    publish: (path: string, patches: JsonPatch[]) => Promise<void>;
+};
+interface ReactiveRoutes {
+    /** `POST` exchanges a credential for a signed ticket. */
+    ticket: string;
+    /** WebSocket upgrade, authenticated by the ticket in the `token` query parameter. */
+    socket: string;
+    /** Reactive HTTP subscribe and unsubscribe, authenticated by the ticket as a bearer token. */
+    reactive: string;
+}
+interface ReactiveRoutesOptions {
+    routes: ReactiveRoutes;
+    /** Ticket signing secret. Requests get 503 when it is not configured. */
+    secret: string | undefined;
+    /** The hub Durable Object stub that serves these routes. */
+    hub: () => HubStub;
+    /** Returns the principal for a ticket request, or undefined to answer 401. */
+    authenticate(request: Request): string | undefined | Promise<string | undefined>;
+    ticketLifetimeSeconds?: number;
+}
+/** Serves the ticket, socket and reactive HTTP routes; `undefined` for any other path. */
+declare function handleReactiveRoutes(request: Request, options: ReactiveRoutesOptions): Promise<Response | undefined>;
+
+export { HUB_PRINCIPAL_HEADER, createDurableObjectHub, handleReactiveRoutes, hubClient };
+export type { DurableObjectHub, DurableObjectHubOptions, DurableObjectStateLike, DurableObjectWebSocket, HubStub, ReactiveRoutes, ReactiveRoutesOptions };

package/dist/cloudflare.js

@@ -0,0 +1,374 @@
+// ../client/src/cluster.ts
+var DEFAULT_TICKET_LIFETIME_SECONDS = 60;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseClusterTicket(value) {
+  if (!isRecord(value) || typeof value.token !== "string" || value.token.length === 0 || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt) || typeof value.url !== "string") {
+    throw new Error("Cluster ticket response is invalid");
+  }
+  const url = new URL(value.url);
+  if (url.protocol !== "wss:") throw new Error("Cluster ticket URL must use WSS");
+  return { token: value.token, expiresAt: value.expiresAt, url: url.toString() };
+}
+var encoder = new TextEncoder();
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+function base64UrlDecode(value) {
+  const padded = value.replaceAll("-", "+").replaceAll("_", "/");
+  const binary = atob(padded + "=".repeat((4 - padded.length % 4) % 4));
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function hmacKey(secret, usage) {
+  return crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    [usage]
+  );
+}
+async function createSignedClusterTicket(options) {
+  const expiresAt = Math.floor((options.now ?? Date.now()) / 1e3) + (options.lifetimeSeconds ?? DEFAULT_TICKET_LIFETIME_SECONDS);
+  const payload = base64UrlEncode(
+    encoder.encode(JSON.stringify({ p: options.principal, exp: expiresAt }))
+  );
+  const signature = new Uint8Array(
+    await crypto.subtle.sign("HMAC", await hmacKey(options.secret, "sign"), encoder.encode(payload))
+  );
+  return parseClusterTicket({
+    token: `${payload}.${base64UrlEncode(signature)}`,
+    expiresAt,
+    url: options.url
+  });
+}
+async function verifySignedClusterTicket(token, secret, now = Date.now()) {
+  const [payload, signature, extra] = token.split(".");
+  if (!payload || !signature || extra !== void 0) return void 0;
+  try {
+    const valid = await crypto.subtle.verify(
+      "HMAC",
+      await hmacKey(secret, "verify"),
+      base64UrlDecode(signature),
+      encoder.encode(payload)
+    );
+    if (!valid) return void 0;
+    const claims = JSON.parse(new TextDecoder().decode(base64UrlDecode(payload)));
+    if (!isRecord(claims) || typeof claims.p !== "string" || typeof claims.exp !== "number" || claims.exp <= Math.floor(now / 1e3)) {
+      return void 0;
+    }
+    return claims.p;
+  } catch {
+    return void 0;
+  }
+}
+
+// ../client/src/hub.ts
+var DEFAULT_MAX_ATTACHMENT_BYTES = 2048;
+var ReactiveHubError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReactiveHubError";
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isHubRequest(value) {
+  if (!isRecord2(value)) return false;
+  return (value.type === "subscribe" || value.type === "unsubscribe") && typeof value.connectionId === "string" && typeof value.subscriptionId === "string" && typeof value.generation === "number" && (value.type === "unsubscribe" || typeof value.path === "string");
+}
+function bearerToken(request) {
+  const match = /^Bearer ([^\s]+)$/u.exec(request.headers.get("authorization") ?? "");
+  return match?.[1] ?? "";
+}
+function createHubSocketState(connectionId, principal) {
+  return { connectionId, principal, subscriptions: [] };
+}
+function socketState(socket) {
+  const state = socket.deserializeAttachment();
+  return { ...state, subscriptions: state.subscriptions.filter((entry) => entry.path) };
+}
+function send(socket, event) {
+  try {
+    socket.send(JSON.stringify(event));
+  } catch {
+  }
+}
+function createReactiveHub(options) {
+  const { sockets, versions } = options;
+  const maxAttachmentBytes = options.maxAttachmentBytes ?? DEFAULT_MAX_ATTACHMENT_BYTES;
+  const resolve = (path) => typeof options.paths === "function" ? options.paths(path) : Object.hasOwn(options.paths, path) ? options.paths[path] : void 0;
+  const ownedSocket = (connectionId, principal) => {
+    const socket = sockets.byConnectionId(connectionId);
+    return socket && socketState(socket).principal === principal ? socket : void 0;
+  };
+  const subscribersOf = (path) => sockets.all().flatMap(
+    (socket) => socketState(socket).subscriptions.filter((subscription) => subscription.path === path).map((subscription) => ({ socket, subscription }))
+  );
+  const bump = async (path) => {
+    const fromVersion = await versions.get(path);
+    const toVersion = fromVersion + 1;
+    await versions.set(path, toVersion);
+    return { fromVersion, toVersion };
+  };
+  return {
+    /** Answers the client's `init` and `ping` frames. */
+    message(socket, raw) {
+      let frame;
+      try {
+        frame = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      const type = isRecord2(frame) ? frame.type : void 0;
+      if (type === "init") {
+        send(socket, { type: "connected", connectionId: socketState(socket).connectionId });
+      } else if (type === "ping") {
+        send(socket, { type: "pong" });
+      }
+    },
+    async subscribe(request, principal) {
+      const handler = resolve(request.path);
+      if (!handler) throw new ReactiveHubError("Unknown subscription path");
+      if (!ownedSocket(request.connectionId, principal)) {
+        throw new ReactiveHubError("Unknown connection");
+      }
+      const context = { path: request.path, principal, input: request.input };
+      if (handler.authorize && !await handler.authorize(context)) {
+        throw new ReactiveHubError("Subscription not allowed");
+      }
+      const socket = ownedSocket(request.connectionId, principal);
+      if (!socket) throw new ReactiveHubError("Unknown connection");
+      const state = socketState(socket);
+      const next = {
+        ...state,
+        subscriptions: [
+          ...state.subscriptions.filter(
+            (entry) => entry.subscriptionId !== request.subscriptionId
+          ),
+          {
+            subscriptionId: request.subscriptionId,
+            generation: request.generation,
+            path: request.path
+          }
+        ]
+      };
+      if (new TextEncoder().encode(JSON.stringify(next)).length > maxAttachmentBytes) {
+        throw new ReactiveHubError("Too many subscriptions on this connection");
+      }
+      socket.serializeAttachment(next);
+      const version = await versions.get(request.path);
+      const data = await handler.snapshot(context);
+      return {
+        type: "snapshot",
+        subscriptionId: request.subscriptionId,
+        generation: request.generation,
+        version,
+        data
+      };
+    },
+    unsubscribe(request, principal) {
+      const socket = ownedSocket(request.connectionId, principal);
+      if (!socket) return;
+      const state = socketState(socket);
+      socket.serializeAttachment({
+        ...state,
+        subscriptions: state.subscriptions.filter(
+          (entry) => entry.subscriptionId !== request.subscriptionId
+        )
+      });
+    },
+    /** Bumps the path's version and asks each of its subscribers to re-fetch. */
+    async notify(path) {
+      const { fromVersion, toVersion } = await bump(path);
+      for (const { socket, subscription } of subscribersOf(path)) {
+        send(socket, {
+          type: "resync",
+          subscriptionId: subscription.subscriptionId,
+          generation: subscription.generation,
+          fromVersion,
+          toVersion,
+          messageId: crypto.randomUUID()
+        });
+      }
+    },
+    /**
+     * Bumps the path's version and sends the same JSON patches to each subscriber.
+     * Use it only when every subscriber of the path sees the same data.
+     */
+    async publish(path, patches) {
+      const { fromVersion, toVersion } = await bump(path);
+      for (const { socket, subscription } of subscribersOf(path)) {
+        send(socket, {
+          type: "patch",
+          subscriptionId: subscription.subscriptionId,
+          generation: subscription.generation,
+          fromVersion,
+          toVersion,
+          messageId: crypto.randomUUID(),
+          patches
+        });
+      }
+    }
+  };
+}
+
+// ../client/src/cloudflare.ts
+var HUB_PRINCIPAL_HEADER = "x-reactive-principal";
+var HUB_ACTION_URL = "https://reactive-hub/";
+function json(value, status = 200) {
+  return Response.json(value, { status, headers: { "cache-control": "no-store" } });
+}
+function error(message, status) {
+  return json({ type: "error", message }, status);
+}
+function workersGlobal(name) {
+  return globalThis[name];
+}
+function createDurableObjectHub(ctx, options) {
+  const versionKey = options.versionKey ?? ((path) => `version:${path}`);
+  const randomId = options.randomId ?? (() => crypto.randomUUID());
+  const hub = createReactiveHub({
+    sockets: {
+      all: () => ctx.getWebSockets(),
+      // Tagging by connection id lets HTTP subscribes find the socket after hibernation.
+      byConnectionId: (connectionId) => ctx.getWebSockets(connectionId)[0]
+    },
+    versions: {
+      get: async (path) => await ctx.storage.get(versionKey(path)) ?? 0,
+      set: (path, version) => ctx.storage.put(versionKey(path), version)
+    },
+    paths: options.paths,
+    ...options.maxAttachmentBytes === void 0 ? {} : { maxAttachmentBytes: options.maxAttachmentBytes }
+  });
+  if (options.autoPong !== false) {
+    const Pair = workersGlobal("WebSocketRequestResponsePair");
+    if (Pair && ctx.setWebSocketAutoResponse) {
+      ctx.setWebSocketAutoResponse(
+        new Pair(JSON.stringify({ type: "ping" }), JSON.stringify({ type: "pong" }))
+      );
+    }
+  }
+  const accept = (request) => {
+    const principal = request.headers.get(HUB_PRINCIPAL_HEADER);
+    if (!principal) return error("Unauthorized", 401);
+    const Pair = options.WebSocketPair ?? workersGlobal("WebSocketPair");
+    if (!Pair) throw new Error("WebSocketPair is not available in this runtime");
+    const pair = new Pair();
+    const connectionId = randomId();
+    ctx.acceptWebSocket(pair[1], [connectionId]);
+    pair[1].serializeAttachment(createHubSocketState(connectionId, principal));
+    return new Response(null, { status: 101, webSocket: pair[0] });
+  };
+  const act = async (action) => {
+    try {
+      switch (action.action) {
+        case "subscribe":
+          return json(await hub.subscribe(action.body, action.principal));
+        case "unsubscribe":
+          hub.unsubscribe(action.body, action.principal);
+          return json({ type: "ok" });
+        case "notify":
+          await hub.notify(action.path);
+          return json({ type: "ok" });
+        case "publish":
+          await hub.publish(action.path, action.patches);
+          return json({ type: "ok" });
+        default:
+          return error("Unknown hub action", 400);
+      }
+    } catch (cause) {
+      if (cause instanceof ReactiveHubError) return error(cause.message, 400);
+      throw cause;
+    }
+  };
+  return {
+    hub,
+    /** The Durable Object's `fetch`: WebSocket upgrades and actions from `hubClient`. */
+    async fetch(request) {
+      if (request.headers.get("upgrade") === "websocket") return accept(request);
+      return act(await request.json());
+    },
+    webSocketMessage(socket, message) {
+      if (typeof message === "string") hub.message(socket, message);
+    },
+    webSocketClose(socket, code) {
+      try {
+        socket.close(code === 1005 ? 1e3 : code, "closed");
+      } catch {
+      }
+    },
+    webSocketError(socket) {
+      try {
+        socket.close(1011, "error");
+      } catch {
+      }
+    }
+  };
+}
+function hubClient(stub) {
+  const post = (action) => stub.fetch(new Request(HUB_ACTION_URL, { method: "POST", body: JSON.stringify(action) }));
+  const ok = async (response) => {
+    if (!response.ok) throw new Error(`Hub request failed: HTTP ${response.status}`);
+  };
+  return {
+    /** Forwards a reactive HTTP request and returns the hub's response unchanged. */
+    request: (body, principal) => post(
+      body.type === "subscribe" ? { action: "subscribe", principal, body } : { action: "unsubscribe", principal, body }
+    ),
+    notify: async (path) => ok(await post({ action: "notify", path })),
+    publish: async (path, patches) => ok(await post({ action: "publish", path, patches }))
+  };
+}
+async function handleReactiveRoutes(request, options) {
+  const url = new URL(request.url);
+  const { routes, secret } = options;
+  if (![routes.ticket, routes.socket, routes.reactive].includes(url.pathname)) return void 0;
+  if (!secret) return error("Reactive hub is not configured", 503);
+  if (url.pathname === routes.ticket) {
+    if (request.method !== "POST") return error("Method not allowed", 405);
+    const principal2 = await options.authenticate(request);
+    if (!principal2) return error("Unauthorized", 401);
+    const socketUrl = new URL(routes.socket, url);
+    socketUrl.protocol = "wss:";
+    return json(
+      await createSignedClusterTicket({
+        secret,
+        principal: principal2,
+        url: socketUrl.toString(),
+        ...options.ticketLifetimeSeconds === void 0 ? {} : { lifetimeSeconds: options.ticketLifetimeSeconds }
+      })
+    );
+  }
+  if (url.pathname === routes.socket) {
+    if (request.headers.get("upgrade") !== "websocket") {
+      return error("Expected a WebSocket upgrade", 426);
+    }
+    const principal2 = await verifySignedClusterTicket(url.searchParams.get("token") ?? "", secret);
+    if (!principal2) return new Response("Unauthorized", { status: 401 });
+    const forwarded = new Request(request);
+    forwarded.headers.set(HUB_PRINCIPAL_HEADER, principal2);
+    return options.hub().fetch(forwarded);
+  }
+  if (request.method !== "POST") return error("Method not allowed", 405);
+  const principal = await verifySignedClusterTicket(bearerToken(request), secret);
+  if (!principal) return error("Unauthorized", 401);
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return error("Invalid JSON", 400);
+  }
+  if (!isHubRequest(body)) return error("Unsupported reactive request", 400);
+  return hubClient(options.hub()).request(body, principal);
+}
+
+export { HUB_PRINCIPAL_HEADER, createDurableObjectHub, handleReactiveRoutes, hubClient };
+//# sourceMappingURL=cloudflare.js.map
+//# sourceMappingURL=cloudflare.js.map