@floegence/flowersec-core 0.20.0 → 0.20.2

package/dist/client-connect/connectCore.d.ts

@@ -25,6 +25,8 @@ export type ConnectOptionsBase = Readonly<{
     maxRecordBytes?: number;
     /** Maximum buffered plaintext bytes in the secure channel (0 uses default). */
     maxBufferedBytes?: number;
+    /** Maximum queued outbound plaintext bytes in the secure channel (default 4 MiB; 0 uses default). */
+    maxOutboundBufferedBytes?: number;
     /** Preferred plaintext bytes per outbound encrypted record (default 64 KiB). */
     outboundRecordChunkBytes?: number;
     /** WebSocket inbound and outbound queue limits. */

package/dist/client-connect/connectCore.js

@@ -14,6 +14,7 @@ import { isTunnelAttachCloseReason } from "./tunnelAttachCloseReason.js";
 import { enforceTransportSecurity } from "./transportSecurity.js";
 import { maxPlaintextBytes } from "../e2ee/record.js";
 import { isYamuxResourceExhaustedError } from "../yamux/errors.js";
+import { registerClientTermination } from "./termination.js";
 export async function connectCore(args) {
     const observer = normalizeObserver(args.opts.observer, { path: args.path });
     const signal = args.opts.signal;
@@ -75,6 +76,10 @@ export async function connectCore(args) {
     if (!Number.isSafeInteger(maxBufferedBytes) || maxBufferedBytes < 0) {
         invalidOption("maxBufferedBytes must be a non-negative integer");
     }
+    const maxOutboundBufferedBytes = args.opts.maxOutboundBufferedBytes ?? 0;
+    if (!Number.isSafeInteger(maxOutboundBufferedBytes) || maxOutboundBufferedBytes < 0) {
+        invalidOption("maxOutboundBufferedBytes must be a non-negative integer");
+    }
     const effectiveMaxRecordBytes = maxRecordBytes > 0 ? maxRecordBytes : (1 << 20);
     const outboundRecordChunkBytes = args.opts.outboundRecordChunkBytes ?? 64 * 1024;
     if (!Number.isSafeInteger(outboundRecordChunkBytes) || outboundRecordChunkBytes <= 0 || outboundRecordChunkBytes > maxPlaintextBytes(effectiveMaxRecordBytes)) {
@@ -182,6 +187,7 @@ export async function connectCore(args) {
                 maxRecordBytes: effectiveMaxRecordBytes,
                 outboundRecordChunkBytes,
                 ...(maxBufferedBytes > 0 ? { maxBufferedBytes } : {}),
+                ...(maxOutboundBufferedBytes > 0 ? { maxOutboundBufferedBytes } : {}),
                 timeoutMs: handshakeTimeoutMs,
                 ...(signal !== undefined ? { signal } : {}),
             }), {
@@ -220,9 +226,28 @@ export async function connectCore(args) {
             write: (b) => secure.write(b),
             close: () => secure.close(),
         };
+        let resolveTermination;
+        const termination = new Promise((resolve) => {
+            resolveTermination = resolve;
+        });
+        let terminationReported = false;
+        let closeAll = () => {
+            try {
+                secure.close();
+            }
+            catch { /* ignore */ }
+        };
+        const reportTermination = (error) => {
+            if (terminationReported)
+                return;
+            terminationReported = true;
+            closeAll();
+            resolveTermination({ error });
+        };
         const mux = new YamuxSession(conn, {
             client: true,
             ...(args.opts.yamuxLimits === undefined ? {} : { limits: args.opts.yamuxLimits }),
+            onTerminal: reportTermination,
             onDiagnostic: (event) => emitObserverDiagnostic(args.opts.observer, {
                 path: args.path,
                 stage: "yamux",
@@ -234,9 +259,19 @@ export async function connectCore(args) {
                 limit: event.limit,
             }),
         });
+        closeAll = () => {
+            try {
+                mux.close();
+            }
+            catch { /* ignore */ }
+            try {
+                secure.close();
+            }
+            catch { /* ignore */ }
+        };
         let rpcStream;
         try {
-            rpcStream = await mux.openStream();
+            rpcStream = await mux.openStream(signal === undefined ? {} : { signal });
         }
         catch (e) {
             mux.close();
@@ -266,7 +301,7 @@ export async function connectCore(args) {
                 cause: e,
             });
         }
-        const rpc = new RpcClient(readExactly, write, { observer });
+        const rpc = new RpcClient(readExactly, write, { observer, onTerminal: reportTermination });
         const ping = async () => {
             try {
                 await secure.sendPing();
@@ -306,7 +341,7 @@ export async function connectCore(args) {
             clearInterval(livenessTimer);
             livenessTimer = undefined;
         };
-        const closeAll = () => {
+        closeAll = () => {
             stopLiveness();
             try {
                 rpc.close();
@@ -342,7 +377,7 @@ export async function connectCore(args) {
             }, liveness.intervalMs);
             livenessTimer?.unref?.();
         }
-        return {
+        const client = {
             path: args.path,
             ...(args.attach != null ? { endpointInstanceId: args.attach.endpointInstanceId } : {}),
             secure,
@@ -374,9 +409,12 @@ export async function connectCore(args) {
                 let abortListener;
                 let s;
                 try {
-                    s = await mux.openStream();
+                    s = await mux.openStream(signal === undefined ? {} : { signal });
                 }
                 catch (e) {
+                    if (signal?.aborted) {
+                        throw new FlowersecError({ path: args.path, stage: "yamux", code: "canceled", message: "open stream aborted", cause: signal.reason });
+                    }
                     const exhausted = isYamuxResourceExhaustedError(e);
                     throw new FlowersecError({ path: args.path, stage: "yamux", code: exhausted ? "resource_exhausted" : "open_stream_failed", message: exhausted ? "yamux stream limit reached" : "open stream failed", cause: e });
                 }
@@ -456,6 +494,8 @@ export async function connectCore(args) {
             },
             close: closeAll,
         };
+        registerClientTermination(client, termination);
+        return client;
     }
     catch (e) {
         try {

package/dist/client-connect/termination.d.ts

@@ -0,0 +1,6 @@
+import type { Client } from "../client.js";
+export type ClientTermination = Readonly<{
+    error: Error;
+}>;
+export declare function registerClientTermination(client: Client, termination: Promise<ClientTermination>): void;
+export declare function getClientTermination(client: Client): Promise<ClientTermination> | undefined;

package/dist/client-connect/termination.js

@@ -0,0 +1,7 @@
+const clientTerminations = new WeakMap();
+export function registerClientTermination(client, termination) {
+    clientTerminations.set(client, termination);
+}
+export function getClientTermination(client) {
+    return clientTerminations.get(client);
+}

package/dist/e2ee/handshake.d.ts

@@ -18,6 +18,8 @@ export type HandshakeClientOptions = Readonly<{
     outboundRecordChunkBytes?: number;
     /** Maximum buffered plaintext bytes for the secure channel. */
     maxBufferedBytes?: number;
+    /** Maximum queued outbound plaintext bytes for the secure channel. */
+    maxOutboundBufferedBytes?: number;
     /** Optional AbortSignal to cancel the handshake. */
     signal?: AbortSignal;
     /** Optional total handshake timeout in milliseconds (>= 0; 0 disables). */
@@ -44,6 +46,8 @@ export type HandshakeServerOptions = Readonly<{
     outboundRecordChunkBytes?: number;
     /** Maximum buffered plaintext bytes for the secure channel. */
     maxBufferedBytes?: number;
+    /** Maximum queued outbound plaintext bytes for the secure channel. */
+    maxOutboundBufferedBytes?: number;
     /** Optional AbortSignal to cancel the handshake. */
     signal?: AbortSignal;
     /** Optional total handshake timeout in milliseconds (>= 0; 0 disables). */

package/dist/e2ee/handshake.js

@@ -161,6 +161,7 @@ export async function clientHandshake(transport, opts) {
         maxRecordBytes: opts.maxRecordBytes,
         ...(opts.outboundRecordChunkBytes !== undefined ? { outboundRecordChunkBytes: opts.outboundRecordChunkBytes } : {}),
         ...(opts.maxBufferedBytes !== undefined ? { maxBufferedBytes: opts.maxBufferedBytes } : {}),
+        ...(opts.maxOutboundBufferedBytes !== undefined ? { maxOutboundBufferedBytes: opts.maxOutboundBufferedBytes } : {}),
         sendKey: keys.c2sKey,
         recvKey: keys.s2cKey,
         sendNoncePrefix: keys.c2sNoncePrefix,
@@ -190,6 +191,7 @@ export class ServerHandshakeCache {
         }
         this.ttlMs = ttlMs;
         this.maxEntries = maxEntries;
+        serverHandshakeCacheStores.set(this, this.m);
     }
     cleanup(nowMs) {
         if (this.ttlMs <= 0)
@@ -231,6 +233,15 @@ export class ServerHandshakeCache {
         this.m.delete(initKey);
     }
 }
+const serverHandshakeCacheStores = new WeakMap();
+function takeServerHandshakeState(cache, expected) {
+    const store = serverHandshakeCacheStores.get(cache);
+    const current = store?.get(expected.initKey);
+    if (current !== expected)
+        return undefined;
+    store.delete(expected.initKey);
+    return current;
+}
 // serverHandshake performs the server side of the E2EE handshake.
 export async function serverHandshake(transport, cache, opts) {
     if (opts.initExpireAtUnixS <= 0)
@@ -281,6 +292,8 @@ export async function serverHandshake(transport, cache, opts) {
         }
         if (decoded.handshakeType !== HANDSHAKE_TYPE_ACK)
             throw new Error("unexpected handshake type");
+        if (takeServerHandshakeState(cache, entry) == null)
+            throw new Error("handshake state unavailable");
         ack = JSON.parse(td.decode(decoded.payloadJsonUtf8));
         break;
     }
@@ -309,7 +322,6 @@ export async function serverHandshake(transport, cache, opts) {
         throw new E2EEHandshakeError("auth_tag_mismatch", "auth tag mismatch");
     const shared = suiteSharedSecret(suite, entry.serverPriv, clientPub);
     const keys = deriveSessionKeys(opts.psk, shared, th);
-    cache.delete(init);
     // Server-finished confirmation: send an encrypted ping record (seq=1) immediately after the handshake.
     const pingFrame = encryptRecord(keys.s2cKey, keys.s2cNoncePrefix, RECORD_FLAG_PING, 1n, new Uint8Array(), opts.maxRecordBytes);
     await transport.writeBinary(pingFrame, ioWriteOpts(opts.signal));
@@ -319,6 +331,7 @@ export async function serverHandshake(transport, cache, opts) {
         maxRecordBytes: opts.maxRecordBytes,
         ...(opts.outboundRecordChunkBytes !== undefined ? { outboundRecordChunkBytes: opts.outboundRecordChunkBytes } : {}),
         ...(opts.maxBufferedBytes !== undefined ? { maxBufferedBytes: opts.maxBufferedBytes } : {}),
+        ...(opts.maxOutboundBufferedBytes !== undefined ? { maxOutboundBufferedBytes: opts.maxOutboundBufferedBytes } : {}),
         sendKey: keys.s2cKey,
         recvKey: keys.c2sKey,
         sendNoncePrefix: keys.s2cNoncePrefix,

package/dist/e2ee/secureChannel.d.ts

@@ -21,8 +21,10 @@ export type SecureChannelOptions = Readonly<{
     maxRecordBytes: number;
     /** Preferred plaintext bytes per outbound record. */
     outboundRecordChunkBytes?: number;
-    /** Maximum queued plaintext bytes before backpressure/errors. */
+    /** Maximum queued inbound plaintext bytes before the channel is closed. */
     maxBufferedBytes?: number;
+    /** Maximum queued outbound plaintext bytes (default 4 MiB; 0 uses default). */
+    maxOutboundBufferedBytes?: number;
 }>;
 type Direction = 1 | 2;
 export declare class SecureChannel {
@@ -30,6 +32,7 @@ export declare class SecureChannel {
     private readonly maxRecordBytes;
     private readonly outboundRecordChunkBytes;
     private readonly maxBufferedBytes;
+    private readonly maxOutboundBufferedBytes;
     private sendKey;
     private recvKey;
     private sendNoncePrefix;
@@ -44,6 +47,7 @@ export declare class SecureChannel {
     private sendQueueHead;
     private sendWaiters;
     private sendWaitersHead;
+    private sendQueueBytes;
     private sendClosed;
     private sendErr;
     private readonly recvQueue;
@@ -57,6 +61,7 @@ export declare class SecureChannel {
         maxRecordBytes: number;
         outboundRecordChunkBytes?: number;
         maxBufferedBytes?: number;
+        maxOutboundBufferedBytes?: number;
         sendKey: Uint8Array;
         recvKey: Uint8Array;
         sendNoncePrefix: Uint8Array;

package/dist/e2ee/secureChannel.js

@@ -17,6 +17,7 @@ export class SecureChannel {
     outboundRecordChunkBytes;
     // Upper bound for buffered plaintext in memory.
     maxBufferedBytes;
+    maxOutboundBufferedBytes;
     // Active encryption keys and nonce prefixes for the current epoch.
     sendKey;
     recvKey;
@@ -37,6 +38,7 @@ export class SecureChannel {
     sendQueueHead = 0;
     sendWaiters = [];
     sendWaitersHead = 0;
+    sendQueueBytes = 0;
     sendClosed = false;
     sendErr = null;
     // Receive queue and waiters for plaintext delivery.
@@ -55,6 +57,11 @@ export class SecureChannel {
             throw new RangeError("outboundRecordChunkBytes must be a positive integer within the record plaintext limit");
         }
         this.maxBufferedBytes = Math.max(0, args.maxBufferedBytes ?? 4 * (1 << 20));
+        const maxOutboundBufferedBytes = args.maxOutboundBufferedBytes ?? 4 * (1 << 20);
+        if (!Number.isSafeInteger(maxOutboundBufferedBytes) || maxOutboundBufferedBytes < 0) {
+            throw new RangeError("maxOutboundBufferedBytes must be a non-negative safe integer");
+        }
+        this.maxOutboundBufferedBytes = maxOutboundBufferedBytes === 0 ? 4 * (1 << 20) : maxOutboundBufferedBytes;
         this.sendKey = args.sendKey;
         this.recvKey = args.recvKey;
         this.sendNoncePrefix = args.sendNoncePrefix;
@@ -72,7 +79,7 @@ export class SecureChannel {
     async write(plaintext) {
         if (plaintext.length === 0)
             return;
-        await this.enqueueSend("app", plaintext.slice());
+        await this.enqueueSend("app", plaintext);
     }
     // read resolves with the next plaintext chunk or throws on errors/close.
     async read() {
@@ -121,6 +128,10 @@ export class SecureChannel {
             return Promise.reject(this.sendErr);
         if (this.closed || this.sendClosed)
             return Promise.reject(new Error("closed"));
+        const bufferedBytes = payload?.byteLength ?? 0;
+        if (this.sendQueueBytes + bufferedBytes > this.maxOutboundBufferedBytes) {
+            return Promise.reject(new Error("secure channel outbound buffer exceeded"));
+        }
         return new Promise((resolve, reject) => {
             if (this.sendErr != null) {
                 reject(this.sendErr);
@@ -130,7 +141,15 @@ export class SecureChannel {
                 reject(new Error("closed"));
                 return;
             }
-            const req = payload === undefined ? { kind, resolve, reject } : { kind, payload, resolve, reject };
+            if (this.sendQueueBytes + bufferedBytes > this.maxOutboundBufferedBytes) {
+                reject(new Error("secure channel outbound buffer exceeded"));
+                return;
+            }
+            const retainedPayload = payload?.slice();
+            const req = retainedPayload === undefined
+                ? { kind, bufferedBytes, resolve, reject }
+                : { kind, payload: retainedPayload, bufferedBytes, resolve, reject };
+            this.sendQueueBytes += bufferedBytes;
             this.sendQueue.push(req);
             const w = this.shiftSendWaiter();
             if (w != null)
@@ -182,8 +201,11 @@ export class SecureChannel {
         const start = this.sendQueueHead;
         this.sendQueue = [];
         this.sendQueueHead = 0;
-        for (let i = start; i < queued.length; i++)
-            queued[i].reject(err);
+        for (let i = start; i < queued.length; i++) {
+            const req = queued[i];
+            this.sendQueueBytes = Math.max(0, this.sendQueueBytes - req.bufferedBytes);
+            req.reject(err);
+        }
     }
     failSend(err) {
         if (this.sendErr != null)
@@ -207,15 +229,15 @@ export class SecureChannel {
             const req = await this.nextSend();
             if (req == null)
                 return;
-            if (this.sendErr != null) {
-                req.reject(this.sendErr);
-                continue;
-            }
-            if (this.closed || this.sendClosed) {
-                req.reject(new Error("closed"));
-                continue;
-            }
             try {
+                if (this.sendErr != null) {
+                    req.reject(this.sendErr);
+                    continue;
+                }
+                if (this.closed || this.sendClosed) {
+                    req.reject(new Error("closed"));
+                    continue;
+                }
                 let frame;
                 if (req.kind === "app") {
                     const payload = req.payload ?? new Uint8Array();
@@ -247,6 +269,9 @@ export class SecureChannel {
                 this.close();
                 return;
             }
+            finally {
+                this.sendQueueBytes = Math.max(0, this.sendQueueBytes - req.bufferedBytes);
+            }
         }
     }
     async readLoop() {

package/dist/proxy/appWindow.d.ts

@@ -6,6 +6,7 @@ export type RegisterProxyAppWindowOptions = Readonly<{
     controllerWindow?: Window | null;
     targetWindow?: Window;
     maxWsFrameBytes?: number;
+    maxWsBufferedAmountBytes?: number;
     capabilityNonce?: string;
 }>;
 export type ProxyAppWindowHandle = Readonly<{

package/dist/proxy/appWindow.js

@@ -1,6 +1,6 @@
 import { createServiceWorkerControllerGuard, } from "./controllerGuard.js";
 import { createMessagePortBackedStream } from "./portStream.js";
-import { PROXY_WINDOW_FETCH_FORWARD_MSG_TYPE, PROXY_WINDOW_FETCH_MSG_TYPE, PROXY_WINDOW_WS_ERROR_MSG_TYPE, PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE, PROXY_WINDOW_WS_OPEN_MSG_TYPE, } from "./windowBridgeProtocol.js";
+import { PROXY_WINDOW_FETCH_FORWARD_MSG_TYPE, PROXY_WINDOW_FETCH_MSG_TYPE, PROXY_WINDOW_WS_ERROR_MSG_TYPE, PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE, PROXY_WINDOW_WS_OPEN_MSG_TYPE, PROXY_WINDOW_WS_WRITE_ACK_CAPABILITY, } from "./windowBridgeProtocol.js";
 function resolveTargetWindow(raw) {
     const target = raw ?? globalThis.window;
     if (target == null)
@@ -83,7 +83,12 @@ export function registerProxyAppWindow(opts) {
     };
     sw?.addEventListener("message", onServiceWorkerMessage);
     const runtime = {
-        limits: opts.maxWsFrameBytes === undefined ? {} : { maxWsFrameBytes: opts.maxWsFrameBytes },
+        limits: {
+            ...(opts.maxWsFrameBytes === undefined ? {} : { maxWsFrameBytes: opts.maxWsFrameBytes }),
+            ...(opts.maxWsBufferedAmountBytes === undefined
+                ? {}
+                : { maxWsBufferedAmountBytes: opts.maxWsBufferedAmountBytes }),
+        },
         openWebSocketStream: async (path, wsOpts = {}) => {
             const channel = new MessageChannel();
             const port = channel.port1;
@@ -102,11 +107,18 @@ export function registerProxyAppWindow(opts) {
                     }
                     reject(error instanceof Error ? error : new Error(String(error)));
                 };
-                const finishResolve = (protocol) => {
+                const finishResolve = (ack) => {
                     if (settled)
                         return;
                     settled = true;
-                    resolve({ stream: createMessagePortBackedStream(port), protocol });
+                    const capabilities = Array.isArray(ack.capabilities)
+                        ? ack.capabilities.filter((value) => typeof value === "string")
+                        : [];
+                    const writeAcknowledgements = capabilities.includes(PROXY_WINDOW_WS_WRITE_ACK_CAPABILITY);
+                    resolve({
+                        stream: createMessagePortBackedStream(port, { writeAcknowledgements }),
+                        protocol: String(ack.protocol ?? ""),
+                    });
                 };
                 port.onmessage = (ev) => {
                     const data = ev.data;
@@ -114,7 +126,7 @@ export function registerProxyAppWindow(opts) {
                         return;
                     const type = typeof data.type === "string" ? data.type : "";
                     if (type === PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE) {
-                        finishResolve(String(data.protocol ?? ""));
+                        finishResolve(data);
                         return;
                     }
                     if (type === PROXY_WINDOW_WS_ERROR_MSG_TYPE) {

package/dist/proxy/controllerWindow.js

@@ -1,4 +1,4 @@
-import { PROXY_WINDOW_FETCH_MSG_TYPE, PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE, PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE, PROXY_WINDOW_STREAM_END_MSG_TYPE, PROXY_WINDOW_STREAM_RESET_MSG_TYPE, PROXY_WINDOW_WS_ERROR_MSG_TYPE, PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE, PROXY_WINDOW_WS_OPEN_MSG_TYPE, } from "./windowBridgeProtocol.js";
+import { PROXY_WINDOW_FETCH_MSG_TYPE, PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE, PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE, PROXY_WINDOW_STREAM_END_MSG_TYPE, PROXY_WINDOW_STREAM_RESET_MSG_TYPE, PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE, PROXY_WINDOW_WS_ERROR_MSG_TYPE, PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE, PROXY_WINDOW_WS_OPEN_MSG_TYPE, PROXY_WINDOW_WS_WRITE_ACK_CAPABILITY, } from "./windowBridgeProtocol.js";
 function normalizeOrigins(origins) {
     const out = [];
     const seen = new Set();
@@ -41,7 +41,12 @@ function hasExpectedCapability(data, capabilityNonce) {
 }
 function bridgeWebSocket(runtime, msg, port) {
     const ac = new AbortController();
-    let streamClosed = false;
+    let terminal = false;
+    let acceptingWrites = true;
+    let stream = null;
+    let pendingWriteBytes = 0;
+    let writeChain = Promise.resolve();
+    const maxBufferedBytes = runtime.limits.maxWsBufferedAmountBytes ?? 4 * (1 << 20);
     const closePort = () => {
         try {
             port.close();
@@ -50,13 +55,43 @@ function bridgeWebSocket(runtime, msg, port) {
             // Best-effort.
         }
     };
+    const failBridge = (error) => {
+        if (terminal)
+            return;
+        terminal = true;
+        acceptingWrites = false;
+        const err = error instanceof Error ? error : new Error(String(error));
+        try {
+            stream?.reset(err);
+        }
+        catch {
+            // Best-effort.
+        }
+        try {
+            ac.abort(err.message);
+        }
+        catch {
+            // Best-effort.
+        }
+        try {
+            port.postMessage({
+                type: PROXY_WINDOW_STREAM_RESET_MSG_TYPE,
+                message: err.message,
+            });
+        }
+        catch {
+            // Best-effort.
+        }
+        closePort();
+    };
     void (async () => {
         try {
             const wsOpts = {
                 signal: ac.signal,
                 ...(msg.protocols === undefined ? {} : { protocols: msg.protocols }),
             };
-            const { stream, protocol } = await runtime.openWebSocketStream(msg.path, wsOpts);
+            const opened = await runtime.openWebSocketStream(msg.path, wsOpts);
+            stream = opened.stream;
             port.onmessage = (ev) => {
                 const data = ev.data;
                 if (data == null || typeof data !== "object")
@@ -64,21 +99,50 @@ function bridgeWebSocket(runtime, msg, port) {
                 const type = typeof data.type === "string" ? data.type : "";
                 switch (type) {
                     case PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE: {
+                        if (!acceptingWrites || stream == null)
+                            return;
                         const raw = data.data;
                         if (!(raw instanceof ArrayBuffer))
                             return;
-                        void stream.write(new Uint8Array(raw));
+                        if (pendingWriteBytes + raw.byteLength > maxBufferedBytes) {
+                            failBridge(new Error("proxy WebSocket outbound buffer exceeded"));
+                            return;
+                        }
+                        const rawWriteId = data.writeId;
+                        const writeId = Number.isSafeInteger(rawWriteId) && Number(rawWriteId) > 0
+                            ? Number(rawWriteId)
+                            : undefined;
+                        const chunk = new Uint8Array(raw);
+                        pendingWriteBytes += chunk.byteLength;
+                        writeChain = writeChain
+                            .then(async () => {
+                            if (terminal || stream == null)
+                                throw new Error("stream is closed");
+                            await stream.write(chunk);
+                            if (terminal || writeId === undefined)
+                                return;
+                            port.postMessage({
+                                type: PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE,
+                                writeId,
+                            });
+                        })
+                            .catch((error) => failBridge(error))
+                            .finally(() => {
+                            pendingWriteBytes = Math.max(0, pendingWriteBytes - chunk.byteLength);
+                        });
                         return;
                     }
                     case PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE:
-                        void stream.close();
+                        if (!acceptingWrites || stream == null)
+                            return;
+                        acceptingWrites = false;
+                        writeChain = writeChain
+                            .then(() => stream?.close())
+                            .catch((error) => failBridge(error));
                         return;
                     case PROXY_WINDOW_STREAM_RESET_MSG_TYPE: {
                         const message = String(data.message ?? "stream reset");
-                        stream.reset(new Error(message));
-                        streamClosed = true;
-                        ac.abort(message);
-                        closePort();
+                        failBridge(new Error(message));
                         return;
                     }
                     default:
@@ -86,11 +150,16 @@ function bridgeWebSocket(runtime, msg, port) {
                 }
             };
             port.start?.();
-            port.postMessage({ type: PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE, protocol });
-            while (!streamClosed) {
+            port.postMessage({
+                type: PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE,
+                protocol: opened.protocol,
+                capabilities: [PROXY_WINDOW_WS_WRITE_ACK_CAPABILITY],
+            });
+            while (!terminal) {
                 const chunk = await stream.read();
                 if (chunk == null) {
-                    streamClosed = true;
+                    terminal = true;
+                    acceptingWrites = false;
                     port.postMessage({ type: PROXY_WINDOW_STREAM_END_MSG_TYPE });
                     closePort();
                     return;
@@ -101,8 +170,12 @@ function bridgeWebSocket(runtime, msg, port) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            port.postMessage({ type: PROXY_WINDOW_WS_ERROR_MSG_TYPE, message });
-            closePort();
+            if (stream == null) {
+                port.postMessage({ type: PROXY_WINDOW_WS_ERROR_MSG_TYPE, message });
+                closePort();
+                return;
+            }
+            failBridge(error);
         }
     })();
 }

package/dist/proxy/headerPolicy.js

@@ -16,15 +16,24 @@ const DEFAULT_RESPONSE_HEADER_ALLOWLIST = new Set([
     "content-disposition",
     "content-encoding",
     "content-language",
+    "content-security-policy",
+    "content-security-policy-report-only",
     "content-type",
+    "cross-origin-embedder-policy",
+    "cross-origin-opener-policy",
+    "cross-origin-resource-policy",
     "etag",
     "expires",
     "last-modified",
     "location",
+    "permissions-policy",
     "pragma",
+    "referrer-policy",
     "vary",
     "www-authenticate",
-    "set-cookie"
+    "set-cookie",
+    "x-content-type-options",
+    "x-frame-options"
 ]);
 const DEFAULT_WS_HEADER_ALLOWLIST = new Set(["sec-websocket-protocol", "cookie"]);
 export function normalizeHeaderName(name) {

package/dist/proxy/integration.d.ts

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

package/dist/proxy/integration.js

@@ -180,7 +180,19 @@ function buildRuntimeOptions(preset, runtime) {
         maxChunkBytes: runtime?.maxChunkBytes ?? preset.limits.max_chunk_bytes,
         maxBodyBytes: runtime?.maxBodyBytes ?? preset.limits.max_body_bytes,
         maxWsFrameBytes: runtime?.maxWsFrameBytes ?? preset.limits.max_ws_frame_bytes,
+        ...(runtime?.maxWsBufferedAmountBytes === undefined
+            ? {}
+            : { maxWsBufferedAmountBytes: runtime.maxWsBufferedAmountBytes }),
         timeoutMs: runtime?.timeoutMs ?? preset.limits.timeout_ms ?? 0,
+        ...(runtime?.maxConcurrentHttpStreams === undefined
+            ? {}
+            : { maxConcurrentHttpStreams: runtime.maxConcurrentHttpStreams }),
+        ...(runtime?.maxQueuedHttpRequests === undefined
+            ? {}
+            : { maxQueuedHttpRequests: runtime.maxQueuedHttpRequests }),
+        ...(runtime?.maxQueuedHttpBodyBytes === undefined
+            ? {}
+            : { maxQueuedHttpBodyBytes: runtime.maxQueuedHttpBodyBytes }),
         ...(runtime?.pathPolicy === undefined ? {} : { pathPolicy: runtime.pathPolicy }),
         ...(runtime?.externalOrigin === undefined ? {} : { externalOrigin: runtime.externalOrigin }),
         ...(runtime?.runtimeRegistrationToken === undefined ? {} : { runtimeRegistrationToken: runtime.runtimeRegistrationToken }),

package/dist/proxy/portStream.d.ts

@@ -1,2 +1,4 @@
 import type { YamuxStream } from "../yamux/stream.js";
-export declare function createMessagePortBackedStream(port: MessagePort): YamuxStream;
+export declare function createMessagePortBackedStream(port: MessagePort, opts?: Readonly<{
+    writeAcknowledgements?: boolean;
+}>): YamuxStream;