@floegence/flowersec-core 0.24.0 → 0.26.0

package/dist/proxy/portStream.d.ts

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

package/dist/proxy/portStream.js

@@ -4,79 +4,151 @@ function cloneChunk(chunk) {
     out.set(chunk);
     return out.buffer;
 }
+function validWriteId(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}
 export function createMessagePortBackedStream(port, opts = {}) {
     let closed = false;
+    let acceptingWrites = true;
     let error = null;
     const queue = [];
     const waiters = [];
-    const pendingWrites = new Map();
+    let pendingInboundWriteId = null;
+    let pendingOutboundAcknowledgement = null;
     let nextWriteId = 1;
-    const resolveWaiter = (value) => {
-        const waiter = waiters.shift();
-        if (waiter) {
-            waiter(value);
-            return true;
+    let writeTail = Promise.resolve();
+    let queuedWriteBytes = 0;
+    const maxBufferedBytes = opts.maxBufferedBytes ?? 4 * (1 << 20);
+    let terminalNotified = false;
+    const notifyTerminal = () => {
+        if (terminalNotified)
+            return;
+        terminalNotified = true;
+        opts.onTerminal?.();
+    };
+    const closePort = () => {
+        try {
+            port.close();
+        }
+        catch {
+            // Best-effort.
         }
-        return false;
     };
-    const pushValue = (value) => {
-        if (resolveWaiter(value))
-            return;
-        queue.push(value);
+    const drainWaiters = (value) => {
+        for (const waiter of waiters.splice(0))
+            waiter(value);
     };
-    const fail = (err) => {
+    const terminateWithError = (err, notifyPeer) => {
         if (error != null)
             return;
         error = err;
-        while (resolveWaiter(err)) {
-            // Drain waiters.
+        closed = true;
+        acceptingWrites = false;
+        queue.length = 0;
+        pendingInboundWriteId = null;
+        drainWaiters(err);
+        pendingOutboundAcknowledgement?.reject(err);
+        pendingOutboundAcknowledgement = null;
+        if (notifyPeer) {
+            try {
+                port.postMessage({
+                    type: PROXY_WINDOW_STREAM_RESET_MSG_TYPE,
+                    message: err.message,
+                });
+            }
+            catch {
+                // The local error remains authoritative.
+            }
+        }
+        closePort();
+        notifyTerminal();
+    };
+    const failProtocol = (message) => {
+        terminateWithError(new Error(`proxy Window stream protocol error: ${message}`), true);
+    };
+    const finishClosed = () => {
+        if (closed)
+            return;
+        if (pendingInboundWriteId != null) {
+            failProtocol("stream ended before the pending chunk was acknowledged");
+            return;
+        }
+        closed = true;
+        acceptingWrites = false;
+        const closeError = new Error("stream is closed");
+        pendingOutboundAcknowledgement?.reject(closeError);
+        pendingOutboundAcknowledgement = null;
+        drainWaiters(null);
+        closePort();
+        notifyTerminal();
+    };
+    const acknowledgeRead = (item) => {
+        if (closed)
+            return;
+        if (pendingInboundWriteId !== item.writeId) {
+            failProtocol("read acknowledgement does not match the pending chunk");
+            throw error;
+        }
+        pendingInboundWriteId = null;
+        try {
+            port.postMessage({
+                type: PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE,
+                writeId: item.writeId,
+            });
+        }
+        catch (cause) {
+            const err = cause instanceof Error ? cause : new Error(String(cause));
+            terminateWithError(err, false);
+            throw err;
         }
-        for (const pending of pendingWrites.values())
-            pending.reject(err);
-        pendingWrites.clear();
     };
     port.onmessage = (ev) => {
+        if (closed)
+            return;
         const data = ev.data;
         if (data == null || typeof data !== "object")
             return;
         const type = typeof data.type === "string" ? data.type : "";
         switch (type) {
             case PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE: {
-                const raw = data.data;
-                if (!(raw instanceof ArrayBuffer))
+                const msg = data;
+                if (!(msg.data instanceof ArrayBuffer) || !validWriteId(msg.writeId)) {
+                    failProtocol("invalid stream chunk");
+                    return;
+                }
+                if (pendingInboundWriteId != null || queue.length > 0) {
+                    failProtocol("received more than one unacknowledged chunk");
                     return;
-                pushValue(new Uint8Array(raw));
+                }
+                pendingInboundWriteId = msg.writeId;
+                const item = { chunk: new Uint8Array(msg.data), writeId: msg.writeId };
+                const waiter = waiters.shift();
+                if (waiter == null) {
+                    queue.push(item);
+                }
+                else {
+                    waiter(item);
+                }
                 return;
             }
             case PROXY_WINDOW_STREAM_END_MSG_TYPE:
             case PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE:
-                closed = true;
-                for (const pending of pendingWrites.values())
-                    pending.reject(new Error("stream is closed"));
-                pendingWrites.clear();
-                pushValue(null);
+                finishClosed();
                 return;
             case PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE: {
                 const writeId = data.writeId;
-                if (!Number.isSafeInteger(writeId) || writeId <= 0)
-                    return;
-                const pending = pendingWrites.get(writeId);
-                if (pending == null)
+                const pending = pendingOutboundAcknowledgement;
+                if (!validWriteId(writeId) || pending == null || pending.writeId !== writeId) {
+                    failProtocol("unexpected stream write acknowledgement");
                     return;
-                pendingWrites.delete(writeId);
+                }
+                pendingOutboundAcknowledgement = null;
                 pending.resolve();
                 return;
             }
             case PROXY_WINDOW_STREAM_RESET_MSG_TYPE: {
-                closed = true;
                 const message = String(data.message ?? "stream reset");
-                fail(new Error(message));
-                try {
-                    port.close();
-                }
-                catch {
-                    // Best-effort.
-                }
+                terminateWithError(new Error(message), false);
                 return;
             }
             default:
@@ -88,9 +160,11 @@ export function createMessagePortBackedStream(port, opts = {}) {
         async read() {
             if (error != null)
                 throw error;
-            const next = queue.shift();
-            if (next !== undefined)
-                return next;
+            const queued = queue.shift();
+            if (queued != null) {
+                acknowledgeRead(queued);
+                return queued.chunk;
+            }
             if (closed)
                 return null;
             const value = await new Promise((resolve) => {
@@ -98,60 +172,85 @@ export function createMessagePortBackedStream(port, opts = {}) {
             });
             if (value instanceof Error)
                 throw value;
-            return value;
+            if (value == null)
+                return null;
+            acknowledgeRead(value);
+            return value.chunk;
         },
         async write(chunk) {
             if (error != null)
                 throw error;
-            if (closed)
+            if (!acceptingWrites || closed)
                 throw new Error("stream is closed");
-            const ab = cloneChunk(chunk);
-            if (opts.writeAcknowledgements !== true) {
-                port.postMessage({ type: PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE, data: ab }, [ab]);
-                return;
+            const nextQueuedWriteBytes = queuedWriteBytes + chunk.byteLength;
+            if (!Number.isSafeInteger(nextQueuedWriteBytes) || nextQueuedWriteBytes > maxBufferedBytes) {
+                throw new Error("proxy WebSocket outbound buffer exceeded");
             }
-            const writeId = nextWriteId++;
-            await new Promise((resolve, reject) => {
-                pendingWrites.set(writeId, { resolve, reject });
-                try {
-                    port.postMessage({ type: PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE, data: ab, writeId }, [ab]);
+            queuedWriteBytes = nextQueuedWriteBytes;
+            const ab = cloneChunk(chunk);
+            const operation = writeTail.then(async () => {
+                if (error != null)
+                    throw error;
+                if (closed)
+                    throw new Error("stream is closed");
+                if (!Number.isSafeInteger(nextWriteId)) {
+                    failProtocol("stream write identifier space exhausted");
+                    throw error;
                 }
-                catch (error) {
-                    pendingWrites.delete(writeId);
-                    reject(error instanceof Error ? error : new Error(String(error)));
+                if (pendingOutboundAcknowledgement != null) {
+                    failProtocol("multiple outbound chunks are awaiting acknowledgement");
+                    throw error;
                 }
+                const writeId = nextWriteId++;
+                await new Promise((resolve, reject) => {
+                    pendingOutboundAcknowledgement = { writeId, resolve, reject };
+                    try {
+                        port.postMessage({
+                            type: PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE,
+                            data: ab,
+                            writeId,
+                        }, [ab]);
+                    }
+                    catch (cause) {
+                        pendingOutboundAcknowledgement = null;
+                        const postError = cause instanceof Error ? cause : new Error(String(cause));
+                        terminateWithError(postError, false);
+                        reject(postError);
+                    }
+                });
             });
+            writeTail = operation.catch(() => { });
+            try {
+                await operation;
+            }
+            finally {
+                queuedWriteBytes = Math.max(0, queuedWriteBytes - chunk.byteLength);
+            }
         },
         async close() {
+            if (closed)
+                return;
+            acceptingWrites = false;
+            await writeTail;
+            if (error != null)
+                throw error;
             if (closed)
                 return;
             closed = true;
-            const closeError = new Error("stream is closed");
-            for (const pending of pendingWrites.values())
-                pending.reject(closeError);
-            pendingWrites.clear();
+            queue.length = 0;
+            pendingInboundWriteId = null;
+            drainWaiters(null);
             try {
                 port.postMessage({ type: PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE });
             }
             finally {
-                pushValue(null);
+                closePort();
+                notifyTerminal();
             }
         },
         reset(err) {
-            const message = err instanceof Error ? err.message : String(err);
-            closed = true;
-            fail(err instanceof Error ? err : new Error(message));
-            try {
-                port.postMessage({ type: PROXY_WINDOW_STREAM_RESET_MSG_TYPE, message });
-            }
-            finally {
-                try {
-                    port.close();
-                }
-                catch {
-                    // Best-effort.
-                }
-            }
+            const resetError = err instanceof Error ? err : new Error(String(err));
+            terminateWithError(resetError, true);
         },
     };
 }

package/dist/proxy/preset.d.ts

@@ -26,5 +26,4 @@ export type ResolvedProxyPreset = Readonly<{
 export declare const DEFAULT_PROXY_PRESET_MANIFEST: ProxyPresetManifest;
 export type ProxyPresetInput = ProxyPresetManifest | Partial<ProxyPresetLimits>;
 export declare function assertProxyPresetManifest(value: unknown): ProxyPresetManifest;
-export declare function resolveNamedProxyPreset(name: string): ProxyPresetManifest;
 export declare function resolveProxyPreset(input?: ProxyPresetInput): ResolvedProxyPreset;

package/dist/proxy/preset.js

@@ -75,15 +75,6 @@ export function assertProxyPresetManifest(value) {
         limits: assertLimits(value.limits),
     });
 }
-export function resolveNamedProxyPreset(name) {
-    switch (String(name ?? "").trim()) {
-        case "":
-        case "default":
-            return DEFAULT_PROXY_PRESET_MANIFEST;
-        default:
-            throw new Error(`unknown proxy preset: ${name}`);
-    }
-}
 function toResolved(manifest) {
     return Object.freeze({
         v: 1,

package/dist/proxy/runtimeScope.js

@@ -1,4 +1,4 @@
-import { assertProxyPresetManifest, resolveNamedProxyPreset, } from "./preset.js";
+import { assertProxyPresetManifest, } from "./preset.js";
 const RUNTIME_SCOPE_NAME = "proxy.runtime";
 const PRESET_ID_RE = /^[a-z][a-z0-9._-]{0,63}$/;
 const MAX_RUNTIME_PAYLOAD_BYTES = 8 * 1024;
@@ -203,12 +203,7 @@ export function resolvePresetInputFromScope(scope, presetOverride) {
         return presetOverride;
     if (scope.preset.snapshot)
         return scope.preset.snapshot;
-    try {
-        return resolveNamedProxyPreset(scope.preset.presetId);
-    }
-    catch {
-        return undefined;
-    }
+    throw new Error("proxy.runtime preset snapshot is required");
 }
 export function resolveRuntimePresetLimits(scope) {
     if (scope.limits === undefined)

package/dist/proxy/server.d.ts

@@ -10,6 +10,7 @@ export type ProxyServerOptions = Readonly<{
     maxChunkBytes?: number;
     maxBodyBytes?: number;
     maxWsFrameBytes?: number;
+    maxWsQueuedBytes?: number;
     defaultTimeoutMs?: number;
     maxTimeoutMs?: number;
     maxConcurrentStreams?: number;