@floegence/floe-webapp-protocol 0.40.21 → 0.41.1

package/dist/client.d.ts

@@ -1,20 +1,31 @@
+import type { ArtifactSource, ConnectionSnapshot, ConnectionState, Session } from '@floegence/flowersec-core';
+import type { ConnectionControllerOptions } from '@floegence/flowersec-core/browser';
 import { type JSX } from 'solid-js';
-import type { ArtifactSource, ConnectionControllerOptions, ConnectionState, Session } from '@floegence/flowersec-core';
 import type { ProtocolContract } from './contract';
 interface ProtocolContextValue {
     status: () => ConnectionState;
+    snapshot: () => ConnectionSnapshot;
     error: () => Error | null;
     session: () => Session | null;
     rpcTransport: () => Session['rpc'] | null;
     contract: () => ProtocolContract;
     connect: (config: ConnectConfig) => Promise<void>;
-    reconnect: (config?: ConnectConfig) => Promise<void>;
+    replaceConnection: (config: ConnectConfig) => Promise<void>;
+    retryNow: () => boolean;
     disconnect: () => void;
 }
+export interface ConnectionLifecycle {
+    synchronize(snapshot: ConnectionSnapshot): void;
+    dispose(): void;
+}
 export type ConnectConfig = Readonly<{
     source: ArtifactSource;
     controller?: ConnectionControllerOptions;
+    lifecycle?: ConnectionLifecycle;
 }>;
