@floegence/flowersec-core 3.2.1 → 5.0.0

package/dist/node/acceptor.js

@@ -1,17 +1,7 @@
 import { RpcRouter } from "../rpc/server.js";
 import { assertRpcError, assertRpcTypeId } from "../rpc/validate.js";
-import { acceptReceivedSessionV2, receiveSessionAdmissionV2, rejectSessionAdmissionV2, } from "../connector/sessionAcceptor.js";
-import { nodeSessionRuntimeV2 } from "./sessionRuntime.js";
-import { startNodeWebSocketServer, } from "./webSocketServer.js";
-import { createNativeRawQuicDriver } from "./nativeTransportAddon.js";
-import { startNodeRawQuicServer, } from "./rawQuicServer.js";
-import { unwrapArtifact } from "../public/artifact.js";
-import { SessionError, } from "../public/contract.js";
-import { projectSessionV2 } from "../v2/publicSession.js";
-import { runtimeAuthorizationRequestFromDecoded, } from "./controlplane.js";
-import { HandlerRegistrationError, StreamHandlers, LegacyStreamHandlers, freezeStreamHandlers, registerStreamHandlersAtomically, serveFrozenStreamHandlers, } from "../public/streamHandlers.js";
+import { HandlerRegistrationError, StreamHandlers, freezeStreamHandlers, registerStreamHandlersAtomically, } from "../public/streamHandlers.js";
 export { HandlerRegistrationError } from "../public/streamHandlers.js";
