@floegence/flowersec-core 2.4.1 → 2.4.2

package/dist/framing/jsonframe.js

@@ -2,7 +2,7 @@ import { readU32be, u32be } from "../utils/bin.js";
 import { SDK_DEFAULTS } from "../defaults.js";
 export const DEFAULT_MAX_JSON_FRAME_BYTES = SDK_DEFAULTS.rpc.maxJsonFrameBytes;
 const te = new TextEncoder();
-const td = new TextDecoder();
+const td = new TextDecoder("utf-8", { fatal: true });
 // JsonFramingError marks malformed or oversized frames.
 export class JsonFramingError extends Error {
 }
@@ -29,5 +29,12 @@ export async function readJsonFrame(readExactly, maxBytes) {
     if (maxBytes > 0 && n > maxBytes)
         throw new JsonFramingError("frame too large");
     const payload = await read(n);
-    return JSON.parse(td.decode(payload));
+    let text;
+    try {
+        text = td.decode(payload);
+    }
+    catch {
+        throw new JsonFramingError("invalid UTF-8");
+    }
+    return JSON.parse(text);
 }

package/dist/node/acceptor.js

@@ -1,4 +1,5 @@
 import { RpcRouter } from "../rpc/server.js";
+import { assertRpcError } from "../rpc/validate.js";
 import { acceptReceivedSessionV2, receiveSessionAdmissionV2, rejectSessionAdmissionV2, } from "../connector/sessionAcceptor.js";
 import { nodeSessionRuntimeV2 } from "./sessionRuntime.js";
 import { startNodeWebSocketServer, } from "./webSocketServer.js";
