@floegence/flowersec-core 2.5.3 → 3.0.0

package/dist/v3/webSocketCarrier.js

@@ -0,0 +1,370 @@
+import { YamuxSession } from "../yamux/session.js";
+import { CarrierError } from "./carrier.js";
+export function createWebSocketCarrierSessionV3(transport, options) {
+    return new WebSocketYamuxCarrierSession(transport, options);
+}
+export function createServerWebSocketCarrierSessionV3(transport, options) {
+    requireCapacity(options.inboundBidirectionalStreamCapacity);
+    const carrier = new ServerWebSocketAdmissionCarrier(transport, options);
+    serverAdmissionCarriers.set(carrier, carrier);
+    return carrier;
+}
+const serverAdmissionCarriers = new WeakMap();
+export function configureServerWebSocketCarrierRoleV3(carrier, client) {
+    const server = serverAdmissionCarriers.get(carrier);
+    if (server === undefined)
+        throw new CarrierError("closed", "WebSocket carrier is not a server admission carrier");
+    server.configureRole(client);
+}
+class ServerWebSocketAdmissionCarrier {
+    transport;
+    options;
+    kind = "websocket";
+    path;
+    inboundBidirectionalStreamCapacity;
+    unreliableDatagrams = undefined;
+    admissionAvailable = true;
+    active;
+    closed = false;
+    client = false;
+    constructor(transport, options) {
+        this.transport = transport;
+        this.options = options;
+        this.path = options.path;
+        this.inboundBidirectionalStreamCapacity = options.inboundBidirectionalStreamCapacity;
+    }
+    async openStream(options = {}) {
+        return await this.activate().openStream(options);
+    }
+    async acceptStream(options = {}) {
+        throwIfAborted(options.signal);
+        if (this.closed)
+            throw new CarrierError("closed", "WebSocket carrier is closed");
+        if (this.admissionAvailable) {
+            this.admissionAvailable = false;
+            return new WebSocketAdmissionStream(this.transport);
+        }
+        return await this.activate().acceptStream(options);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.active === undefined)
+            this.transport.close();
+        else
+            await this.active.close();
+    }
+    abort() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.active === undefined)
+            this.transport.close();
+        else
+            this.active.abort();
+    }
+    async waitTermination() {
+        if (this.closed && this.active === undefined)
+            return;
+        await this.activate().waitTermination();
+    }
+    configureRole(client) {
+        if (this.closed || this.active !== undefined)
+            throw new CarrierError("closed", "WebSocket carrier is already active");
+        this.client = client;
+    }
+    activate() {
+        if (this.closed)
+            throw new CarrierError("closed", "WebSocket carrier is closed");
+        if (this.admissionAvailable) {
+            throw new CarrierError("closed", "WebSocket admission has not completed");
+        }
+        this.active ??= createWebSocketCarrierSessionV3(this.transport, {
+            path: this.options.path,
+            client: this.client,
+            inboundBidirectionalStreamCapacity: this.options.inboundBidirectionalStreamCapacity,
+            ...(this.options.resourcePolicy === undefined ? {} : { resourcePolicy: this.options.resourcePolicy }),
+        });
+        return this.active;
+    }
+}
+class WebSocketAdmissionStream {
+    transport;
+    readComplete = false;
+    writeComplete = false;
+    outbound = [];
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async read(options = {}) {
+        if (this.readComplete)
+            return null;
+        this.readComplete = true;
+        return await this.transport.readBinary(options);
+    }
+    async write(data, options = {}) {
+        throwIfAborted(options.signal);
+        if (this.writeComplete)
+            throw new CarrierError("write_closed", "admission response is closed");
+        this.outbound.push(data.slice());
+        return data.length;
+    }
+    async closeWrite() {
+        if (this.writeComplete)
+            return;
+        this.writeComplete = true;
+        const length = this.outbound.reduce((total, chunk) => total + chunk.length, 0);
+        const response = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of this.outbound) {
+            response.set(chunk, offset);
+            offset += chunk.length;
+        }
+        this.outbound.length = 0;
+        await this.transport.writeBinary(response);
+    }
+    async stopSending() {
+        this.transport.close();
+    }
+    async reset() {
+        this.transport.close();
+    }
+    abort() {
+        this.transport.close();
+    }
+}
+class WebSocketYamuxCarrierSession {
+    transport;
+    kind = "websocket";
+    path;
+    inboundBidirectionalStreamCapacity;
+    unreliableDatagrams = undefined;
+    incoming = new IncomingStreamQueue();
+    yamux;
+    termination = deferred();
+    terminalError;
+    closed = false;
+    constructor(transport, options) {
+        this.transport = transport;
+        requireCapacity(options.inboundBidirectionalStreamCapacity);
+        this.path = options.path;
+        this.inboundBidirectionalStreamCapacity = options.inboundBidirectionalStreamCapacity;
+        const duplex = {
+            read: async () => await transport.readBinary(),
+            write: async (chunk) => await transport.writeBinary(chunk),
+            close: () => transport.close(),
+        };
+        const policy = options.resourcePolicy ?? {};
+        this.yamux = new YamuxSession(duplex, {
+            client: options.client,
+            limits: {
+                maxActiveStreams: Math.max(policy.maxConcurrentStreams ?? this.inboundBidirectionalStreamCapacity, this.inboundBidirectionalStreamCapacity),
+                maxInboundStreams: this.inboundBidirectionalStreamCapacity,
+                ...(policy.maxFrameBytes === undefined ? {} : { maxFrameBytes: policy.maxFrameBytes }),
+                ...(policy.preferredWriteBytes === undefined ? {} : { preferredOutboundFrameBytes: policy.preferredWriteBytes }),
+                ...(policy.maxStreamWriteQueueBytes === undefined ? {} : { maxStreamWriteQueueBytes: policy.maxStreamWriteQueueBytes }),
+                ...(policy.maxStreamReceiveBytes === undefined ? {} : { maxStreamReceiveBytes: policy.maxStreamReceiveBytes }),
+                ...(policy.maxSessionReceiveBytes === undefined ? {} : { maxSessionReceiveBytes: policy.maxSessionReceiveBytes }),
+            },
+            onIncomingStream: (stream) => this.incoming.push(new YamuxCarrierStreamAdapter(stream)),
+            onTerminal: (error) => {
+                const failure = error instanceof CarrierError
+                    ? error
+                    : new CarrierError("closed", "WebSocket carrier terminated", error);
+                this.closed = true;
+                this.terminalError = failure;
+                this.incoming.fail(failure);
+                this.termination.resolve();
+            },
+        });
+    }
+    async openStream(options = {}) {
+        this.assertOpen();
+        try {
+            return new YamuxCarrierStreamAdapter(await this.yamux.openStream(options));
+        }
+        catch (error) {
+            throw error instanceof CarrierError ? error : new CarrierError("closed", "WebSocket stream open failed", error);
+        }
+    }
+    async acceptStream(options = {}) {
+        this.assertOpen();
+        return await this.incoming.shift(options.signal);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        await this.transport.flush().catch(() => undefined);
+        this.closeLocally();
+    }
+    abort() {
+        this.closeLocally();
+    }
+    async waitTermination() {
+        await this.termination.promise;
+        if (this.terminalError !== undefined)
+            throw this.terminalError;
+    }
+    assertOpen() {
+        if (this.terminalError !== undefined)
+            throw this.terminalError;
+        if (this.closed)
+            throw new CarrierError("closed", "WebSocket carrier is closed");
+    }
+    closeLocally() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const failure = new CarrierError("closed", "WebSocket carrier is closed");
+        this.incoming.fail(failure);
+        this.yamux.close();
+        this.termination.resolve();
+    }
+}
+class YamuxCarrierStreamAdapter {
+    stream;
+    constructor(stream) {
+        this.stream = stream;
+    }
+    async read(options = {}) {
+        try {
+            return await abortable(this.stream.read(), options.signal, () => this.stream.abort());
+        }
+        catch (error) {
+            throw error instanceof CarrierError ? error : new CarrierError("reset", "WebSocket stream read failed", error);
+        }
+    }
+    async write(data, options = {}) {
+        throwIfAborted(options.signal);
+        try {
+            await abortable(this.stream.write(data), options.signal, () => this.stream.abort());
+        }
+        catch (error) {
+            throw error instanceof CarrierError ? error : new CarrierError("reset", "WebSocket stream write failed", error);
+        }
+        return data.length;
+    }
+    async closeWrite() {
+        await this.stream.close();
+    }
+    async reset() {
+        await this.stream.reset();
+    }
+    async stopSending() {
+        throw new CarrierError("stop_sending_unavailable", "WebSocket/Yamux cannot stop only the receive side of a bidirectional stream");
+    }
+    abort(error) {
+        this.stream.abort(error);
+    }
+}
+class IncomingStreamQueue {
+    values = [];
+    waiters = new Set();
+    terminalError;
+    push(value) {
+        if (this.terminalError !== undefined) {
+            value.abort(this.terminalError);
+            return;
+        }
+        const waiter = this.waiters.values().next().value;
+        if (waiter === undefined)
+            this.values.push(value);
+        else {
+            this.waiters.delete(waiter);
+            waiter.deliver(value);
+        }
+    }
+    shift(signal) {
+        throwIfAborted(signal);
+        if (this.terminalError !== undefined)
+            return Promise.reject(this.terminalError);
+        const value = this.values.shift();
+        if (value !== undefined)
+            return Promise.resolve(value);
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                this.waiters.delete(waiter);
+                signal?.removeEventListener("abort", abort);
+            };
+            const waiter = {
+                deliver: (stream) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    resolve(stream);
+                },
+                fail: (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    reject(error);
+                },
+            };
+            const abort = () => waiter.fail(new CarrierError("aborted", "carrier operation aborted"));
+            this.waiters.add(waiter);
+            signal?.addEventListener("abort", abort, { once: true });
+            if (signal?.aborted === true)
+                abort();
+        });
+    }
+    fail(error) {
+        if (this.terminalError !== undefined)
+            return;
+        this.terminalError = error;
+        for (const stream of this.values)
+            stream.abort(error);
+        this.values.length = 0;
+        for (const waiter of this.waiters)
+            waiter.fail(error);
+        this.waiters.clear();
+    }
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => { resolve = resolvePromise; });
+    return { promise, resolve };
+}
+function requireCapacity(value) {
+    if (!Number.isInteger(value) || value < 3 || value > 130) {
+        throw new RangeError("inboundBidirectionalStreamCapacity must be an integer from 3 to 130");
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted === true)
+        throw new CarrierError("aborted", "carrier operation aborted");
+}
+async function abortable(promise, signal, onAbort) {
+    if (signal === undefined)
+        return await promise;
+    throwIfAborted(signal);
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => signal.removeEventListener("abort", abort);
+        const abort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            onAbort();
+            reject(new CarrierError("aborted", "carrier operation aborted"));
+        };
+        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);
+        });
+    });
+}

package/dist/v3/webTransportCarrier.d.ts

@@ -0,0 +1,27 @@
+import { type NativeCarrierSessionV3 } from "./carrier.js";
+import type { PathKind } from "./contract.js";
+export type WebTransportBidirectionalLikeV3 = Readonly<{
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+}>;
+export type WebTransportDatagramsLikeV3 = Readonly<{
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+    maxDatagramSize?: number;
+}>;
+export type WebTransportSessionLikeV3 = Readonly<{
+    closed: Promise<unknown>;
+    incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalLikeV3>;
+    datagrams: WebTransportDatagramsLikeV3;
+    createBidirectionalStream(): Promise<WebTransportBidirectionalLikeV3>;
+    close(info?: Readonly<{
+        closeCode: number;
+        reason: string;
+    }>): void;
+}>;
+export declare function adaptWebTransportCarrierSessionV3(native: WebTransportSessionLikeV3, options: Readonly<{
+    path: PathKind;
+    inboundBidirectionalStreamCapacity: number;
+    datagramMaxSize?: number;
+}>): NativeCarrierSessionV3;
+export declare function hasWebTransportConstructorSurfaceV3(value: unknown): boolean;