+export declare class ConnectionReplacementRequiredError extends Error {
+    constructor();
+}
 export declare function ProtocolProvider(props: {
     children: JSX.Element;
     contract: ProtocolContract;

package/dist/contract.d.ts

@@ -1,26 +1,15 @@
-export type RpcTransportCall = (typeId: number, payload: unknown) => Promise<{
-    payload: unknown;
-    error?: {
-        code: number;
-        message?: string;
-    };
-}>;
-export type RpcTransportNotify = (typeId: number, payload: unknown) => Promise<void> | void;
-export type RpcTransportOnNotify = (typeId: number, handler: (payload: unknown) => void) => () => void;
+import type { JsonValue, RpcPeer } from '@floegence/flowersec-core';
 export interface RpcClientLike {
-    rpc: {
-        call: RpcTransportCall;
-        notify: RpcTransportNotify;
-        onNotify: RpcTransportOnNotify;
-    };
+    rpc: Pick<RpcPeer, 'call' | 'notify' | 'onNotify'>;
 }
+export type RpcDecoder<T> = (payload: JsonValue) => T;
 export interface RpcHelpers {
-    call: <Req, Res>(typeId: number, payload: Req) => Promise<Res>;
+    call: <Req extends JsonValue, Res>(typeId: number, payload: Req, decodeResponse: RpcDecoder<Res>) => Promise<Res>;
     /** Strict notification: detached transports fail with ProtocolNotConnectedError. */
-    notify: <Req>(typeId: number, payload: Req) => Promise<void>;
+    notify: <Req extends JsonValue>(typeId: number, payload: Req) => Promise<void>;
     /** Best-effort notification: detached transports are treated as already dropped. */
-    notifyBestEffort: <Req>(typeId: number, payload: Req) => Promise<void>;
-    onNotify: <Payload>(typeId: number, handler: (payload: Payload) => void) => () => void;
+    notifyBestEffort: <Req extends JsonValue>(typeId: number, payload: Req) => Promise<void>;
+    onNotify: <Payload>(typeId: number, decodePayload: RpcDecoder<Payload>, handler: (payload: Payload) => void | Promise<void>) => () => void;
 }
 export interface ProtocolContract<TApi = unknown> {
     /** A stable identifier for logging and debugging (e.g. "app_v1"). */

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { ProtocolProvider, useProtocol, type ConnectConfig } from './client';
+export { ConnectionReplacementRequiredError, ProtocolProvider, useProtocol, type ConnectConfig, type ConnectionLifecycle, } from './client';
 export { useRpc, RpcError, ProtocolNotConnectedError } from './rpc';
-export { ControlplaneRequestError, requestConnectArtifact, requestEntryConnectArtifact, type RequestConnectArtifactInput, type RequestEntryConnectArtifactInput, } from './controlplane';
-export type { ProtocolContract, RpcClientLike, RpcHelpers } from './contract';
+export type { ProtocolContract, RpcClientLike, RpcDecoder, RpcHelpers, } from './contract';

package/dist/index.js

@@ -1,13 +1,10 @@
-import { ProtocolProvider as t, useProtocol as e } from "./index2.js";
-import { ProtocolNotConnectedError as n, RpcError as p, useRpc as f } from "./index3.js";
-import { ControlplaneRequestError as s, requestConnectArtifact as u, requestEntryConnectArtifact as C } from "./index4.js";
+import { ConnectionReplacementRequiredError as e, ProtocolProvider as t, useProtocol as c } from "./index2.js";
+import { ProtocolNotConnectedError as p, RpcError as l, useRpc as P } from "./index3.js";
 export {
-  s as ControlplaneRequestError,
-  n as ProtocolNotConnectedError,
+  e as ConnectionReplacementRequiredError,
+  p as ProtocolNotConnectedError,
   t as ProtocolProvider,
-  p as RpcError,
-  u as requestConnectArtifact,
-  C as requestEntryConnectArtifact,
-  e as useProtocol,
-  f as useRpc
+  l as RpcError,
+  c as useProtocol,
+  P as useRpc
 };

package/dist/index2.js

@@ -1,72 +1,114 @@
-import { createContext as b, onCleanup as y, createComponent as h, useContext as x } from "solid-js";
-import { createStore as S } from "solid-js/store";
-const E = () => import("@floegence/flowersec-core/browser"), w = b();
-function F(r) {
-  const [s, u] = S({
-    status: "idle",
-    error: null,
-    session: null
-  }), C = r.contract;
-  let o = null, c = null, a = null, n = null, l = 0;
-  const m = (t) => {
-    const e = t.failure;
-    u({
-      status: t.state,
-      session: t.currentSession ?? null,
-      error: e === void 0 ? null : new Error(`${e.phase}:${e.code}`)
-    });
-  }, f = async () => {
-    c?.(), c = null;
-    const t = o;
-    o = null, t && await t.close(), u({
-      status: "idle",
-      session: null,
+import { createContext as b, onCleanup as v, createComponent as P, useContext as S } from "solid-js";
+import { createStore as x } from "solid-js/store";
+const E = () => import("@floegence/flowersec-core/browser");
+class z extends Error {
+  constructor() {
+    super("Connection source or options changed; call replaceConnection() explicitly"), this.name = "ConnectionReplacementRequiredError";
+  }
+}
+const w = b(), y = Object.freeze({
+  state: "idle",
+  attempt: 0
+});
+function D(t) {
+  const [n, f] = x({
+    snapshot: y,
+    error: null
+  }), C = t.contract;
+  let o = null, a = null, c = null, r = null, s = 0;
+  const m = (e) => {
+    const l = c;
+    if (l !== null)
+      try {
+        l.lifecycle?.synchronize(e), f({
+          snapshot: e,
+          error: O(e)
+        });
+      } catch (u) {
+        const i = u instanceof Error ? u : new Error("Floe connection binding failed");
+        l.lifecycle?.dispose(), f({
+          snapshot: Object.freeze({
+            state: "failed",
+            attempt: e.attempt,
+            failure: Object.freeze({
+              phase: "artifact",
+              code: "connected_acquisition_failed"
+            }),
+            retryDisposition: Object.freeze({
+              kind: "terminal"
+            })
+          }),
+          error: i
+        }), o?.close();
+      }
+  }, p = async () => {
+    a?.(), a = null;
+    const e = o, l = c;
+    o = null, c = null, l?.lifecycle?.dispose(), e !== null && await e.close(), f({
+      snapshot: y,
       error: null
     });
-  }, p = async (t) => {
-    const e = ++l;
-    await f(), a = t;
-    const {
-      createConnectionController: P
+  }, d = async (e) => {
+    const l = s, {
+      createConnectionController: u
     } = await E();
-    if (e !== l) return;
-    const i = P(t.source, t.controller);
-    o = i, c = i.subscribe(m), i.start(), await i.waitForSession();
-  }, d = async (t) => n || (n = (async () => {
-    o && a?.source === t.source && o.state === "connected" || await p(t);
-  })().finally(() => {
-    n = null;
-  }), n), v = {
-    status: () => s.status,
-    error: () => s.error,
-    session: () => s.session,
-    rpcTransport: () => s.session?.rpc ?? null,
+    if (l !== s) return;
+    const i = u(e.source, e.controller);
+    c = e, o = i, a = i.subscribe(m), i.start(), await i.waitForSession();
+  }, h = {
+    status: () => n.snapshot.state,
+    snapshot: () => n.snapshot,
+    error: () => n.error,
+    session: () => n.snapshot.currentSession ?? null,
+    rpcTransport: () => n.snapshot.currentSession?.rpc ?? null,
     contract: () => C,
-    connect: d,
-    reconnect: async (t) => {
-      const e = t ?? a;
-      if (!e) throw new Error("reconnect() requires a config before the first connect() call");
-      await d(e);
+    connect: async (e) => {
+      if (o !== null && c !== null && !g(c, e))
+        throw new z();
+      return r !== null || (r = (async () => {
+        if (o === null) {
+          await d(e);
+          return;
+        }
+        o.start(), await o.waitForSession();
+      })().finally(() => {
+        r = null;
+      })), r;
     },
+    replaceConnection: async (e) => (r !== null && await r.catch(() => {
+    }), r = (async () => {
+      s += 1, await p(), s += 1, await d(e);
+    })().finally(() => {
+      r = null;
+    }), r),
+    retryNow: () => o?.retryNow() ?? !1,
     disconnect: () => {
-      l += 1, f();
+      s += 1, p();
     }
   };
-  return y(() => {
-    l += 1, c?.(), o?.close();
-  }), h(w.Provider, {
-    value: v,
+  return v(() => {
+    s += 1, a?.(), c?.lifecycle?.dispose(), o?.close();
+  }), P(w.Provider, {
+    value: h,
     get children() {
-      return r.children;
+      return t.children;
     }
   });
 }
-function G() {
-  const r = x(w);
-  if (!r) throw new Error("useProtocol must be used within a ProtocolProvider");
-  return r;
+function T() {
+  const t = S(w);
+  if (!t) throw new Error("useProtocol must be used within a ProtocolProvider");
+  return t;
+}
+function g(t, n) {
+  return t.source === n.source && t.controller === n.controller && t.lifecycle === n.lifecycle;
+}
+function O(t) {
+  const n = t.failure;
+  return n === void 0 ? null : new Error(`${n.phase}:${n.code}`);
 }
 export {
-  F as ProtocolProvider,
-  G as useProtocol
+  z as ConnectionReplacementRequiredError,
+  D as ProtocolProvider,
+  T as useProtocol
 };

package/dist/index3.js

@@ -1,5 +1,5 @@
-import { useProtocol as u } from "./index2.js";
-class d extends Error {
+import { useProtocol as y } from "./index2.js";
+class f extends Error {
   constructor() {
     super("Not connected"), this.name = "ProtocolNotConnectedError";
   }
@@ -11,54 +11,52 @@ class p extends Error {
     super(o.message ?? `RPC error: ${o.code}`, { cause: o.cause }), this.name = "RpcError", this.typeId = o.typeId, this.code = o.code;
   }
 }
-function y(c) {
-  const o = async (t, e) => {
-    const n = c.rpcTransport();
-    if (!n) throw new d();
-    let r;
+function h(n) {
+  const o = async (r, t, s) => {
+    const c = n.rpcTransport();
+    if (!c) throw new f();
+    let e;
     try {
-      r = await n.call(t, e, (s) => s);
-    } catch (s) {
-      throw new p({ typeId: t, code: -1, message: "RPC transport error", cause: s });
+      e = await c.call(r, t, s);
+    } catch (u) {
+      throw new p({ typeId: r, code: -1, message: "RPC transport or response decode error", cause: u });
     }
-    if (!r.ok)
+    if (!e.ok)
       throw new p({
-        typeId: t,
-        code: r.error.code,
-        message: r.error.message ?? `RPC error: ${r.error.code}`,
-        cause: r.error
+        typeId: r,
+        code: e.error.code,
+        message: e.error.message ?? `RPC error: ${e.error.code}`,
+        cause: e.error
       });
-    return r.payload;
-  }, a = async (t, e, n) => {
-    const r = c.rpcTransport();
-    if (!r) {
-      if (n.detached === "ignore") return;
-      throw new d();
+    return e.payload;
+  }, a = async (r, t, s) => {
+    const c = n.rpcTransport();
+    if (!c) {
+      if (s.detached === "ignore") return;
+      throw new f();
     }
     try {
-      await r.notify(t, e);
-    } catch (s) {
-      throw new p({ typeId: t, code: -1, message: "RPC notify transport error", cause: s });
+      await c.notify(r, t);
+    } catch (e) {
+      throw new p({ typeId: r, code: -1, message: "RPC notify transport error", cause: e });
     }
   };
-  return { call: o, notify: async (t, e) => {
-    await a(t, e, { detached: "throw" });
-  }, notifyBestEffort: async (t, e) => {
-    await a(t, e, { detached: "ignore" });
-  }, onNotify: (t, e) => {
-    const n = c.rpcTransport();
-    return n ? n.onNotify(t, (r) => r, (r) => {
-      e(r);
-    }) : () => {
+  return { call: o, notify: async (r, t) => {
+    await a(r, t, { detached: "throw" });
+  }, notifyBestEffort: async (r, t) => {
+    await a(r, t, { detached: "ignore" });
+  }, onNotify: (r, t, s) => {
+    const c = n.rpcTransport();
+    return c ? c.onNotify(r, t, s) : () => {
     };
   } };
 }
-function l(c) {
-  const o = u(), a = c?.contract ?? o.contract(), i = y(o), f = a.createRpc(i);
-  return Object.assign(f, i);
+function m(n) {
+  const o = y(), a = n?.contract ?? o.contract(), i = h(o), d = a.createRpc(i);
+  return Object.assign(d, i);
 }
 export {
-  d as ProtocolNotConnectedError,
+  f as ProtocolNotConnectedError,
   p as RpcError,
-  l as useRpc
+  m as useRpc
 };

package/dist/rpc.d.ts

@@ -1,9 +1,4 @@
 import type { ProtocolContract, RpcHelpers } from './contract';
-/**
- * RPC wrapper for typed remote calls.
- *
- * This module is contract-driven: a contract defines TypeIds + wire codecs + domain surface.
- */
 export declare class ProtocolNotConnectedError extends Error {
     constructor();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-protocol",
-  "version": "0.40.21",
+  "version": "0.41.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -33,7 +33,7 @@
     "solid-js": "^1.8.0"
   },
   "dependencies": {
-    "@floegence/flowersec-core": "2.4.2"
+    "@floegence/flowersec-core": "2.5.1"
   },
   "devDependencies": {
     "solid-js": "^1.9.11",

package/dist/controlplane.d.ts

@@ -1,20 +0,0 @@
-import { type Artifact, type JsonObject } from '@floegence/flowersec-core';
-export type RequestConnectArtifactInput = Readonly<{
-    baseUrl: string;
-    endpointId: string;
-    payload?: JsonObject;
-    correlation?: Readonly<{
-        traceId?: string;
-    }>;
-    fetch?: typeof globalThis.fetch;
-}>;
-export type RequestEntryConnectArtifactInput = RequestConnectArtifactInput & Readonly<{
-    entryTicket: string;
-}>;
-export declare class ControlplaneRequestError extends Error {
-    readonly status: number;
-    readonly code: string;
-    constructor(status: number, code: string, message: string);
-}
-export declare function requestConnectArtifact(input: RequestConnectArtifactInput): Promise<Artifact>;
-export declare function requestEntryConnectArtifact(input: RequestEntryConnectArtifactInput): Promise<Artifact>;

package/dist/index4.js

@@ -1,42 +0,0 @@
-import { parseArtifact as f } from "@floegence/flowersec-core";
-class a extends Error {
-  constructor(c, o, e) {
-    super(e), this.status = c, this.code = o, this.name = "ControlplaneRequestError";
-  }
-}
-async function i(t) {
-  const c = t.fetch ?? globalThis.fetch, o = new URL(t.baseUrl);
-  if (o.protocol !== "https:") throw new a(0, "transport_policy_denied", "controlplane transport policy denied");
-  const e = "entryTicket" in t, s = new URL(`/v1/connect/artifact${e ? "/entry" : ""}`, o).toString(), l = {
-    endpoint_id: t.endpointId,
-    ...t.payload === void 0 ? {} : { payload: t.payload },
-    ...!e && t.correlation === void 0 ? {} : e ? {} : { correlation: { trace_id: t.correlation?.traceId } }
-  }, r = await c(s, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json",
-      ...e ? { authorization: `Bearer ${t.entryTicket}` } : {}
-    },
-    body: JSON.stringify(l),
-    credentials: "omit",
-    redirect: "error"
-  });
-  if (!r.ok) throw new a(r.status, "request_failed", `controlplane request failed: ${r.status}`);
-  const n = await r.json();
-  if (n.connect_artifact === void 0)
-    throw new a(200, "invalid_request", "Invalid controlplane response: missing `connect_artifact`");
-  const d = typeof n.connect_artifact == "string" || n.connect_artifact instanceof Uint8Array ? n.connect_artifact : JSON.stringify(n.connect_artifact);
-  return f(d);
-}
-function y(t) {
-  return i(t);
-}
-function h(t) {
-  return i(t);
-}
-export {
-  a as ControlplaneRequestError,
-  y as requestConnectArtifact,
-  h as requestEntryConnectArtifact
-};