@floegence/flowersec-core 3.2.1 → 5.0.0

package/dist/v2/session.js

@@ -1,2127 +0,0 @@
-import { RpcClient } from "../rpc/client.js";
-import { RpcRouter, RpcServer } from "../rpc/server.js";
-import { CarrierError } from "./carrier.js";
-import { computeClientConfirmV2, computeHandshakeH0V2, computeHandshakeH1V2, computeHandshakeH2V2, computeHandshakeH3V2, computeServerConfirmV2, computeSharedSecretV2, decodeClientFinishedV2, decodeClientInitV2, decodeHandshakeFrameV2, decodeServerFinishedV2, deriveHandshakePRKV2, deriveSessionPRKV2, encodeClientFinishedCoreV2, encodeClientFinishedV2, encodeClientInitV2, encodeControlPrefaceV2, encodeServerFinishedCoreV2, encodeServerFinishedV2, generateEphemeralKeyV2, parseControlPrefaceV2, validateClientInitV2, validateServerFinishedV2, } from "./handshake.js";
-import { DirectionV2, InnerTypeV2, computeFSS2HashV2, computeOpenHashV2, computeSetupMAC, decodeInnerRecordV2, decodeOpenACKV2, decodeOpenPayload, decodeOpenRejectV2, decodeRecordHeader, decodeSetupPrefaceV2, decodeStreamKeyUpdateACKV2, deriveControlMaterial, deriveEpochZero, deriveEpochRoots, deriveNextEpoch, deriveStreamMaterial, encodeInnerRecordV2, encodeOpenACKV2, encodeOpenPayload, encodeOpenRejectV2, encodeRecordHeader, encodeSetupPreface, encodeStreamKeyUpdateACKV2, openRecord, sealRecord, verifySetupMAC, } from "./protocol.js";
-import { StreamLifetimeLedgerV2, StreamLifetimeLedgerV2Error, maxLogicalStreamIDV2, } from "./streamLifetimeLedger.js";
-import { UNRELIABLE_MESSAGES_FEATURE_V2, UNRELIABLE_MESSAGE_WIRE_BYTES_V2, createInternalUnreliableMessageChannelV2, } from "./unreliableMessage.js";
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-const MAX_DATA_BYTES = 16_384;
-const MAX_BUFFERED_STREAM_BYTES = 4 * 1024 * 1024;
-const RESERVED_RPC_KIND = "flowersec.rpc.v2";
-const DEFAULT_IDLE_TIMEOUT_MS = 60_000;
-const DEFAULT_CLOSE_TIMEOUT_MS = 2_000;
-const DEFAULT_CONTROL_CONFIRM_TIMEOUT_MS = 2_000;
-export class SessionV2Error extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = "SessionV2Error";
-    }
-}
-class SessionRpcPeerV2 {
-    outbound;
-    inbound;
-    constructor(outbound, inbound) {
-        this.outbound = outbound;
-        this.inbound = inbound;
-    }
-    call(typeId, payload, signal) {
-        return this.outbound.call(typeId, payload, signal);
-    }
-    notify(typeId, payload) {
-        return this.outbound.notify(typeId, payload);
-    }
-    onNotify(typeId, handler) {
-        return this.inbound.onNotify(typeId, handler);
-    }
-    close() {
-        this.outbound.close();
-    }
-}
-export async function establishSessionV2(carrier, config, options = {}) {
-    validateConfig(carrier, config);
-    const establishDeadline = createSessionDeadline(config, "establish");
-    const establishSignal = combineSignals(options.signal, establishDeadline.signal);
-    throwIfAborted(establishSignal.signal);
-    let control;
-    try {
-        control = config.role === "client"
-            ? await carrier.openStream(signalOptions(establishSignal.signal))
-            : await carrier.acceptStream(signalOptions(establishSignal.signal));
-        const reader = new ExactReader(control);
-        const localFeatures = supportedFeatures(carrier.unreliableDatagrams);
-        const material = config.role === "client"
-            ? await clientHandshake(control, reader, config, localFeatures, establishSignal.signal)
-            : await serverHandshake(control, reader, config, localFeatures, establishSignal.signal);
-        const session = new SessionV2(carrier, control, reader, config, material);
-        session.start();
-        return session;
-    }
-    catch (error) {
-        control?.abort(asError(error));
-        carrier.abort({ code: 6, reason: "handshake failed" });
-        if (error instanceof SessionV2Error)
-            throw error;
-        throw new SessionV2Error("handshake", `Flowersec v2 handshake failed: ${errorMessage(error)}`);
-    }
-    finally {
-        establishSignal.cancel();
-        establishDeadline.cancel();
-    }
-}
-export class SessionV2 {
-    carrier;
-    control;
-    controlReader;
-    config;
-    path;
-    endpointInstanceId;
-    rpc;
-    termination;
-    unreliableMessages;
-    terminalError;
-    role;
-    sendDirection;
-    receiveDirection;
-    h3;
-    sendRoots = new Map();
-    receiveRoots = new Map();
-    sendEpoch = 0;
-    receiveEpoch = 0;
-    controlSendEpoch = 0;
-    controlSendSequence = 0n;
-    controlReceiveEpoch = 0;
-    controlReceiveSequence = 0n;
-    controlWriteTail = Promise.resolve();
-    controlTerminalSealed = false;
-    nextLogicalID;
-    receivedGoAway = false;
-    receivedGoAwayLastAccepted = 0n;
-    receivedGoAwayReason = 0;
-    sentGoAway = false;
-    sentGoAwayLastAccepted = 0n;
-    sentGoAwayReason = 0;
-    closePromise;
-    lifecycle = "opening";
-    sentSessionClose = false;
-    sessionCloseCommitted = false;
-    peerSessionClose = deferred();
-    streams = new Map();
-    releasedStreams = new Map();
-    releasedStreamCleanup = releasedStreamCleanup(this.releasedStreams);
-    peerLedger;
-    outboundLedger;
-    incoming = new AsyncQueue();
-    outboundPermits;
-    inboundPermits;
-    pings = new Map();
-    backgroundTasks = new Set();
-    nextPing = 1n;
-    rpcActivation = deferred();
-    rpcStreamPromise;
-    rpcServing = false;
-    rekeyTail = Promise.resolve();
-    nextTransition = 1n;
-    receiveTransition = 0n;
-    pendingSessionRekey;
-    lastSessionRekeyACK;
-    preparingSendEpoch;
-    pendingReceiveEpoch;
-    openFrozen = false;
-    openGate = deferred();
-    outboundFrontierChanged = deferred();
-    activeInboundResponders = 0;
-    localResponderFrozen = false;
-    peerResponderFrozen = false;
-    responderChanged = deferred();
-    idleWatchdogStarted = false;
-    idleTimerCancel;
-    terminationState = deferred();
-    terminationController = new AbortController();
-    rpcRouter;
-    constructor(carrier, control, controlReader, config, material) {
-        this.carrier = carrier;
-        this.control = control;
-        this.controlReader = controlReader;
-        this.config = config;
-        this.path = config.path;
-        this.termination = this.terminationState.promise;
-        this.endpointInstanceId = config.path === "tunnel" ? config.expectedPeerEndpointInstanceID : undefined;
-        this.role = config.role === "client" ? 1 : 2;
-        this.sendDirection = this.role === 1 ? DirectionV2.ClientToServer : DirectionV2.ServerToClient;
-        this.receiveDirection = this.role === 1 ? DirectionV2.ServerToClient : DirectionV2.ClientToServer;
-        this.nextLogicalID = this.role === 1 ? 1n : 2n;
-        this.peerLedger = new StreamLifetimeLedgerV2(this.role === 1 ? 2 : 1);
-        this.outboundLedger = new StreamLifetimeLedgerV2(this.role);
-        this.h3 = material.h3.slice();
-        this.sendRoots.set(0, deriveEpochZero(material.sessionPRK, this.sendDirection));
-        this.receiveRoots.set(0, deriveEpochZero(material.sessionPRK, this.receiveDirection));
-        this.unreliableMessages = (material.selectedFeatures & UNRELIABLE_MESSAGES_FEATURE_V2) !== 0
-            ? createInternalUnreliableMessageChannelV2({
-                transport: requireUnreliableDatagrams(carrier),
-                suite: config.suite,
-                h3: this.h3,
-                sendDirection: this.sendDirection,
-                receiveDirection: this.receiveDirection,
-                currentSendEpoch: () => ({
-                    epoch: this.sendEpoch,
-                    epochSecret: this.rootForSend(this.sendEpoch).epochSecret,
-                }),
-                receiveEpochSecret: (epoch) => epoch <= this.receiveEpoch && epoch + 1 >= this.receiveEpoch
-                    ? this.receiveRoots.get(epoch)?.epochSecret
-                    : undefined,
-            })
-            : undefined;
-        this.outboundPermits = new AsyncSemaphore(config.maxInboundStreams);
-        this.inboundPermits = new AsyncSemaphore(config.maxInboundStreams);
-        this.rpcRouter = config.rpcRouter ?? new RpcRouter();
-        const rpcReadState = { reader: undefined };
-        const rpcClient = new RpcClient(async (length) => {
-            await this.rpcActivation.promise;
-            const stream = await this.ensureRPCStream();
-            rpcReadState.reader ??= new ExactReader(stream);
-            return await rpcReadState.reader.readExactly(length);
-        }, async (payload) => {
-            this.rpcActivation.resolve();
-            const stream = await this.ensureRPCStream();
-            await stream.write(payload);
-        }, { onTerminal: (error) => this.fail(error) });
-        this.rpc = new SessionRpcPeerV2(rpcClient, this.rpcRouter);
-    }
-    async openStream(kind, options = {}) {
-        if (kind === RESERVED_RPC_KIND)
-            throw new SessionV2Error("open_rejected", "reserved RPC stream kind");
-        return await this.openLogicalStream(kind, options, false);
-    }
-    async acceptStream(options = {}) {
-        this.assertOpen();
-        return await this.incoming.shift(options.signal);
-    }
-    async probeLiveness(options = {}) {
-        this.assertOpen();
-        throwIfAborted(options.signal);
-        const nonce = this.nextPing++;
-        const pending = deferred();
-        this.pings.set(nonce, pending);
-        const started = this.config.runtime.monotonicMilliseconds();
-        try {
-            await this.sendControl(InnerTypeV2.Ping, u64(nonce), options.signal);
-            await raceAbort(pending.promise, options.signal);
-            return Math.max(0, this.config.runtime.monotonicMilliseconds() - started);
-        }
-        finally {
-            this.pings.delete(nonce);
-        }
-    }
-    async rekey(options = {}) {
-        this.assertOpen();
-        throwIfAborted(options.signal);
-        const task = this.rekeyTail.then(async () => {
-            throwIfAborted(options.signal);
-            await this.rekeyOnce(options);
-        });
-        this.rekeyTail = task.catch(() => undefined);
-        await raceAbort(task, options.signal);
-    }
-    close() {
-        if (this.closePromise === undefined) {
-            this.beginClosing();
-            this.closePromise = this.closeOnce();
-        }
-        return this.closePromise;
-    }
-    start() {
-        if (this.lifecycle !== "opening")
-            return;
-        this.lifecycle = "open";
-        this.startIdleWatchdog();
-        void this.controlLoop();
-        void this.acceptCarrierLoop();
-        void this.carrier.waitTermination().then(() => this.fail(new CarrierError("closed", "carrier session terminated"), false), (error) => this.fail(asError(error), false));
-    }
-    rootForSend(epoch) {
-        const roots = this.sendRoots.get(epoch);
-        if (roots === undefined)
-            throw protocolError("missing send epoch roots");
-        return roots;
-    }
-    rootForReceive(epoch) {
-        const roots = this.receiveRoots.get(epoch);
-        if (roots === undefined)
-            throw protocolError("missing receive epoch roots");
-        return roots;
-    }
-    hasReceiveRoots(epoch) {
-        return this.receiveRoots.has(epoch);
-    }
-    installReceiveRoots(epoch, roots) {
-        const existing = this.receiveRoots.get(epoch);
-        if (existing !== undefined && !bytesEqual(existing.epochSecret, roots.epochSecret)) {
-            throw protocolError("conflicting receive epoch roots");
-        }
-        this.receiveRoots.set(epoch, roots);
-    }
-    transcriptHash() {
-        return this.h3;
-    }
-    receiveDirectionValue() {
-        return this.receiveDirection;
-    }
-    terminationSignal() {
-        return this.terminationController.signal;
-    }
-    async sendStreamRecord(stream, type, payload, signal) {
-        this.assertOpen();
-        const inner = encodeInnerRecordV2(type, payload);
-        const roots = this.rootForSend(stream.sendEpoch);
-        const material = deriveStreamMaterial(roots.streamRoot, this.h3, stream.id, this.sendDirection, stream.sendEpoch);
-        const header = {
-            epoch: stream.sendEpoch,
-            sequence: stream.sendSequence,
-            ciphertextLength: inner.length + 16,
-        };
-        const ciphertext = sealRecord(this.config.suite, material, this.h3, stream.id, this.sendDirection, header, inner);
-        stream.sendSequence += 1n;
-        await writeAll(stream.carrier, concat(encodeRecordHeader(header), ciphertext), signal);
-        this.markAuthenticatedActivity();
-    }
-    async readStreamRecord(stream) {
-        const header = decodeRecordHeader(await stream.reader.readExactly(24));
-        const priorACK = stream.priorACK !== undefined &&
-            header.epoch === stream.priorACK.epoch && header.sequence === stream.priorACK.sequence;
-        if (!priorACK && (header.epoch !== stream.receiveEpoch || header.sequence !== stream.receiveSequence)) {
-            throw protocolError("unexpected stream epoch or sequence");
-        }
-        const roots = this.rootForReceive(header.epoch);
-        const material = deriveStreamMaterial(roots.streamRoot, this.h3, stream.id, this.receiveDirection, header.epoch);
-        const ciphertext = await stream.reader.readExactly(header.ciphertextLength);
-        const inner = decodeInnerRecordV2(openRecord(this.config.suite, material, this.h3, stream.id, this.receiveDirection, header, ciphertext));
-        if (priorACK) {
-            if (inner.type !== InnerTypeV2.StreamKeyUpdateACK)
-                throw protocolError("late old-epoch record is not rekey ACK");
-            stream.priorACK = undefined;
-            this.cleanupEpochRoots();
-        }
-        else {
-            stream.receiveSequence += 1n;
-        }
-        this.markAuthenticatedActivity();
-        return { ...inner, header };
-    }
-    async localReset(stream, error) {
-        if (!stream.markTerminal(error))
-            return;
-        this.releaseStream(stream);
-        let controlConfirmed = false;
-        try {
-            if (await this.sendControlCleanup(InnerTypeV2.StreamReset, idReason(stream.id, 6))) {
-                this.commitLocalReset(stream.id);
-                if (stream.hasRemoteFIN())
-                    controlConfirmed = await this.confirmControlDelivery();
-            }
-        }
-        catch (cause) {
-            this.fail(asError(cause));
-        }
-        if (controlConfirmed) {
-            await stream.carrier.closeWrite().catch(async () => await stream.carrier.reset().catch(() => undefined));
-        }
-        else {
-            await stream.carrier.reset().catch(() => undefined);
-        }
-    }
-    releaseStream(stream) {
-        if (stream.terminalError !== undefined) {
-            this.releasedStreams.delete(stream.id);
-            this.releasedStreamCleanup.unregister(stream);
-        }
-        if (this.streams.get(stream.id) !== stream)
-            return;
-        this.streams.delete(stream.id);
-        if (stream.terminalError === undefined) {
-            this.releasedStreams.set(stream.id, new WeakRef(stream));
-            this.releasedStreamCleanup.register(stream, stream.id, stream);
-        }
-        stream.releasePermit();
-        this.cleanupEpochRoots();
-    }
-    async confirmControlDelivery() {
-        if (this.lifecycle !== "open" || this.controlTerminalSealed)
-            return false;
-        const nonce = this.nextPing++;
-        const pending = deferred();
-        this.pings.set(nonce, pending);
-        try {
-            await this.sendControl(InnerTypeV2.Ping, u64(nonce));
-            return await resolveWithin(pending.promise, DEFAULT_CONTROL_CONFIRM_TIMEOUT_MS);
-        }
-        finally {
-            this.pings.delete(nonce);
-        }
-    }
-    async openLogicalStream(kind, options, internal) {
-        this.assertOpen();
-        throwIfAborted(options.signal);
-        await this.waitOpenGate(options.signal);
-        const releasePermit = internal ? () => undefined : await this.outboundPermits.acquire(options.signal);
-        let stream;
-        let carrierStream;
-        let id;
-        let ledgerAllocated = false;
-        try {
-            this.assertOpen();
-            await this.waitOpenGate(options.signal);
-            if (this.sentGoAway || this.receivedGoAway)
-                throw new SessionV2Error("going_away", "session is going away");
-            id = this.nextLogicalID;
-            if (id > maxLogicalStreamIDV2(this.role)) {
-                await this.sendGoAway(5);
-                throw new SessionV2Error("resource_exhausted", "logical stream lifetime ledger exhausted");
-            }
-            this.nextLogicalID += 2n;
-            const setupAction = this.outboundLedger.validFSS2(id);
-            ledgerAllocated = true;
-            if (setupAction === "reset") {
-                this.notifyOutboundFrontierChanged();
-                throw new SessionV2Error("closed", "logical stream identity was already reset by peer");
-            }
-            carrierStream = await this.carrier.openStream(options);
-            if (!this.localOpeningAllowedAfterGoAway(id)) {
-                throw new SessionV2Error("going_away", "logical stream is beyond the peer GOAWAY boundary");
-            }
-            const roots = this.rootForSend(this.sendEpoch);
-            const unsigned = {
-                openerRole: this.role,
-                logicalStreamID: id,
-                initialSendEpoch: this.sendEpoch,
-                setupMAC: new Uint8Array(32),
-            };
-            const prefaceRaw = encodeSetupPreface({
-                ...unsigned,
-                setupMAC: computeSetupMAC(roots.setupRoot, this.h3, unsigned),
-            });
-            await writeAll(carrierStream, prefaceRaw, options.signal);
-            if (!this.localOpeningAllowedAfterGoAway(id)) {
-                throw new SessionV2Error("going_away", "logical stream is beyond the peer GOAWAY boundary");
-            }
-            const metadata = encodeMetadata(options.metadata ?? {});
-            const openRaw = encodeOpenPayload({
-                logicalStreamID: id,
-                fss2Hash: computeFSS2HashV2(prefaceRaw),
-                kind,
-                metadata,
-            });
-            stream = new EncryptedStreamV2(this, carrierStream, id, kind, this.sendEpoch, this.receiveEpoch, releasePermit);
-            this.streams.set(id, stream);
-            stream.setOpenHash(computeOpenHashV2(openRaw));
-            await stream.send(InnerTypeV2.Open, openRaw, options.signal);
-            stream.startPump();
-            await raceAbort(stream.opened.promise, options.signal);
-            if (!this.localOpeningAllowedAfterGoAway(id)) {
-                throw new SessionV2Error("going_away", "logical stream is beyond the peer GOAWAY boundary");
-            }
-            return stream;
-        }
-        catch (error) {
-            if (stream !== undefined)
-                await this.localReset(stream, asError(error));
-            else {
-                await carrierStream?.reset().catch(() => undefined);
-                if (id !== undefined && ledgerAllocated) {
-                    await this.commitOutboundReset(id).catch((cause) => this.fail(asError(cause)));
-                }
-                releasePermit();
-            }
-            throw error;
-        }
-    }
-    ensureRPCStream() {
-        this.rpcActivation.resolve();
-        this.rpcStreamPromise ??= this.openLogicalStream(RESERVED_RPC_KIND, {}, true);
-        return this.rpcStreamPromise;
-    }
-    async acceptCarrierLoop() {
-        try {
-            while (this.lifecycle === "open") {
-                const carrierStream = await this.carrier.acceptStream();
-                void this.acceptCarrierStream(carrierStream).catch((error) => {
-                    void carrierStream.reset();
-                    if (error instanceof StreamLifetimeLedgerV2Error && error.code === "duplicate") {
-                        this.fail(protocolError(error.message));
-                    }
-                });
-            }
-        }
-        catch (error) {
-            if (this.lifecycle !== "closed")
-                this.fail(asError(error));
-        }
-    }
-    async acceptCarrierStream(carrierStream) {
-        let responderHeld = false;
-        let ledgerID;
-        try {
-            this.assertOpen();
-            await this.enterInboundResponder();
-            responderHeld = true;
-            const reader = new ExactReader(carrierStream);
-            let prefaceRaw;
-            let preface;
-            prefaceRaw = await reader.readExactly(56);
-            preface = decodeSetupPrefaceV2(prefaceRaw);
-            const peerRole = this.role === 1 ? 2 : 1;
-            if (preface.openerRole !== peerRole || preface.initialSendEpoch !== this.receiveEpoch) {
-                await carrierStream.reset().catch(() => undefined);
-                return;
-            }
-            const receiveRoots = this.rootForReceive(preface.initialSendEpoch);
-            if (!verifySetupMAC(receiveRoots.setupRoot, this.h3, preface) || !this.acceptsPeerStreamAfterGoAway(preface.logicalStreamID)) {
-                await carrierStream.reset().catch(() => undefined);
-                return;
-            }
-            let setupAction;
-            try {
-                setupAction = this.peerLedger.validFSS2(preface.logicalStreamID);
-            }
-            catch (error) {
-                if (error instanceof StreamLifetimeLedgerV2Error && error.code === "duplicate")
-                    throw error;
-                await carrierStream.reset().catch(() => undefined);
-                return;
-            }
-            if (setupAction === "reset") {
-                await carrierStream.reset().catch(() => undefined);
-                return;
-            }
-            ledgerID = preface.logicalStreamID;
-            await this.acceptCarrierStreamAfterFSS2(carrierStream, reader, prefaceRaw, preface);
-        }
-        catch (error) {
-            if (ledgerID !== undefined)
-                await this.resetInboundBeforeDelivery(ledgerID, carrierStream);
-            else
-                await carrierStream.reset().catch(() => undefined);
-            if (error instanceof StreamLifetimeLedgerV2Error && error.code === "duplicate")
-                throw error;
-        }
-        finally {
-            if (responderHeld)
-                this.leaveInboundResponder();
-        }
-    }
-    async acceptCarrierStreamAfterFSS2(carrierStream, reader, prefaceRaw, preface) {
-        this.assertOpen();
-        const temporary = new EncryptedStreamV2(this, carrierStream, preface.logicalStreamID, "", this.sendEpoch, preface.initialSendEpoch, () => undefined, reader);
-        const first = await this.readStreamRecord(temporary);
-        if (first.type !== InnerTypeV2.Open)
-            throw protocolError("OPEN must be first");
-        const open = decodeOpenPayload(first.payload);
-        if (open.logicalStreamID !== preface.logicalStreamID ||
-            !bytesEqual(open.fss2Hash, computeFSS2HashV2(prefaceRaw))) {
-            throw protocolError("OPEN binding mismatch");
-        }
-        this.peerLedger.validOpen(preface.logicalStreamID);
-        const internalRPC = open.kind === RESERVED_RPC_KIND;
-        if (internalRPC && decoder.decode(open.metadata) !== "{}") {
-            await temporary.send(InnerTypeV2.OpenReject, encodeOpenRejectV2(computeOpenHashV2(first.payload), 4));
-            await carrierStream.closeWrite();
-            return;
-        }
-        const releasePermit = internalRPC ? () => undefined : this.inboundPermits.tryAcquire();
-        if (releasePermit === undefined) {
-            await temporary.send(InnerTypeV2.OpenReject, encodeOpenRejectV2(computeOpenHashV2(first.payload), 2));
-            await carrierStream.closeWrite();
-            return;
-        }
-        const stream = new EncryptedStreamV2(this, carrierStream, preface.logicalStreamID, open.kind, this.sendEpoch, preface.initialSendEpoch, releasePermit, reader);
-        this.assertOpen();
-        stream.receiveSequence = temporary.receiveSequence;
-        this.streams.set(stream.id, stream);
-        await stream.send(InnerTypeV2.OpenACK, encodeOpenACKV2(computeOpenHashV2(first.payload)));
-        stream.markOpen();
-        stream.startPump();
-        if (!this.acceptsPeerStreamAfterGoAway(stream.id)) {
-            await this.localReset(stream, new SessionV2Error("going_away", "peer stream exceeds the sent GOAWAY boundary"));
-            return;
-        }
-        if (internalRPC) {
-            if (this.rpcServing) {
-                await this.localReset(stream, protocolError("duplicate reserved RPC stream"));
-                return;
-            }
-            this.rpcServing = true;
-            const rpcReader = new ExactReader(stream);
-            const server = new RpcServer({
-                readExactly: async (length) => await rpcReader.readExactly(length),
-                write: async (payload) => { await stream.write(payload); },
-                close: () => { void stream.reset(); },
-            }, this.config.rpcServerOptions, this.rpcRouter);
-            void server.serve().catch((error) => {
-                if (this.lifecycle !== "closed")
-                    this.fail(asError(error));
-            });
-            return;
-        }
-        this.incoming.push({
-            id: stream.id,
-            kind: stream.kind,
-            metadata: decodeMetadata(open.metadata),
-            stream,
-        });
-    }
-    async resetInboundBeforeDelivery(id, carrierStream) {
-        await carrierStream.reset().catch(() => undefined);
-        try {
-            if (await this.sendControlCleanup(InnerTypeV2.StreamReset, idReason(id, 3))) {
-                this.peerLedger.localResetCommitted(id);
-            }
-        }
-        catch (error) {
-            this.fail(asError(error));
-        }
-    }
-    async sendControl(type, payload, signal) {
-        if (this.controlTerminalSealed) {
-            throw this.terminalError ?? new SessionV2Error("closed", "Flowersec v2 control stream is sealed");
-        }
-        const task = this.controlWriteTail.then(async () => {
-            if (this.lifecycle === "closed")
-                throw this.terminalError ?? new SessionV2Error("closed", "Flowersec v2 session closed");
-            await this.writeControl(type, payload, signal);
-        });
-        this.controlWriteTail = task.catch(() => undefined);
-        await task;
-    }
-    async sendControlResponse(type, payload) {
-        if (this.lifecycle !== "open" || this.controlTerminalSealed)
-            return false;
-        const task = this.controlWriteTail.then(async () => {
-            if (this.lifecycle !== "open" || this.controlTerminalSealed)
-                return false;
-            await this.writeControl(type, payload);
-            return true;
-        });
-        this.controlWriteTail = task.then(() => undefined, () => undefined);
-        return await task;
-    }
-    async sendControlCleanup(type, payload) {
-        if (this.controlTerminalSealed || this.lifecycle === "closed")
-            return false;
-        const task = this.controlWriteTail.then(async () => {
-            if (this.lifecycle === "closed")
-                return false;
-            await this.writeControl(type, payload);
-            return true;
-        });
-        this.controlWriteTail = task.then(() => undefined, () => undefined);
-        return await task;
-    }
-    sendTerminalControl(reason) {
-        if (this.controlTerminalSealed)
-            return this.controlWriteTail;
-        this.controlTerminalSealed = true;
-        const task = this.controlWriteTail.then(async () => {
-            if (this.lifecycle === "closed")
-                throw this.terminalError ?? new SessionV2Error("closed", "Flowersec v2 session closed");
-            if (!this.sentGoAway) {
-                this.sentGoAway = true;
-                this.sentGoAwayLastAccepted = this.peerLedger.frontier;
-                this.sentGoAwayReason = reason;
-            }
-            await this.writeControl(InnerTypeV2.GoAway, idReason(this.sentGoAwayLastAccepted, this.sentGoAwayReason));
-            if (!this.sentSessionClose) {
-                this.sentSessionClose = true;
-                await this.writeControl(InnerTypeV2.SessionClose, Uint8Array.of(0, reason));
-                this.sessionCloseCommitted = true;
-            }
-            await this.control.closeWrite();
-        });
-        this.controlWriteTail = task.catch(() => undefined);
-        return task;
-    }
-    async writeControl(type, payload, signal) {
-        const inner = encodeInnerRecordV2(type, payload);
-        const roots = this.rootForSend(this.controlSendEpoch);
-        const material = deriveControlMaterial(roots.controlRoot, this.h3, this.sendDirection, this.controlSendEpoch);
-        const header = {
-            epoch: this.controlSendEpoch,
-            sequence: this.controlSendSequence,
-            ciphertextLength: inner.length + 16,
-        };
-        const ciphertext = sealRecord(this.config.suite, material, this.h3, 0n, this.sendDirection, header, inner);
-        this.controlSendSequence += 1n;
-        await writeAll(this.control, concat(encodeRecordHeader(header), ciphertext), signal);
-        this.markAuthenticatedActivity();
-    }
-    async readControl() {
-        const header = decodeRecordHeader(await this.controlReader.readExactly(24));
-        const cutover = header.epoch === this.controlReceiveEpoch + 1 &&
-            header.epoch <= this.receiveEpoch && header.sequence === 0n;
-        if (!cutover && (header.epoch !== this.controlReceiveEpoch || header.sequence !== this.controlReceiveSequence)) {
-            throw protocolError("unexpected control epoch or sequence");
-        }
-        const roots = this.rootForReceive(header.epoch);
-        const material = deriveControlMaterial(roots.controlRoot, this.h3, this.receiveDirection, header.epoch);
-        const ciphertext = await this.controlReader.readExactly(header.ciphertextLength);
-        const inner = decodeInnerRecordV2(openRecord(this.config.suite, material, this.h3, 0n, this.receiveDirection, header, ciphertext));
-        if (cutover) {
-            this.controlReceiveEpoch = header.epoch;
-            this.controlReceiveSequence = 1n;
-            this.cleanupEpochRoots();
-        }
-        else {
-            this.controlReceiveSequence += 1n;
-        }
-        this.markAuthenticatedActivity();
-        return inner;
-    }
-    async controlLoop() {
-        try {
-            while (this.lifecycle !== "closed") {
-                const record = await this.readControl();
-                switch (record.type) {
-                    case InnerTypeV2.Ping:
-                        await this.sendControlResponse(InnerTypeV2.Pong, record.payload);
-                        break;
-                    case InnerTypeV2.Pong:
-                        this.pings.get(readU64(record.payload))?.resolve();
-                        break;
-                    case InnerTypeV2.StreamReset: {
-                        const { id, reason } = parseIDReason(record.payload);
-                        if (id === 0n || reason === 0)
-                            throw protocolError("invalid STREAM_RESET");
-                        const stream = this.streams.get(id);
-                        if (stream !== undefined) {
-                            stream.peerReset(new SessionV2Error("stream_reset", "logical stream reset by peer"));
-                        }
-                        else {
-                            const released = this.releasedStreams.get(id);
-                            if (released !== undefined) {
-                                this.releasedStreams.delete(id);
-                                const releasedStream = released.deref();
-                                if (releasedStream !== undefined) {
-                                    this.releasedStreamCleanup.unregister(releasedStream);
-                                    releasedStream.markTerminal(new SessionV2Error("stream_reset", "logical stream reset by peer"));
-                                }
-                            }
-                        }
-                        if (this.isLocalLogicalID(id)) {
-                            this.outboundLedger.peerReset(id);
-                            this.notifyOutboundFrontierChanged();
-                        }
-                        else {
-                            this.peerLedger.peerReset(id);
-                        }
-                        break;
-                    }
-                    case InnerTypeV2.SessionKeyUpdate:
-                        await this.receiveSessionRekey(record.payload);
-                        break;
-                    case InnerTypeV2.SessionKeyUpdateACK:
-                        this.receiveSessionRekeyACK(record.payload);
-                        break;
-                    case InnerTypeV2.GoAway:
-                        await this.receiveGoAway(record.payload);
-                        break;
-                    case InnerTypeV2.SessionClose:
-                        if (record.payload.length !== 2 || readU16(record.payload, 0) === 0) {
-                            throw protocolError("invalid SESSION_CLOSE");
-                        }
-                        this.peerSessionClose.resolve();
-                        await this.close();
-                        throw new SessionV2Error("closed", "Flowersec v2 session closed by peer");
-                    default:
-                        throw protocolError(`unexpected control type ${record.type}`);
-                }
-            }
-        }
-        catch (error) {
-            if (this.lifecycle !== "closed")
-                this.fail(asError(error));
-        }
-    }
-    async closeOnce() {
-        if (this.lifecycle === "closed")
-            return;
-        const closed = new SessionV2Error("closed", "Flowersec v2 session closed");
-        const terminal = this.sendTerminalControl(1);
-        const work = (async () => {
-            try {
-                await terminal;
-            }
-            catch {
-                // Closing is best-effort once the bounded shutdown has started.
-            }
-            await this.peerSessionClose.promise;
-            this.fail(closed, false);
-            await this.carrier.close({ code: 1, reason: "session closed" }).catch(() => undefined);
-        })();
-        if (!await settleWithin(work, sessionCloseTimeoutMs(this.config))) {
-            this.carrier.abort({ code: 1, reason: "session close deadline exceeded" });
-            this.peerSessionClose.resolve();
-            void work.catch(() => undefined);
-        }
-        this.fail(closed, false);
-    }
-    async waitTermination() {
-        return await this.termination;
-    }
-    async rekeyOnce(options) {
-        this.assertOpen();
-        throwIfAborted(options.signal);
-        this.openFrozen = true;
-        this.openGate = deferred();
-        let committed = false;
-        const prepareDeadline = createSessionDeadline(this.config, "rekey_prepare");
-        const prepareSignal = combineSignals(options.signal, prepareDeadline.signal);
-        let completionDeadline;
-        let completionSignal;
-        let respondersFrozen = false;
-        try {
-            await this.freezeInboundResponders(false, prepareSignal.signal);
-            respondersFrozen = true;
-            const currentEpoch = this.sendEpoch;
-            if (currentEpoch === 0xffffffff)
-                throw new SessionV2Error("resource_exhausted", "session epoch exhausted");
-            const nextEpoch = currentEpoch + 1;
-            const currentRoots = this.rootForSend(currentEpoch);
-            const nextRoots = deriveEpochRoots(deriveNextEpoch(currentRoots.rekeyRoot, this.h3, this.sendDirection, nextEpoch));
-            this.sendRoots.set(nextEpoch, nextRoots);
-            this.preparingSendEpoch = nextEpoch;
-            const transition = this.nextTransition++;
-            const watermark = this.nextLogicalID > 2n ? this.nextLogicalID - 2n : 0n;
-            await this.waitOutboundFrontier(watermark, prepareSignal.signal);
-            prepareSignal.cancel();
-            prepareDeadline.cancel();
-            completionDeadline = createSessionDeadline(this.config, "rekey_completion");
-            completionSignal = combineSignals(options.signal, completionDeadline.signal);
-            committed = true;
-            throwIfAborted(completionSignal.signal);
-            const payload = concat(u64(transition), u32(nextEpoch), u64(watermark));
-            const active = [...this.streams.values()].filter((stream) => stream.canRekeySend());
-            const updates = active.map((stream) => stream.startSendRekey(transition, nextEpoch));
-            await Promise.all(updates.map(async (update) => await raceAbort(update.armed.promise, completionSignal.signal)));
-            const pending = {
-                payload,
-                epoch: nextEpoch,
-                acknowledged: deferred(),
-                committed: { value: false },
-            };
-            this.pendingSessionRekey = pending;
-            this.preparingSendEpoch = undefined;
-            await this.sendControl(InnerTypeV2.SessionKeyUpdate, payload);
-            await raceAbort(pending.acknowledged.promise, completionSignal.signal);
-            await Promise.all(updates.map(async (update) => await raceAbort(update.done.promise, completionSignal.signal)));
-            if (this.pendingSessionRekey === pending)
-                this.pendingSessionRekey = undefined;
-            this.cleanupEpochRoots();
-        }
-        catch (error) {
-            if (committed)
-                this.fail(asError(error));
-            throw error;
-        }
-        finally {
-            prepareSignal.cancel();
-            prepareDeadline.cancel();
-            completionSignal?.cancel();
-            completionDeadline?.cancel();
-            this.openFrozen = false;
-            this.openGate.resolve();
-            if (respondersFrozen)
-                this.unfreezeInboundResponders(false);
-            this.preparingSendEpoch = undefined;
-            this.cleanupEpochRoots();
-        }
-    }
-    async receiveSessionRekey(payload) {
-        const completionDeadline = createSessionDeadline(this.config, "rekey_completion");
-        let respondersFrozen = false;
-        try {
-            await this.freezeInboundResponders(true, completionDeadline.signal);
-            respondersFrozen = true;
-            await this.receiveSessionRekeyBeforeDeadline(payload, completionDeadline.signal);
-        }
-        finally {
-            if (respondersFrozen)
-                this.unfreezeInboundResponders(true);
-            completionDeadline.cancel();
-        }
-    }
-    async enterInboundResponder() {
-        while (this.localResponderFrozen || this.peerResponderFrozen) {
-            this.assertOpen();
-            await this.responderChanged.promise;
-        }
-        this.assertOpen();
-        this.activeInboundResponders++;
-        this.notifyResponderChanged();
-    }
-    leaveInboundResponder() {
-        if (this.activeInboundResponders === 0)
-            return;
-        this.activeInboundResponders--;
-        this.notifyResponderChanged();
-    }
-    async freezeInboundResponders(peer, signal) {
-        if (peer)
-            this.peerResponderFrozen = true;
-        else
-            this.localResponderFrozen = true;
-        this.notifyResponderChanged();
-        while (this.activeInboundResponders !== 0) {
-            await raceAbort(this.responderChanged.promise, signal);
-            this.assertOpen();
-        }
-    }
-    unfreezeInboundResponders(peer) {
-        if (peer)
-            this.peerResponderFrozen = false;
-        else
-            this.localResponderFrozen = false;
-        this.notifyResponderChanged();
-    }
-    notifyResponderChanged() {
-        this.responderChanged.resolve();
-        this.responderChanged = deferred();
-    }
-    async receiveSessionRekeyBeforeDeadline(payload, signal) {
-        throwIfAborted(signal);
-        const transition = readU64(payload);
-        const nextEpoch = readU32(payload, 8);
-        const watermark = readU64At(payload, 12);
-        if (payload.length !== 20 || transition !== this.receiveTransition + 1n || nextEpoch !== this.receiveEpoch + 1) {
-            throw protocolError("invalid SESSION_KEY_UPDATE");
-        }
-        if (watermark !== this.peerLedger.frontier)
-            throw protocolError("SESSION_KEY_UPDATE watermark mismatch");
-        this.pendingReceiveEpoch = nextEpoch;
-        const current = this.rootForReceive(this.receiveEpoch);
-        if (!this.receiveRoots.has(nextEpoch)) {
-            this.receiveRoots.set(nextEpoch, deriveEpochRoots(deriveNextEpoch(current.rekeyRoot, this.h3, this.receiveDirection, nextEpoch)));
-        }
-        const streams = [...this.streams.values()];
-        await Promise.all(streams.map(async (stream) => await stream.waitReceiveRekey(transition, nextEpoch, signal)));
-        const acknowledged = await raceAbort(this.sendControlResponse(InnerTypeV2.SessionKeyUpdateACK, payload), signal);
-        if (!acknowledged) {
-            this.pendingReceiveEpoch = undefined;
-            this.cleanupEpochRoots();
-            return;
-        }
-        throwIfAborted(signal);
-        this.receiveEpoch = nextEpoch;
-        this.receiveTransition = transition;
-        this.pendingReceiveEpoch = undefined;
-        for (const stream of streams)
-            stream.publishReceiveRekey(transition, nextEpoch);
-        this.cleanupEpochRoots();
-    }
-    receiveSessionRekeyACK(payload) {
-        const pending = this.pendingSessionRekey;
-        if (pending === undefined) {
-            if (this.lastSessionRekeyACK !== undefined && bytesEqual(payload, this.lastSessionRekeyACK))
-                return;
-            throw protocolError("unexpected SESSION_KEY_UPDATE_ACK");
-        }
-        if (!bytesEqual(payload, pending.payload))
-            throw protocolError("unexpected SESSION_KEY_UPDATE_ACK");
-        if (pending.committed.value)
-            return;
-        pending.committed.value = true;
-        this.sendEpoch = pending.epoch;
-        this.controlSendEpoch = pending.epoch;
-        this.controlSendSequence = 0n;
-        this.lastSessionRekeyACK = payload.slice();
-        pending.acknowledged.resolve();
-        this.cleanupEpochRoots();
-    }
-    async waitOpenGate(signal) {
-        while (this.openFrozen)
-            await raceAbort(this.openGate.promise, signal);
-    }
-    resolveOutboundOpen(id) {
-        this.outboundLedger.validOpen(id);
-        this.notifyOutboundFrontierChanged();
-    }
-    async waitOutboundFrontier(watermark, signal) {
-        while (this.outboundLedger.frontier !== watermark) {
-            if (this.outboundLedger.frontier > watermark)
-                throw protocolError("outbound frontier exceeded watermark");
-            await raceAbort(this.outboundFrontierChanged.promise, signal);
-        }
-    }
-    async commitOutboundReset(id) {
-        if (await this.sendControlCleanup(InnerTypeV2.StreamReset, idReason(id, 6))) {
-            this.outboundLedger.localResetCommitted(id);
-            this.notifyOutboundFrontierChanged();
-        }
-    }
-    commitLocalReset(id) {
-        if (this.isLocalLogicalID(id)) {
-            this.outboundLedger.localResetCommitted(id);
-            this.notifyOutboundFrontierChanged();
-            return;
-        }
-        this.peerLedger.localResetCommitted(id);
-    }
-    notifyOutboundFrontierChanged() {
-        this.outboundFrontierChanged.resolve();
-        this.outboundFrontierChanged = deferred();
-    }
-    isLocalLogicalID(id) {
-        return id > 0n && (this.role === 1 ? (id & 1n) === 1n : (id & 1n) === 0n);
-    }
-    localOpenHighWatermark() {
-        const first = this.role === 1 ? 1n : 2n;
-        return this.nextLogicalID === first ? 0n : this.nextLogicalID - 2n;
-    }
-    validGoAwayBoundary(lastAccepted) {
-        if (lastAccepted === 0n)
-            return true;
-        return this.isLocalLogicalID(lastAccepted) && lastAccepted <= this.localOpenHighWatermark();
-    }
-    async sendGoAway(reason) {
-        if (!Number.isInteger(reason) || reason < 1 || reason > 0xffff)
-            throw protocolError("invalid GOAWAY reason");
-        if (this.sentGoAway) {
-            if (this.sentGoAwayReason !== reason)
-                throw protocolError("conflicting local GOAWAY reason");
-            return;
-        }
-        const lastAccepted = this.peerLedger.frontier;
-        this.sentGoAway = true;
-        this.sentGoAwayLastAccepted = lastAccepted;
-        this.sentGoAwayReason = reason;
-        await this.sendControl(InnerTypeV2.GoAway, idReason(lastAccepted, reason));
-    }
-    async receiveGoAway(payload) {
-        const { id: lastAccepted, reason } = parseIDReason(payload);
-        if (reason === 0 || !this.validGoAwayBoundary(lastAccepted))
-            throw protocolError("invalid GOAWAY boundary");
-        if (this.receivedGoAway) {
-            if (this.receivedGoAwayLastAccepted !== lastAccepted || this.receivedGoAwayReason !== reason) {
-                throw protocolError("conflicting GOAWAY");
-            }
-            return;
-        }
-        this.receivedGoAway = true;
-        this.receivedGoAwayLastAccepted = lastAccepted;
-        this.receivedGoAwayReason = reason;
-        const excluded = [...this.streams.values()].filter((stream) => this.isLocalLogicalID(stream.id) && stream.id > lastAccepted);
-        for (const stream of excluded) {
-            this.trackBackground(this.localReset(stream, new SessionV2Error("going_away", "logical stream exceeds peer GOAWAY boundary")));
-        }
-    }
-    trackBackground(task) {
-        this.backgroundTasks.add(task);
-        void task.catch((error) => {
-            if (this.lifecycle !== "closed")
-                this.fail(asError(error));
-        }).finally(() => this.backgroundTasks.delete(task));
-    }
-    localOpeningAllowedAfterGoAway(id) {
-        return !this.receivedGoAway || id <= this.receivedGoAwayLastAccepted;
-    }
-    acceptsPeerStreamAfterGoAway(id) {
-        return !this.sentGoAway || id <= this.sentGoAwayLastAccepted;
-    }
-    cleanupEpochRoots() {
-        const sendInUse = new Set([this.sendEpoch, this.controlSendEpoch]);
-        const receiveInUse = new Set([this.receiveEpoch, this.controlReceiveEpoch]);
-        if (this.preparingSendEpoch !== undefined)
-            sendInUse.add(this.preparingSendEpoch);
-        if (this.pendingReceiveEpoch !== undefined)
-            receiveInUse.add(this.pendingReceiveEpoch);
-        if (this.pendingSessionRekey !== undefined)
-            sendInUse.add(this.pendingSessionRekey.epoch);
-        for (const stream of this.streams.values()) {
-            for (const epoch of stream.sendEpochsInUse())
-                sendInUse.add(epoch);
-            for (const epoch of stream.receiveEpochsInUse())
-                receiveInUse.add(epoch);
-        }
-        this.cleanupRootMap(this.sendRoots, sendInUse);
-        this.cleanupRootMap(this.receiveRoots, receiveInUse);
-    }
-    streamEpochStateChanged() {
-        this.cleanupEpochRoots();
-    }
-    cleanupRootMap(roots, inUse) {
-        for (const [epoch, value] of roots) {
-            if (inUse.has(epoch))
-                continue;
-            wipeEpochRoots(value);
-            roots.delete(epoch);
-        }
-    }
-    wipeAllRoots() {
-        for (const roots of this.sendRoots.values())
-            wipeEpochRoots(roots);
-        for (const roots of this.receiveRoots.values())
-            wipeEpochRoots(roots);
-        this.sendRoots.clear();
-        this.receiveRoots.clear();
-    }
-    startIdleWatchdog() {
-        this.idleWatchdogStarted = true;
-        this.markAuthenticatedActivity();
-    }
-    markAuthenticatedActivity() {
-        if (!this.idleWatchdogStarted || this.lifecycle !== "open")
-            return;
-        const timeoutMs = sessionIdleTimeoutMs(this.config);
-        if (timeoutMs === 0)
-            return;
-        this.idleTimerCancel?.();
-        this.idleTimerCancel = scheduleLongTimeout(() => {
-            this.idleTimerCancel = undefined;
-            this.fail(new SessionV2Error("timeout", "Flowersec v2 session idle timeout exceeded"));
-        }, timeoutMs);
-    }
-    fail(error, abortCarrier = true) {
-        if (this.lifecycle === "closed")
-            return;
-        this.terminationController.abort(error);
-        this.controlTerminalSealed = true;
-        this.beginClosing();
-        const normalPeerCarrierClose = this.sessionCloseCommitted && error instanceof CarrierError && error.code === "closed";
-        if (normalPeerCarrierClose)
-            this.peerSessionClose.resolve();
-        this.terminalError = error;
-        this.lifecycle = "closed";
-        this.terminationState.resolve({ error });
-        this.idleTimerCancel?.();
-        this.idleTimerCancel = undefined;
-        this.incoming.fail(error);
-        this.outboundPermits.fail(error);
-        this.inboundPermits.fail(error);
-        this.notifyResponderChanged();
-        for (const ping of this.pings.values())
-            ping.reject(error);
-        this.pings.clear();
-        this.rpc.close();
-        for (const stream of [...this.streams.values()])
-            stream.peerReset(error);
-        for (const released of this.releasedStreams.values()) {
-            const stream = released.deref();
-            if (stream !== undefined)
-                this.releasedStreamCleanup.unregister(stream);
-        }
-        this.releasedStreams.clear();
-        this.wipeAllRoots();
-        this.h3.fill(0);
-        if (abortCarrier && !normalPeerCarrierClose)
-            this.carrier.abort({ code: 6, reason: "session terminated" });
-    }
-    assertOpen() {
-        if (this.lifecycle === "open")
-            return;
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-        throw new SessionV2Error("closed", "Flowersec v2 session closed");
-    }
-    beginClosing() {
-        if (this.lifecycle === "opening" || this.lifecycle === "open")
-            this.lifecycle = "closing";
-    }
-}
-class EncryptedStreamV2 {
-    session;
-    carrier;
-    id;
-    kind;
-    sendEpoch;
-    receiveEpoch;
-    permitRelease;
-    reader;
-    opened = deferred();
-    data = new ByteQueue(MAX_BUFFERED_STREAM_BYTES);
-    terminalError;
-    sendSequence = 0n;
-    receiveSequence = 0n;
-    priorACK;
-    sendTail = Promise.resolve();
-    localFIN = false;
-    remoteFIN = false;
-    pumpStarted = false;
-    permitReleased = false;
-    closeWriteTask;
-    pendingSendRekey;
-    lastSendRekeyACK;
-    receiveRekey;
-    receiveRekeyChanged = deferred();
-    constructor(session, carrier, id, kind, sendEpoch, receiveEpoch, permitRelease, reader) {
-        this.session = session;
-        this.carrier = carrier;
-        this.id = id;
-        this.kind = kind;
-        this.sendEpoch = sendEpoch;
-        this.receiveEpoch = receiveEpoch;
-        this.permitRelease = permitRelease;
-        this.reader = reader ?? new ExactReader(carrier);
-    }
-    async read(options = {}) {
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-        return await this.data.read(options.signal);
-    }
-    async write(payload, options = {}) {
-        if (!(payload instanceof Uint8Array))
-            throw new TypeError("stream write requires Uint8Array");
-        if (payload.length === 0)
-            return 0;
-        throwIfAborted(options.signal);
-        await this.opened.promise;
-        await this.waitSendRekey(options.signal);
-        if (this.localFIN)
-            throw new SessionV2Error("closed", "write after FIN");
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-        const copy = payload.slice();
-        await this.enqueueSend(async () => {
-            try {
-                for (let offset = 0; offset < copy.length; offset += MAX_DATA_BYTES) {
-                    throwIfAborted(options.signal);
-                    await this.session.sendStreamRecord(this, InnerTypeV2.Data, copy.subarray(offset, Math.min(copy.length, offset + MAX_DATA_BYTES)), options.signal);
-                }
-            }
-            catch (error) {
-                const normalized = asError(error);
-                void this.session.localReset(this, normalized);
-                throw normalized;
-            }
-        });
-        return copy.length;
-    }
-    async closeWrite() {
-        await this.opened.promise;
-        await this.waitSendRekey();
-        if (this.localFIN)
-            return;
-        if (this.terminalError !== undefined)
-            throw this.terminalError;
-        this.closeWriteTask ??= this.enqueueSend(async () => {
-            try {
-                if (this.localFIN)
-                    return;
-                await this.session.sendStreamRecord(this, InnerTypeV2.FIN, new Uint8Array());
-                await this.carrier.closeWrite();
-                this.localFIN = true;
-                this.releaseIfClean();
-            }
-            catch (error) {
-                const normalized = asError(error);
-                void this.session.localReset(this, normalized);
-                throw normalized;
-            }
-        });
-        await this.closeWriteTask;
-    }
-    async reset() {
-        await this.session.localReset(this, new SessionV2Error("stream_reset", "logical stream reset"));
-    }
-    async close() {
-        await this.reset();
-    }
-    send(type, payload, signal) {
-        return this.enqueueSend(async () => await this.session.sendStreamRecord(this, type, payload, signal));
-    }
-    canRekeySend() {
-        return this.terminalError === undefined && this.opened.settled && !this.localFIN;
-    }
-    hasRemoteFIN() {
-        return this.remoteFIN;
-    }
-    startSendRekey(transition, epoch) {
-        if (this.pendingSendRekey !== undefined)
-            throw protocolError("overlapping stream rekey");
-        const pending = { transition, epoch, armed: deferred(), done: deferred() };
-        this.pendingSendRekey = pending;
-        void this.enqueueSend(async () => {
-            await this.session.sendStreamRecord(this, InnerTypeV2.StreamKeyUpdate, concat(u64(transition), u32(epoch)));
-            pending.armed.resolve();
-        }).catch((error) => {
-            pending.armed.reject(error);
-            pending.done.reject(error);
-            void this.session.localReset(this, asError(error));
-        });
-        return pending;
-    }
-    async waitReceiveRekey(transition, epoch, signal) {
-        throwIfAborted(signal);
-        if (this.terminalError !== undefined || this.remoteFIN)
-            return;
-        while (true) {
-            const pending = this.receiveRekey;
-            if (pending !== undefined) {
-                if (pending.transition !== transition || pending.epoch !== epoch)
-                    throw protocolError("stream rekey mismatch");
-                await raceAbort(pending.acknowledged.promise, signal);
-                return;
-            }
-            await raceAbort(this.receiveRekeyChanged.promise, signal);
-            if (this.terminalError !== undefined || this.remoteFIN)
-                return;
-        }
-    }
-    publishReceiveRekey(transition, epoch) {
-        if (this.receiveRekey?.transition === transition && this.receiveRekey.epoch === epoch) {
-            this.receiveRekey = undefined;
-        }
-    }
-    notifyReceiveRekeyChanged() {
-        const changed = this.receiveRekeyChanged;
-        this.receiveRekeyChanged = deferred();
-        changed.resolve();
-    }
-    startPump() {
-        if (this.pumpStarted)
-            return;
-        this.pumpStarted = true;
-        void this.pump();
-    }
-    markOpen() {
-        this.opened.resolve();
-    }
-    markTerminal(error) {
-        if (this.terminalError !== undefined)
-            return false;
-        this.terminalError = error;
-        const pendingSendRekey = this.pendingSendRekey;
-        this.pendingSendRekey = undefined;
-        pendingSendRekey?.armed.reject(error);
-        pendingSendRekey?.done.reject(error);
-        this.notifyReceiveRekeyChanged();
-        this.opened.reject(error);
-        this.data.fail(error);
-        return true;
-    }
-    peerReset(error) {
-        if (!this.markTerminal(error))
-            return;
-        this.carrier.abort(error);
-        this.session.releaseStream(this);
-    }
-    carrierReset() {
-        if (!this.markTerminal(new SessionV2Error("stream_reset", "logical stream reset by peer")))
-            return;
-        this.session.releaseStream(this);
-    }
-    abort(error = new SessionV2Error("closed", "logical stream aborted")) {
-        this.peerReset(error);
-    }
-    releasePermit() {
-        if (this.permitReleased)
-            return;
-        this.permitReleased = true;
-        this.permitRelease();
-    }
-    async pump() {
-        try {
-            while (this.terminalError === undefined) {
-                const record = await this.session.readStreamRecord(this);
-                if (!this.opened.settled) {
-                    if (record.type === InnerTypeV2.OpenACK) {
-                        const got = decodeOpenACKV2(record.payload);
-                        if (!bytesEqual(got, this.openedHash()))
-                            throw protocolError("OPEN ACK hash mismatch");
-                        this.session.resolveOutboundOpen(this.id);
-                        this.markOpen();
-                        continue;
-                    }
-                    if (record.type === InnerTypeV2.OpenReject) {
-                        const reject = decodeOpenRejectV2(record.payload);
-                        if (!bytesEqual(reject.openHash, this.openedHash()))
-                            throw protocolError("OPEN REJECT hash mismatch");
-                        this.session.resolveOutboundOpen(this.id);
-                        const error = new SessionV2Error("open_rejected", `logical stream rejected (${reject.reason})`);
-                        this.markTerminal(error);
-                        await this.carrier.closeWrite().catch(() => undefined);
-                        this.session.releaseStream(this);
-                        return;
-                    }
-                    throw protocolError("expected OPEN ACK or REJECT");
-                }
-                switch (record.type) {
-                    case InnerTypeV2.Data:
-                        if (this.remoteFIN)
-                            throw protocolError("DATA after FIN");
-                        await this.data.waitForCapacity(record.payload.length);
-                        this.data.push(record.payload);
-                        break;
-                    case InnerTypeV2.FIN:
-                        if (this.remoteFIN)
-                            throw protocolError("duplicate FIN");
-                        this.remoteFIN = true;
-                        this.data.close();
-                        this.releaseIfClean();
-                        break;
-                    case InnerTypeV2.StreamKeyUpdate:
-                        await this.receiveStreamKeyUpdate(record.payload, record.header);
-                        break;
-                    case InnerTypeV2.StreamKeyUpdateACK:
-                        this.receiveStreamKeyUpdateACK(record.payload);
-                        break;
-                    default:
-                        throw protocolError(`unexpected stream type ${record.type}`);
-                }
-            }
-        }
-        catch (error) {
-            const normalized = asError(error);
-            if (normalized instanceof CarrierError && normalized.code === "reset") {
-                this.carrierReset();
-                return;
-            }
-            if (this.remoteFIN && /closed|EOF/i.test(normalized.message)) {
-                this.releaseIfClean();
-                return;
-            }
-            await this.session.localReset(this, normalized);
-        }
-    }
-    openedHash() {
-        const value = this.openHash;
-        if (value === undefined)
-            throw protocolError("missing OPEN hash");
-        return value;
-    }
-    setOpenHash(value) {
-        this.openHash = value.slice();
-    }
-    enqueueSend(operation) {
-        const task = this.sendTail.then(async () => {
-            if (this.terminalError !== undefined)
-                throw this.terminalError;
-            await operation();
-        });
-        this.sendTail = task.catch(() => undefined);
-        return task;
-    }
-    async waitSendRekey(signal) {
-        while (this.pendingSendRekey !== undefined) {
-            await raceAbort(this.pendingSendRekey.done.promise, signal);
-        }
-    }
-    async receiveStreamKeyUpdate(payload, header) {
-        if (payload.length !== 12 || this.receiveRekey !== undefined)
-            throw protocolError("invalid STREAM_KEY_UPDATE");
-        const transition = readU64(payload);
-        const nextEpoch = readU32(payload, 8);
-        if (transition === 0n || nextEpoch !== this.receiveEpoch + 1)
-            throw protocolError("invalid stream rekey transition");
-        const current = this.session.rootForReceive(this.receiveEpoch);
-        if (!this.session.hasReceiveRoots(nextEpoch)) {
-            this.session.installReceiveRoots(nextEpoch, deriveEpochRoots(deriveNextEpoch(current.rekeyRoot, this.session.transcriptHash(), this.session.receiveDirectionValue(), nextEpoch)));
-        }
-        if (this.pendingSendRekey?.transition === transition && this.pendingSendRekey.epoch === nextEpoch) {
-            this.priorACK = { epoch: header.epoch, sequence: this.receiveSequence };
-        }
-        this.receiveEpoch = nextEpoch;
-        this.receiveSequence = 0n;
-        const pending = { transition, epoch: nextEpoch, acknowledged: deferred() };
-        this.receiveRekey = pending;
-        this.notifyReceiveRekeyChanged();
-        await this.send(InnerTypeV2.StreamKeyUpdateACK, encodeStreamKeyUpdateACKV2({
-            logicalStreamID: this.id,
-            transition,
-            epoch: nextEpoch,
-        }), this.session.terminationSignal());
-        pending.acknowledged.resolve();
-    }
-    receiveStreamKeyUpdateACK(payload) {
-        const decoded = decodeStreamKeyUpdateACKV2(payload);
-        if (decoded.logicalStreamID !== this.id)
-            throw protocolError("invalid STREAM_KEY_UPDATE_ACK");
-        const { transition, epoch } = decoded;
-        const pending = this.pendingSendRekey;
-        if (pending === undefined) {
-            if (this.lastSendRekeyACK?.transition === transition && this.lastSendRekeyACK.epoch === epoch)
-                return;
-            throw protocolError("unexpected STREAM_KEY_UPDATE_ACK");
-        }
-        if (pending.transition !== transition || pending.epoch !== epoch)
-            throw protocolError("unexpected STREAM_KEY_UPDATE_ACK");
-        this.sendEpoch = epoch;
-        this.sendSequence = 0n;
-        this.pendingSendRekey = undefined;
-        this.lastSendRekeyACK = { transition, epoch };
-        pending.done.resolve();
-        this.session.streamEpochStateChanged();
-    }
-    sendEpochsInUse() {
-        return this.pendingSendRekey === undefined ? [this.sendEpoch] : [this.sendEpoch, this.pendingSendRekey.epoch];
-    }
-    receiveEpochsInUse() {
-        const epochs = new Set([this.receiveEpoch]);
-        if (this.priorACK !== undefined)
-            epochs.add(this.priorACK.epoch);
-        if (this.receiveRekey !== undefined)
-            epochs.add(this.receiveRekey.epoch);
-        return [...epochs];
-    }
-    releaseIfClean() {
-        if (!this.localFIN || !this.remoteFIN || this.terminalError !== undefined)
-            return;
-        this.session.releaseStream(this);
-    }
-}
-async function clientHandshake(control, reader, config, offeredFeatures, signal) {
-    const key = generateEphemeralKeyV2(config.suite, config.runtime.entropy);
-    const fsc2 = encodeControlPrefaceV2();
-    const initRaw = encodeClientInitV2({
-        profile: "flowersec/2",
-        channelID: config.channelID,
-        sessionContractHash: config.sessionContractHash,
-        clientRole: 1,
-        suite: config.suite,
-        clientEphemeralPublic: key.publicKey,
-        nonceC: sessionRandomBytes(config, 32),
-        selectedFeatures: offeredFeatures,
-        maxInboundStreams: config.maxInboundStreams,
-        clientAdmissionBinding: config.localAdmissionBinding,
-        clientEndpointInstanceID: config.localEndpointInstanceID,
-    });
-    await writeAll(control, fsc2, signal);
-    await writeAll(control, initRaw, signal);
-    const serverRaw = await readHandshakeFrame(reader, signal);
-    const server = decodeServerFinishedV2(serverRaw, config.suite);
-    validateServerFinishedV2(server, expectations(config, false));
-    if ((server.core.selectedFeatures & ~offeredFeatures) !== 0) {
-        throw protocolError("server selected an unoffered feature");
-    }
-    const shared = computeSharedSecretV2(config.suite, key.privateKey, server.core.serverEphemeralPublic);
-    const handshakePRK = deriveHandshakePRKV2(config.psk, shared);
-    const h0 = computeHandshakeH0V2(fsc2, initRaw);
-    const h1 = computeHandshakeH1V2(h0, encodeServerFinishedCoreV2(server.core, config.suite));
-    if (!bytesEqual(server.serverConfirm, computeServerConfirmV2(handshakePRK, h1))) {
-        throw protocolError("server confirm mismatch");
-    }
-    const clientCore = encodeClientFinishedCoreV2(server.core.handshakeID);
-    const h2 = computeHandshakeH2V2(h1, serverRaw, clientCore);
-    const clientRaw = encodeClientFinishedV2({
-        handshakeID: server.core.handshakeID,
-        clientConfirm: computeClientConfirmV2(handshakePRK, h2),
-    });
-    await writeAll(control, clientRaw, signal);
-    const h3 = computeHandshakeH3V2(h2, clientRaw);
-    return {
-        h3,
-        sessionPRK: deriveSessionPRKV2(h3, handshakePRK),
-        selectedFeatures: server.core.selectedFeatures,
-    };
-}
-async function serverHandshake(control, reader, config, localFeatures, signal) {
-    const fsc2 = await reader.readExactly(16, signal);
-    parseControlPrefaceV2(fsc2);
-    const clientRaw = await readHandshakeFrame(reader, signal);
-    const client = decodeClientInitV2(clientRaw);
-    validateClientInitV2(client, expectations(config, true));
-    const key = generateEphemeralKeyV2(config.suite, config.runtime.entropy);
-    const shared = computeSharedSecretV2(config.suite, key.privateKey, client.clientEphemeralPublic);
-    const handshakePRK = deriveHandshakePRKV2(config.psk, shared);
-    const core = {
-        suite: config.suite,
-        handshakeID: sessionRandomBytes(config, 16),
-        serverEphemeralPublic: key.publicKey,
-        nonceS: sessionRandomBytes(config, 32),
-        sessionContractHash: config.sessionContractHash,
-        selectedFeatures: client.selectedFeatures & localFeatures,
-        maxInboundStreams: config.maxInboundStreams,
-        serverAdmissionBinding: config.localAdmissionBinding,
-        serverEndpointInstanceID: config.localEndpointInstanceID,
-    };
-    const h0 = computeHandshakeH0V2(fsc2, clientRaw);
-    const h1 = computeHandshakeH1V2(h0, encodeServerFinishedCoreV2(core, config.suite));
-    const serverRaw = encodeServerFinishedV2({
-        core,
-        serverConfirm: computeServerConfirmV2(handshakePRK, h1),
-    }, config.suite);
-    await writeAll(control, serverRaw, signal);
-    const clientFinishedRaw = await readHandshakeFrame(reader, signal);
-    const clientFinished = decodeClientFinishedV2(clientFinishedRaw);
-    if (!bytesEqual(clientFinished.handshakeID, core.handshakeID))
-        throw protocolError("handshake ID mismatch");
-    const clientCore = encodeClientFinishedCoreV2(clientFinished.handshakeID);
-    const h2 = computeHandshakeH2V2(h1, serverRaw, clientCore);
-    if (!bytesEqual(clientFinished.clientConfirm, computeClientConfirmV2(handshakePRK, h2))) {
-        throw protocolError("client confirm mismatch");
-    }
-    const h3 = computeHandshakeH3V2(h2, clientFinishedRaw);
-    return {
-        h3,
-        sessionPRK: deriveSessionPRKV2(h3, handshakePRK),
-        selectedFeatures: core.selectedFeatures,
-    };
-}
-function expectations(config, peerIsClient) {
-    return {
-        path: config.path,
-        channelID: peerIsClient ? config.channelID : "",
-        sessionContractHash: config.sessionContractHash,
-        suite: config.suite,
-        maxInboundStreams: config.maxInboundStreams,
-        admissionBinding: config.peerAdmissionBinding,
-        expectedEndpointInstanceID: config.expectedPeerEndpointInstanceID,
-    };
-}
-async function readHandshakeFrame(reader, signal) {
-    const header = await reader.readExactly(12, signal);
-    const length = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint32(8, false);
-    if (length < 1 || length > 8_192)
-        throw protocolError("invalid handshake payload length");
-    const raw = concat(header, await reader.readExactly(length, signal));
-    decodeHandshakeFrameV2(raw);
-    return raw;
-}
-class ExactReader {
-    stream;
-    chunks = [];
-    offset = 0;
-    bytes = 0;
-    constructor(stream) {
-        this.stream = stream;
-    }
-    async readExactly(length, signal) {
-        while (this.bytes < length) {
-            const chunk = await this.stream.read(signal === undefined ? {} : { signal });
-            if (chunk === null)
-                throw new SessionV2Error("closed", "unexpected carrier EOF");
-            if (chunk.length === 0)
-                continue;
-            this.chunks.push(chunk);
-            this.bytes += chunk.length;
-        }
-        const out = new Uint8Array(length);
-        let written = 0;
-        while (written < length) {
-            const chunk = this.chunks[0];
-            const take = Math.min(length - written, chunk.length - this.offset);
-            out.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 out;
-    }
-}
-class ByteQueue {
-    limit;
-    chunks = [];
-    head = 0;
-    bytes = 0;
-    closed = false;
-    error;
-    waiters = new Set();
-    capacityWaiters = new Set();
-    constructor(limit) {
-        this.limit = limit;
-    }
-    push(chunk) {
-        if (this.closed || this.error !== undefined)
-            throw protocolError("DATA after terminal stream state");
-        if (this.bytes + chunk.length > this.limit)
-            throw new SessionV2Error("resource_exhausted", "stream receive buffer exceeded");
-        this.chunks.push(chunk.slice());
-        this.bytes += chunk.length;
-        this.wake();
-    }
-    close() {
-        this.closed = true;
-        this.wake();
-    }
-    fail(error) {
-        if (this.error !== undefined)
-            return;
-        this.error = error;
-        this.chunks.length = 0;
-        this.head = 0;
-        this.bytes = 0;
-        this.wake(error);
-        this.wakeCapacity(error);
-    }
-    async waitForCapacity(required) {
-        if (!Number.isInteger(required) || required < 0 || required > this.limit) {
-            throw new RangeError("invalid stream receive capacity request");
-        }
-        while (this.bytes + required > this.limit) {
-            if (this.error !== undefined)
-                throw this.error;
-            if (this.closed)
-                return;
-            const waiter = deferred();
-            this.capacityWaiters.add(waiter);
-            try {
-                await waiter.promise;
-            }
-            finally {
-                this.capacityWaiters.delete(waiter);
-            }
-        }
-    }
-    async read(signal) {
-        while (true) {
-            if (this.error !== undefined)
-                throw this.error;
-            if (this.head < this.chunks.length) {
-                const chunk = this.chunks[this.head++];
-                this.bytes -= chunk.length;
-                this.wakeCapacity();
-                if (this.head > 1_024 && this.head * 2 > this.chunks.length) {
-                    this.chunks.splice(0, this.head);
-                    this.head = 0;
-                }
-                return chunk;
-            }
-            if (this.closed)
-                return null;
-            const waiter = deferred();
-            this.waiters.add(waiter);
-            try {
-                await raceAbort(waiter.promise, signal);
-            }
-            finally {
-                this.waiters.delete(waiter);
-            }
-        }
-    }
-    wake(error) {
-        for (const waiter of [...this.waiters])
-            error === undefined ? waiter.resolve() : waiter.reject(error);
-        this.waiters.clear();
-    }
-    wakeCapacity(error) {
-        for (const waiter of [...this.capacityWaiters])
-            error === undefined ? waiter.resolve() : waiter.reject(error);
-        this.capacityWaiters.clear();
-    }
-}
-class AsyncSemaphore {
-    available;
-    waiters = new Set();
-    error;
-    constructor(count) { this.available = count; }
-    async acquire(signal) {
-        if (this.error !== undefined)
-            throw this.error;
-        if (this.available > 0) {
-            this.available--;
-            return this.releaser();
-        }
-        return await new Promise((resolve, reject) => {
-            let settled = false;
-            const cleanup = () => {
-                this.waiters.delete(waiter);
-                signal?.removeEventListener("abort", abort);
-            };
-            const waiter = {
-                deliver: (release) => {
-                    if (settled) {
-                        release();
-                        return false;
-                    }
-                    settled = true;
-                    cleanup();
-                    resolve(release);
-                    return true;
-                },
-                fail: (error) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    reject(error);
-                },
-            };
-            const abort = () => waiter.fail(abortReason(signal));
-            this.waiters.add(waiter);
-            signal?.addEventListener("abort", abort, { once: true });
-            if (signal?.aborted === true)
-                abort();
-        });
-    }
-    tryAcquire() {
-        if (this.error !== undefined || this.available === 0)
-            return undefined;
-        this.available--;
-        return this.releaser();
-    }
-    fail(error) {
-        this.error = error;
-        for (const waiter of [...this.waiters])
-            waiter.fail(error);
-    }
-    releaser() {
-        let released = false;
-        return () => {
-            if (released)
-                return;
-            released = true;
-            const waiter = this.waiters.values().next().value;
-            if (waiter === undefined)
-                this.available++;
-            else
-                waiter.deliver(this.releaser());
-        };
-    }
-}
-class AsyncQueue {
-    values = [];
-    waiters = new Set();
-    error;
-    push(value) {
-        if (this.error !== undefined)
-            return;
-        const waiter = this.waiters.values().next().value;
-        if (waiter === undefined || !waiter.deliver(value))
-            this.values.push(value);
-    }
-    async shift(signal) {
-        if (this.error !== undefined)
-            throw this.error;
-        const value = this.values.shift();
-        if (value !== undefined)
-            return value;
-        return await new Promise((resolve, reject) => {
-            let settled = false;
-            const cleanup = () => {
-                this.waiters.delete(waiter);
-                signal?.removeEventListener("abort", abort);
-            };
-            const waiter = {
-                deliver: (next) => {
-                    if (settled)
-                        return false;
-                    settled = true;
-                    cleanup();
-                    resolve(next);
-                    return true;
-                },
-                fail: (error) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    reject(error);
-                },
-            };
-            const abort = () => waiter.fail(abortReason(signal));
-            this.waiters.add(waiter);
-            signal?.addEventListener("abort", abort, { once: true });
-            if (signal?.aborted === true)
-                abort();
-        });
-    }
-    fail(error) {
-        this.error = error;
-        this.values.length = 0;
-        for (const waiter of [...this.waiters])
-            waiter.fail(error);
-    }
-}
-function deferred() {
-    let resolvePromise;
-    let rejectPromise;
-    let settled = false;
-    const promise = new Promise((resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-    });
-    return {
-        promise,
-        resolve: (value) => { if (!settled) {
-            settled = true;
-            resolvePromise(value);
-        } },
-        reject: (reason) => { if (!settled) {
-            settled = true;
-            rejectPromise(reason);
-        } },
-        get settled() { return settled; },
-    };
-}
-function validateConfig(carrier, config) {
-    if (config.runtime === undefined ||
-        typeof config.runtime.entropy !== "function" ||
-        typeof config.runtime.monotonicMilliseconds !== "function") {
-        throw new SessionV2Error("handshake", "session protocol runtime is required");
-    }
-    if (carrier.path !== config.path || (config.role !== "client" && config.role !== "server")) {
-        throw new SessionV2Error("handshake", "invalid session carrier/config binding");
-    }
-    if (!Number.isInteger(config.maxInboundStreams) || config.maxInboundStreams < 1 || config.maxInboundStreams > 128) {
-        throw new SessionV2Error("handshake", "invalid maxInboundStreams");
-    }
-    if (carrier.inboundBidirectionalStreamCapacity !== config.maxInboundStreams + 2) {
-        throw new SessionV2Error("handshake", "carrier inbound bidirectional stream capacity mismatch");
-    }
-    sessionIdleTimeoutMs(config);
-    sessionCloseTimeoutMs(config);
-    for (const [name, value] of [
-        ["session contract hash", config.sessionContractHash],
-        ["PSK", config.psk],
-        ["local admission binding", config.localAdmissionBinding],
-        ["peer admission binding", config.peerAdmissionBinding],
-    ]) {
-        if (value.length !== 32)
-            throw new SessionV2Error("handshake", `${name} must be 32 bytes`);
-    }
-    if (config.path === "direct") {
-        if (config.localEndpointInstanceID !== "" || config.expectedPeerEndpointInstanceID !== "") {
-            throw new SessionV2Error("handshake", "direct session endpoint IDs must be empty");
-        }
-    }
-    else if (config.localEndpointInstanceID === "" || config.expectedPeerEndpointInstanceID === "") {
-        throw new SessionV2Error("handshake", "tunnel session endpoint IDs are required");
-    }
-}
-function supportedFeatures(datagrams) {
-    return datagrams !== undefined && datagrams.maxDatagramSize >= UNRELIABLE_MESSAGE_WIRE_BYTES_V2
-        ? UNRELIABLE_MESSAGES_FEATURE_V2
-        : 0;
-}
-function requireUnreliableDatagrams(carrier) {
-    const datagrams = carrier.unreliableDatagrams;
-    if (datagrams === undefined || datagrams.maxDatagramSize < UNRELIABLE_MESSAGE_WIRE_BYTES_V2) {
-        throw new SessionV2Error("handshake", "negotiated unreliable messages require native DATAGRAM support");
-    }
-    return datagrams;
-}
-function encodeMetadata(value) {
-    return encoder.encode(canonicalJSON(value));
-}
-function decodeMetadata(raw) {
-    return JSON.parse(decoder.decode(raw));
-}
-function canonicalJSON(value) {
-    if (value === null || typeof value === "boolean" || typeof value === "number")
-        return JSON.stringify(value);
-    if (typeof value === "string")
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(canonicalJSON).join(",")}]`;
-    if (typeof value !== "object" || value === null)
-        throw new TypeError("metadata must be JSON");
-    const object = value;
-    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJSON(object[key])}`).join(",")}}`;
-}
-async function writeAll(stream, value, signal) {
-    let offset = 0;
-    while (offset < value.length) {
-        throwIfAborted(signal);
-        const written = await stream.write(value.subarray(offset), signal === undefined ? {} : { signal });
-        if (written < 1 || written > value.length - offset)
-            throw protocolError("short carrier write");
-        offset += written;
-    }
-}
-async function settleWithin(promise, timeoutMs) {
-    return await new Promise((resolve) => {
-        const timer = setTimeout(() => resolve(false), timeoutMs);
-        void promise.then(() => { clearTimeout(timer); resolve(true); }, () => { clearTimeout(timer); resolve(true); });
-    });
-}
-async function resolveWithin(promise, timeoutMs) {
-    return await new Promise((resolve) => {
-        const timer = setTimeout(() => resolve(false), timeoutMs);
-        void promise.then(() => { clearTimeout(timer); resolve(true); }, () => { clearTimeout(timer); resolve(false); });
-    });
-}
-function sessionIdleTimeoutMs(config) {
-    const timeoutMs = config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0) {
-        throw new RangeError("idleTimeoutMs must be a non-negative integer");
-    }
-    return timeoutMs;
-}
-function sessionCloseTimeoutMs(config) {
-    const timeoutMs = config.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000) {
-        throw new RangeError("closeTimeoutMs must be an integer from 1 to 60000");
-    }
-    return timeoutMs;
-}
-function sessionRandomBytes(config, length) {
-    const output = config.runtime.entropy(length);
-    if (!(output instanceof Uint8Array) || output.length !== length) {
-        throw new SessionV2Error("handshake", `session entropy must return exactly ${length} bytes`);
-    }
-    return output.slice();
-}
-function idReason(id, reason) {
-    return concat(u64(id), Uint8Array.of((reason >>> 8) & 0xff, reason & 0xff));
-}
-function parseIDReason(payload) {
-    if (payload.length !== 10)
-        throw protocolError("invalid ID/reason payload");
-    return { id: readU64(payload), reason: readU16(payload, 8) };
-}
-function u64(value) {
-    const out = new Uint8Array(8);
-    new DataView(out.buffer).setBigUint64(0, value, false);
-    return out;
-}
-function u32(value) {
-    const out = new Uint8Array(4);
-    new DataView(out.buffer).setUint32(0, value, false);
-    return out;
-}
-function readU64(value) {
-    if (value.length < 8)
-        throw protocolError("truncated uint64");
-    return new DataView(value.buffer, value.byteOffset, value.byteLength).getBigUint64(0, false);
-}
-function readU64At(value, offset) {
-    if (value.length < offset + 8)
-        throw protocolError("truncated uint64");
-    return new DataView(value.buffer, value.byteOffset, value.byteLength).getBigUint64(offset, false);
-}
-function readU32(value, offset) {
-    if (value.length < offset + 4)
-        throw protocolError("truncated uint32");
-    return new DataView(value.buffer, value.byteOffset, value.byteLength).getUint32(offset, false);
-}
-function readU16(value, offset) {
-    if (value.length < offset + 2)
-        throw protocolError("truncated uint16");
-    return new DataView(value.buffer, value.byteOffset, value.byteLength).getUint16(offset, false);
-}
-function concat(...values) {
-    const out = new Uint8Array(values.reduce((sum, value) => sum + value.length, 0));
-    let offset = 0;
-    for (const value of values) {
-        out.set(value, offset);
-        offset += value.length;
-    }
-    return out;
-}
-function bytesEqual(left, right) {
-    if (left.length !== right.length)
-        return false;
-    let difference = 0;
-    for (let index = 0; index < left.length; index++)
-        difference |= left[index] ^ right[index];
-    return difference === 0;
-}
-function wipeEpochRoots(roots) {
-    roots.epochSecret.fill(0);
-    roots.controlRoot.fill(0);
-    roots.streamRoot.fill(0);
-    roots.setupRoot.fill(0);
-    roots.rekeyRoot.fill(0);
-}
-async function raceAbort(promise, signal) {
-    if (signal === undefined)
-        return await promise;
-    throwIfAborted(signal);
-    return await new Promise((resolve, reject) => {
-        const abort = () => reject(abortReason(signal));
-        signal.addEventListener("abort", abort, { once: true });
-        void promise.then((value) => { signal.removeEventListener("abort", abort); resolve(value); }, (error) => { signal.removeEventListener("abort", abort); reject(error); });
-    });
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted === true)
-        throw abortReason(signal);
-}
-function abortedError() {
-    return new SessionV2Error("aborted", "operation aborted");
-}
-function abortReason(signal) {
-    return signal.reason instanceof Error ? signal.reason : abortedError();
-}
-function releasedStreamCleanup(streams) {
-    return new FinalizationRegistry((id) => {
-        const stream = streams.get(id);
-        if (stream !== undefined && stream.deref() === undefined)
-            streams.delete(id);
-    });
-}
-function createSessionDeadline(config, phase) {
-    const deadlines = config.deadlines;
-    const timeoutMs = phase === "establish"
-        ? deadlines?.establishTimeoutMs ?? 30_000
-        : phase === "rekey_prepare"
-            ? deadlines?.rekeyPrepareTimeoutMs ?? 10_000
-            : deadlines?.rekeyCompletionTimeoutMs ?? 30_000;
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-        throw new RangeError(`${phase} timeout must be positive`);
-    return (deadlines?.factory ?? defaultDeadlineFactory)(timeoutMs, phase);
-}
-function defaultDeadlineFactory(timeoutMs, phase) {
-    const controller = new AbortController();
-    const cancelTimer = scheduleLongTimeout(() => {
-        controller.abort(new SessionV2Error("timeout", `${phase} deadline exceeded`));
-    }, timeoutMs);
-    return {
-        signal: controller.signal,
-        cancel: cancelTimer,
-    };
-}
-const MAX_NATIVE_TIMEOUT_MS = 2_147_483_647;
-// Node and browsers clamp setTimeout delays above a signed 32-bit integer.
-// Keep the public timeout range intact by scheduling the remaining duration in
-// bounded segments against a monotonic wall-clock deadline.
-function scheduleLongTimeout(callback, timeoutMs) {
-    const clock = () => typeof performance !== "undefined" ? performance.now() : Date.now();
-    const deadline = clock() + timeoutMs;
-    let timer;
-    let canceled = false;
-    const schedule = () => {
-        if (canceled)
-            return;
-        const remaining = deadline - clock();
-        if (remaining <= 0) {
-            callback();
-            return;
-        }
-        timer = setTimeout(schedule, Math.min(remaining, MAX_NATIVE_TIMEOUT_MS));
-    };
-    schedule();
-    return () => {
-        canceled = true;
-        if (timer !== undefined)
-            clearTimeout(timer);
-    };
-}
-function combineSignals(...signals) {
-    const controller = new AbortController();
-    const cleanups = [];
-    const abortFrom = (signal) => {
-        if (!controller.signal.aborted)
-            controller.abort(abortReason(signal));
-    };
-    for (const signal of signals) {
-        if (signal === undefined)
-            continue;
-        const abort = () => abortFrom(signal);
-        signal.addEventListener("abort", abort, { once: true });
-        cleanups.push(() => signal.removeEventListener("abort", abort));
-        if (signal.aborted)
-            abortFrom(signal);
-    }
-    return {
-        signal: controller.signal,
-        cancel: () => { for (const cleanup of cleanups.splice(0))
-            cleanup(); },
-    };
-}
-function signalOptions(signal) {
-    return signal === undefined ? {} : { signal };
-}
-function protocolError(message) {
-    return new SessionV2Error("protocol", message);
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}