@floegence/flowersec-core 0.21.0 → 0.22.0

package/dist/reconnect/index.js

@@ -1,24 +1,25 @@
 import { getClientTermination } from "../client-connect/termination.js";
 import { emitObserverDiagnostic, withObserverContext } from "../observability/observer.js";
+import { SDK_DEFAULTS } from "../defaults.js";
 export { createArtifactResolver, createControlplaneArtifactSource } from "./artifactControlplane.js";
 function normalizeAutoReconnect(cfg) {
     if (!cfg?.enabled) {
         return {
             enabled: false,
             maxAttempts: 1,
-            initialDelayMs: 500,
-            maxDelayMs: 10_000,
-            factor: 1.8,
-            jitterRatio: 0.2,
+            initialDelayMs: SDK_DEFAULTS.reconnect.initialDelayMs,
+            maxDelayMs: SDK_DEFAULTS.reconnect.maxDelayMs,
+            factor: SDK_DEFAULTS.reconnect.factor,
+            jitterRatio: SDK_DEFAULTS.reconnect.jitterRatio,
         };
     }
     return {
         enabled: true,
-        maxAttempts: Math.max(1, cfg.maxAttempts ?? 5),
-        initialDelayMs: Math.max(0, cfg.initialDelayMs ?? 500),
-        maxDelayMs: Math.max(0, cfg.maxDelayMs ?? 10_000),
-        factor: Math.max(1, cfg.factor ?? 1.8),
-        jitterRatio: Math.max(0, cfg.jitterRatio ?? 0.2),
+        maxAttempts: Math.max(1, cfg.maxAttempts ?? SDK_DEFAULTS.reconnect.maxAttempts),
+        initialDelayMs: Math.max(0, cfg.initialDelayMs ?? SDK_DEFAULTS.reconnect.initialDelayMs),
+        maxDelayMs: Math.max(0, cfg.maxDelayMs ?? SDK_DEFAULTS.reconnect.maxDelayMs),
+        factor: Math.max(1, cfg.factor ?? SDK_DEFAULTS.reconnect.factor),
+        jitterRatio: Math.max(0, cfg.jitterRatio ?? SDK_DEFAULTS.reconnect.jitterRatio),
     };
 }
 function backoffDelayMs(attemptIndex, cfg) {
@@ -138,8 +139,9 @@ export function createReconnectManager() {
         }
         token += 1;
         const nextToken = token;
+        const reconnectPromise = startConnectLoop(nextToken, cfg);
         setState({ status: "connecting", error, client: null });
-        void connectWithRetry(nextToken, cfg).catch(() => {
+        void reconnectPromise.catch(() => {
             // connectWithRetry updates state; keep errors observable via state().
         });
     };
@@ -262,6 +264,22 @@ export function createReconnectManager() {
             }
         }
     };
+    const startConnectLoop = (t, cfg) => {
+        let resolveLoop;
+        let rejectLoop;
+        const loop = new Promise((resolve, reject) => {
+            resolveLoop = resolve;
+            rejectLoop = reject;
+        });
+        let promise;
+        promise = loop.finally(() => {
+            if (activeConnectPromise === promise)
+                activeConnectPromise = null;
+        });
+        activeConnectPromise = promise;
+        void connectWithRetry(t, cfg).then(resolveLoop, rejectLoop);
+        return promise;
+    };
     const connect = async (cfg) => {
         cancelRetrySleep();
         abortActiveAttempt();
@@ -277,25 +295,18 @@ export function createReconnectManager() {
                 // ignore
             }
         }
+        const connectPromise = startConnectLoop(t, cfg);
         setState({ status: "connecting", error: null, client: null });
