@floegence/flowersec-core 3.2.1 → 5.0.0

package/dist/connector/adapters/webTransportCandidate.js

@@ -1,73 +0,0 @@
-import { adaptNativeCarrierSessionV2, } from "../../v2/carrier.js";
-export function createWebTransportCandidateFactoryV2(factory) {
-    return {
-        create(candidate, artifact) {
-            if (candidate.carrier !== "webtransport") {
-                throw new Error(`unsupported WebTransport carrier ${candidate.carrier}`);
-            }
-            return new WebTransportCandidateAttempt(candidate, artifact, factory);
-        },
-    };
-}
-class WebTransportCandidateAttempt {
-    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 = carrier.kind === "webtransport"
-                        ? await carrier.acceptStream(options)
-                        : await carrier.openStream(options);
-                    return {
-                        framing: "stream",
-                        stream,
-                        abort: (error) => stream.abort(error),
-                    };
-                },
-                finalize: () => {
-                    if (this.finalized)
-                        throw new Error("WebTransport 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("WebTransport 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/admissionCommit.d.ts

@@ -1,31 +0,0 @@
-import { type CanonicalArtifactCandidateV2 } from "../v2/artifact.js";
-import type { CarrierSessionV2, NativeCarrierStreamV2 } from "../v2/carrier.js";
-import type { CarrierKind, OperationOptionsV2, PathKind } from "../v2/contract.js";
-import type { SessionConfigV2 } from "../v2/session.js";
-import { type ArtifactLeaseV2 } from "../v2/artifactLease.js";
-export declare class CredentialCommitError extends Error {
-    constructor(cause: unknown);
-}
-export type ClientAdmissionChannelV2 = Readonly<{
-    framing: "message";
-    write(data: Uint8Array, options?: OperationOptionsV2): Promise<void>;
-    read(options?: OperationOptionsV2): Promise<Uint8Array>;
-    abort(error: Error): void;
-}> | Readonly<{
-    framing: "stream";
-    stream: NativeCarrierStreamV2;
-    abort(error: Error): void;
-}>;
-export type ReadyAdmissionTransportV2 = Readonly<{
-    candidate: CanonicalArtifactCandidateV2;
-    kind: CarrierKind;
-    path: PathKind;
-    inboundBidirectionalStreamCapacity: number;
-    openAdmissionChannel(signal?: AbortSignal): Promise<ClientAdmissionChannelV2>;
-    finalize(): CarrierSessionV2;
-    close(): Promise<void>;
-    abort(): void;
-}>;
-export declare function commitClientAdmissionV2(ready: ReadyAdmissionTransportV2, lease: ArtifactLeaseV2, assertCredentialValid: () => void, rawFSB2: Uint8Array, config: SessionConfigV2, signal?: AbortSignal): Promise<CarrierSessionV2>;
-export declare function requireExactCarrierCapacityV2(physical: number, logical: number): void;
-export declare function validateOutboundAdmissionV2(rawFSB2: Uint8Array, config: SessionConfigV2, carrier: CarrierKind): void;

package/dist/connector/admissionCommit.js

@@ -1,239 +0,0 @@
-import { AdmissionStatusV2, computeSessionContractHashV2, decodeFSB2RequestV2, decodeFSA2ResponseV2, } from "../v2/artifact.js";
-import { AdmissionSessionV2Error } from "../v2/admissionError.js";
-import { base64urlDecode, base64urlEncode } from "../utils/base64url.js";
-import { commitArtifactLeaseSpendV2, } from "../v2/artifactLease.js";
-export class CredentialCommitError extends Error {
-    constructor(cause) {
-        super("durable credential spend failed", { cause });
-        this.name = "CredentialCommitError";
-    }
-}
-export async function commitClientAdmissionV2(ready, lease, assertCredentialValid, rawFSB2, config, signal) {
-    throwIfAborted(signal);
-    requireReadyTransportBinding(ready, config);
-    validateOutboundAdmissionV2(rawFSB2, config, ready.kind);
-    const channel = await ready.openAdmissionChannel(signal);
-    try {
-        assertCredentialValid();
-        try {
-            await commitArtifactLeaseSpendV2(lease, signal);
-        }
-        catch (error) {
-            throw new CredentialCommitError(error);
-        }
-        assertCredentialValid();
-        throwIfAborted(signal);
-        const rawFSA2 = channel.framing === "message"
-            ? await exchangeMessage(channel, rawFSB2, signal)
-            : await exchangeStream(channel.stream, rawFSB2, signal);
-        requireAdmissionSuccessV2(rawFSA2);
-        return ready.finalize();
-    }
-    catch (error) {
-        const failure = asError(error);
-        channel.abort(failure);
-        ready.abort();
-        throw error;
-    }
-}
-function requireReadyTransportBinding(ready, config) {
-    if (ready.candidate.carrier !== ready.kind) {
-        throw new AdmissionSessionV2Error("carrier_mismatch", "ready carrier does not match its artifact candidate");
-    }
-    if (ready.path !== config.path) {
-        throw new AdmissionSessionV2Error("path_mismatch", "ready carrier path does not match SessionV2 path");
-    }
-    requireExactCarrierCapacityV2(ready.inboundBidirectionalStreamCapacity, config.maxInboundStreams);
-}
-async function exchangeMessage(channel, rawFSB2, signal) {
-    const options = signalOptions(signal);
-    await channel.write(rawFSB2, options);
-    return await channel.read(options);
-}
-async function exchangeStream(stream, rawFSB2, signal) {
-    await writeAll(stream, rawFSB2, signal);
-    await raceAbort(stream.closeWrite(), signal);
-    const reader = new NativeExactReader(stream);
-    const header = await reader.readExactly(8, signal);
-    const reasonLength = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint16(6, false);
-    if (reasonLength > 64)
-        throw new AdmissionSessionV2Error("invalid_fsa2", "FSA2 reason exceeds limit");
-    const rawFSA2 = concat(header, await reader.readExactly(reasonLength, signal));
-    await reader.expectCleanEOF(signal);
-    return rawFSA2;
-}
-export function requireExactCarrierCapacityV2(physical, logical) {
-    if (!validLogicalStreamCapacity(logical) || physical !== logical + 2) {
-        throw new AdmissionSessionV2Error("stream_capacity_mismatch", "carrier inbound bidirectional stream capacity does not match SessionV2 logical limit");
-    }
-}
-export function validateOutboundAdmissionV2(rawFSB2, config, carrier) {
-    let decoded;
-    try {
-        decoded = decodeFSB2RequestV2(rawFSB2);
-    }
-    catch (error) {
-        throw new AdmissionSessionV2Error("invalid_fsb2", error instanceof Error ? error.message : "invalid FSB2 request");
-    }
-    const request = decoded.request;
-    if (request.pathKind !== config.path) {
-        throw new AdmissionSessionV2Error("path_mismatch", "FSB2 path does not match SessionV2 path");
-    }
-    validateSessionContract(config);
-    const expectedRole = request.pathKind === "tunnel" && request.role === 2 ? "server" : "client";
-    if (config.role !== expectedRole) {
-        throw new AdmissionSessionV2Error("role_mismatch", "FSB2 role does not match SessionV2 role");
-    }
-    if (request.channel_id !== config.channelID ||
-        request.session_contract_hash_b64u !== base64urlEncode(config.sessionContractHash)) {
-        throw new AdmissionSessionV2Error("session_config_mismatch", "FSB2 session identity does not match SessionV2 config");
-    }
-    if (request.pathKind === "tunnel" && request.endpoint_instance_id !== config.localEndpointInstanceID) {
-        throw new AdmissionSessionV2Error("endpoint_mismatch", "FSB2 endpoint identity does not match SessionV2 config");
-    }
-    if (!bytesEqual(decoded.localAdmissionBinding, config.localAdmissionBinding)) {
-        throw new AdmissionSessionV2Error("admission_binding_mismatch", "FSB2 admission binding does not match SessionV2 config");
-    }
-    if (request.pathKind === "direct" && !bytesEqual(decoded.localAdmissionBinding, config.peerAdmissionBinding)) {
-        throw new AdmissionSessionV2Error("peer_admission_binding_mismatch", "direct FSB2 admission binding does not match SessionV2 peer binding");
-    }
-    const candidate = request.candidates.find((entry) => entry.id === request.chosen_candidate_id);
-    if (candidate?.carrier !== carrier) {
-        throw new AdmissionSessionV2Error("carrier_mismatch", "FSB2 chosen candidate does not match the carrier");
-    }
-}
-function validateSessionContract(config) {
-    const contract = config.sessionContract;
-    if (contract === undefined) {
-        throw new AdmissionSessionV2Error("session_config_mismatch", "admitted SessionV2 requires a validated session contract");
-    }
-    let hash;
-    let hashBase64URL;
-    let psk;
-    try {
-        hashBase64URL = computeSessionContractHashV2(contract).hashBase64URL;
-        hash = base64urlDecode(hashBase64URL);
-        psk = base64urlDecode(contract.e2ee_psk_b64u);
-    }
-    catch (error) {
-        throw new AdmissionSessionV2Error("session_config_mismatch", error instanceof Error ? error.message : "invalid session contract");
-    }
-    if (contract.contract_hash_b64u !== hashBase64URL ||
-        !bytesEqual(hash, config.sessionContractHash) ||
-        contract.channel_id !== config.channelID ||
-        contract.max_inbound_streams !== config.maxInboundStreams ||
-        contract.default_suite !== config.suite ||
-        !contract.allowed_suites.includes(config.suite) ||
-        !bytesEqual(psk, config.psk) ||
-        contract.selected_features !== 0 ||
-        (config.idleTimeoutMs ?? 60_000) !== contract.idle_timeout_seconds * 1_000 ||
-        (config.deadlines?.establishTimeoutMs ?? 30_000) !== contract.establish_timeout_seconds * 1_000 ||
-        (config.deadlines?.rekeyPrepareTimeoutMs ?? 10_000) !== contract.rekey_prepare_timeout_seconds * 1_000 ||
-        (config.deadlines?.rekeyCompletionTimeoutMs ?? 30_000) !== contract.rekey_completion_timeout_seconds * 1_000) {
-        throw new AdmissionSessionV2Error("session_config_mismatch", "SessionV2 config does not match the signed session contract");
-    }
-}
-function requireAdmissionSuccessV2(rawFSA2) {
-    const response = decodeFSA2ResponseV2(rawFSA2);
-    if (response.status !== AdmissionStatusV2.Success) {
-        throw new AdmissionSessionV2Error(response.reason, `Flowersec v2 admission rejected: ${response.reason}`);
-    }
-}
-class NativeExactReader {
-    stream;
-    chunks = [];
-    offset = 0;
-    bytes = 0;
-    constructor(stream) {
-        this.stream = stream;
-    }
-    async readExactly(length, signal) {
-        while (this.bytes < length) {
-            throwIfAborted(signal);
-            const chunk = await raceAbort(this.stream.read(), signal);
-            if (chunk === null)
-                throw new AdmissionSessionV2Error("truncated_fsa2", "unexpected admission EOF");
-            if (chunk.length === 0)
-                continue;
-            this.chunks.push(chunk);
-            this.bytes += chunk.length;
-        }
-        const output = new Uint8Array(length);
-        let written = 0;
-        while (written < length) {
-            const chunk = this.chunks[0];
-            const take = Math.min(length - written, chunk.length - this.offset);
-            output.set(chunk.subarray(this.offset, this.offset + take), written);
-            written += take;
-            this.offset += take;
-            this.bytes -= take;
-            if (this.offset === chunk.length) {
-                this.chunks.shift();
-                this.offset = 0;
-            }
-        }
-        return output;
-    }
-    async expectCleanEOF(signal) {
-        if (this.bytes !== 0)
-            throw new AdmissionSessionV2Error("invalid_fsa2", "trailing bytes after FSA2");
-        while (true) {
-            throwIfAborted(signal);
-            const chunk = await raceAbort(this.stream.read(), signal);
-            if (chunk === null)
-                return;
-            if (chunk.length !== 0)
-                throw new AdmissionSessionV2Error("invalid_fsa2", "trailing bytes after FSA2");
-        }
-    }
-}
-async function writeAll(stream, value, signal) {
-    let offset = 0;
-    while (offset < value.length) {
-        throwIfAborted(signal);
-        const written = await raceAbort(stream.write(value.subarray(offset)), signal);
-        if (written < 1 || written > value.length - offset) {
-            throw new AdmissionSessionV2Error("short_write", "short admission write");
-        }
-        offset += written;
-    }
-}
-function signalOptions(signal) {
-    return signal === undefined ? {} : { signal };
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted === true)
-        throw new AdmissionSessionV2Error("aborted", "admission aborted");
-}
-async function raceAbort(promise, signal) {
-    if (signal === undefined)
-        return await promise;
-    throwIfAborted(signal);
-    return await new Promise((resolve, reject) => {
-        const abort = () => reject(signal.reason instanceof Error
-            ? signal.reason
-            : new AdmissionSessionV2Error("aborted", "admission aborted"));
-        signal.addEventListener("abort", abort, { once: true });
-        void promise.then((value) => { signal.removeEventListener("abort", abort); resolve(value); }, (error) => { signal.removeEventListener("abort", abort); reject(error); });
-    });
-}
-function concat(left, right) {
-    const output = new Uint8Array(left.length + right.length);
-    output.set(left);
-    output.set(right, left.length);
-    return output;
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}
-function validLogicalStreamCapacity(logical) {
-    return Number.isInteger(logical) && logical >= 1 && logical <= 128;
-}
-function bytesEqual(left, right) {
-    if (left.length !== right.length)
-        return false;
-    let different = 0;
-    for (let index = 0; index < left.length; index++)
-        different |= left[index] ^ right[index];
-    return different === 0;
-}

package/dist/connector/sessionAcceptor.d.ts

@@ -1,38 +0,0 @@
-import { AdmissionStatusV2, type ArtifactV2, type DecodedFSB2RequestV2 } from "../v2/artifact.js";
-import type { CarrierSessionV2, CarrierStreamV2 } from "../v2/carrier.js";
-import type { SessionProtocolRuntimeV2, SessionV2 as InternalSessionV2 } from "../v2/session.js";
-import type { RpcRouter } from "../rpc/server.js";
-export type AdmissionDecisionV2 = Readonly<{
-    accepted: true;
-    artifact: ArtifactV2;
-}> | Readonly<{
-    accepted: false;
-    status: AdmissionStatusV2.Reject | AdmissionStatusV2.Retryable;
-    reason: string;
-}>;
-export type AdmissionAuthorizerV2 = (request: DecodedFSB2RequestV2, signal?: AbortSignal) => Promise<AdmissionDecisionV2>;
-export type ReceivedSessionAdmissionV2 = Readonly<{
-    carrier: CarrierSessionV2;
-    stream: CarrierStreamV2;
-    rawFSB2: Uint8Array;
-    decoded: DecodedFSB2RequestV2;
-}>;
-export declare function receiveSessionAdmissionV2(carrier: CarrierSessionV2, signal?: AbortSignal): Promise<ReceivedSessionAdmissionV2>;
-export declare function rejectSessionAdmissionV2(received: ReceivedSessionAdmissionV2, decision: Extract<AdmissionDecisionV2, Readonly<{
-    accepted: false;
-}>>, signal?: AbortSignal): Promise<never>;
-export declare function acceptReceivedSessionV2(received: ReceivedSessionAdmissionV2, artifact: ArtifactV2, options: Readonly<{
-    runtime: SessionProtocolRuntimeV2;
-    rpcRouter?: RpcRouter;
-    signal?: AbortSignal;
-    role?: "client" | "server";
-    localAdmissionBinding?: Uint8Array;
-    peerAdmissionBinding?: Uint8Array;
-    localEndpointInstanceID?: string;
-    expectedPeerEndpointInstanceID?: string;
-}>): Promise<InternalSessionV2>;
-export declare function acceptNativeSessionV2(carrier: CarrierSessionV2, authorize: AdmissionAuthorizerV2, options: Readonly<{
-    runtime: SessionProtocolRuntimeV2;
-    rpcRouter?: RpcRouter;
-    signal?: AbortSignal;
-}>): Promise<InternalSessionV2>;

package/dist/connector/sessionAcceptor.js

@@ -1,158 +0,0 @@
-import { AdmissionStatusV2, buildFSB2RequestV2, decodeFSB2RequestV2, encodeFSB2RequestV2, encodeFSA2ResponseV2, } from "../v2/artifact.js";
-import { establishSessionV2 } from "../v2/session.js";
-import { AdmissionSessionV2Error } from "../v2/admissionError.js";
-import { sessionConfigFromArtifactV2 } from "./sessionConfig.js";
-export async function receiveSessionAdmissionV2(carrier, signal) {
-    const stream = carrier.kind === "webtransport"
-        ? await carrier.openStream(signalOptions(signal))
-        : await carrier.acceptStream(signalOptions(signal));
-    try {
-        const rawFSB2 = await readFSB2(stream, signal);
-        return Object.freeze({ carrier, stream, rawFSB2, decoded: decodeFSB2RequestV2(rawFSB2) });
-    }
-    catch (error) {
-        stream.abort(asError(error));
-        carrier.abort({ code: 6, reason: "admission failed" });
-        throw error;
-    }
-}
-export async function rejectSessionAdmissionV2(received, decision, signal) {
-    await respondAdmission(received.stream, { status: decision.status, reason: decision.reason }, signal);
-    received.carrier.abort({ code: 6, reason: "admission rejected" });
-    throw new AdmissionSessionV2Error(decision.reason, `Flowersec v2 admission rejected: ${decision.reason}`);
-}
-export async function acceptReceivedSessionV2(received, artifact, options) {
-    try {
-        const expected = encodeFSB2RequestV2(buildFSB2RequestV2(artifact, received.decoded.request.chosen_candidate_id));
-        if (!equalBytes(expected, received.rawFSB2))
-            throw new Error("authorized artifact does not match admission");
-        await respondAdmission(received.stream, { status: AdmissionStatusV2.Success, reason: "" }, options.signal);
-        const base = sessionConfigFromArtifactV2(artifact, received.rawFSB2, options.runtime, undefined, options.role);
-        const config = {
-            ...base,
-            ...(options.rpcRouter === undefined ? {} : { rpcRouter: options.rpcRouter }),
-            ...(options.localAdmissionBinding === undefined ? {} : { localAdmissionBinding: options.localAdmissionBinding }),
-            ...(options.peerAdmissionBinding === undefined ? {} : { peerAdmissionBinding: options.peerAdmissionBinding }),
-            ...(options.localEndpointInstanceID === undefined ? {} : { localEndpointInstanceID: options.localEndpointInstanceID }),
-            ...(options.expectedPeerEndpointInstanceID === undefined ? {} : { expectedPeerEndpointInstanceID: options.expectedPeerEndpointInstanceID }),
-        };
-        return await establishSessionV2(received.carrier, config, signalOptions(options.signal));
-    }
-    catch (error) {
-        received.stream.abort(asError(error));
-        received.carrier.abort({ code: 6, reason: "admission failed" });
-        throw error;
-    }
-}
-export async function acceptNativeSessionV2(carrier, authorize, options) {
-    const received = await receiveSessionAdmissionV2(carrier, options.signal);
-    try {
-        const decision = await authorize(received.decoded, options.signal);
-        if (!decision.accepted) {
-            return await rejectSessionAdmissionV2(received, decision, options.signal);
-        }
-        return await acceptReceivedSessionV2(received, decision.artifact, { ...options, role: "server" });
-    }
-    catch (error) {
-        received.stream.abort(asError(error));
-        carrier.abort({ code: 6, reason: "admission failed" });
-        throw error;
-    }
-}
-async function respondAdmission(stream, response, signal) {
-    await writeAll(stream, encodeFSA2ResponseV2(response), signal);
-    await raceAbort(stream.closeWrite(), signal);
-}
-function equalBytes(left, right) {
-    if (left.length !== right.length)
-        return false;
-    let difference = 0;
-    for (let index = 0; index < left.length; index += 1)
-        difference |= left[index] ^ right[index];
-    return difference === 0;
-}
-async function readFSB2(stream, signal) {
-    const reader = new NativeReader(stream);
-    const header = await reader.readExactly(12, signal);
-    const length = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint32(8, false);
-    if (length < 1 || length > 32_768)
-        throw new Error("invalid FSB2 payload length");
-    const payload = await reader.readExactly(length, signal);
-    await reader.expectEOF(signal);
-    const raw = new Uint8Array(header.length + payload.length);
-    raw.set(header);
-    raw.set(payload, header.length);
-    return raw;
-}
-class NativeReader {
-    stream;
-    chunks = [];
-    offset = 0;
-    available = 0;
-    constructor(stream) {
-        this.stream = stream;
-    }
-    async readExactly(length, signal) {
-        while (this.available < length) {
-            const chunk = await raceAbort(this.stream.read(), signal);
-            if (chunk === null)
-                throw new Error("truncated admission stream");
-            if (chunk.length === 0)
-                continue;
-            this.chunks.push(chunk);
-            this.available += chunk.length;
-        }
-        const result = new Uint8Array(length);
-        let written = 0;
-        while (written < length) {
-            const chunk = this.chunks[0];
-            const take = Math.min(length - written, chunk.length - this.offset);
-            result.set(chunk.subarray(this.offset, this.offset + take), written);
-            this.offset += take;
-            this.available -= take;
-            written += take;
-            if (this.offset === chunk.length) {
-                this.chunks.shift();
-                this.offset = 0;
-            }
-        }
-        return result;
-    }
-    async expectEOF(signal) {
-        if (this.available !== 0)
-            throw new Error("trailing bytes after FSB2");
-        while (true) {
-            const chunk = await raceAbort(this.stream.read(), signal);
-            if (chunk === null)
-                return;
-            if (chunk.length !== 0)
-                throw new Error("trailing bytes after FSB2");
-        }
-    }
-}
-async function writeAll(stream, value, signal) {
-    let offset = 0;
-    while (offset < value.length) {
-        const written = await raceAbort(stream.write(value.subarray(offset)), signal);
-        if (written < 1 || written > value.length - offset)
-            throw new Error("short admission write");
-        offset += written;
-    }
-}
-function signalOptions(signal) {
-    return signal === undefined ? {} : { signal };
-}
-async function raceAbort(promise, signal) {
-    if (signal === undefined)
-        return await promise;
-    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));
-    });
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}

