@floegence/flowersec-core 3.2.0 → 4.0.0

package/dist/connectionController.js

@@ -1,441 +0,0 @@
-import { ConnectError } from "./public/connectError.js";
-import { retryDispositionForConnectError, retryDispositionForSessionError, } from "./v2/retryDisposition.js";
-import { SDK_DEFAULTS } from "./defaults.js";
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-export class ConnectionControllerError extends Error {
-    code;
-    failure;
-    constructor(code, failure = undefined) {
-        super(`Flowersec connection controller stopped (code=${code})`);
-        this.code = code;
-        this.failure = failure;
-        this.name = "ConnectionControllerError";
-    }
-}
-/** @internal Runtime facades supply the only runtime-specific operation: one one-shot connection attempt. */
-export function createConnectionControllerV2(source, connectOneShot, options = {}) {
-    return new ConnectionControllerV2Impl(source, connectOneShot, options);
-}
-class ConnectionControllerV2Impl {
-    source;
-    connectOneShot;
-    controllerState = "idle";
-    session;
-    lastFailure;
-    currentRetryDisposition;
-    attempt = 0;
-    consecutiveFailures = 0;
-    resetAttemptOnRetry = false;
-    lifetime = new AbortController();
-    listeners = new Set();
-    issuedLeases = new WeakSet();
-    issuedSessions = new WeakSet();
-    maxAttempts;
-    scheduler;
-    closeOperation;
-    pendingConnectCleanup;
-    pendingAcquisitionCleanup;
-    waitingWake;
-    manualRetryRequested = false;
-    retryNotBefore = 0;
-    constructor(source, connectOneShot, options) {
-        this.source = source;
-        this.connectOneShot = connectOneShot;
-        if (source === null || typeof source !== "object" || typeof source.acquire !== "function") {
-            throw new TypeError("artifact source must provide acquire()");
-        }
-        if (typeof connectOneShot !== "function")
-            throw new TypeError("one-shot connector is required");
-        if (options.maximumAttempts !== undefined &&
-            (!Number.isSafeInteger(options.maximumAttempts) || options.maximumAttempts < 1)) {
-            throw new TypeError("maximumAttempts must be a positive safe integer");
-        }
-        this.maxAttempts = options.maximumAttempts;
-    }
-    get state() { return this.controllerState; }
-    get currentSession() { return this.connectedSession(); }
-    get failure() { return this.lastFailure; }
-    start() {
-        if (this.controllerState !== "idle")
-            return;
-        this.scheduler = this.run();
-    }
-    retryNow() {
-        if (this.controllerState !== "waiting" || Date.now() < this.retryNotBefore)
-            return false;
-        this.manualRetryRequested = true;
-        this.waitingWake?.();
-        return true;
-    }
-    async waitForSession(options = {}) {
-        const ready = this.connectedSession();
-        if (ready !== undefined)
-            return ready;
-        if (this.controllerState === "failed")
-            throw new ConnectionControllerError("failed", this.lastFailure);
-        if (this.controllerState === "closed")
-            throw new ConnectionControllerError("closed", this.lastFailure);
-        if (options.signal?.aborted === true)
-            throw new ConnectionControllerError("canceled");
-        return await new Promise((resolve, reject) => {
-            const finish = (result) => {
-                this.listeners.delete(listener);
-                options.signal?.removeEventListener("abort", canceled);
-                if (result.session !== undefined)
-                    resolve(result.session);
-                else
-                    reject(result.error ?? new ConnectionControllerError("failed", this.lastFailure));
-            };
-            const listener = (snapshot) => {
-                if (snapshot.state === "connected" && snapshot.currentSession !== undefined) {
-                    finish({ session: snapshot.currentSession });
-                }
-                else if (snapshot.state === "failed") {
-                    finish({ error: new ConnectionControllerError("failed", snapshot.failure) });
-                }
-                else if (snapshot.state === "closed") {
-                    finish({ error: new ConnectionControllerError("closed", snapshot.failure) });
-                }
-            };
-            const canceled = () => finish({ error: new ConnectionControllerError("canceled") });
-            this.listeners.add(listener);
-            options.signal?.addEventListener("abort", canceled, { once: true });
-        });
-    }
-    subscribe(listener) {
-        if (typeof listener !== "function")
-            throw new TypeError("connection listener must be a function");
-        this.listeners.add(listener);
-        try {
-            listener(this.snapshot());
-        }
-        catch (error) {
-            this.listeners.delete(listener);
-            throw error;
-        }
-        return () => { this.listeners.delete(listener); };
-    }
-    close() {
-        if (this.closeOperation !== undefined)
-            return this.closeOperation;
-        let resolveClose;
-        this.closeOperation = new Promise((resolve) => {
-            resolveClose = resolve;
-        });
-        const active = this.session;
-        // A closed controller must never advertise a session that it has just retired.
-        this.session = undefined;
-        this.currentRetryDisposition = undefined;
-        this.lifetime.abort(new ConnectionControllerError("closed", this.lastFailure));
-        this.transition("closed");
-        void this.finishClose(active).then(resolveClose);
-        return this.closeOperation;
-    }
-    async finishClose(active) {
-        this.waitingWake?.();
-        const activeClose = active === undefined
-            ? Promise.resolve()
-            : active.close();
-        await Promise.allSettled([this.scheduler ?? Promise.resolve(), activeClose]);
-        const pendingCleanup = this.pendingConnectCleanup;
-        const acquisitionCleanup = this.pendingAcquisitionCleanup;
-        await Promise.allSettled([
-            ...(pendingCleanup === undefined ? [] : [pendingCleanup]),
-            ...(acquisitionCleanup === undefined ? [] : [acquisitionCleanup]),
-        ]);
-    }
-    async run() {
-        let disposition;
-        while (!this.lifetime.signal.aborted) {
-            if (disposition !== undefined) {
-                const canContinue = await this.waitForRetry(disposition);
-                if (!canContinue)
-                    return;
-            }
-            if (this.maxAttempts !== undefined && this.attempt >= this.maxAttempts) {
-                this.currentRetryDisposition = Object.freeze({ kind: "terminal" });
-                this.transition("failed");
-                return;
-            }
-            this.currentRetryDisposition = undefined;
-            this.attempt += 1;
-            this.transition("connecting");
-            const acquisition = await this.acquireLease();
-            if (this.lifetime.signal.aborted)
-                return;
-            if (acquisition.kind === "failure") {
-                this.lastFailure = Object.freeze({ phase: "artifact", code: acquisition.code });
-                disposition = acquisition.disposition;
-                this.currentRetryDisposition = disposition;
-                if (disposition.kind === "terminal") {
-                    this.transition("failed");
-                    return;
-                }
-                this.consecutiveFailures += 1;
-                continue;
-            }
-            let connected;
-            try {
-                connected = await this.connect(acquisition.lease);
-            }
-            catch (error) {
-                if (this.lifetime.signal.aborted)
-                    return;
-                const failure = connectFailure(error);
-                this.lastFailure = failure.failure;
-                disposition = failure.disposition;
-                this.currentRetryDisposition = disposition;
-                if (disposition.kind === "terminal") {
-                    this.transition("failed");
-                    return;
-                }
-                this.consecutiveFailures += 1;
-                continue;
-            }
-            if (this.lifetime.signal.aborted) {
-                await connected.close().catch(() => undefined);
-                return;
-            }
-            this.session = connected;
-            this.lastFailure = undefined;
-            this.currentRetryDisposition = undefined;
-            this.consecutiveFailures = 0;
-            disposition = undefined;
-            this.transition("connected");
-            const termination = await raceTermination(connected, this.lifetime.signal);
-            if (termination === undefined || this.lifetime.signal.aborted)
-                return;
-            // A terminated session is no longer current while the replacement attempt waits.
-            this.session = undefined;
-            await connected.close().catch(() => undefined);
-            if (this.lifetime.signal.aborted)
-                return;
-            const failure = sessionFailure(termination.error);
-            this.lastFailure = failure.failure;
-            disposition = failure.disposition;
-            this.currentRetryDisposition = disposition;
-            if (disposition.kind === "terminal") {
-                this.transition("failed");
-                return;
-            }
-            this.consecutiveFailures = 1;
-            this.resetAttemptOnRetry = true;
-        }
-    }
-    async acquireLease() {
-        let result;
-        let pending;
-        try {
-            pending = this.source.acquire({ signal: this.lifetime.signal });
-        }
-        catch {
-            return terminalArtifactFailure("artifact_source_failed");
-        }
-        const cleanup = pending.then(() => undefined, () => undefined);
-        this.pendingAcquisitionCleanup = cleanup;
-        void cleanup.finally(() => {
-            if (this.pendingAcquisitionCleanup === cleanup)
-                this.pendingAcquisitionCleanup = undefined;
-        }).catch(() => undefined);
-        try {
-            result = await raceAbort(pending, this.lifetime.signal);
-        }
-        catch {
-            return terminalArtifactFailure("artifact_source_failed");
-        }
-        try {
-            if (result === null || typeof result !== "object")
-                return terminalArtifactFailure("artifact_source_failed");
-            if (result.kind === "failure") {
-                if (!validFailureCode(result.code) || !validDisposition(result.disposition)) {
-                    return terminalArtifactFailure("artifact_source_failed");
-                }
-                return Object.freeze({ kind: "failure", code: result.code, disposition: normalizeDisposition(result.disposition) });
-            }
-            if (result.kind !== "lease" || result.lease === null || typeof result.lease !== "object") {
-                return terminalArtifactFailure("artifact_source_failed");
-            }
-            if (this.issuedLeases.has(result.lease))
-                return terminalArtifactFailure("reused_artifact_lease");
-            this.issuedLeases.add(result.lease);
-            return result;
-        }
-        catch {
-            return terminalArtifactFailure("artifact_source_failed");
-        }
-    }
-    async connect(lease) {
-        const pending = this.connectOneShot(lease, this.lifetime.signal);
-        try {
-            const session = await raceAbort(pending, this.lifetime.signal);
-            if (session === null || typeof session !== "object" ||
-                typeof session.close !== "function" || typeof session.waitTermination !== "function") {
-                throw new TypeError("one-shot connector returned an invalid session");
-            }
-            if (this.issuedSessions.has(session)) {
-                await session.close().catch(() => undefined);
-                throw new Error("one-shot connector reused a previous session");
-            }
-            this.issuedSessions.add(session);
-            return session;
-        }
-        catch (error) {
-            if (this.lifetime.signal.aborted) {
-                const cleanup = pending.then(async (lateSession) => await lateSession.close(), () => undefined);
-                this.pendingConnectCleanup = cleanup;
-                void cleanup.finally(() => {
-                    if (this.pendingConnectCleanup === cleanup)
-                        this.pendingConnectCleanup = undefined;
-                }).catch(() => undefined);
-            }
-            throw error;
-        }
-    }
-    async waitForRetry(disposition) {
-        if (this.maxAttempts !== undefined && !this.resetAttemptOnRetry && this.attempt >= this.maxAttempts) {
-            this.currentRetryDisposition = Object.freeze({ kind: "terminal" });
-            this.transition("failed");
-            return false;
-        }
-        const now = Date.now();
-        const backoffDeadline = now + retryDelay(this.consecutiveFailures);
-        const hardDeadline = disposition.kind === "retry_after"
-            ? disposition.notBeforeUnixMilliseconds
-            : 0;
-        this.retryNotBefore = hardDeadline;
-        this.manualRetryRequested = false;
-        this.transition("waiting");
-        while (!this.lifetime.signal.aborted) {
-            const deadline = this.manualRetryRequested
-                ? hardDeadline
-                : Math.max(backoffDeadline, hardDeadline);
-            const remaining = deadline - Date.now();
-            if (remaining <= 0) {
-                this.waitingWake = undefined;
-                this.retryNotBefore = 0;
-                if (this.resetAttemptOnRetry) {
-                    this.attempt = 0;
-                    this.resetAttemptOnRetry = false;
-                }
-                return true;
-            }
-            await this.wait(Math.min(remaining, MAX_TIMER_DELAY_MS));
-        }
-        this.waitingWake = undefined;
-        this.retryNotBefore = 0;
-        return false;
-    }
-    async wait(milliseconds) {
-        await new Promise((resolve) => {
-            let settled = false;
-            const finish = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                this.lifetime.signal.removeEventListener("abort", finish);
-                if (this.waitingWake === finish)
-                    this.waitingWake = undefined;
-                resolve();
-            };
-            const timer = setTimeout(finish, milliseconds);
-            this.waitingWake = finish;
-            this.lifetime.signal.addEventListener("abort", finish, { once: true });
-        });
-    }
-    connectedSession() {
-        return this.controllerState === "connected" ? this.session : undefined;
-    }
-    transition(state) {
-        this.controllerState = state;
-        const snapshot = this.snapshot();
-        for (const listener of this.listeners) {
-            try {
-                listener(snapshot);
-            }
-            catch { /* Listener failures do not own controller lifecycle. */ }
-        }
-    }
-    snapshot() {
-        const currentSession = this.connectedSession();
-        return Object.freeze({
-            state: this.controllerState,
-            attempt: this.attempt,
-            ...(currentSession === undefined ? {} : { currentSession }),
-            ...(this.lastFailure === undefined ? {} : { failure: this.lastFailure }),
-            ...(this.currentRetryDisposition === undefined ? {} : { retryDisposition: this.currentRetryDisposition }),
-        });
-    }
-}
-function connectFailure(error) {
-    if (!(error instanceof ConnectError)) {
-        return Object.freeze({
-            failure: Object.freeze({ phase: "connect", code: "connection_failed" }),
-            disposition: Object.freeze({ kind: "terminal" }),
-        });
-    }
-    const disposition = retryDispositionForConnectError(error);
-    return Object.freeze({
-        failure: Object.freeze({ phase: "connect", code: error.code }),
-        disposition,
-    });
-}
-function sessionFailure(error) {
-    const disposition = retryDispositionForSessionError(error);
-    return Object.freeze({
-        failure: Object.freeze({ phase: "session", code: error.code }),
-        disposition,
-    });
-}
-function terminalArtifactFailure(code) {
-    return Object.freeze({
-        kind: "failure",
-        code,
-        disposition: Object.freeze({ kind: "terminal" }),
-    });
-}
-function validFailureCode(code) {
-    return typeof code === "string" && /^[a-z][a-z0-9_]{0,63}$/.test(code);
-}
-function validDisposition(value) {
-    if (value === null || typeof value !== "object" || !("kind" in value))
-        return false;
-    const disposition = value;
-    if (disposition.kind === "terminal" || disposition.kind === "retryable")
-        return true;
-    return disposition.kind === "retry_after" &&
-        typeof disposition.notBeforeUnixMilliseconds === "number" &&
-        Number.isSafeInteger(disposition.notBeforeUnixMilliseconds) &&
-        disposition.notBeforeUnixMilliseconds >= 0;
-}
-function normalizeDisposition(disposition) {
-    if (disposition.kind === "retry_after") {
-        return Object.freeze({
-            kind: "retry_after",
-            notBeforeUnixMilliseconds: disposition.notBeforeUnixMilliseconds,
-        });
-    }
-    return Object.freeze({ kind: disposition.kind });
-}
-function retryDelay(failures) {
-    const exponent = Math.max(0, Math.min(30, failures - 1));
-    return Math.min(SDK_DEFAULTS.connectionController.maxDelayMs, SDK_DEFAULTS.connectionController.initialDelayMs *
-        (SDK_DEFAULTS.connectionController.factor ** exponent));
-}
-async function raceAbort(promise, signal) {
-    if (signal.aborted)
-        throw signal.reason;
-    return await new Promise((resolve, reject) => {
-        const abort = () => reject(signal.reason);
-        signal.addEventListener("abort", abort, { once: true });
-        void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
-    });
-}
-async function raceTermination(session, signal) {
-    try {
-        return await raceAbort(session.waitTermination(), signal);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/connector/adapters/rawQuicCandidate.d.ts

@@ -1,5 +0,0 @@
-import type { ArtifactV2, CanonicalArtifactCandidateV2 } from "../../v2/artifact.js";
-import { type NativeCarrierSessionV2 } from "../../v2/carrier.js";
-import type { CandidateAttemptFactoryV2 } from "../sessionConnector.js";
-export type RawQuicClientFactoryV2 = (candidate: CanonicalArtifactCandidateV2, artifact: ArtifactV2, signal: AbortSignal) => Promise<NativeCarrierSessionV2>;
-export declare function createRawQuicCandidateFactoryV2(factory: RawQuicClientFactoryV2): CandidateAttemptFactoryV2;

package/dist/connector/adapters/rawQuicCandidate.js

@@ -1,71 +0,0 @@
-import { adaptNativeCarrierSessionV2, } from "../../v2/carrier.js";
-export function createRawQuicCandidateFactoryV2(factory) {
-    return {
-        create(candidate, artifact) {
-            if (candidate.carrier !== "raw_quic") {
-                throw new Error(`unsupported raw QUIC carrier ${candidate.carrier}`);
-            }
-            return new RawQuicCandidateAttempt(candidate, artifact, factory);
-        },
-    };
-}
-class RawQuicCandidateAttempt {
-    candidate;
-    artifact;
-    factory;
-    controller = new AbortController();
-    carrier;
-    finalized = false;
-    constructor(candidate, artifact, factory) {
-        this.candidate = candidate;
-        this.artifact = artifact;
-        this.factory = factory;
-    }
-    async ready(signal) {
-        const unlink = linkAbort(signal, this.controller);
-        try {
-            const carrier = await this.factory(this.candidate, this.artifact, this.controller.signal);
-            this.carrier = carrier;
-            return {
-                candidate: this.candidate,
-                kind: carrier.kind,
-                path: carrier.path,
-                inboundBidirectionalStreamCapacity: carrier.inboundBidirectionalStreamCapacity,
-                openAdmissionChannel: async (channelSignal) => {
-                    const options = channelSignal === undefined ? {} : { signal: channelSignal };
-                    const stream = await carrier.openStream(options);
-                    return {
-                        framing: "stream",
-                        stream,
-                        abort: (error) => stream.abort(error),
-                    };
-                },
-                finalize: () => {
-                    if (this.finalized)
-                        throw new Error("raw QUIC candidate already finalized");
-                    this.finalized = true;
-                    return adaptNativeCarrierSessionV2(carrier);
-                },
-                close: async () => await carrier.close(),
-                abort: () => carrier.abort({ code: 6, reason: "candidate aborted" }),
-            };
-        }
-        finally {
-            unlink();
-        }
-    }
-    abort() {
-        this.controller.abort(new Error("raw QUIC candidate aborted"));
-        this.carrier?.abort({ code: 6, reason: "candidate aborted" });
-    }
-}
-function linkAbort(parent, child) {
-    if (parent === undefined)
-        return () => undefined;
-    const abort = () => child.abort(parent.reason);
-    if (parent.aborted)
-        abort();
-    else
-        parent.addEventListener("abort", abort, { once: true });
-    return () => parent.removeEventListener("abort", abort);
-}

package/dist/connector/adapters/webSocketCandidate.d.ts

@@ -1,7 +0,0 @@
-import type { CandidateAttemptFactoryV2 } from "../sessionConnector.js";
-import { type WebSocketLike } from "../../ws-client/binaryTransport.js";
-type WebSocketLikeWithProtocol = WebSocketLike & Readonly<{
-    protocol?: string;
-}>;
-export declare function createWebSocketCandidateFactoryV2(factory: (url: string, subprotocol: string) => WebSocketLikeWithProtocol): CandidateAttemptFactoryV2;
-export {};

package/dist/connector/adapters/webSocketCandidate.js

@@ -1,116 +0,0 @@
-import { createWebSocketCarrierSessionV2 } from "../../transport/webSocketAdapter.js";
-import { WebSocketBinaryTransport } from "../../ws-client/binaryTransport.js";
-export function createWebSocketCandidateFactoryV2(factory) {
-    return {
-        create(candidate, artifact) {
-            if (candidate.carrier !== "websocket")
-                throw new Error(`unsupported WebSocket carrier ${candidate.carrier}`);
-            return new WebSocketCandidateAttempt(candidate, artifact, factory);
-        },
-    };
-}
-class WebSocketCandidateAttempt {
-    candidate;
-    artifact;
-    factory;
-    socket;
-    transport;
-    aborted = false;
-    finalized = false;
-    constructor(candidate, artifact, factory) {
-        this.candidate = candidate;
-        this.artifact = artifact;
-        this.factory = factory;
-    }
-    async ready(signal) {
-        if (this.aborted)
-            throw new Error("WebSocket candidate aborted");
-        const path = this.artifact.path.kind;
-        const subprotocol = path === "direct" ? "flowersec.direct.v2" : "flowersec.tunnel.v2";
-        const socket = this.factory(this.candidate.normalized_url, subprotocol);
-        this.socket = socket;
-        await waitForOpen(socket, subprotocol, signal);
-        if (this.aborted)
-            throw new Error("WebSocket candidate aborted");
-        const transport = new WebSocketBinaryTransport(socket);
-        this.transport = transport;
-        const inboundBidirectionalStreamCapacity = this.artifact.session.max_inbound_streams + 2;
-        return {
-            candidate: this.candidate,
-            kind: "websocket",
-            path,
-            inboundBidirectionalStreamCapacity,
-            openAdmissionChannel: async () => ({
-                framing: "message",
-                write: async (data, options = {}) => await transport.writeBinary(data, options),
-                read: async (options = {}) => await transport.readBinary(options),
-                abort: () => transport.close(),
-            }),
-            finalize: () => {
-                if (this.finalized)
-                    throw new Error("WebSocket candidate already finalized");
-                this.finalized = true;
-                return createWebSocketCarrierSessionV2(transport, {
-                    path,
-                    client: this.artifact.path.kind !== "tunnel" || this.artifact.path.role !== 2,
-                    inboundBidirectionalStreamCapacity,
-                });
-            },
-            close: async () => transport.close(),
-            abort: () => transport.close(),
-        };
-    }
-    abort() {
-        this.aborted = true;
-        this.transport?.close();
-        this.socket?.close();
-    }
-}
-function waitForOpen(socket, expectedProtocol, signal) {
-    if (socket.readyState === 1) {
-        validateSubprotocol(socket, expectedProtocol);
-        return Promise.resolve();
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const cleanup = () => {
-            socket.removeEventListener("open", open);
-            socket.removeEventListener("error", error);
-            socket.removeEventListener("close", close);
-            signal?.removeEventListener("abort", abort);
-        };
-        const finish = (failure) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            failure === undefined ? resolve() : reject(failure);
-        };
-        const open = () => {
-            try {
-                validateSubprotocol(socket, expectedProtocol);
-                finish();
-            }
-            catch (cause) {
-                finish(asError(cause));
-            }
-        };
-        const error = () => finish(new Error("WebSocket candidate failed before ready"));
-        const close = () => finish(new Error("WebSocket candidate closed before ready"));
-        const abort = () => { socket.close(); finish(new Error("WebSocket candidate aborted")); };
-        socket.addEventListener("open", open);
-        socket.addEventListener("error", error);
-        socket.addEventListener("close", close);
-        signal?.addEventListener("abort", abort, { once: true });
-        if (signal?.aborted === true)
-            abort();
-    });
-}
-function validateSubprotocol(socket, expected) {
-    if (socket.protocol !== undefined && socket.protocol !== expected) {
-        throw new Error(`unexpected WebSocket subprotocol ${socket.protocol}`);
-    }
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}

package/dist/connector/adapters/webTransportCandidate.d.ts

@@ -1,5 +0,0 @@
-import type { ArtifactV2, CanonicalArtifactCandidateV2 } from "../../v2/artifact.js";
-import { type NativeCarrierSessionV2 } from "../../v2/carrier.js";
-import type { CandidateAttemptFactoryV2 } from "../sessionConnector.js";
-export type WebTransportClientFactoryV2 = (candidate: CanonicalArtifactCandidateV2, artifact: ArtifactV2, signal: AbortSignal) => Promise<NativeCarrierSessionV2>;
-export declare function createWebTransportCandidateFactoryV2(factory: WebTransportClientFactoryV2): CandidateAttemptFactoryV2;