-        const p = connectWithRetry(t, cfg);
-        activeConnectPromise = p;
-        try {
-            await p;
-        }
-        finally {
-            if (activeConnectPromise === p)
-                activeConnectPromise = null;
-        }
+        await connectPromise;
     };
     const connectIfNeeded = async (cfg) => {
         if (isSameConfig(active, cfg)) {
-            if (s.status === "connected" && s.client)
-                return;
-            if (s.status === "connecting" && activeConnectPromise) {
+            if (activeConnectPromise) {
                 await activeConnectPromise;
                 return;
             }
+            if (s.status === "connected" && s.client)
+                return;
         }
         await connect(cfg);
     };

package/dist/rpc/server.d.ts

@@ -13,9 +13,14 @@ export type RpcServerTransport = Readonly<{
     write(bytes: Uint8Array): Promise<void>;
     close(error: unknown): void;
 }>;
+export declare class RpcRouter {
+    private readonly handlers;
+    register(typeId: number, handler: RpcHandler): void;
+    handler(typeId: number): RpcHandler | undefined;
+}
 export declare class RpcServer {
     private readonly transport;
-    private readonly handlers;
+    private readonly router;
     private closed;
     private readonly options;
     private readonly requests;
@@ -27,8 +32,9 @@ export declare class RpcServer {
     private readonly terminalSignal;
     private signalTerminal;
     private transportClosed;
-    constructor(transport: RpcServerTransport, options?: RpcServerOptions);
+    constructor(transport: RpcServerTransport, options?: RpcServerOptions, router?: RpcRouter);
     register(typeId: number, h: RpcHandler): void;
+    notify(typeId: number, payload: unknown): Promise<void>;
     serve(signal?: AbortSignal): Promise<void>;
     close(error?: unknown): void;
     private fail;
@@ -37,4 +43,5 @@ export declare class RpcServer {
     private nextWork;
     private wakeOne;
     private writeResponse;
+    private writeEnvelope;
 }

package/dist/rpc/server.js

@@ -1,15 +1,24 @@
 import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
 import { assertRpcEnvelope } from "./validate.js";
+import { SDK_DEFAULTS } from "../defaults.js";
 const DEFAULT_RPC_SERVER_OPTIONS = Object.freeze({
-    maxConcurrentRequests: 32,
-    maxQueuedRequests: 128,
-    maxQueuedNotifications: 128,
+    maxConcurrentRequests: SDK_DEFAULTS.rpc.maxConcurrentRequests,
+    maxQueuedRequests: SDK_DEFAULTS.rpc.maxQueuedRequests,
+    maxQueuedNotifications: SDK_DEFAULTS.rpc.maxQueuedNotifications,
 });
+export class RpcRouter {
+    handlers = new Map();
+    register(typeId, handler) {
+        this.handlers.set(typeId >>> 0, handler);
+    }
+    handler(typeId) {
+        return this.handlers.get(typeId >>> 0);
+    }
+}
 // RpcServer dispatches request envelopes to registered handlers.
 export class RpcServer {
     transport;
-    // Registered handlers keyed by type ID.
-    handlers = new Map();
+    router;
     // Closed flag to stop the serve loop.
     closed = false;
     options;
@@ -22,8 +31,9 @@ export class RpcServer {
     terminalSignal;
     signalTerminal;
     transportClosed = false;
-    constructor(transport, options = {}) {
+    constructor(transport, options = {}, router = new RpcRouter()) {
         this.transport = transport;
+        this.router = router;
         this.terminalSignal = new Promise((resolve) => { this.signalTerminal = resolve; });
         this.options = {
             maxConcurrentRequests: positiveInteger(options.maxConcurrentRequests ?? DEFAULT_RPC_SERVER_OPTIONS.maxConcurrentRequests, "maxConcurrentRequests"),
@@ -33,7 +43,17 @@ export class RpcServer {
     }
     // register binds a handler to a type ID.
     register(typeId, h) {
-        this.handlers.set(typeId >>> 0, h);
+        this.router.register(typeId, h);
+    }
+    async notify(typeId, payload) {
+        if (this.closed)
+            throw new Error("rpc server closed");
+        await this.writeEnvelope({
+            type_id: typeId >>> 0,
+            request_id: 0,
+            response_to: 0,
+            payload,
+        });
     }
     // serve handles request/response frames until closed or aborted.
     async serve(signal) {
@@ -106,7 +126,7 @@ export class RpcServer {
             if (work == null)
                 return;
             const v = work.envelope;
-            const h = this.handlers.get(v.type_id >>> 0);
+            const h = this.router.handler(v.type_id);
             let out;
             if (h == null)
                 out = { payload: null, error: { code: 404, message: "handler not found" } };
@@ -129,7 +149,7 @@ export class RpcServer {
             if (work == null)
                 return;
             const v = work.envelope;
-            const h = this.handlers.get(v.type_id >>> 0);
+            const h = this.router.handler(v.type_id);
             if (h == null)
                 continue;
             try {
@@ -158,7 +178,10 @@ export class RpcServer {
             payload: out.payload,
             ...(out.error != null ? { error: out.error } : {}),
         };
-        const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, resp));
+        await this.writeEnvelope(resp);
+    }
+    async writeEnvelope(envelope) {
+        const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, envelope));
         this.writeChain = write.catch(() => { });
         await write;
     }

package/dist/yamux/session.d.ts

@@ -12,8 +12,11 @@ export type YamuxLimits = Readonly<{
     preferredOutboundFrameBytes: number;
     maxStreamReceiveBytes: number;
     maxSessionReceiveBytes: number;
+    /** Maximum bytes retained by pending write calls on one stream. */
+    maxStreamWriteQueueBytes?: number;
 }>;
-export declare const DEFAULT_YAMUX_LIMITS: YamuxLimits;
+type ResolvedYamuxLimits = Readonly<Required<YamuxLimits>>;
+export declare const DEFAULT_YAMUX_LIMITS: ResolvedYamuxLimits;
 export type ByteDuplex = {
     /** Reads the next chunk from the underlying connection. */
     read(): Promise<Uint8Array>;
@@ -60,6 +63,7 @@ export declare class YamuxSession {
     getStream(id: number): YamuxStream | undefined;
     writeRaw(chunk: Uint8Array): Promise<void>;
     outboundFrameBytes(): number;
+    streamWriteQueueBytes(): number;
     releaseReceiveBytes(bytes: number): void;
     probeLiveness(timeoutMs?: number): Promise<number>;
     private startLivenessProbe;
@@ -79,3 +83,4 @@ export declare class YamuxSession {
     private isInboundStreamIdValid;
     private diagnostic;
 }
+export {};

package/dist/yamux/session.js

@@ -3,13 +3,15 @@ import { decodeHeader, encodeHeader, HEADER_LEN } from "./header.js";
 import { FLAG_ACK, FLAG_RST, FLAG_SYN, TYPE_DATA, TYPE_GO_AWAY, TYPE_PING, TYPE_WINDOW_UPDATE, YAMUX_VERSION } from "./constants.js";
 import { YamuxStream } from "./stream.js";
 import { YamuxResourceExhaustedError } from "./errors.js";
+import { SDK_DEFAULTS } from "../defaults.js";
 export const DEFAULT_YAMUX_LIMITS = Object.freeze({
-    maxActiveStreams: 64,
-    maxInboundStreams: 32,
-    maxFrameBytes: 256 * 1024,
-    preferredOutboundFrameBytes: 64 * 1024,
-    maxStreamReceiveBytes: 256 * 1024,
-    maxSessionReceiveBytes: 16 * (1 << 20),
+    maxActiveStreams: SDK_DEFAULTS.yamux.maxActiveStreams,
+    maxInboundStreams: SDK_DEFAULTS.yamux.maxInboundStreams,
+    maxFrameBytes: SDK_DEFAULTS.yamux.maxFrameBytes,
+    preferredOutboundFrameBytes: SDK_DEFAULTS.yamux.preferredOutboundFrameBytes,
+    maxStreamReceiveBytes: SDK_DEFAULTS.yamux.maxStreamReceiveBytes,
+    maxSessionReceiveBytes: SDK_DEFAULTS.yamux.maxSessionReceiveBytes,
+    maxStreamWriteQueueBytes: SDK_DEFAULTS.e2ee.maxOutboundBufferedBytes,
 });
 // YamuxSession multiplexes multiple streams over a single byte stream.
 export class YamuxSession {
@@ -92,6 +94,9 @@ export class YamuxSession {
     outboundFrameBytes() {
         return this.limits.preferredOutboundFrameBytes;
     }
+    streamWriteQueueBytes() {
+        return this.limits.maxStreamWriteQueueBytes;
+    }
     releaseReceiveBytes(bytes) {
         this.sessionReceiveBytes = Math.max(0, this.sessionReceiveBytes - Math.max(0, bytes));
     }
@@ -436,6 +441,7 @@ function normalizeYamuxLimits(input) {
         preferredOutboundFrameBytes: input?.preferredOutboundFrameBytes ?? Math.min(DEFAULT_YAMUX_LIMITS.preferredOutboundFrameBytes, maxFrameBytes),
         maxStreamReceiveBytes: input?.maxStreamReceiveBytes ?? DEFAULT_YAMUX_LIMITS.maxStreamReceiveBytes,
         maxSessionReceiveBytes: input?.maxSessionReceiveBytes ?? DEFAULT_YAMUX_LIMITS.maxSessionReceiveBytes,
+        maxStreamWriteQueueBytes: input?.maxStreamWriteQueueBytes ?? DEFAULT_YAMUX_LIMITS.maxStreamWriteQueueBytes,
     };
     for (const [name, value] of Object.entries(limits)) {
         if (!Number.isSafeInteger(value) || value <= 0)

package/dist/yamux/stream.d.ts

@@ -13,6 +13,7 @@ export declare class YamuxStream {
     private error;
     private resetTask;
     private writeChain;
+    private writeQueueBytes;
     private finalized;
     constructor(session: YamuxSession, id: number, state: StreamState);
     open(): Promise<void>;

package/dist/yamux/stream.js

@@ -1,6 +1,7 @@
 import { concatBytes } from "../utils/bin.js";
 import { encodeHeader } from "./header.js";
 import { DEFAULT_MAX_STREAM_WINDOW, FLAG_ACK, FLAG_FIN, FLAG_RST, FLAG_SYN, TYPE_DATA, TYPE_WINDOW_UPDATE } from "./constants.js";
+import { YamuxResourceExhaustedError } from "./errors.js";
 // YamuxStream manages per-stream flow control and state transitions.
 export class YamuxStream {
     // Stream identifier within the session.
@@ -24,6 +25,7 @@ export class YamuxStream {
     error = null;
     resetTask;
     writeChain = Promise.resolve();
+    writeQueueBytes = 0;
     finalized = false;
     constructor(session, id, state) {
         this.session = session;
@@ -87,10 +89,23 @@ export class YamuxStream {
     }
     // write sends DATA frames, respecting the send window.
     async write(data) {
-        const payload = data.slice();
-        const write = this.writeChain.then(() => this.writeSerial(payload));
-        this.writeChain = write.catch(() => { });
-        await write;
+        this.ensureWritable();
+        const byteCount = data.byteLength;
+        const nextQueueBytes = this.writeQueueBytes + byteCount;
+        const limit = this.session.streamWriteQueueBytes();
+        if (!Number.isSafeInteger(nextQueueBytes) || nextQueueBytes > limit) {
+            throw new YamuxResourceExhaustedError("stream_write_queue_bytes", nextQueueBytes, limit);
+        }
+        this.writeQueueBytes = nextQueueBytes;
+        try {
+            const payload = data.slice();
+            const write = this.writeChain.then(() => this.writeSerial(payload));
+            this.writeChain = write.catch(() => { });
+            await write;
+        }
+        finally {
+            this.writeQueueBytes = Math.max(0, this.writeQueueBytes - byteCount);
+        }
     }
     async writeSerial(data) {
         this.ensureWritable();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {
@@ -40,6 +40,10 @@
       "types": "./dist/controlplane/index.d.ts",
       "default": "./dist/controlplane/index.js"
     },
+    "./endpoint": {
+      "types": "./dist/endpoint/index.d.ts",
+      "default": "./dist/endpoint/index.js"
+    },
     "./framing": {
       "types": "./dist/framing/index.d.ts",
       "default": "./dist/framing/index.js"