package/dist/connector/sessionConfig.d.ts

@@ -1,3 +0,0 @@
-import { type ArtifactV2 } from "../v2/artifact.js";
-import type { SessionConfigV2, SessionDeadlineFactoryV2, SessionProtocolRuntimeV2 } from "../v2/session.js";
-export declare function sessionConfigFromArtifactV2(artifact: ArtifactV2, rawFSB2: Uint8Array, runtime: SessionProtocolRuntimeV2, deadlineFactory?: SessionDeadlineFactoryV2, role?: SessionConfigV2["role"]): SessionConfigV2;

package/dist/connector/sessionConfig.js

@@ -1,30 +0,0 @@
-import { admissionBindingV2 } from "../v2/artifact.js";
-import { base64urlDecode } from "../utils/base64url.js";
-const SESSION_CLOSE_TIMEOUT_MS = 5_000;
-export function sessionConfigFromArtifactV2(artifact, rawFSB2, runtime, deadlineFactory, role) {
-    const localBinding = admissionBindingV2(rawFSB2);
-    const tunnel = artifact.path.kind === "tunnel" ? artifact.path : undefined;
-    return {
-        role: role ?? (tunnel?.role === 2 ? "server" : "client"),
-        path: artifact.path.kind,
-        channelID: artifact.session.channel_id,
-        sessionContractHash: base64urlDecode(artifact.session.contract_hash_b64u),
-        suite: artifact.session.default_suite,
-        psk: base64urlDecode(artifact.session.e2ee_psk_b64u),
-        maxInboundStreams: artifact.session.max_inbound_streams,
-        sessionContract: artifact.session,
-        idleTimeoutMs: artifact.session.idle_timeout_seconds * 1_000,
-        closeTimeoutMs: SESSION_CLOSE_TIMEOUT_MS,
-        runtime,
-        localAdmissionBinding: localBinding,
-        peerAdmissionBinding: tunnel === undefined ? localBinding : new Uint8Array(32),
-        localEndpointInstanceID: tunnel?.local_endpoint_instance_id ?? "",
-        expectedPeerEndpointInstanceID: tunnel?.expected_peer_endpoint_instance_id ?? "",
-        deadlines: {
-            establishTimeoutMs: artifact.session.establish_timeout_seconds * 1_000,
-            rekeyPrepareTimeoutMs: artifact.session.rekey_prepare_timeout_seconds * 1_000,
-            rekeyCompletionTimeoutMs: artifact.session.rekey_completion_timeout_seconds * 1_000,
-            ...(deadlineFactory === undefined ? {} : { factory: deadlineFactory }),
-        },
-    };
-}