@@ -264,11 +265,27 @@ export class Acceptor {
     }
     async close() {
         const state = acceptorState(this);
-        state.abort.abort();
-        state.accepted.close();
-        await Promise.all(state.listeners.map(async (listener) => await listener.close()));
-        await boundedCleanup(state.tasks, state.cleanupTimeoutMs);
-        state.tasks.clear();
+        if (state.lifecycle.completion === undefined) {
+            state.lifecycle.completion = closeAcceptor(state);
+        }
+        await withCleanupTimeout(state.lifecycle.completion, state.cleanupTimeoutMs);
+    }
+}
+const MAX_CONCURRENT_ADMISSIONS = 64;
+const MAX_PENDING_ACCEPTED_SESSIONS = 64;
+async function closeAcceptor(state) {
+    state.abort.abort();
+    const queued = state.accepted.close();
+    const cleanup = await Promise.allSettled([
+        ...state.listeners.map(async (listener) => await listener.close()),
+        ...queued.map(async (accepted) => await accepted.close()),
+    ]);
+    while (state.tasks.size > 0) {
+        await Promise.allSettled([...state.tasks]);
+    }
+    if (cleanup.some((result) => result.status === "rejected") ||
+        state.lifecycle.cleanupFailed) {
+        throw new SessionError("operation_failed");
     }
 }
 async function releaseLease(state, leaseId) {
@@ -280,7 +297,7 @@ async function authorizeCarrier(state, carrier) {
     const received = await receiveSessionAdmissionV2(carrier, state.abort.signal);
     const decoded = received.decoded;
     const request = runtimeAuthorizationRequestFromDecoded(decoded);
-    const decision = await abortableCallback(state.options.authorize(request, { signal: state.abort.signal }), state.abort.signal);
+    const decision = await state.options.authorize(request, { signal: state.abort.signal });
     if (decision.decision !== "allow") {
         return await rejectSessionAdmissionV2(received, {
             accepted: false,
@@ -294,9 +311,7 @@ async function authorizeCarrier(state, carrier) {
     try {
         const registry = state.options.resolveHandlers === undefined
             ? new SessionHandlers()
-            : await abortableCallback(Promise.resolve(state.options.resolveHandlers(request, {
-                signal: state.abort.signal,
-            })), state.abort.signal);
+            : await state.options.resolveHandlers(request, { signal: state.abort.signal });
         const handlers = freezeSessionHandlers(registry);
         const leg = {
             received,
@@ -326,28 +341,50 @@ async function processCarrier(state, carrier) {
     const leg = await authorizeCarrier(state, carrier);
     if (leg === undefined)
         return;
+    let releaseOwnedByAcceptedSession = false;
     try {
         if (leg.received.decoded.request.pathKind !== "direct" ||
             leg.artifact.path.kind !== "direct") {
             await leg.received.carrier.close().catch(() => undefined);
             throw new SessionError("operation_failed");
         }
-        state.accepted.push(await establishDirect(leg, state.abort.signal, leg.leaseId === undefined ? undefined : () => releaseLease(state, leg.leaseId)));
+        const accepted = await establishDirect(leg, state.abort.signal, leg.leaseId === undefined ? undefined : () => releaseLease(state, leg.leaseId));
+        releaseOwnedByAcceptedSession = true;
+        if (state.accepted.push(accepted) === "rejected") {
+            try {
+                await accepted.close();
+            }
+            catch {
+                state.lifecycle.cleanupFailed = true;
+                throw new SessionError("operation_failed");
+            }
+        }
     }
     catch (error) {
-        await releaseLease(state, leg.leaseId).catch(() => undefined);
+        if (!releaseOwnedByAcceptedSession) {
+            await releaseLease(state, leg.leaseId).catch(() => undefined);
+        }
         throw error;
     }
 }
 async function runAcceptLoop(state) {
     while (!state.abort.signal.aborted) {
         try {
+            while (state.admissions.size >= MAX_CONCURRENT_ADMISSIONS) {
+                await Promise.race(state.admissions);
+                if (state.abort.signal.aborted)
+                    return;
+            }
             const carrier = await state.accept({ signal: state.abort.signal });
             const task = processCarrier(state, carrier)
                 .catch(async () => {
                 await carrier.close().catch(() => undefined);
             })
-                .finally(() => state.tasks.delete(task));
+                .finally(() => {
+                state.admissions.delete(task);
+                state.tasks.delete(task);
+            });
+            state.admissions.add(task);
             state.tasks.add(task);
         }
         catch (error) {
@@ -362,16 +399,19 @@ class AcceptedQueue {
     waiters = new Set();
     failure;
     push(value) {
-        if (this.failure !== undefined) {
-            void value.close();
-            return;
-        }
+        if (this.failure !== undefined)
+            return "rejected";
         const waiter = this.waiters.values().next().value;
-        if (waiter === undefined)
+        if (waiter === undefined) {
+            if (this.values.length >= MAX_PENDING_ACCEPTED_SESSIONS)
+                return "rejected";
             this.values.push(value);
+            return "queued";
+        }
         else {
             this.waiters.delete(waiter);
             waiter.resolve(value);
+            return "delivered";
         }
     }
     async shift(signal) {
@@ -412,6 +452,7 @@ class AcceptedQueue {
     }
     close() {
         this.fail(new SessionError("closed"));
+        return this.values.splice(0);
     }
 }
 const acceptorStates = new WeakMap();
@@ -482,6 +523,7 @@ export async function createAcceptor(options) {
     const accepted = new AcceptedQueue();
     const abort = new AbortController();
     const tasks = new Set();
+    const admissions = new Set();
     let started = false;
     const state = {
         listeners,
@@ -490,7 +532,9 @@ export async function createAcceptor(options) {
         accepted,
         abort,
         tasks,
+        admissions,
         cleanupTimeoutMs,
+        lifecycle: { cleanupFailed: false },
         start() {
             if (started)
                 return;
@@ -502,52 +546,26 @@ export async function createAcceptor(options) {
     acceptorStates.set(acceptor, state);
     return Object.freeze(acceptor);
 }
-async function boundedCleanup(tasks, timeoutMs) {
-    await Promise.race([
-        Promise.allSettled([...tasks]).then(() => undefined),
-        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
-    ]);
-}
-async function abortableCallback(promise, signal) {
-    if (signal.aborted)
-        throw signal.reason instanceof Error ? signal.reason : new SessionError("closed");
-    return await new Promise((resolve, reject) => {
-        let settled = false;
-        const cleanup = () => signal.removeEventListener("abort", abort);
-        const abort = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(signal.reason instanceof Error ? signal.reason : new SessionError("closed"));
-        };
-        signal.addEventListener("abort", abort, { once: true });
-        void promise.then((value) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(value);
-        }, (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(error);
-        });
-    });
+async function withCleanupTimeout(completion, timeoutMs) {
+    let timer;
+    try {
+        await Promise.race([
+            completion,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new SessionError("timeout")), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
 }
 function validRPCError(error) {
-    if (!Number.isSafeInteger(error.code) ||
-        error.code < 1 ||
-        error.code > 0xffff_ffff) {
-        return { code: 500, message: "handler failed" };
+    try {
+        return assertRpcError(error);
     }
-    if (error.message !== undefined &&
-        encoder.encode(error.message).length > 1024) {
+    catch {
         return { code: 500, message: "handler failed" };
     }
-    return error.message === undefined
-        ? { code: error.code }
-        : { code: error.code, message: error.message };
 }

package/dist/node/controlplane.js

@@ -1,4 +1,4 @@
-import { randomBytes as nodeRandomBytes } from "node:crypto";
+import { randomBytes as nodeRandomBytes, timingSafeEqual } from "node:crypto";
 import { buildFSB2RequestV2, canonicalizeCandidatesV2, computeSessionContractHashV2, decodeArtifactV2JSON, decodeFSB2RequestV2, encodeArtifactV2JSON, encodeFSB2RequestV2, } from "../v2/artifact.js";
 import { wrapArtifact } from "../public/artifact.js";
 import { base64urlDecode, base64urlEncode } from "../utils/base64url.js";
@@ -413,7 +413,11 @@ function validTCPAddress(value) {
     return port >= 1 && port <= 65_535;
 }
 function validObservedText(value) { return value.length > 0 && value.length <= 512 && !/[\u0000-\u001f\u007f]/u.test(value); }
-function bytesEqual(a, b) { return a.length === b.length && a.every((value, index) => value === b[index]); }
+function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(a, b);
+}
 function strictObject(bytes) {
     let value;
     try {

package/dist/public/artifactLease.js

@@ -36,13 +36,6 @@ export async function commitArtifactLeaseSpend(lease, signal) {
     const leaseState = artifactLeaseStates.get(lease);
     if (leaseState === undefined || leaseState.state !== "idle")
         throw new ArtifactLeaseError();
-    leaseState.state = "spending";
-    try {
-        await leaseState.commitSpend(signal);
-        leaseState.state = "consumed";
-    }
-    catch (error) {
-        leaseState.state = "idle";
-        throw error;
-    }
+    leaseState.state = "consumed";
+    await leaseState.commitSpend(signal);
 }

package/dist/rpc/server.js

@@ -1,5 +1,5 @@
 import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
-import { assertRpcEnvelope } from "./validate.js";
+import { assertRpcEnvelope, assertRpcError } from "./validate.js";
 import { SDK_DEFAULTS } from "../defaults.js";
 const DEFAULT_RPC_SERVER_OPTIONS = Object.freeze({
     maxConcurrentRequests: SDK_DEFAULTS.rpc.maxConcurrentRequests,
@@ -217,12 +217,21 @@ export class RpcServer {
         waiters.shift()?.();
     }
     async writeResponse(request, out) {
+        let error;
+        if (out.error != null) {
+            try {
+                error = assertRpcError(out.error);
+            }
+            catch {
+                error = { code: 500, message: "internal error" };
+            }
+        }
         const resp = {
             type_id: request.type_id,
             request_id: 0,
             response_to: request.request_id,
             payload: out.payload,
-            ...(out.error != null ? { error: out.error } : {}),
+            ...(error != null ? { error } : {}),
         };
         await this.writeEnvelope(resp);
     }

package/dist/rpc/validate.d.ts

@@ -1,2 +1,3 @@
-import type { RpcEnvelope } from "./wire.js";
+import type { RpcEnvelope, RpcError } from "./wire.js";
 export declare function assertRpcEnvelope(v: unknown): RpcEnvelope;
+export declare function assertRpcError(value: unknown): RpcError;

package/dist/rpc/validate.js

@@ -1,4 +1,6 @@
 import { isSafeU32Number, isSafeU64Number } from "../utils/number.js";
+const encoder = new TextEncoder();
+const strictDecoder = new TextDecoder("utf-8", { fatal: true });
 // assertRpcEnvelope validates numeric fields that are u32/u64 in the IDL.
 //
 // The wire format is JSON, so JS numbers are used. For u64 we enforce the safe integer range
@@ -15,13 +17,29 @@ export function assertRpcEnvelope(v) {
         throw new Error("bad rpc envelope: response_to");
     // payload: unknown (JSON)
     if (o.error != null) {
-        if (typeof o.error !== "object" || o.error == null)
-            throw new Error("bad rpc envelope: error");
-        if (!isSafeU32Number(o.error.code))
-            throw new Error("bad rpc envelope: error.code");
-        const msg = o.error.message;
-        if (msg !== undefined && typeof msg !== "string")
-            throw new Error("bad rpc envelope: error.message");
+        assertRpcError(o.error);
     }
     return o;
 }
+export function assertRpcError(value) {
+    if (typeof value !== "object" || value == null)
+        throw new Error("bad rpc envelope: error");
+    const error = value;
+    if (Object.keys(error).some((key) => key !== "code" && key !== "message")) {
+        throw new Error("bad rpc envelope: error shape");
+    }
+    if (!isSafeU32Number(error.code) || error.code === 0) {
+        throw new Error("bad rpc envelope: error.code");
+    }
+    const message = error.message;
+    if (message !== undefined && typeof message !== "string") {
+        throw new Error("bad rpc envelope: error.message");
+    }
+    if (typeof message === "string") {
+        const encoded = encoder.encode(message);
+        if (encoded.byteLength > 1_024 || strictDecoder.decode(encoded) !== message) {
+            throw new Error("bad rpc envelope: error.message");
+        }
+    }
+    return message === undefined ? { code: error.code } : { code: error.code, message };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "Flowersec core TypeScript library for carrier-neutral encrypted sessions and multiplexed streams.",
   "license": "MIT",
   "repository": {
@@ -77,7 +77,7 @@
     "ws": "^8.21.2"
   },
   "optionalDependencies": {
-    "@floegence/flowersec-node-native": "2.4.1"
+    "@floegence/flowersec-node-native": "2.4.2"
   },
   "devDependencies": {
     "@playwright/test": "1.62.1",
@@ -95,5 +95,5 @@
     "vite": "^8.2.1",
     "vitest": "4.1.10"
   },
-  "flowersecSourceCommit": "3605cb0c32551ec5bc2f799cd2e086c5c3102177"
+  "flowersecSourceCommit": "1393acdb891a6c935a435bee9068f65b68268795"
 }

package/sbom/cyclonedx.json

@@ -1,20 +1,20 @@
 {
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:1b2d0f50-da64-544b-8761-aaf9dd5a7c79",
+  "serialNumber": "urn:uuid:a7cb7385-1123-5452-8424-bbcb7904bbbb",
   "version": 1,
   "metadata": {
     "component": {
       "type": "library",
       "name": "@floegence/flowersec-core",
-      "version": "2.4.1",
-      "purl": "pkg:npm/%40floegence/flowersec-core@2.4.1",
-      "bom-ref": "pkg:npm/%40floegence/flowersec-core@2.4.1"
+      "version": "2.4.2",
+      "purl": "pkg:npm/%40floegence/flowersec-core@2.4.2",
+      "bom-ref": "pkg:npm/%40floegence/flowersec-core@2.4.2"
     },
     "properties": [
       {
         "name": "flowersec:source-inventory-sha256",
-        "value": "661d332941b82dbf168619a507636c87c3d13befebe1b70ddec45674655e1941"
+        "value": "59d233df0e12f2c371ab542c83edf97a2968a75c7d17c057e453b97f530a90e4"
       }
     ]
   },
@@ -190,7 +190,7 @@
   ],
   "dependencies": [
     {
-      "ref": "pkg:npm/%40floegence/flowersec-core@2.4.1",
+      "ref": "pkg:npm/%40floegence/flowersec-core@2.4.2",
       "dependsOn": [
         "pkg:npm/%40noble/ciphers@2.3.0",
         "pkg:npm/%40noble/curves@2.3.0",

package/sbom/spdx.json

@@ -3,7 +3,7 @@
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
   "name": "flowersec-ts",
-  "documentNamespace": "https://github.com/floegence/flowersec/sbom/flowersec-ts/661d332941b82dbf168619a507636c87c3d13befebe1b70ddec45674655e1941",
+  "documentNamespace": "https://github.com/floegence/flowersec/sbom/flowersec-ts/59d233df0e12f2c371ab542c83edf97a2968a75c7d17c057e453b97f530a90e4",
   "creationInfo": {
     "created": "1970-01-01T00:00:00Z",
     "creators": [
@@ -13,19 +13,19 @@
   "packages": [
     {
       "name": "@floegence/flowersec-core",
-      "SPDXID": "SPDXRef-Package-4eeba6fa52c374d21b02",
-      "versionInfo": "2.4.1",
+      "SPDXID": "SPDXRef-Package-9eec732cc29715c69e1e",
+      "versionInfo": "2.4.2",
       "downloadLocation": "NOASSERTION",
       "filesAnalyzed": false,
       "licenseConcluded": "NOASSERTION",
       "licenseDeclared": "NOASSERTION",
       "copyrightText": "NOASSERTION",
-      "comment": "Flowersec source inventory SHA-256: 661d332941b82dbf168619a507636c87c3d13befebe1b70ddec45674655e1941",
+      "comment": "Flowersec source inventory SHA-256: 59d233df0e12f2c371ab542c83edf97a2968a75c7d17c057e453b97f530a90e4",
       "externalRefs": [
         {
           "referenceCategory": "PACKAGE-MANAGER",
           "referenceType": "purl",
-          "referenceLocator": "pkg:npm/%40floegence/flowersec-core@2.4.1"
+          "referenceLocator": "pkg:npm/%40floegence/flowersec-core@2.4.2"
         }
       ]
     },
@@ -136,30 +136,30 @@
     {
       "spdxElementId": "SPDXRef-DOCUMENT",
       "relationshipType": "DESCRIBES",
-      "relatedSpdxElement": "SPDXRef-Package-4eeba6fa52c374d21b02"
+      "relatedSpdxElement": "SPDXRef-Package-9eec732cc29715c69e1e"
     },
     {
-      "spdxElementId": "SPDXRef-Package-4eeba6fa52c374d21b02",
+      "spdxElementId": "SPDXRef-Package-9eec732cc29715c69e1e",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-5ce913a03239b02770fb"
     },
     {
-      "spdxElementId": "SPDXRef-Package-4eeba6fa52c374d21b02",
+      "spdxElementId": "SPDXRef-Package-9eec732cc29715c69e1e",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-01009adf60db02c13634"
     },
     {
-      "spdxElementId": "SPDXRef-Package-4eeba6fa52c374d21b02",
+      "spdxElementId": "SPDXRef-Package-9eec732cc29715c69e1e",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-8815b117c8a1d5f7eeb0"
     },
     {
-      "spdxElementId": "SPDXRef-Package-4eeba6fa52c374d21b02",
+      "spdxElementId": "SPDXRef-Package-9eec732cc29715c69e1e",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-f8b45a289df643042b94"
     },
     {
-      "spdxElementId": "SPDXRef-Package-4eeba6fa52c374d21b02",
+      "spdxElementId": "SPDXRef-Package-9eec732cc29715c69e1e",
       "relationshipType": "DEPENDS_ON",
       "relatedSpdxElement": "SPDXRef-Package-b779412f685822663496"
     },