@floegence/floe-webapp-protocol 0.35.2 → 0.35.3

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { type JSX } from 'solid-js';
-import type { ChannelInitGrant, Client, ClientObserverLike, DirectConnectInfo } from '@floegence/flowersec-core';
+import type { Client } from '@floegence/flowersec-core';
+import { type BrowserReconnectConfig } from '@floegence/flowersec-core/browser';
 import { type AutoReconnectConfig, type ConnectionStatus } from '@floegence/flowersec-core/reconnect';
-import { type ControlplaneConfig } from './controlplane';
 import type { ProtocolContract, RpcClientLike } from './contract';
 interface ProtocolContextValue {
     status: () => ConnectionStatus;
@@ -15,24 +15,7 @@ interface ProtocolContextValue {
     disconnect: () => void;
 }
 export type { AutoReconnectConfig, ConnectionStatus };
-export interface ConnectConfig {
-    mode?: 'tunnel' | 'direct';
-    observer?: ClientObserverLike;
-    keepaliveIntervalMs?: number;
-    connectTimeoutMs?: number;
-    handshakeTimeoutMs?: number;
-    autoReconnect?: AutoReconnectConfig;
-    controlplane?: ControlplaneConfig;
-    /**
-     * Provide a fresh grant for each connection attempt.
-     *
-     * This is the recommended way to support "reconnect requires new ticket/grant"
-     * flows (e.g. entry_ticket -> channel_init -> grant_client).
-     */
-    getGrant?: () => Promise<ChannelInitGrant>;
-    grant?: ChannelInitGrant;
-    directInfo?: DirectConnectInfo;
-}
+export type ConnectConfig = BrowserReconnectConfig;
 export declare function ProtocolProvider(props: {
     children: JSX.Element;
     contract: ProtocolContract;

package/dist/controlplane.d.ts

@@ -1,13 +1 @@
-import { type ChannelInitGrant } from '@floegence/flowersec-core';
-export interface ControlplaneConfig {
-    baseUrl: string;
-    endpointId: string;
-}
-/**
- * Request a tunnel grant (ChannelInitGrant) from the controlplane.
- *
- * HTTP contract (documented in `docs/protocol.md`):
- * - POST `${baseUrl}/v1/channel/init`, body: { endpoint_id }
- * - Response: `{ grant_client: ChannelInitGrant }`
- */
-export declare function requestChannelGrant(config: ControlplaneConfig): Promise<ChannelInitGrant>;
+export { requestChannelGrant, requestEntryChannelGrant, type ControlplaneConfig, type EntryControlplaneConfig, } from '@floegence/flowersec-core/browser';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { ProtocolProvider, useProtocol, type ConnectionStatus, type ConnectConfig, type AutoReconnectConfig } from './client';
 export { useRpc, RpcError, ProtocolNotConnectedError } from './rpc';
-export { requestChannelGrant, type ControlplaneConfig } from './controlplane';
+export { requestChannelGrant, requestEntryChannelGrant, type ControlplaneConfig, type EntryControlplaneConfig } from './controlplane';
 export type { ProtocolContract, RpcClientLike, RpcHelpers } from './contract';

package/dist/index.js

@@ -1,11 +1,12 @@
 import { ProtocolProvider as e, useProtocol as t } from "./index2.js";
-import { ProtocolNotConnectedError as n, RpcError as p, useRpc as l } from "./index3.js";
-import { requestChannelGrant as f } from "./index4.js";
+import { ProtocolNotConnectedError as c, RpcError as l, useRpc as p } from "./index3.js";
+import { requestChannelGrant as s, requestEntryChannelGrant as u } from "@floegence/flowersec-core/browser";
 export {
-  n as ProtocolNotConnectedError,
+  c as ProtocolNotConnectedError,
   e as ProtocolProvider,
-  p as RpcError,
-  f as requestChannelGrant,
+  l as RpcError,
+  s as requestChannelGrant,
+  u as requestEntryChannelGrant,
   t as useProtocol,
-  l as useRpc
+  p as useRpc
 };

package/dist/index2.js

@@ -1,111 +1,84 @@
-import { onCleanup as x, createComponent as I, useContext as M, createContext as k } from "solid-js";
-import { createStore as q } from "solid-js/store";
-import { RpcProxy as E } from "@floegence/flowersec-core/rpc";
-import { createReconnectManager as G } from "@floegence/flowersec-core/reconnect";
-import { requestChannelGrant as R } from "./index4.js";
-const m = k();
-function _(c) {
-  const o = G(), a = o.state(), [s, h] = q({
-    status: a.status,
-    error: a.error,
-    client: a.client
-  }), p = c.contract, r = new E(), w = {
+import { createContext as y, onCleanup as P, createComponent as g, useContext as C } from "solid-js";
+import { createStore as x } from "solid-js/store";
+import { createBrowserReconnectConfig as b } from "@floegence/flowersec-core/browser";
+import { RpcProxy as v } from "@floegence/flowersec-core/rpc";
+import { createReconnectManager as N } from "@floegence/flowersec-core/reconnect";
+const f = y();
+function F(o) {
+  const r = N(), i = r.state(), [s, d] = x({
+    status: i.status,
+    error: i.error,
+    client: i.client
+  }), h = o.contract, c = new v(), p = {
     rpc: {
-      call: (t, e) => r.call(t, e),
-      notify: (t, e) => r.notify(t, e),
-      onNotify: (t, e) => r.onNotify(t, e)
+      call: (t, n) => c.call(t, n),
+      notify: (t, n) => c.notify(t, n),
+      onNotify: (t, n) => c.onNotify(t, n)
     }
   };
-  a.client && r.attach(a.client.rpc);
-  const y = o.subscribe((t) => {
-    t.client ? r.attach(t.client.rpc) : r.detach(), h({
+  i.client && c.attach(i.client.rpc);
+  const m = r.subscribe((t) => {
+    t.client ? c.attach(t.client.rpc) : c.detach(), d({
       status: t.status,
       error: t.error,
       client: t.client
     });
   });
-  let i = null, n = null;
-  const l = async (t, e) => {
-    const u = {
-      autoReconnect: t.autoReconnect,
-      observer: t.observer,
-      connectOnce: async ({
-        signal: P,
-        observer: b
-      }) => {
-        const {
-          connectTunnelBrowser: C,
-          connectDirectBrowser: T
-        } = await import("@floegence/flowersec-core/browser"), d = {
-          observer: b,
-          signal: P,
-          keepaliveIntervalMs: t.keepaliveIntervalMs ?? 15e3,
-          connectTimeoutMs: t.connectTimeoutMs ?? 1e4,
-          handshakeTimeoutMs: t.handshakeTimeoutMs ?? 1e4
-        };
-        if ((t.mode ?? "tunnel") === "tunnel") {
-          const f = (t.getGrant ? await t.getGrant() : null) ?? t.grant ?? (t.controlplane ? await R(t.controlplane) : null);
-          if (!f)
-            throw new Error("Tunnel mode requires `getGrant`, `grant`, or `controlplane` config");
-          return C(f, d);
-        }
-        if (!t.directInfo)
-          throw new Error("Direct mode requires `directInfo`");
-        return T(t.directInfo, d);
-      }
-    };
-    if (e === "hard") {
-      await o.connect(u);
+  let a = null, e = null;
+  const l = async (t, n) => {
+    const u = b(t);
+    if (n === "hard") {
+      await r.connect(u);
       return;
     }
-    await o.connectIfNeeded(u);
-  }, v = {
+    await r.connectIfNeeded(u);
+  }, w = {
     status: () => s.status,
     error: () => s.error,
     client: () => s.client,
-    rpcTransport: () => w,
-    contract: () => p,
+    rpcTransport: () => p,
+    contract: () => h,
     connect: async (t) => {
-      i = t;
-      const e = o.state();
-      if (!(e.status === "connected" && e.client) && !(e.status === "connecting" && !n)) {
-        if (n) {
-          await n;
+      a = t;
+      const n = r.state();
+      if (!(n.status === "connected" && n.client) && !(n.status === "connecting" && !e)) {
+        if (e) {
+          await e;
           return;
         }
-        n = l(t, "if_needed").finally(() => {
-          n = null;
-        }), await n;
+        e = l(t, "if_needed").finally(() => {
+          e = null;
+        }), await e;
       }
     },
     reconnect: async (t) => {
-      const e = t ?? i;
-      if (!e)
+      const n = t ?? a;
+      if (!n)
         throw new Error("reconnect() requires a config before the first connect() call");
-      return n || (i = e, n = l(e, "hard").finally(() => {
-        n = null;
-      }), n);
+      return e || (a = n, e = l(n, "hard").finally(() => {
+        e = null;
+      }), e);
     },
     disconnect: () => {
-      r.detach(), o.disconnect();
+      c.detach(), r.disconnect();
     }
   };
-  return x(() => {
-    y(), r.detach(), o.disconnect();
-  }), I(m.Provider, {
-    value: v,
+  return P(() => {
+    m(), c.detach(), r.disconnect();
+  }), g(f.Provider, {
+    value: w,
     get children() {
-      return c.children;
+      return o.children;
     }
   });
 }
-function j() {
-  const c = M(m);
-  if (!c)
+function M() {
+  const o = C(f);
+  if (!o)
     throw new Error("useProtocol must be used within a ProtocolProvider");
-  return c;
+  return o;
 }
 export {
-  _ as ProtocolProvider,
-  j as useProtocol
+  F as ProtocolProvider,
+  M as useProtocol
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-protocol",
-  "version": "0.35.2",
+  "version": "0.35.3",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -30,7 +30,7 @@
     "solid-js": "^1.8.0"
   },
   "dependencies": {
-    "@floegence/flowersec-core": "^0.16.1"
+    "@floegence/flowersec-core": "^0.16.2"
   },
   "devDependencies": {
     "solid-js": "^1.9.11",

package/dist/index4.js

@@ -1,19 +0,0 @@
-import { assertChannelInitGrant as r } from "@floegence/flowersec-core";
-async function o(t) {
-  const n = await fetch(`${t.baseUrl}/v1/channel/init`, {
-    method: "POST",
-    credentials: "omit",
-    cache: "no-store",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ endpoint_id: t.endpointId })
-  });
-  if (!n.ok)
-    throw new Error(`Failed to get channel grant: ${n.status}`);
-  const e = await n.json();
-  if (!e?.grant_client)
-    throw new Error("Invalid controlplane response: missing `grant_client`");
-  return r(e.grant_client);
-}
-export {
-  o as requestChannelGrant
-};