-const DEFAULT_CLEANUP_TIMEOUT_MS = 2_000;
 export class RPCHandlers {
     constructor() {
         rpcHandlerStates.set(this, createRPCHandlerState());
@@ -23,28 +13,6 @@ export class RPCHandlers {
         registerNotification(mutableRPCHandlerState(this), typeId, handler);
     }
 }
-export class SessionHandlers {
-    constructor(options = {}) {
-        sessionHandlerStates.set(this, {
-            rpc: createRPCHandlerState(),
-            streams: new LegacyStreamHandlers(options),
-            frozen: false,
-        });
-    }
-    handleRPC(typeId, handler) {
-        const state = mutableSessionHandlerState(this);
-        registerRPC(state.rpc, typeId, handler);
-    }
-    handleNotification(typeId, handler) {
-        const state = mutableSessionHandlerState(this);
-        registerNotification(state.rpc, typeId, handler);
-    }
-    handleStream(kind, handler) {
-        const state = mutableSessionHandlerState(this);
-        state.streams.handleStream(kind, handler);
-    }
-}
-/** Strict-v3 accepted-session handlers. */
 export class SessionHandlersV3 {
     constructor(options = {}) {
         sessionHandlerStates.set(this, {
@@ -147,8 +115,9 @@ export function createRPCRouter(snapshot) {
     for (const [typeId, handler] of snapshot.requests) {
         router.register(typeId, async (payload) => {
             const result = await handler(payload, Object.freeze({ typeId }));
-            if ("error" in result)
+            if ("error" in result) {
                 return { payload: null, error: validRPCError(result.error) };
+            }
             return { payload: result.payload };
         });
     }
@@ -160,23 +129,6 @@ export function createRPCRouter(snapshot) {
     return router;
 }
 /** @internal */
-export function freezeSessionHandlers(handlers) {
-    if (!(handlers instanceof SessionHandlers)) {
-        throw new HandlerRegistrationError("invalid_handler");
-    }
-    const state = sessionHandlerStates.get(handlers);
-    if (state === undefined)
-        throw new HandlerRegistrationError("invalid_handler");
-    if (state.snapshot !== undefined)
-        return state.snapshot;
-    state.frozen = true;
-    state.snapshot = Object.freeze({
-        rpc: freezeRPCHandlerState(state.rpc),
-        streams: freezeStreamHandlers(state.streams),
-    });
-    return state.snapshot;
-}
-/** @internal */
 export function freezeSessionHandlersV3(handlers) {
     if (!(handlers instanceof SessionHandlersV3)) {
         throw new HandlerRegistrationError("invalid_handler");
@@ -193,375 +145,6 @@ export function freezeSessionHandlersV3(handlers) {
     });
     return state.snapshot;
 }
-export class AcceptedSession {
-    constructor() { }
-    get session() {
-        return acceptedSessionState(this).session;
-    }
-    async serve(options = {}) {
-        const state = acceptedSessionState(this);
-        await serveFrozenStreamHandlers(state.handlers.streams, this.session, options, async () => await this.close());
-    }
-    async close() {
-        const state = acceptedSessionState(this);
-        if (state.closePromise === undefined) {
-            state.closePromise = (async () => {
-                try {
-                    await state.session.close();
-                }
-                finally {
-                    if (state.release !== undefined && state.releasePromise === undefined) {
-                        state.releasePromise = Promise.resolve().then(() => state.release());
-                    }
-                    await state.releasePromise;
-                }
-            })();
-        }
-        await state.closePromise;
-    }
-}
-const acceptedSessionStates = new WeakMap();
-function acceptedSessionState(accepted) {
-    const state = acceptedSessionStates.get(accepted);
-    if (state === undefined)
-        throw new SessionError("operation_failed");
-    return state;
-}
-function createAcceptedSession(session, handlers, release) {
-    const accepted = new AcceptedSession();
-    const state = { session, handlers };
-    if (release !== undefined)
-        state.release = release;
-    acceptedSessionStates.set(accepted, state);
-    return Object.freeze(accepted);
-}
-export class Acceptor {
-    constructor() { }
-    addresses() {
-        return acceptorState(this).listeners.map((listener) => listener.address());
-    }
-    async accept(operation = {}) {
-        const state = acceptorState(this);
-        state.start();
-        return await state.accepted.shift(operation.signal);
-    }
-    async close() {
-        const state = acceptorState(this);
-        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) {
-    if (leaseId === undefined || state.options.release === undefined)
-        return;
-    await state.options.release(leaseId);
-}
-async function authorizeCarrier(state, carrier) {
-    const received = await receiveSessionAdmissionV2(carrier, state.abort.signal);
-    const decoded = received.decoded;
-    const request = runtimeAuthorizationRequestFromDecoded(decoded);
-    const decision = await state.options.authorize(request, { signal: state.abort.signal });
-    if (decision.decision !== "allow") {
-        return await rejectSessionAdmissionV2(received, {
-            accepted: false,
-            status: decision.decision === "retry" ? 2 : 1,
-            reason: decision.reason,
-        }, state.abort.signal);
-    }
-    const leaseId = "leaseId" in decision && typeof decision.leaseId === "string"
-        ? decision.leaseId
-        : undefined;
-    try {
-        const registry = state.options.resolveHandlers === undefined
-            ? new SessionHandlers()
-            : await state.options.resolveHandlers(request, { signal: state.abort.signal });
-        const handlers = freezeSessionHandlers(registry);
-        const leg = {
-            received,
-            artifact: unwrapArtifact(decision.artifact),
-            handlers,
-            router: createRPCRouter(handlers.rpc),
-        };
-        if (leaseId !== undefined)
-            leg.leaseId = leaseId;
-        return leg;
-    }
-    catch (error) {
-        await releaseLease(state, leaseId).catch(() => undefined);
-        throw error;
-    }
-}
-async function establishDirect(leg, signal, release) {
-    const internal = await acceptReceivedSessionV2(leg.received, leg.artifact, {
-        runtime: nodeSessionRuntimeV2,
-        rpcRouter: leg.router,
-        role: "server",
-        signal,
-    });
-    return createAcceptedSession(projectSessionV2(internal), leg.handlers, release);
-}
-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");
-        }
-        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) {
-        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.admissions.delete(task);
-                state.tasks.delete(task);
-            });
-            state.admissions.add(task);
-            state.tasks.add(task);
-        }
-        catch (error) {
-            if (!state.abort.signal.aborted)
-                state.accepted.fail(error instanceof Error ? error : new Error(String(error)));
-            return;
-        }
-    }
-}
-class AcceptedQueue {
-    values = [];
-    waiters = new Set();
-    failure;
-    push(value) {
-        if (this.failure !== undefined)
-            return "rejected";
-        const waiter = this.waiters.values().next().value;
-        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) {
-        if (signal?.aborted === true)
-            throw new SessionError("canceled");
-        const value = this.values.shift();
-        if (value !== undefined)
-            return value;
-        if (this.failure !== undefined)
-            throw this.failure;
-        return await new Promise((resolve, reject) => {
-            const waiter = {
-                resolve: (session) => {
-                    cleanup();
-                    resolve(session);
-                },
-                reject: (error) => {
-                    cleanup();
-                    reject(error);
-                },
-            };
-            const abort = () => {
-                this.waiters.delete(waiter);
-                reject(new SessionError("canceled"));
-            };
-            const cleanup = () => signal?.removeEventListener("abort", abort);
-            this.waiters.add(waiter);
-            signal?.addEventListener("abort", abort, { once: true });
-        });
-    }
-    fail(error) {
-        if (this.failure !== undefined)
-            return;
-        this.failure = error;
-        for (const waiter of this.waiters)
-            waiter.reject(error);
-        this.waiters.clear();
-    }
-    close() {
-        this.fail(new SessionError("closed"));
-        return this.values.splice(0);
-    }
-}
-const acceptorStates = new WeakMap();
-function acceptorState(acceptor) {
-    const state = acceptorStates.get(acceptor);
-    if (state === undefined)
-        throw new SessionError("operation_failed");
-    return state;
-}
-export async function createAcceptor(options) {
-    if (!Number.isSafeInteger(options.maxInboundStreams) ||
-        options.maxInboundStreams < 1 ||
-        options.maxInboundStreams > 128 ||
-        options.listeners.length === 0) {
-        throw new TypeError("invalid Flowersec Acceptor options");
-    }
-    const cleanupTimeoutMs = options.cleanupTimeoutMs ?? DEFAULT_CLEANUP_TIMEOUT_MS;
-    if (!Number.isSafeInteger(cleanupTimeoutMs) || cleanupTimeoutMs < 1 || cleanupTimeoutMs > 60_000) {
-        throw new TypeError("invalid Flowersec Acceptor cleanup timeout");
-    }
-    if (options.listeners.some((listener) => listener.path !== "direct")) {
-        throw new TypeError("Flowersec Acceptor listeners must use the direct path");
-    }
-    const listeners = [];
-    let rawQuicDriver;
-    try {
-        for (const listener of options.listeners) {
-            if (listener.carrier === "websocket") {
-                listeners.push(await startNodeWebSocketServer({
-                    ...listener,
-                    inboundBidirectionalStreamCapacity: options.maxInboundStreams + 2,
-                }));
-            }
-            else {
-                rawQuicDriver ??= createNativeRawQuicDriver();
-                listeners.push(await startNodeRawQuicServer(rawQuicDriver, {
-                    ...listener,
-                    inboundBidirectionalStreamCapacity: options.maxInboundStreams + 2,
-                }));
-            }
-        }
-    }
-    catch (error) {
-        await Promise.allSettled(listeners.map(async (listener) => await listener.close()));
-        throw error;
-    }
-    let cursor = 0;
-    const accept = async (operation) => {
-        if (listeners.length === 1)
-            return await listeners[0].accept(operation);
-        const controller = new AbortController();
-        const abort = () => controller.abort(operation.signal?.reason);
-        operation.signal?.addEventListener("abort", abort, { once: true });
-        try {
-            return await new Promise((resolve, reject) => {
-                let settled = false;
-                let remaining = listeners.length;
-                const errors = [];
-                listeners.forEach((listener, index) => {
-                    const selected = listeners[(index + cursor) % listeners.length];
-                    void selected.accept({ signal: controller.signal }).then((carrier) => {
-                        if (!settled) {
-                            settled = true;
-                            cursor = (cursor + 1) % listeners.length;
-                            controller.abort();
-                            resolve(carrier);
-                        }
-                        else {
-                            carrier.abort({ code: 1000, reason: "accept race lost" });
-                        }
-                    }, (error) => {
-                        errors.push(error);
-                        remaining -= 1;
-                        if (!settled && remaining === 0) {
-                            settled = true;
-                            reject(new AggregateError(errors, "all listeners failed to accept"));
-                        }
-                    });
-                });
-            });
-        }
-        finally {
-            operation.signal?.removeEventListener("abort", abort);
-        }
-    };
-    const acceptor = new Acceptor();
-    const accepted = new AcceptedQueue();
-    const abort = new AbortController();
-    const tasks = new Set();
-    const admissions = new Set();
-    let started = false;
-    const state = {
-        listeners,
-        options,
-        accept,
-        accepted,
-        abort,
-        tasks,
-        admissions,
-        cleanupTimeoutMs,
-        lifecycle: { cleanupFailed: false },
-        start() {
-            if (started)
-                return;
-            started = true;
-            const task = runAcceptLoop(state).finally(() => tasks.delete(task));
-            tasks.add(task);
-        },
-    };
-    acceptorStates.set(acceptor, state);
-    return Object.freeze(acceptor);
-}
-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) {
     try {
         return assertRpcError(error);

package/dist/node/acceptorV3.js

@@ -5,7 +5,7 @@ import { AdmissionStatusV3 } from "../v3/artifact.js";
 import { unwrapArtifactHandleV3, } from "../v3/publicApi.js";
 import { SessionHandlersV3, createRPCRouter, freezeSessionHandlersV3, } from "./acceptor.js";
 import { serveFrozenStreamHandlers } from "../public/streamHandlers.js";
-import { createNativeRawQuicDriverV3, loadNativeTransportAddon, } from "./nativeTransportAddon.js";
+import { createNativeRawQuicDriver, loadNativeTransportAddon, } from "./nativeTransportAddon.js";
 import { startNodeRawQuicListenerV3, } from "./rawQuicServerV3.js";
 import { startNodeWebSocketListenerV3, } from "./webSocketServerV3.js";
 import { runtimeAuthorizationRequestV3FromDecoded, } from "./runtimeAuthorizationV3.js";
@@ -126,7 +126,7 @@ export async function createAcceptorV3(options) {
                     ...listener,
                     inboundBidirectionalStreamCapacity: options.maxInboundStreams + 2,
                 })
-                : await startNodeRawQuicListenerV3(rawDriver ??= createNativeRawQuicDriverV3(loadNativeTransportAddon()), {
+                : await startNodeRawQuicListenerV3(rawDriver ??= createNativeRawQuicDriver(loadNativeTransportAddon()), {
                     ...listener,
                     inboundBidirectionalStreamCapacity: options.maxInboundStreams + 2,
                 });

package/dist/node/connectSessionV3.js

@@ -5,7 +5,7 @@ import { attemptClaimedArtifactLeaseV3, connectArtifactLeaseV3 } from "../v3/ses
 import { readyNativeAdmissionV3, readyWebSocketAdmissionV3 } from "../v3/runtimeAdapters.js";
 import { ConnectErrorV3, TransportFailureV3 } from "../v3/security.js";
 import { nodeSessionRuntimeV3 } from "../v3/nodeSessionRuntime.js";
-import { createNativeRawQuicDriverV3, tryLoadNativeTransportAddon, } from "./nativeTransportAddon.js";
+import { createNativeRawQuicDriver, tryLoadNativeTransportAddon, } from "./nativeTransportAddon.js";
 import { createNodeRawQuicClientV3 } from "./rawQuicAdapterV3.js";
 import { createRPCRouter, freezeRPCHandlers, } from "./acceptor.js";
 export async function connectV3(lease, options) {
@@ -26,7 +26,7 @@ function nodeRuntime(options) {
         throw new ConnectErrorV3("artifact_invalid", { kind: "terminal" });
     }
     const addon = tryLoadNativeTransportAddon();
-    const rawQuic = addon === undefined ? undefined : createNativeRawQuicDriverV3(addon);
+    const rawQuic = addon === undefined ? undefined : createNativeRawQuicDriver(addon);
     const capability = detectNodeRuntimeCapabilityV3(rawQuic !== undefined, options.origin !== undefined);
     let rpcSnapshot;
     try {

package/dist/node/index.d.ts

@@ -1,32 +1,17 @@
 export { AcceptedSessionV3 as AcceptedSession, AcceptorV3 as Acceptor, createAcceptorV3 as createAcceptor, } from "./acceptorV3.js";
 export type { AcceptorListenerV3 as AcceptorListener, AcceptorAuthorizationDecisionV3 as AcceptorAuthorizationDecision, AcceptorAuthorizerV3 as AcceptorAuthorizer, AcceptorOptionsV3 as AcceptorOptions, } from "./acceptorV3.js";
-/** @deprecated Use the corresponding unversioned acceptor exports. */
-export { AcceptedSessionV3, AcceptorV3, createAcceptorV3 } from "./acceptorV3.js";
-/** @deprecated Use the corresponding unversioned acceptor types. */
-export type { AcceptorListenerV3, AcceptorAuthorizationDecisionV3, AcceptorAuthorizerV3, AcceptorOptionsV3, } from "./acceptorV3.js";
 export { TunnelRuntimeV3 as TunnelRuntime, createTunnelRuntimeV3 as createTunnelRuntime, } from "./tunnelRuntimeV3.js";
 export type { TunnelAuthorizationDecisionV3 as TunnelAuthorizationDecision, TunnelRuntimeListenerV3 as TunnelRuntimeListener, TunnelRuntimeOptionsV3 as TunnelRuntimeOptions, } from "./tunnelRuntimeV3.js";
-/** @deprecated Use TunnelRuntime and createTunnelRuntime. */
-export { TunnelRuntimeV3, createTunnelRuntimeV3 } from "./tunnelRuntimeV3.js";
-/** @deprecated Use the corresponding unversioned tunnel runtime types. */
-export type { TunnelAuthorizationDecisionV3, TunnelRuntimeListenerV3, TunnelRuntimeOptionsV3, } from "./tunnelRuntimeV3.js";
 export { RuntimeAuthorizationRequestV3 as RuntimeAuthorizationRequest, TunnelAuthorizationGrantV3 as TunnelAuthorizationGrant, verifyTunnelAuthorizationGrantV3 as verifyTunnelAuthorizationGrant, } from "./runtimeAuthorizationV3.js";
 export type { TunnelAuthorizationGrantOptionsV3 as TunnelAuthorizationGrantOptions, } from "./runtimeAuthorizationV3.js";
-/** @deprecated Use the corresponding unversioned runtime-authorization exports. */
-export { RuntimeAuthorizationRequestV3, TunnelAuthorizationGrantV3, verifyTunnelAuthorizationGrantV3, } from "./runtimeAuthorizationV3.js";
-/** @deprecated Use TunnelAuthorizationGrantOptions. */
-export type { TunnelAuthorizationGrantOptionsV3 } from "./runtimeAuthorizationV3.js";
 export * from "../facade.js";
-export * as v2 from "./v2.js";
 import type { NodeTLSRootsV3 as NodeTLSRoots } from "./connectSessionV3.js";
 export { connectV3 as connect, createConnectionControllerV3 as createConnectionController, } from "./connectSessionV3.js";
-/** @deprecated Use connect and createConnectionController. */
-export { connectV3, createConnectionControllerV3 } from "./connectSessionV3.js";
 export type { ConnectionControllerOptionsV3 as ConnectionControllerOptions, NodeTLSRootsV3 as NodeTLSRoots, SessionOptionsV3 as SessionOptions, } from "./connectSessionV3.js";
-/** @deprecated Use ConnectionControllerOptions, SessionTLSOptions, and SessionOptions. */
-export type { ConnectionControllerOptionsV3, NodeTLSRootsV3, SessionOptionsV3, } from "./connectSessionV3.js";
 export type SessionTLSOptions = Readonly<{
     ca?: NodeTLSRoots;
 }>;
 export { HandlerRegistrationError, RPCHandlers, SessionHandlersV3 as SessionHandlers, } from "./acceptor.js";
 export type { NotificationHandler, RPCHandler, RPCHandlerResult, SessionHandlerOptions, } from "./acceptor.js";
+export { ProxyServer, ProxyServerError } from "./proxyServer.js";
+export type { ProxyServerOptions } from "./proxyServer.js";

package/dist/node/index.js

@@ -1,15 +1,7 @@
 export { AcceptedSessionV3 as AcceptedSession, AcceptorV3 as Acceptor, createAcceptorV3 as createAcceptor, } from "./acceptorV3.js";
-/** @deprecated Use the corresponding unversioned acceptor exports. */
-export { AcceptedSessionV3, AcceptorV3, createAcceptorV3 } from "./acceptorV3.js";
 export { TunnelRuntimeV3 as TunnelRuntime, createTunnelRuntimeV3 as createTunnelRuntime, } from "./tunnelRuntimeV3.js";
-/** @deprecated Use TunnelRuntime and createTunnelRuntime. */
-export { TunnelRuntimeV3, createTunnelRuntimeV3 } from "./tunnelRuntimeV3.js";
 export { RuntimeAuthorizationRequestV3 as RuntimeAuthorizationRequest, TunnelAuthorizationGrantV3 as TunnelAuthorizationGrant, verifyTunnelAuthorizationGrantV3 as verifyTunnelAuthorizationGrant, } from "./runtimeAuthorizationV3.js";
-/** @deprecated Use the corresponding unversioned runtime-authorization exports. */
-export { RuntimeAuthorizationRequestV3, TunnelAuthorizationGrantV3, verifyTunnelAuthorizationGrantV3, } from "./runtimeAuthorizationV3.js";
 export * from "../facade.js";
-export * as v2 from "./v2.js";
 export { connectV3 as connect, createConnectionControllerV3 as createConnectionController, } from "./connectSessionV3.js";
-/** @deprecated Use connect and createConnectionController. */
-export { connectV3, createConnectionControllerV3 } from "./connectSessionV3.js";
 export { HandlerRegistrationError, RPCHandlers, SessionHandlersV3 as SessionHandlers, } from "./acceptor.js";
+export { ProxyServer, ProxyServerError } from "./proxyServer.js";

package/dist/node/nativeTransportAddon.d.ts

@@ -1,16 +1,6 @@
-import { type NativeCarrierSessionV2 } from "../v2/carrier.js";
-import type { PathKind } from "../v2/contract.js";
 import type { NativeCarrierSessionV3 } from "../v3/carrier.js";
-export declare const NATIVE_TRANSPORT_CONTRACT_VERSION = 2;
-export type NativeRawQuicConnectOptions = Readonly<{
-    host: string;
-    port: number;
-    serverName: string;
-    path: PathKind;
-    trustRootsDer: readonly Uint8Array[];
-    inboundBidirectionalStreamCapacity: number;
-    handshakeTimeoutMs: number;
-}>;
+import type { PathKind } from "../v3/contract.js";
+export declare const NATIVE_TRANSPORT_CONTRACT_VERSION = 3;
 export type NativeRawQuicBindOptions = Readonly<{
     host: string;
     port: number;
@@ -20,7 +10,7 @@ export type NativeRawQuicBindOptions = Readonly<{
     inboundBidirectionalStreamCapacity: number;
     handshakeTimeoutMs?: number;
 }>;
-type NativeRawQuicConnectOptionsV3Base = Readonly<{
+type NativeRawQuicConnectOptionsBase = Readonly<{
     host: string;
     port: number;
     serverName: string;
@@ -28,7 +18,7 @@ type NativeRawQuicConnectOptionsV3Base = Readonly<{
     inboundBidirectionalStreamCapacity: number;
     handshakeTimeoutMs: number;
 }>;
-export type NativeRawQuicConnectOptionsV3 = NativeRawQuicConnectOptionsV3Base & (Readonly<{
+export type NativeRawQuicConnectOptions = NativeRawQuicConnectOptionsBase & (Readonly<{
     tlsMode: "ca";
     trustRootsDer: readonly Uint8Array[];
     activeLeafDerSha256?: never;
@@ -44,30 +34,14 @@ export type NativeRawQuicListener = Readonly<{
     }>;
     accept(options?: Readonly<{
         signal?: AbortSignal;
-    }>): Promise<NativeCarrierSessionV2>;
+    }>): Promise<NativeCarrierSessionV3>;
     close(): Promise<void>;
 }>;
 export type NativeRawQuicDriver = Readonly<{
     connectRawQuic(options: NativeRawQuicConnectOptions, operation?: Readonly<{
         signal?: AbortSignal;
-    }>): Promise<NativeCarrierSessionV2>;
-    bindRawQuic(options: NativeRawQuicBindOptions): Promise<NativeRawQuicListener>;
-}>;
-export type NativeRawQuicListenerV3 = Readonly<{
-    address(): Readonly<{
-        host: string;
-        port: number;
-    }>;
-    accept(options?: Readonly<{
-        signal?: AbortSignal;
     }>): Promise<NativeCarrierSessionV3>;
-    close(): Promise<void>;
-}>;
-export type NativeRawQuicDriverV3 = Readonly<{
-    connectRawQuic(options: NativeRawQuicConnectOptionsV3, operation?: Readonly<{
-        signal?: AbortSignal;
-    }>): Promise<NativeCarrierSessionV3>;
-    bindRawQuic(options: NativeRawQuicBindOptions): Promise<NativeRawQuicListenerV3>;
+    bindRawQuic(options: NativeRawQuicBindOptions): Promise<NativeRawQuicListener>;
 }>;
 type NativeOperation<T> = Readonly<{
     result(): Promise<T>;
@@ -85,7 +59,7 @@ type NativeRawQuicStreamBinding = Readonly<{
 type NativeRawQuicSessionBinding = Readonly<{
     kind: "raw_quic";
     path: PathKind;
-    wireVersion: 2 | 3;
+    wireVersion: 3;
     inboundBidirectionalStreamCapacity: number;
     maxDatagramSize?: number;
     localAddress(): Readonly<{
@@ -117,8 +91,6 @@ export type NativeTransportAddonBinding = Readonly<{
     contractVersion(): number;
     connectRawQuic(options: NativeRawQuicConnectOptions): NativeOperation<NativeRawQuicSessionBinding>;
     bindRawQuic(options: NativeRawQuicBindOptions): Promise<NativeRawQuicListenerBinding>;
-    connectRawQuicV3(options: NativeRawQuicConnectOptionsV3): NativeOperation<NativeRawQuicSessionBinding>;
-    bindRawQuicV3(options: NativeRawQuicBindOptions): Promise<NativeRawQuicListenerBinding>;
 }>;
 export type NativeTransportAddon = NativeTransportAddonBinding;
 export declare class NativeTransportUnavailableError extends Error {
@@ -129,5 +101,4 @@ type RequireFunction = (specifier: string) => unknown;
 export declare function loadNativeTransportAddon(requireFunction?: RequireFunction): NativeTransportAddonBinding;
 export declare function tryLoadNativeTransportAddon(requireFunction?: RequireFunction): NativeTransportAddonBinding | undefined;
 export declare function createNativeRawQuicDriver(addon?: NativeTransportAddonBinding): NativeRawQuicDriver;
-export declare function createNativeRawQuicDriverV3(addon?: NativeTransportAddonBinding): NativeRawQuicDriverV3;
 export {};