package/dist/connector/sessionConnector.d.ts

@@ -1,47 +0,0 @@
-import { type ArtifactV2, type CanonicalArtifactCandidateV2 } from "../v2/artifact.js";
-import { type SessionDeadlineFactoryV2, type SessionProtocolRuntimeV2, type SessionV2 as InternalSessionV2 } from "../v2/session.js";
-import type { ArtifactLeaseV2 } from "../v2/artifactLease.js";
-import { type RuntimeCapabilityDescriptorV2 } from "../v2/capability.js";
-import type { RpcRouter } from "../rpc/server.js";
-import { type ReadyAdmissionTransportV2 } from "./admissionCommit.js";
-export type SessionConnectorStateV2 = "attempt" | "ready" | "winner" | "admitted" | "established" | "terminated";
-export type ConnectorArtifactLeaseV2 = ArtifactLeaseV2;
-export type CandidateAttemptV2 = Readonly<{
-    candidate: CanonicalArtifactCandidateV2;
-    ready(signal?: AbortSignal): Promise<ReadyAdmissionTransportV2>;
-    abort(): void;
-}>;
-export type CandidateAttemptFactoryV2 = Readonly<{
-    create(candidate: CanonicalArtifactCandidateV2, artifact: ArtifactV2): CandidateAttemptV2;
-}>;
-export declare function composeCandidateAttemptFactoryV2(factories: Readonly<Partial<Record<CanonicalArtifactCandidateV2["carrier"], CandidateAttemptFactoryV2>>>): CandidateAttemptFactoryV2;
-export type SessionConnectorOptionsV2 = Readonly<{
-    signal?: AbortSignal;
-    connectTimeoutMs?: number;
-}>;
-type SessionConnectorInternalOptionsV2 = Readonly<{
-    runtime: SessionProtocolRuntimeV2;
-    rpcRouter?: RpcRouter;
-    connectTimeoutMs?: number;
-    deadlineFactory?: SessionDeadlineFactoryV2;
-    loserCloseTimeoutMs?: number;
-    now?: () => number;
-    capability?: RuntimeCapabilityDescriptorV2;
-}>;
-export type SessionConnectResultV2 = Readonly<{
-    candidate: CanonicalArtifactCandidateV2;
-    session: InternalSessionV2;
-}>;
-export declare class SessionConnectorV2 {
-    private readonly lease;
-    private readonly attemptFactory;
-    private readonly options;
-    state: SessionConnectorStateV2;
-    private claimed;
-    private readonly artifact;
-    constructor(lease: ConnectorArtifactLeaseV2, attemptFactory: CandidateAttemptFactoryV2, options: SessionConnectorInternalOptionsV2);
-    connect(options?: Readonly<{
-        signal?: AbortSignal;
-    }>): Promise<SessionConnectResultV2>;
-}
-export {};