@floegence/flowersec-core 0.20.0 → 0.20.1

package/dist/proxy/integration.d.ts

@@ -33,6 +33,8 @@ export type RegisterProxyIntegrationOptions = Readonly<{
         maxChunkBytes?: number;
         maxBodyBytes?: number;
         maxWsFrameBytes?: number;
+        maxConcurrentHttpStreams?: number;
+        maxQueuedHttpRequests?: number;
         timeoutMs?: number;
         pathPolicy?: ProxyRuntimePathPolicy;
         externalOrigin?: string;

package/dist/proxy/integration.js

@@ -181,6 +181,12 @@ function buildRuntimeOptions(preset, runtime) {
         maxBodyBytes: runtime?.maxBodyBytes ?? preset.limits.max_body_bytes,
         maxWsFrameBytes: runtime?.maxWsFrameBytes ?? preset.limits.max_ws_frame_bytes,
         timeoutMs: runtime?.timeoutMs ?? preset.limits.timeout_ms ?? 0,
+        ...(runtime?.maxConcurrentHttpStreams === undefined
+            ? {}
+            : { maxConcurrentHttpStreams: runtime.maxConcurrentHttpStreams }),
+        ...(runtime?.maxQueuedHttpRequests === undefined
+            ? {}
+            : { maxQueuedHttpRequests: runtime.maxQueuedHttpRequests }),
         ...(runtime?.pathPolicy === undefined ? {} : { pathPolicy: runtime.pathPolicy }),
         ...(runtime?.externalOrigin === undefined ? {} : { externalOrigin: runtime.externalOrigin }),
         ...(runtime?.runtimeRegistrationToken === undefined ? {} : { runtimeRegistrationToken: runtime.runtimeRegistrationToken }),

package/dist/proxy/runtime.d.ts

@@ -15,6 +15,8 @@ export type ProxyRuntimeLimits = Readonly<{
     maxChunkBytes: number;
     maxBodyBytes: number;
     maxWsFrameBytes: number;
+    maxConcurrentHttpStreams: number;
+    maxQueuedHttpRequests: number;
 }>;
 export type ProxyRuntime = Readonly<{
     limits: ProxyRuntimeLimits;
@@ -40,6 +42,8 @@ export type ProxyRuntimeOptions = Readonly<{
     maxChunkBytes?: number;
     maxBodyBytes?: number;
     maxWsFrameBytes?: number;
+    maxConcurrentHttpStreams?: number;
+    maxQueuedHttpRequests?: number;
     timeoutMs?: number;
     extraRequestHeaders?: readonly string[];
     extraResponseHeaders?: readonly string[];

package/dist/proxy/runtime.js

@@ -2,6 +2,7 @@ import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../
 import { createByteReader } from "../streamio/index.js";
 import { base64urlEncode } from "../utils/base64url.js";
 import { readU32be, u32be } from "../utils/bin.js";
+import { AbortError, FlowersecError, isFlowersecError } from "../utils/errors.js";
 import { CookieJar } from "./cookieJar.js";
 import { DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CHUNK_BYTES, DEFAULT_MAX_WS_FRAME_BYTES, PROXY_KIND_HTTP1, PROXY_KIND_WS, PROXY_PROTOCOL_VERSION } from "./constants.js";
 import { filterRequestHeaders, filterResponseHeaders, filterWsOpenHeaders } from "./headerPolicy.js";
@@ -129,6 +130,123 @@ function normalizeMaxBytes(name, v, defaultValue) {
         return defaultValue;
     return n;
 }
+const DEFAULT_MAX_CONCURRENT_HTTP_STREAMS = 24;
+const DEFAULT_MAX_QUEUED_HTTP_REQUESTS = 128;
+function normalizePositiveLimit(name, value, defaultValue) {
+    if (value == null)
+        return defaultValue;
+    if (!Number.isFinite(value) || !Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${name} must be a positive safe integer`);
+    }
+    return value;
+}
+function normalizeNonNegativeLimit(name, value, defaultValue) {
+    if (value == null)
+        return defaultValue;
+    if (!Number.isFinite(value) || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${name} must be a non-negative safe integer`);
+    }
+    return value;
+}
+class HttpStreamAdmission {
+    path;
+    maxConcurrent;
+    maxQueued;
+    active = 0;
+    pending = [];
+    closed = false;
+    constructor(path, maxConcurrent, maxQueued) {
+        this.path = path;
+        this.maxConcurrent = maxConcurrent;
+        this.maxQueued = maxQueued;
+    }
+    acquire(signal) {
+        if (this.closed)
+            return Promise.reject(this.closedError());
+        if (signal?.aborted)
+            return Promise.reject(this.abortedError());
+        if (this.active < this.maxConcurrent && this.pending.length === 0) {
+            this.active++;
+            return Promise.resolve(this.createRelease());
+        }
+        if (this.pending.length >= this.maxQueued) {
+            return Promise.reject(new FlowersecError({
+                path: this.path,
+                stage: "yamux",
+                code: "resource_exhausted",
+                message: "proxy runtime HTTP request queue is full",
+            }));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                ...(signal === undefined ? {} : { signal }),
+            };
+            waiter.onAbort = () => {
+                const index = this.pending.indexOf(waiter);
+                if (index < 0)
+                    return;
+                this.pending.splice(index, 1);
+                this.cleanupWaiter(waiter);
+                reject(this.abortedError());
+            };
+            signal?.addEventListener("abort", waiter.onAbort, { once: true });
+            this.pending.push(waiter);
+        });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const waiter of this.pending.splice(0)) {
+            this.cleanupWaiter(waiter);
+            waiter.reject(this.closedError());
+        }
+    }
+    assertOpen() {
+        if (this.closed)
+            throw this.closedError();
+    }
+    createRelease() {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.active = Math.max(0, this.active - 1);
+            this.drain();
+        };
+    }
+    drain() {
+        while (!this.closed && this.active < this.maxConcurrent && this.pending.length > 0) {
+            const waiter = this.pending.shift();
+            this.cleanupWaiter(waiter);
+            if (waiter.signal?.aborted) {
+                waiter.reject(this.abortedError());
+                continue;
+            }
+            this.active++;
+            waiter.resolve(this.createRelease());
+        }
+    }
+    cleanupWaiter(waiter) {
+        if (waiter.onAbort != null) {
+            waiter.signal?.removeEventListener("abort", waiter.onAbort);
+        }
+    }
+    abortedError() {
+        return new AbortError("proxy HTTP request canceled while waiting for stream admission");
+    }
+    closedError() {
+        return new FlowersecError({
+            path: this.path,
+            stage: "close",
+            code: "not_connected",
+            message: "proxy runtime is disposed",
+        });
+    }
+}
 async function writeChunkFrames(stream, body, chunkSize, maxBodyBytes) {
     if (maxBodyBytes > 0 && body.length > maxBodyBytes)
         throw new Error("request body too large");
@@ -169,6 +287,9 @@ export function createProxyRuntime(opts) {
     const maxChunkBytes = normalizeMaxBytes("maxChunkBytes", opts.maxChunkBytes, DEFAULT_MAX_CHUNK_BYTES);
     const maxBodyBytes = normalizeMaxBytes("maxBodyBytes", opts.maxBodyBytes, DEFAULT_MAX_BODY_BYTES);
     const maxWsFrameBytes = normalizeMaxBytes("maxWsFrameBytes", opts.maxWsFrameBytes, DEFAULT_MAX_WS_FRAME_BYTES);
+    const maxConcurrentHttpStreams = normalizePositiveLimit("maxConcurrentHttpStreams", opts.maxConcurrentHttpStreams, DEFAULT_MAX_CONCURRENT_HTTP_STREAMS);
+    const maxQueuedHttpRequests = normalizeNonNegativeLimit("maxQueuedHttpRequests", opts.maxQueuedHttpRequests, DEFAULT_MAX_QUEUED_HTTP_REQUESTS);
+    const httpStreamAdmission = new HttpStreamAdmission(client.path, maxConcurrentHttpStreams, maxQueuedHttpRequests);
     const timeoutMs = normalizeTimeoutMs(opts.timeoutMs);
     const extraRequestHeaders = opts.extraRequestHeaders ?? [];
     const extraResponseHeaders = opts.extraResponseHeaders ?? [];
@@ -203,6 +324,7 @@ export function createProxyRuntime(opts) {
     const dispatchFetch = (req, port) => {
         const ac = new AbortController();
         let stream = null;
+        let releaseAdmission = null;
         port.onmessage = (ev) => {
             const m = ev.data;
             if (m && typeof m === "object" && m.type === "flowersec-proxy:abort") {
@@ -215,6 +337,8 @@ export function createProxyRuntime(opts) {
                 assertPathPolicyAllows("http", path, pathPolicy);
                 const requestID = req.id.trim() !== "" ? req.id : randomB64u(18);
                 const externalOrigin = externalOriginOverride ?? normalizeExternalOrigin(req.external_origin);
+                releaseAdmission = await httpStreamAdmission.acquire(ac.signal);
+                httpStreamAdmission.assertOpen();
                 stream = await client.openStream(PROXY_KIND_HTTP1, { signal: ac.signal });
                 const reader = createByteReader(stream, { signal: ac.signal });
                 const filteredReqHeaders = filterRequestHeaders(req.headers, { extraAllowed: extraRequestHeaders });
@@ -264,8 +388,17 @@ export function createProxyRuntime(opts) {
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
-                const status = e instanceof ProxyRuntimePolicyError ? e.status : 502;
-                port.postMessage({ type: "flowersec-proxy:response_error", status, message: msg });
+                const code = isFlowersecError(e) ? e.code : undefined;
+                const status = e instanceof ProxyRuntimePolicyError
+                    ? e.status
+                    : code === "resource_exhausted" || code === "not_connected"
+                        ? 503
+                        : 502;
+                port.postMessage({
+                    type: "flowersec-proxy:response_error",
+                    status,
+                    message: msg,
+                });
                 try {
                     stream?.reset(new Error(msg));
                 }
@@ -274,6 +407,7 @@ export function createProxyRuntime(opts) {
                 }
             }
             finally {
+                releaseAdmission?.();
                 try {
                     port.close();
                 }
@@ -312,10 +446,18 @@ export function createProxyRuntime(opts) {
         return { stream, protocol: resp.protocol ?? "" };
     }
     return {
-        limits: { maxJsonFrameBytes, maxChunkBytes, maxBodyBytes, maxWsFrameBytes },
+        limits: {
+            maxJsonFrameBytes,
+            maxChunkBytes,
+            maxBodyBytes,
+            maxWsFrameBytes,
+            maxConcurrentHttpStreams,
+            maxQueuedHttpRequests,
+        },
         dispatchFetch,
         openWebSocketStream,
         dispose: () => {
+            httpStreamAdmission.close();
             sw?.removeEventListener("message", onMessage);
             sw?.removeEventListener("controllerchange", registerRuntime);
         }

package/dist/proxy/runtimeScope.d.ts

@@ -36,12 +36,16 @@ export declare function resolveRuntimeLimitsFromScope(scope: ProxyRuntimeScopeV1
     maxChunkBytes?: number;
     maxBodyBytes?: number;
     maxWsFrameBytes?: number;
+    maxConcurrentHttpStreams?: number;
+    maxQueuedHttpRequests?: number;
     timeoutMs?: number;
 }> | undefined): Readonly<{
     maxJsonFrameBytes?: number;
     maxChunkBytes?: number;
     maxBodyBytes?: number;
     maxWsFrameBytes?: number;
+    maxConcurrentHttpStreams?: number;
+    maxQueuedHttpRequests?: number;
     timeoutMs?: number;
 }> | undefined;
 export declare function resolvePresetInputFromScope(scope: ProxyRuntimeScopeV1, presetOverride: ProxyPresetInput | undefined): ProxyPresetInput | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {