@api.global/typedsocket 6.3.0 → 7.1.0

package/dist_ts/classes.virtualstreammanager.js

@@ -0,0 +1,2115 @@
+import * as plugins from './plugins.js';
+import { TYPEDSOCKET_HANDSHAKE_TIMEOUT_MS, TYPEDSOCKET_PACKAGE_MAJOR, TYPEDSOCKET_VERSION_METHOD, VIRTUAL_STREAM_CAPABILITY_TIMEOUT_MS, VIRTUAL_STREAM_FRAME_TYPES, VIRTUAL_STREAM_MAX_ARRIVAL_STAMP_BYTES_PER_CONNECTION, VIRTUAL_STREAM_MAX_ARRIVAL_STAMPS_PER_CONNECTION, VIRTUAL_STREAM_MAX_CONNECTIONS_PER_SERVER, VIRTUAL_STREAM_MAX_CORRELATION_ID_BYTES, VIRTUAL_STREAM_MAX_FRAGMENT_PAYLOAD_BYTES, VIRTUAL_STREAM_MAX_LOGICAL_CHUNK_BYTES, VIRTUAL_STREAM_MAX_OUTBOUND_FRAMES_PER_CONNECTION, VIRTUAL_STREAM_MAX_QUEUED_BYTES_PER_CONNECTION, VIRTUAL_STREAM_MAX_QUEUED_BYTES_PER_STREAM, VIRTUAL_STREAM_MAX_QUEUED_CHUNKS_PER_CONNECTION, VIRTUAL_STREAM_MAX_QUEUED_CHUNKS_PER_STREAM, VIRTUAL_STREAM_MAX_RAW_QUEUE_BYTES, VIRTUAL_STREAM_MAX_RAW_QUEUE_FRAMES, VIRTUAL_STREAM_MAX_REVALIDATIONS_PER_CONNECTION, VIRTUAL_STREAM_MAX_REVALIDATIONS_PER_SERVER, VIRTUAL_STREAM_MAX_RETAINED_BYTES_PER_SERVER, VIRTUAL_STREAM_MAX_STREAMS_PER_CONNECTION, VIRTUAL_STREAM_MAX_STREAMS_PER_SERVER, VIRTUAL_STREAM_MAX_TOMBSTONES_PER_CONNECTION, VIRTUAL_STREAM_PROGRESS_TIMEOUT_MS, VIRTUAL_STREAM_PROTOCOL, VIRTUAL_STREAM_REVALIDATION_TIMEOUT_MS, VIRTUAL_STREAM_RESET_CODES, VIRTUAL_STREAM_TOMBSTONE_RETENTION_MS, } from './constants.virtualstream.js';
+import { copyVirtualStreamBytes, createVirtualStreamDescriptorDigest, decodeVirtualStreamFrame, encodeVirtualStreamFrame, getVirtualStreamFrameByteLength, normalizeVirtualStreamCapability, normalizeVirtualStreamContentType, normalizeVirtualStreamId, normalizeVirtualStreamIntegrity, VirtualStreamProtocolError, } from './helpers.virtualstreamcodec.js';
+import { toClientWebSocketCloseCode } from './helpers.websocket.js';
+const virtualStreamTextEncoder = new TextEncoder();
+const nativePromiseThen = Promise.prototype.then;
+const createAuthorizedServerRegistrationSymbol = Symbol('createAuthorizedServerVirtualStreamRegistration');
+const setServerHandshakeReadyCallbackSymbol = Symbol('setServerHandshakeReadyCallback');
+export class TypedSocketVirtualStreamError extends Error {
+    constructor(messageArg, optionsArg) {
+        super(messageArg, optionsArg);
+        this.name = 'TypedSocketVirtualStreamError';
+    }
+}
+function createDeferred() {
+    let resolvePromise;
+    let rejectPromise;
+    let settled = false;
+    const promise = new Promise((resolveArg, rejectArg) => {
+        resolvePromise = resolveArg;
+        rejectPromise = rejectArg;
+    });
+    void promise.catch(() => { });
+    return {
+        promise,
+        get settled() {
+            return settled;
+        },
+        resolve(valueArg) {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise(valueArg);
+        },
+        reject(reasonArg) {
+            if (settled)
+                return;
+            settled = true;
+            rejectPromise(reasonArg);
+        },
+    };
+}
+function createDefaultTimer(callbackArg, delayMsArg) {
+    const timer = setTimeout(callbackArg, delayMsArg);
+    timer.unref?.();
+    return Object.freeze({ cancel: () => clearTimeout(timer) });
+}
+function clearDefaultTimer(timerArg) {
+    if (!timerArg || typeof timerArg !== 'object')
+        return;
+    const cancel = Reflect.get(timerArg, 'cancel');
+    if (typeof cancel === 'function')
+        Reflect.apply(cancel, timerArg, []);
+}
+function defaultRuntime() {
+    return {
+        now: () => Date.now(),
+        randomBytes: (lengthArg) => {
+            const bytes = new Uint8Array(lengthArg);
+            crypto.getRandomValues(bytes);
+            return bytes;
+        },
+        setTimer: createDefaultTimer,
+        clearTimer: clearDefaultTimer,
+        scheduleMacrotask: (callbackArg) => createDefaultTimer(callbackArg, 0),
+    };
+}
+function bytesToHex(bytesArg) {
+    let result = '';
+    for (const byte of bytesArg)
+        result += byte.toString(16).padStart(2, '0');
+    return result;
+}
+function randomStreamId(runtimeArg) {
+    const hex = bytesToHex(runtimeArg.randomBytes(16));
+    if (hex.length !== 32) {
+        throw new VirtualStreamProtocolError('runtime must return exactly 16 random stream ID bytes');
+    }
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function randomCapability(runtimeArg) {
+    const capability = bytesToHex(runtimeArg.randomBytes(32));
+    return normalizeVirtualStreamCapability(capability);
+}
+function asError(reasonArg, fallbackArg) {
+    return reasonArg instanceof Error
+        ? reasonArg
+        : new TypedSocketVirtualStreamError(reasonArg === undefined ? fallbackArg : String(reasonArg));
+}
+function asPeer(targetArg) {
+    return 'peer' in targetArg ? targetArg.peer : targetArg;
+}
+function isPlainRecord(valueArg) {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        return false;
+    const prototype = Object.getPrototypeOf(valueArg);
+    return prototype === Object.prototype || prototype === null;
+}
+function getOwnEnumerableData(valueArg, keyArg) {
+    const property = Object.getOwnPropertyDescriptor(valueArg, keyArg);
+    return property && property.enumerable && 'value' in property
+        ? property.value
+        : undefined;
+}
+function hasExactEnumerableDataKeys(valueArg, keysArg) {
+    const ownKeys = Reflect.ownKeys(valueArg);
+    return ownKeys.length === keysArg.length
+        && ownKeys.every((keyArg) => typeof keyArg === 'string' && keysArg.includes(keyArg));
+}
+function parseArrivalIdentity(valueArg) {
+    if (!isPlainRecord(valueArg))
+        return undefined;
+    const method = getOwnEnumerableData(valueArg, 'method');
+    const correlation = getOwnEnumerableData(valueArg, 'correlation');
+    if (typeof method !== 'string' || method.length === 0 || !isPlainRecord(correlation)) {
+        return undefined;
+    }
+    const correlationId = getOwnEnumerableData(correlation, 'id');
+    const phase = getOwnEnumerableData(correlation, 'phase');
+    if (typeof correlationId !== 'string'
+        || correlationId.length === 0
+        || virtualStreamTextEncoder.encode(correlationId).byteLength
+            > VIRTUAL_STREAM_MAX_CORRELATION_ID_BYTES
+        || (phase !== 'request' && phase !== 'response')) {
+        return undefined;
+    }
+    return { method, correlationId, phase };
+}
+function isExactPackageMajor(valueArg) {
+    return isPlainRecord(valueArg)
+        && hasExactEnumerableDataKeys(valueArg, ['packageMajor'])
+        && getOwnEnumerableData(valueArg, 'packageMajor') === TYPEDSOCKET_PACKAGE_MAJOR;
+}
+function isExactHandshakeRequest(valueArg) {
+    const identity = parseArrivalIdentity(valueArg);
+    if (!identity || !isPlainRecord(valueArg))
+        return false;
+    return identity.method === TYPEDSOCKET_VERSION_METHOD
+        && identity.phase === 'request'
+        && hasExactEnumerableDataKeys(valueArg, ['method', 'request', 'response', 'correlation'])
+        && isPlainRecord(getOwnEnumerableData(valueArg, 'correlation'))
+        && hasExactEnumerableDataKeys(getOwnEnumerableData(valueArg, 'correlation'), ['id', 'phase'])
+        && isExactPackageMajor(getOwnEnumerableData(valueArg, 'request'))
+        && getOwnEnumerableData(valueArg, 'response') === null;
+}
+function isExactHandshakeResponse(valueArg, correlationIdArg) {
+    const identity = parseArrivalIdentity(valueArg);
+    if (!identity || !isPlainRecord(valueArg))
+        return false;
+    const correlation = getOwnEnumerableData(valueArg, 'correlation');
+    return identity.method === TYPEDSOCKET_VERSION_METHOD
+        && identity.phase === 'response'
+        && identity.correlationId === correlationIdArg
+        && hasExactEnumerableDataKeys(valueArg, ['method', 'request', 'response', 'correlation'])
+        && isPlainRecord(correlation)
+        && hasExactEnumerableDataKeys(correlation, ['id', 'phase'])
+        && isExactPackageMajor(getOwnEnumerableData(valueArg, 'request'))
+        && isExactPackageMajor(getOwnEnumerableData(valueArg, 'response'));
+}
+function createReceipt(stateArg) {
+    return Object.freeze({
+        streamId: stateArg.descriptor.streamId,
+        chunkCount: stateArg.processedChunkCount,
+        byteLength: stateArg.processedByteLength,
+        accepted: true,
+        verifiedIntegrity: stateArg.descriptor.integrity ?? null,
+    });
+}
+class VirtualStreamEndpointBase {
+    constructor(manager, state) {
+        this.manager = manager;
+        this.state = state;
+        this.protocol = VIRTUAL_STREAM_PROTOCOL;
+    }
+    get streamId() {
+        return this.state.descriptor.streamId;
+    }
+    get contentType() {
+        return this.state.descriptor.contentType;
+    }
+    get integrity() {
+        return this.state.descriptor.integrity;
+    }
+    get opened() {
+        return this.manager.ensureOpened(this.state);
+    }
+    get completion() {
+        return this.state.completionDeferred.promise;
+    }
+    get closed() {
+        return this.state.closedDeferred.promise;
+    }
+    async abort(reasonArg) {
+        await this.manager.abortEndpoint(this.state, reasonArg);
+    }
+}
+export class VirtualStreamSender extends VirtualStreamEndpointBase {
+    constructor() {
+        super(...arguments);
+        this.direction = 'send';
+    }
+    get writable() {
+        void this.manager.ensureOpened(this.state).catch(() => { });
+        return this.writableInternal ??= new WritableStream({
+            write: async (chunkArg) => this.send(chunkArg),
+            close: async () => { await this.close(); },
+            abort: async (reasonArg) => this.abort(reasonArg),
+        });
+    }
+    async send(chunkArg) {
+        await this.manager.send(this.state, chunkArg);
+    }
+    async close() {
+        return await this.manager.closeSender(this.state);
+    }
+}
+export class VirtualStreamReceiver extends VirtualStreamEndpointBase {
+    constructor() {
+        super(...arguments);
+        this.direction = 'receive';
+    }
+    get readable() {
+        if (this.state.receiveMode === 'direct') {
+            throw new TypedSocketVirtualStreamError('VirtualStream direct receive and readable consumption are mutually exclusive');
+        }
+        this.state.receiveMode = 'readable';
+        void this.manager.ensureOpened(this.state).catch(() => { });
+        return this.readableInternal ??= new ReadableStream({
+            pull: async (controllerArg) => {
+                try {
+                    const chunk = await this.manager.receive(this.state, 'readable');
+                    if (chunk)
+                        controllerArg.enqueue(chunk);
+                    else
+                        controllerArg.close();
+                }
+                catch (errorArg) {
+                    controllerArg.error(errorArg);
+                }
+            },
+            cancel: async (reasonArg) => this.reject(reasonArg),
+        }, { highWaterMark: 0 });
+    }
+    async receive() {
+        return await this.manager.receive(this.state, 'direct');
+    }
+    async accept() {
+        return await this.manager.acceptReceiver(this.state);
+    }
+    async reject(reasonArg) {
+        await this.manager.rejectReceiver(this.state, reasonArg);
+    }
+}
+class VirtualStreamConnectionTransport {
+    constructor(manager, connection) {
+        this.manager = manager;
+        this.connection = connection;
+    }
+    async openVirtualStream(descriptorArg, optionsArg) {
+        return this.manager.stageDescriptor(this.connection, descriptorArg, optionsArg);
+    }
+}
+export class VirtualStreamManager {
+    constructor(optionsArg) {
+        this.serverConnections = new Map();
+        this.serverSettlementConnections = new Map();
+        this.observedInvalidReadyPromises = new WeakSet();
+        this.serverAttached = false;
+        this.retainedRevalidations = 0;
+        this.serverRetainedBytes = 0;
+        if (optionsArg.side !== 'client' && optionsArg.side !== 'server') {
+            throw new TypeError('VirtualStreamManager side must be client or server');
+        }
+        this.side = optionsArg.side;
+        this.runtime = optionsArg.runtime ?? defaultRuntime();
+        this.onDiagnostic = optionsArg.onDiagnostic;
+        this.webSocketTransportOwner = Object.freeze({
+            onOpen: (peerArg) => this.bindServerPeer(peerArg),
+            onFrame: (peerArg, frameArg) => {
+                if (frameArg.type === 'binary') {
+                    this.enqueueServerRawFrame(peerArg, frameArg.data);
+                    return;
+                }
+                this.stampServerTextFrame(peerArg, frameArg.text, frameArg.size);
+            },
+            onClose: (peerArg) => this.unbindServerPeer(peerArg, new Error('WebSocket peer closed')),
+            onError: (peerArg, errorArg) => {
+                const connection = this.serverConnections.get(peerArg);
+                if (connection)
+                    this.failConnection(connection, errorArg, true);
+            },
+            pullBinaryFrame: (peerArg) => this.pullServerBinaryFrame(peerArg),
+            onOutboundFrameSettled: (peerArg, frameArg, settlementArg) => {
+                this.settleServerOutboundFrame(peerArg, frameArg, settlementArg);
+            },
+            onTypedResponseSettled: (peerArg, responseArg, settlementArg) => {
+                this.settleServerHandshake(peerArg, responseArg, settlementArg);
+            },
+        });
+    }
+    attachServer() {
+        if (this.side !== 'server') {
+            throw new TypedSocketVirtualStreamError('attachServer is server-only');
+        }
+        this.serverAttached = true;
+    }
+    detachServer() {
+        this.serverAttached = false;
+        this.onServerHandshakeReady = undefined;
+        for (const connection of [...this.serverConnections.values()]) {
+            this.failConnection(connection, new Error('TypedSocket server detached'), false);
+        }
+        this.serverConnections.clear();
+    }
+    [setServerHandshakeReadyCallbackSymbol](callbackArg) {
+        this.onServerHandshakeReady = callbackArg;
+    }
+    bindClientConnection(webSocketArg, generationArg) {
+        if (this.side !== 'client') {
+            throw new TypedSocketVirtualStreamError('bindClientConnection is client-only');
+        }
+        if (!Number.isSafeInteger(generationArg) || generationArg <= 0) {
+            throw new RangeError('client generation must be a positive safe integer');
+        }
+        if (this.currentClientConnection) {
+            this.failConnection(this.currentClientConnection, new Error('TypedSocket client generation replaced'), false);
+        }
+        this.currentClientConnection = this.createConnection(Object.freeze({
+            side: 'client',
+            generation: generationArg,
+            webSocket: webSocketArg,
+        }));
+    }
+    setClientHandshakeReady(webSocketArg, generationArg) {
+        const connection = this.currentClientConnection;
+        if (!connection
+            || connection.binding.side !== 'client'
+            || connection.binding.webSocket !== webSocketArg
+            || connection.binding.generation !== generationArg
+            || connection.closed) {
+            throw new TypedSocketVirtualStreamError('TypedSocket client generation changed during version handshake');
+        }
+        connection.handshakeReady = true;
+        this.clearConnectionTimer(connection, 'handshakeTimer');
+    }
+    unbindClientConnection(webSocketArg, generationArg, reasonArg) {
+        const connection = this.currentClientConnection;
+        if (!connection
+            || connection.binding.side !== 'client'
+            || connection.binding.webSocket !== webSocketArg
+            || connection.binding.generation !== generationArg)
+            return;
+        this.failConnection(connection, asError(reasonArg, 'TypedSocket client disconnected'), false);
+        if (this.currentClientConnection === connection)
+            this.currentClientConnection = undefined;
+    }
+    enqueueClientRawFrame(webSocketArg, generationArg, dataArg) {
+        const connection = this.currentClientConnection;
+        if (!connection
+            || connection.binding.side !== 'client'
+            || connection.binding.webSocket !== webSocketArg
+            || connection.binding.generation !== generationArg)
+            return;
+        const bytes = dataArg instanceof ArrayBuffer
+            ? new Uint8Array(dataArg)
+            : new Uint8Array(dataArg.buffer, dataArg.byteOffset, dataArg.byteLength);
+        this.enqueueRawFrame(connection, bytes);
+    }
+    prepareServerHandshake(peerArg, packageMajorArg) {
+        const connection = this.serverConnections.get(peerArg);
+        const authority = connection?.authorizedHandshake;
+        if (!connection
+            || connection.closed
+            || connection.handshakePending
+            || connection.handshakeReady
+            || !authority
+            || peerArg.transportOwner !== this.webSocketTransportOwner) {
+            throw new TypedSocketVirtualStreamError('TypedSocket peer cannot start a version handshake');
+        }
+        connection.authorizedHandshake = undefined;
+        if (packageMajorArg !== TYPEDSOCKET_PACKAGE_MAJOR) {
+            this.closeConnection(connection, 1008, 'TypedSocket package major mismatch');
+            throw new TypedSocketVirtualStreamError('TypedSocket packageMajor is malformed');
+        }
+        connection.pendingHandshake = authority;
+        connection.handshakePending = true;
+    }
+    isServerPeerReady(peerArg) {
+        const connection = this.serverConnections.get(peerArg);
+        return Boolean(connection
+            && !connection.closed
+            && connection.handshakeReady
+            && connection.binding.side === 'server'
+            && connection.binding.peer === peerArg
+            && peerArg.transportOwner === this.webSocketTransportOwner);
+    }
+    authorizeServerIncomingEnvelope(peerArg, envelopeArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (!connection
+            || connection.closed
+            || connection.binding.side !== 'server'
+            || connection.binding.peer !== peerArg
+            || peerArg.transportOwner !== this.webSocketTransportOwner) {
+            return false;
+        }
+        const stamp = connection.arrivalStamps[0];
+        if (!stamp)
+            return false;
+        const identity = parseArrivalIdentity(envelopeArg);
+        if (!identity
+            || stamp.method !== identity.method
+            || stamp.correlationId !== identity.correlationId
+            || stamp.phase !== identity.phase) {
+            this.closeConnection(connection, 1008, 'TypedSocket text arrival sequence mismatch');
+            return false;
+        }
+        connection.arrivalStamps.shift();
+        connection.arrivalStampBytes -= stamp.byteLength;
+        this.releaseServerRetainedBytes(connection, stamp.byteLength);
+        if (!stamp.readyAtArrival) {
+            if (!stamp.handshake
+                || !isExactHandshakeRequest(envelopeArg)
+                || connection.authorizedHandshake
+                || connection.pendingHandshake
+                || connection.handshakePending
+                || connection.handshakeReady) {
+                this.closeConnection(connection, 1008, 'TypedSocket pre-ready text authority mismatch');
+                return false;
+            }
+            connection.authorizedHandshake = Object.freeze({
+                correlationId: identity.correlationId,
+                sequence: stamp.sequence,
+            });
+            return true;
+        }
+        if (!connection.handshakeReady || identity.method === TYPEDSOCKET_VERSION_METHOD) {
+            this.closeConnection(connection, 1008, 'TypedSocket text readiness authority mismatch');
+            return false;
+        }
+        return true;
+    }
+    getClientTransport() {
+        const connection = this.currentClientConnection;
+        return connection && !connection.closed ? connection.transport : undefined;
+    }
+    getServerTransport(peerArg) {
+        const connection = this.serverConnections.get(peerArg);
+        return connection
+            && !connection.closed
+            && peerArg.transportOwner === this.webSocketTransportOwner
+            ? connection.transport
+            : undefined;
+    }
+    createRegistration(optionsArg) {
+        if (this.side !== 'client') {
+            throw new TypedSocketVirtualStreamError('Advanced VirtualStream registrations are client-only');
+        }
+        return this.createRegistrationForConnection(this.resolveConnection(), optionsArg);
+    }
+    [createAuthorizedServerRegistrationSymbol](peerArg, optionsArg) {
+        if (this.side !== 'server') {
+            throw new TypedSocketVirtualStreamError('Server VirtualStream registration is server-only');
+        }
+        if (typeof optionsArg.revalidate !== 'function') {
+            throw new TypeError('Server VirtualStream registration requires revalidation');
+        }
+        const connection = this.resolveConnection(peerArg);
+        if (connection.binding.side !== 'server' || connection.binding.peer !== peerArg) {
+            throw new TypedSocketVirtualStreamError('VirtualStream server peer binding is not exact');
+        }
+        return this.createRegistrationForConnection(connection, optionsArg);
+    }
+    createRegistrationForConnection(connection, optionsArg) {
+        this.requireReadyConnection(connection);
+        this.reserveStreamSlot(connection);
+        if (optionsArg.revalidate !== undefined && typeof optionsArg.revalidate !== 'function') {
+            throw new TypeError('VirtualStream revalidate must be a function');
+        }
+        const creatorDirection = optionsArg.creatorDirection;
+        if (creatorDirection !== 'send' && creatorDirection !== 'receive') {
+            throw new TypeError('creatorDirection must be send or receive');
+        }
+        const contentType = normalizeVirtualStreamContentType(optionsArg.contentType);
+        const integrity = normalizeVirtualStreamIntegrity(optionsArg.integrity);
+        const now = this.runtime.now();
+        if (!Number.isSafeInteger(now) || now < 0 || now > Number.MAX_SAFE_INTEGER - VIRTUAL_STREAM_CAPABILITY_TIMEOUT_MS) {
+            throw new VirtualStreamProtocolError('runtime now() cannot create a capability deadline');
+        }
+        this.pruneTombstones(connection);
+        let streamId = '';
+        for (let attempt = 0; attempt < 8; attempt++) {
+            const candidate = randomStreamId(this.runtime);
+            if (!connection.registrations.has(candidate)
+                && !connection.streams.has(candidate)
+                && !connection.tombstones.has(candidate)) {
+                streamId = candidate;
+                break;
+            }
+        }
+        if (!streamId) {
+            throw new TypedSocketVirtualStreamError('runtime repeatedly generated an occupied stream ID');
+        }
+        const descriptor = Object.freeze({
+            _isVirtualStream: true,
+            protocol: VIRTUAL_STREAM_PROTOCOL,
+            streamId,
+            creatorDirection,
+            ...(contentType === undefined ? {} : { contentType }),
+            ...(integrity === undefined ? {} : { integrity }),
+            transport: Object.freeze({
+                capability: randomCapability(this.runtime),
+                expiresAt: now + VIRTUAL_STREAM_CAPABILITY_TIMEOUT_MS,
+            }),
+        });
+        const state = this.createEndpointState(connection, descriptor, creatorDirection, true, optionsArg.revalidate, 'registered');
+        connection.registrations.set(streamId, state);
+        state.timer = this.runtime.setTimer(() => {
+            this.cleanupEndpoint(state, new TypedSocketVirtualStreamError('VirtualStream capability expired'), true, false);
+            if (!connection.closed)
+                this.addTombstone(connection, streamId);
+        }, VIRTUAL_STREAM_CAPABILITY_TIMEOUT_MS);
+        let disposed = false;
+        return Object.freeze({
+            descriptor,
+            endpoint: state.endpoint,
+            dispose: () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                if (state.status !== 'registered')
+                    return;
+                this.cleanupEndpoint(state, new TypedSocketVirtualStreamError('VirtualStream registration disposed'), true, false);
+            },
+        });
+    }
+    getStats(targetArg) {
+        const connection = this.resolveConnectionForInspection(targetArg);
+        let serverStreams = 0;
+        for (const current of this.serverConnections.values()) {
+            serverStreams += current.registrations.size + current.streams.size;
+        }
+        if (!connection) {
+            return {
+                connection: 'none',
+                handshakeReady: false,
+                registeredCapabilities: 0,
+                activeStreams: 0,
+                queuedChunks: 0,
+                queuedBytes: 0,
+                rawQueueFrames: 0,
+                rawQueueBytes: 0,
+                arrivalStamps: 0,
+                arrivalStampBytes: 0,
+                outboundFrames: 0,
+                retainedRevalidations: 0,
+                tombstones: 0,
+                serverConnections: this.serverConnections.size,
+                serverStreams,
+                serverRetainedRevalidations: this.retainedRevalidations,
+                serverRetainedBytes: this.serverRetainedBytes,
+            };
+        }
+        this.pruneTombstones(connection);
+        return {
+            connection: connection.binding.side,
+            handshakeReady: connection.handshakeReady,
+            registeredCapabilities: connection.registrations.size,
+            activeStreams: connection.streams.size,
+            queuedChunks: connection.queuedChunks,
+            queuedBytes: connection.queuedBytes,
+            rawQueueFrames: connection.rawQueue.length,
+            rawQueueBytes: connection.rawQueueBytes,
+            arrivalStamps: connection.arrivalStamps.length,
+            arrivalStampBytes: connection.arrivalStampBytes,
+            outboundFrames: connection.controlQueue.length
+                + connection.dataQueue.length
+                + (connection.serverInflight ? 1 : 0),
+            retainedRevalidations: connection.retainedRevalidations,
+            tombstones: connection.tombstones.size,
+            serverConnections: this.serverConnections.size,
+            serverStreams,
+            serverRetainedRevalidations: this.retainedRevalidations,
+            serverRetainedBytes: this.serverRetainedBytes,
+        };
+    }
+    async stageDescriptor(connectionArg, descriptorArg, optionsArg) {
+        if (!optionsArg
+            || !(optionsArg.abortSignal instanceof AbortSignal)
+            || !Number.isSafeInteger(optionsArg.timeoutMs)
+            || optionsArg.timeoutMs <= 0) {
+            throw new TypeError('VirtualStream open options are invalid');
+        }
+        if (optionsArg.abortSignal.aborted) {
+            throw optionsArg.abortSignal.reason ?? new Error('VirtualStream staging aborted');
+        }
+        this.requireReadyConnection(connectionArg);
+        const descriptor = this.validateDescriptor(descriptorArg);
+        const now = this.runtime.now();
+        if (!Number.isSafeInteger(now) || now < 0 || descriptor.transport.expiresAt <= now) {
+            throw new TypedSocketVirtualStreamError('VirtualStream capability is expired');
+        }
+        this.pruneTombstones(connectionArg);
+        if (connectionArg.registrations.has(descriptor.streamId)
+            || connectionArg.streams.has(descriptor.streamId)
+            || connectionArg.tombstones.has(descriptor.streamId)) {
+            throw new TypedSocketVirtualStreamError('VirtualStream descriptor is already active or consumed on this physical peer');
+        }
+        this.reserveStreamSlot(connectionArg);
+        const direction = descriptor.creatorDirection === 'send' ? 'receive' : 'send';
+        const state = this.createEndpointState(connectionArg, descriptor, direction, false, undefined, 'staged');
+        connectionArg.streams.set(descriptor.streamId, state);
+        state.timer = this.runtime.setTimer(() => {
+            this.cleanupEndpoint(state, new TypedSocketVirtualStreamError('VirtualStream staged capability expired'), true, false);
+        }, Math.min(descriptor.transport.expiresAt - now, VIRTUAL_STREAM_CAPABILITY_TIMEOUT_MS));
+        if (optionsArg.abortSignal.aborted) {
+            this.cleanupEndpoint(state, optionsArg.abortSignal.reason, true, false);
+            throw optionsArg.abortSignal.reason ?? new Error('VirtualStream staging aborted');
+        }
+        return state.endpoint;
+    }
+    ensureOpened(stateArg) {
+        if (stateArg.status === 'closed') {
+            return Promise.reject(stateArg.closeError ?? new Error('VirtualStream is closed'));
+        }
+        if (stateArg.status === 'open' || stateArg.status === 'fin-received' || stateArg.status === 'accepting' || stateArg.status === 'closing') {
+            return Promise.resolve();
+        }
+        if (stateArg.creator)
+            return stateArg.openedDeferred.promise;
+        if (stateArg.activationPromise)
+            return stateArg.activationPromise;
+        stateArg.activationPromise = this.activateStagedEndpoint(stateArg);
+        void stateArg.activationPromise.catch(() => { });
+        return stateArg.activationPromise;
+    }
+    async activateStagedEndpoint(stateArg) {
+        if (stateArg.status !== 'staged')
+            return await stateArg.openedDeferred.promise;
+        const remainingCapabilityMs = stateArg.descriptor.transport.expiresAt - this.runtime.now();
+        if (!Number.isSafeInteger(remainingCapabilityMs) || remainingCapabilityMs <= 0) {
+            const error = new TypedSocketVirtualStreamError('VirtualStream capability expired before OPEN');
+            this.cleanupEndpoint(stateArg, error, true, false);
+            throw error;
+        }
+        this.clearEndpointTimer(stateArg);
+        stateArg.status = 'opening';
+        stateArg.timer = this.runtime.setTimer(() => {
+            void this.failEndpoint(stateArg, new TypedSocketVirtualStreamError('VirtualStream OPEN timed out'), VIRTUAL_STREAM_RESET_CODES.TIMEOUT);
+        }, Math.min(remainingCapabilityMs, VIRTUAL_STREAM_CAPABILITY_TIMEOUT_MS));
+        try {
+            await this.enqueueFrame(stateArg.connection, {
+                type: VIRTUAL_STREAM_FRAME_TYPES.OPEN,
+                streamId: stateArg.descriptor.streamId,
+                capability: stateArg.descriptor.transport.capability,
+                descriptorDigest: createVirtualStreamDescriptorDigest(stateArg.descriptor),
+            });
+            await stateArg.openedDeferred.promise;
+        }
+        catch (errorArg) {
+            await this.failEndpoint(stateArg, errorArg, VIRTUAL_STREAM_RESET_CODES.ABORTED, false);
+            throw errorArg;
+        }
+    }
+    send(stateArg, chunkArg) {
+        let admission;
+        try {
+            admission = this.admitChunk(stateArg, chunkArg);
+        }
+        catch (errorArg) {
+            return Promise.reject(errorArg);
+        }
+        const result = stateArg.operationTail.then(async () => {
+            try {
+                await this.ensureOpened(stateArg);
+                await this.revalidate(stateArg, 'chunk');
+                this.assertEndpointOpen(stateArg, 'send');
+                await this.sendAdmission(stateArg, admission);
+            }
+            catch (errorArg) {
+                await this.failEndpoint(stateArg, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.ABORTED));
+                throw errorArg;
+            }
+        });
+        stateArg.operationTail = result.then(() => undefined, () => undefined);
+        return result.finally(() => this.releaseAdmission(stateArg, admission));
+    }
+    admitChunk(stateArg, chunkArg) {
+        if (!(chunkArg instanceof Uint8Array)) {
+            throw new TypeError('VirtualStream.send accepts only Uint8Array chunks');
+        }
+        if (stateArg.direction !== 'send' || stateArg.status === 'closed' || stateArg.terminalRequested) {
+            throw stateArg.closeError ?? new TypedSocketVirtualStreamError('VirtualStream sender is closing');
+        }
+        if (chunkArg.byteLength > VIRTUAL_STREAM_MAX_LOGICAL_CHUNK_BYTES) {
+            throw new RangeError(`VirtualStream logical chunks must not exceed ${VIRTUAL_STREAM_MAX_LOGICAL_CHUNK_BYTES} bytes`);
+        }
+        if (stateArg.admittedChunkCount >= 0xffffffff) {
+            throw new TypedSocketVirtualStreamError('VirtualStream chunk sequence is exhausted');
+        }
+        const nextByteLength = stateArg.admittedByteLength + chunkArg.byteLength;
+        if (!Number.isSafeInteger(nextByteLength)) {
+            throw new TypedSocketVirtualStreamError('VirtualStream byteLength exceeds the safe integer range');
+        }
+        if (stateArg.descriptor.integrity && nextByteLength > stateArg.descriptor.integrity.byteLength) {
+            throw new TypedSocketVirtualStreamError('VirtualStream bytes exceed declared integrity byteLength');
+        }
+        if (stateArg.pendingAdmissions >= VIRTUAL_STREAM_MAX_QUEUED_CHUNKS_PER_STREAM
+            || stateArg.connection.queuedChunks >= VIRTUAL_STREAM_MAX_QUEUED_CHUNKS_PER_CONNECTION
+            || stateArg.pendingAdmissionBytes + chunkArg.byteLength > VIRTUAL_STREAM_MAX_QUEUED_BYTES_PER_STREAM
+            || stateArg.connection.queuedBytes + chunkArg.byteLength > VIRTUAL_STREAM_MAX_QUEUED_BYTES_PER_CONNECTION) {
+            throw new TypedSocketVirtualStreamError('VirtualStream sender admission capacity exhausted');
+        }
+        this.reserveServerRetainedBytes(stateArg.connection, chunkArg.byteLength);
+        let admission;
+        try {
+            admission = {
+                sequence: stateArg.admittedChunkCount,
+                payload: copyVirtualStreamBytes(chunkArg),
+                accountingOwned: true,
+            };
+            stateArg.admissions.add(admission);
+            stateArg.admittedChunkCount++;
+            stateArg.admittedByteLength = nextByteLength;
+            stateArg.pendingAdmissions++;
+            stateArg.pendingAdmissionBytes += admission.payload.byteLength;
+            stateArg.connection.queuedChunks++;
+            stateArg.connection.queuedBytes += admission.payload.byteLength;
+            return admission;
+        }
+        catch (errorArg) {
+            if (admission)
+                stateArg.admissions.delete(admission);
+            this.releaseServerRetainedBytes(stateArg.connection, chunkArg.byteLength);
+            throw errorArg;
+        }
+    }
+    releaseAdmission(stateArg, admissionArg) {
+        if (!admissionArg.accountingOwned)
+            return;
+        admissionArg.accountingOwned = false;
+        stateArg.admissions.delete(admissionArg);
+        stateArg.pendingAdmissions--;
+        stateArg.pendingAdmissionBytes -= admissionArg.payload.byteLength;
+        stateArg.connection.queuedChunks--;
+        stateArg.connection.queuedBytes -= admissionArg.payload.byteLength;
+        this.releaseServerRetainedBytes(stateArg.connection, admissionArg.payload.byteLength);
+    }
+    async sendAdmission(stateArg, admissionArg) {
+        const acknowledgement = createDeferred();
+        stateArg.awaitingChunkAck = { sequence: admissionArg.sequence, deferred: acknowledgement };
+        try {
+            const payload = admissionArg.payload;
+            if (payload.byteLength === 0) {
+                await this.enqueueFrame(stateArg.connection, {
+                    type: VIRTUAL_STREAM_FRAME_TYPES.CHUNK,
+                    streamId: stateArg.descriptor.streamId,
+                    sequence: admissionArg.sequence,
+                    totalLength: 0,
+                    fragmentOffset: 0,
+                    payload,
+                });
+            }
+            else {
+                let offset = 0;
+                while (offset < payload.byteLength) {
+                    this.assertEndpointOpen(stateArg, 'send');
+                    const fragmentLength = Math.min(VIRTUAL_STREAM_MAX_FRAGMENT_PAYLOAD_BYTES, payload.byteLength - offset);
+                    await this.enqueueFrame(stateArg.connection, {
+                        type: VIRTUAL_STREAM_FRAME_TYPES.CHUNK,
+                        streamId: stateArg.descriptor.streamId,
+                        sequence: admissionArg.sequence,
+                        totalLength: payload.byteLength,
+                        fragmentOffset: offset,
+                        payload: payload.subarray(offset, offset + fragmentLength),
+                    });
+                    offset += fragmentLength;
+                }
+            }
+            stateArg.hasher?.update(payload);
+            stateArg.processedChunkCount++;
+            stateArg.processedByteLength += payload.byteLength;
+            this.refreshProgressTimer(stateArg);
+            await acknowledgement.promise;
+        }
+        finally {
+            if (stateArg.awaitingChunkAck?.deferred === acknowledgement) {
+                stateArg.awaitingChunkAck = undefined;
+            }
+        }
+    }
+    closeSender(stateArg) {
+        if (stateArg.terminalPromise)
+            return stateArg.terminalPromise;
+        if (stateArg.direction !== 'send' || stateArg.status === 'closed') {
+            return Promise.reject(stateArg.closeError ?? new TypedSocketVirtualStreamError('VirtualStream sender is closed'));
+        }
+        stateArg.terminalRequested = true;
+        const closeOperation = stateArg.operationTail.then(async () => {
+            await this.ensureOpened(stateArg);
+            this.assertEndpointOpen(stateArg, 'send');
+            const integrity = stateArg.descriptor.integrity;
+            if (integrity) {
+                const digest = `sha256:${stateArg.hasher.digest()}`;
+                if (stateArg.processedByteLength !== integrity.byteLength
+                    || digest !== integrity.digest) {
+                    const error = new TypedSocketVirtualStreamError('VirtualStream sender integrity does not match the declaration');
+                    await this.failEndpoint(stateArg, error, VIRTUAL_STREAM_RESET_CODES.INTEGRITY_ERROR);
+                    throw error;
+                }
+            }
+            stateArg.status = 'closing';
+            this.refreshProgressTimer(stateArg);
+            await this.enqueueFrame(stateArg.connection, {
+                type: VIRTUAL_STREAM_FRAME_TYPES.FIN,
+                streamId: stateArg.descriptor.streamId,
+                chunkCount: stateArg.processedChunkCount,
+                byteLength: stateArg.processedByteLength,
+            });
+            return await stateArg.completionDeferred.promise;
+        });
+        const result = closeOperation.catch(async (errorArg) => {
+            await this.failEndpoint(stateArg, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.ABORTED));
+            throw errorArg;
+        });
+        stateArg.operationTail = result.then(() => undefined, () => undefined);
+        stateArg.terminalPromise = result;
+        return result;
+    }
+    async receive(stateArg, modeArg) {
+        if (stateArg.direction !== 'receive') {
+            throw new TypeError('send VirtualStreams cannot receive');
+        }
+        if (stateArg.receiveMode && stateArg.receiveMode !== modeArg) {
+            throw new TypedSocketVirtualStreamError('VirtualStream direct receive and readable consumption are mutually exclusive');
+        }
+        stateArg.receiveMode = modeArg;
+        if (stateArg.receiveActive) {
+            throw new TypedSocketVirtualStreamError('VirtualStream receiver permits one active receive');
+        }
+        stateArg.receiveActive = true;
+        try {
+            await this.ensureOpened(stateArg);
+            while (stateArg.completedChunks.length === 0) {
+                if (stateArg.finReceived)
+                    return undefined;
+                if (stateArg.status === 'closed') {
+                    throw stateArg.closeError ?? new TypedSocketVirtualStreamError('VirtualStream receiver is closed');
+                }
+                const waiter = createDeferred();
+                stateArg.receiveWaiters.add(waiter);
+                try {
+                    await waiter.promise;
+                }
+                finally {
+                    stateArg.receiveWaiters.delete(waiter);
+                }
+            }
+            const completed = stateArg.completedChunks.shift();
+            stateArg.connection.queuedChunks--;
+            stateArg.connection.queuedBytes -= completed.payload.byteLength;
+            stateArg.deliveringChunk = completed;
+            await this.enqueueFrame(stateArg.connection, {
+                type: VIRTUAL_STREAM_FRAME_TYPES.CHUNK_ACK,
+                streamId: stateArg.descriptor.streamId,
+                sequence: completed.sequence,
+            });
+            if (stateArg.deliveringChunk === completed)
+                stateArg.deliveringChunk = undefined;
+            this.releaseCompletedChunkAccounting(stateArg, completed);
+            this.refreshProgressTimer(stateArg);
+            return completed.payload;
+        }
+        catch (errorArg) {
+            await this.failEndpoint(stateArg, errorArg, VIRTUAL_STREAM_RESET_CODES.ABORTED);
+            throw errorArg;
+        }
+        finally {
+            stateArg.receiveActive = false;
+        }
+    }
+    acceptReceiver(stateArg) {
+        if (stateArg.terminalPromise)
+            return stateArg.terminalPromise;
+        if (stateArg.direction !== 'receive' || stateArg.status === 'closed') {
+            return Promise.reject(new TypedSocketVirtualStreamError('VirtualStream receiver is closed'));
+        }
+        stateArg.terminalRequested = true;
+        const result = (async () => {
+            try {
+                await this.ensureOpened(stateArg);
+                if (!stateArg.finReceived
+                    || stateArg.completedChunks.length !== 0
+                    || stateArg.reassembly
+                    || stateArg.status !== 'fin-received') {
+                    throw new TypedSocketVirtualStreamError('VirtualStream.accept requires FIN and a fully drained receiver');
+                }
+                await this.revalidate(stateArg, 'accept');
+                this.assertEndpointOwned(stateArg);
+                stateArg.status = 'accepting';
+                const receipt = createReceipt(stateArg);
+                await this.enqueueFrame(stateArg.connection, {
+                    type: VIRTUAL_STREAM_FRAME_TYPES.ACCEPT,
+                    streamId: stateArg.descriptor.streamId,
+                    chunkCount: receipt.chunkCount,
+                    byteLength: receipt.byteLength,
+                    integrityVerified: receipt.verifiedIntegrity !== null,
+                });
+                stateArg.completionDeferred.resolve(receipt);
+                this.cleanupEndpoint(stateArg, undefined, false);
+                return receipt;
+            }
+            catch (errorArg) {
+                await this.failEndpoint(stateArg, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.ABORTED));
+                throw errorArg;
+            }
+        })();
+        stateArg.terminalPromise = result;
+        return result;
+    }
+    rejectReceiver(stateArg, reasonArg) {
+        if (stateArg.terminalPromise)
+            return stateArg.terminalPromise.then(() => undefined);
+        stateArg.terminalRequested = true;
+        const result = (async () => {
+            if (stateArg.creator && stateArg.status === 'registered') {
+                this.cleanupEndpoint(stateArg, asError(reasonArg, 'VirtualStream receiver rejected'), true, false);
+                return;
+            }
+            await this.ensureOpened(stateArg);
+            try {
+                await this.revalidate(stateArg, 'reject');
+            }
+            catch (errorArg) {
+                await this.failEndpoint(stateArg, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.AUTHORITY_REVOKED));
+                throw errorArg;
+            }
+            const error = asError(reasonArg, 'VirtualStream receiver rejected');
+            await this.failEndpoint(stateArg, error, VIRTUAL_STREAM_RESET_CODES.REJECTED);
+        })();
+        stateArg.terminalPromise = result;
+        return result;
+    }
+    async abortEndpoint(stateArg, reasonArg) {
+        if (stateArg.status === 'closed')
+            return await stateArg.closedDeferred.promise;
+        const error = asError(reasonArg, 'VirtualStream aborted');
+        if (stateArg.status === 'registered' || stateArg.status === 'staged') {
+            this.cleanupEndpoint(stateArg, error, true, false);
+            return;
+        }
+        await this.failEndpoint(stateArg, error, VIRTUAL_STREAM_RESET_CODES.ABORTED);
+    }
+    createConnection(bindingArg) {
+        let transport;
+        const connection = {
+            binding: bindingArg,
+            get transport() {
+                return transport;
+            },
+            registrations: new Map(),
+            streams: new Map(),
+            tombstones: new Map(),
+            rawQueue: [],
+            controlQueue: [],
+            dataQueue: [],
+            revalidationControllers: new Set(),
+            arrivalStamps: [],
+            closed: false,
+            handshakePending: false,
+            handshakeReady: false,
+            processingRaw: false,
+            rawQueueBytes: 0,
+            processingRawBytes: 0,
+            arrivalStampBytes: 0,
+            nextArrivalSequence: 1,
+            queuedChunks: 0,
+            queuedBytes: 0,
+            retainedRevalidations: 0,
+            clientTurnScheduled: false,
+        };
+        transport = new VirtualStreamConnectionTransport(this, connection);
+        if (bindingArg.side === 'server') {
+            connection.handshakeTimer = this.runtime.setTimer(() => {
+                if (!connection.closed && !connection.handshakeReady) {
+                    this.closeConnection(connection, 1008, 'TypedSocket version handshake timed out');
+                }
+            }, TYPEDSOCKET_HANDSHAKE_TIMEOUT_MS);
+        }
+        return connection;
+    }
+    createEndpointState(connectionArg, descriptorArg, directionArg, creatorArg, revalidateArg, statusArg) {
+        const retainedMetadataBytes = virtualStreamTextEncoder.encode(JSON.stringify(descriptorArg)).byteLength;
+        this.reserveServerRetainedBytes(connectionArg, retainedMetadataBytes);
+        try {
+            const state = {
+                connection: connectionArg,
+                descriptor: descriptorArg,
+                creator: creatorArg,
+                direction: directionArg,
+                revalidate: revalidateArg,
+                openedDeferred: createDeferred(),
+                completionDeferred: createDeferred(),
+                closedDeferred: createDeferred(),
+                revalidationControllers: new Set(),
+                admissions: new Set(),
+                endpoint: undefined,
+                status: statusArg,
+                hasher: descriptorArg.integrity ? plugins.smarthash.createSha256Hasher() : undefined,
+                operationTail: Promise.resolve(),
+                terminalRequested: false,
+                admittedChunkCount: 0,
+                admittedByteLength: 0,
+                processedChunkCount: 0,
+                processedByteLength: 0,
+                pendingAdmissions: 0,
+                pendingAdmissionBytes: 0,
+                receiveActive: false,
+                completedChunks: [],
+                receiveWaiters: new Set(),
+                finReceived: false,
+                retainedMetadataBytes,
+                metadataAccountingOwned: true,
+            };
+            state.endpoint = directionArg === 'send'
+                ? new VirtualStreamSender(this, state)
+                : new VirtualStreamReceiver(this, state);
+            return state;
+        }
+        catch (errorArg) {
+            this.releaseServerRetainedBytes(connectionArg, retainedMetadataBytes);
+            throw errorArg;
+        }
+    }
+    bindServerPeer(peerArg) {
+        if (this.side !== 'server'
+            || !this.serverAttached
+            || peerArg.transportOwner !== this.webSocketTransportOwner)
+            return;
+        const existing = this.serverConnections.get(peerArg);
+        if (existing && !existing.closed)
+            return;
+        const settlementExisting = this.serverSettlementConnections.get(peerArg);
+        if (settlementExisting?.serverInflight) {
+            try {
+                peerArg.close(1013, 'virtual-stream-v1 peer settlement is still pending');
+            }
+            catch { }
+            return;
+        }
+        if (settlementExisting)
+            this.serverSettlementConnections.delete(peerArg);
+        if (this.serverConnections.size >= VIRTUAL_STREAM_MAX_CONNECTIONS_PER_SERVER) {
+            this.emitDiagnostic({
+                kind: 'peerRejected',
+                side: 'server',
+                closeCode: 1013,
+                reason: 'virtual-stream-v1 server connection capacity exhausted',
+            });
+            try {
+                peerArg.close(1013, 'virtual-stream-v1 server connection capacity exhausted');
+            }
+            catch { }
+            return;
+        }
+        const connection = this.createConnection(Object.freeze({
+            side: 'server',
+            peer: peerArg,
+        }));
+        this.serverConnections.set(peerArg, connection);
+        this.serverSettlementConnections.set(peerArg, connection);
+    }
+    unbindServerPeer(peerArg, reasonArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (!connection)
+            return;
+        this.failConnection(connection, reasonArg, false);
+        this.serverConnections.delete(peerArg);
+    }
+    settleServerHandshake(peerArg, responseArg, settlementArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (!connection || connection.closed || !connection.handshakePending)
+            return;
+        const pendingHandshake = connection.pendingHandshake;
+        connection.handshakePending = false;
+        connection.pendingHandshake = undefined;
+        const exactEnvelope = Boolean(pendingHandshake
+            && isExactHandshakeResponse(responseArg, pendingHandshake.correlationId));
+        const sent = settlementArg.status === 'sent' || settlementArg.status === 'accepted';
+        if (!exactEnvelope || !sent) {
+            this.closeConnection(connection, 1008, 'TypedSocket version handshake failed');
+            return;
+        }
+        this.clearConnectionTimer(connection, 'handshakeTimer');
+        try {
+            const callbackResult = this.onServerHandshakeReady?.(peerArg);
+            if (callbackResult !== undefined) {
+                if (((typeof callbackResult === 'object' && callbackResult !== null)
+                    || typeof callbackResult === 'function')
+                    && !this.observedInvalidReadyPromises.has(callbackResult)) {
+                    this.observedInvalidReadyPromises.add(callbackResult);
+                    try {
+                        void Reflect.apply(nativePromiseThen, callbackResult, [undefined, () => undefined]);
+                    }
+                    catch { }
+                }
+                throw new TypeError('TypedSocket server ready callback must return undefined');
+            }
+        }
+        catch {
+            this.closeConnection(connection, 1011, 'TypedSocket server ready callback failed');
+            return;
+        }
+        connection.handshakeReady = true;
+    }
+    stampServerTextFrame(peerArg, textArg, _reportedSizeArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (!connection
+            || connection.closed
+            || connection.binding.side !== 'server'
+            || connection.binding.peer !== peerArg
+            || peerArg.transportOwner !== this.webSocketTransportOwner) {
+            return undefined;
+        }
+        const byteLength = virtualStreamTextEncoder.encode(textArg).byteLength;
+        if (connection.arrivalStamps.length >= VIRTUAL_STREAM_MAX_ARRIVAL_STAMPS_PER_CONNECTION
+            || connection.arrivalStampBytes + byteLength
+                > VIRTUAL_STREAM_MAX_ARRIVAL_STAMP_BYTES_PER_CONNECTION
+            || connection.nextArrivalSequence > Number.MAX_SAFE_INTEGER) {
+            this.closeConnection(connection, 1009, 'TypedSocket text arrival authority capacity exhausted');
+            return undefined;
+        }
+        let envelope;
+        try {
+            envelope = JSON.parse(textArg);
+        }
+        catch {
+            this.closeConnection(connection, 1007, 'TypedSocket text frame is malformed');
+            return undefined;
+        }
+        const identity = parseArrivalIdentity(envelope);
+        if (!identity) {
+            this.closeConnection(connection, 1008, 'TypedSocket text envelope is malformed');
+            return undefined;
+        }
+        if (identity.phase === 'request') {
+            const request = isPlainRecord(envelope)
+                ? getOwnEnumerableData(envelope, 'request')
+                : undefined;
+            if (!request || typeof request !== 'object') {
+                this.closeConnection(connection, 1008, 'TypedSocket text request is malformed');
+                return undefined;
+            }
+        }
+        const readyAtArrival = connection.handshakeReady;
+        const handshake = isExactHandshakeRequest(envelope);
+        if (!readyAtArrival) {
+            if (!handshake
+                || connection.arrivalStamps.length > 0
+                || connection.authorizedHandshake
+                || connection.pendingHandshake
+                || connection.handshakePending) {
+                this.closeConnection(connection, 1008, 'TypedSocket text frame arrived before readiness');
+                return undefined;
+            }
+        }
+        else if (identity.method === TYPEDSOCKET_VERSION_METHOD) {
+            this.closeConnection(connection, 1008, 'TypedSocket version handshake is reserved for startup');
+            return undefined;
+        }
+        try {
+            this.reserveServerRetainedBytes(connection, byteLength);
+        }
+        catch {
+            this.closeConnection(connection, 1013, 'virtual-stream-v1 server retained-byte capacity exhausted');
+            return undefined;
+        }
+        try {
+            const sequence = connection.nextArrivalSequence++;
+            connection.arrivalStamps.push(Object.freeze({
+                sequence,
+                byteLength,
+                readyAtArrival,
+                method: identity.method,
+                correlationId: identity.correlationId,
+                phase: identity.phase,
+                handshake,
+            }));
+            connection.arrivalStampBytes += byteLength;
+            return sequence;
+        }
+        catch (errorArg) {
+            this.releaseServerRetainedBytes(connection, byteLength);
+            throw errorArg;
+        }
+    }
+    enqueueServerRawFrame(peerArg, dataArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (!connection || peerArg.transportOwner !== this.webSocketTransportOwner)
+            return;
+        if (!connection.handshakeReady) {
+            this.closeConnection(connection, 1008, 'TypedSocket binary frame arrived before readiness');
+            return;
+        }
+        this.enqueueRawFrame(connection, dataArg);
+    }
+    enqueueRawFrame(connectionArg, dataArg) {
+        if (connectionArg.closed)
+            return;
+        if (!connectionArg.handshakeReady) {
+            this.closeConnection(connectionArg, 1008, 'TypedSocket binary frame arrived before readiness');
+            return;
+        }
+        if (connectionArg.rawQueue.length >= VIRTUAL_STREAM_MAX_RAW_QUEUE_FRAMES
+            || connectionArg.rawQueueBytes + dataArg.byteLength > VIRTUAL_STREAM_MAX_RAW_QUEUE_BYTES) {
+            this.closeConnection(connectionArg, 1009, 'virtual-stream-v1 raw queue overflow');
+            return;
+        }
+        try {
+            this.reserveServerRetainedBytes(connectionArg, dataArg.byteLength);
+        }
+        catch {
+            this.closeConnection(connectionArg, 1013, 'virtual-stream-v1 server retained-byte capacity exhausted');
+            return;
+        }
+        try {
+            const bytes = copyVirtualStreamBytes(dataArg);
+            connectionArg.rawQueue.push(bytes);
+            connectionArg.rawQueueBytes += bytes.byteLength;
+        }
+        catch (errorArg) {
+            this.releaseServerRetainedBytes(connectionArg, dataArg.byteLength);
+            this.failConnection(connectionArg, errorArg, true);
+            return;
+        }
+        if (!connectionArg.processingRaw)
+            void this.processRawQueue(connectionArg);
+    }
+    async processRawQueue(connectionArg) {
+        if (connectionArg.processingRaw || connectionArg.closed)
+            return;
+        connectionArg.processingRaw = true;
+        try {
+            while (!connectionArg.closed && connectionArg.rawQueue.length > 0) {
+                const bytes = connectionArg.rawQueue.shift();
+                connectionArg.rawQueueBytes -= bytes.byteLength;
+                connectionArg.processingRawBytes = bytes.byteLength;
+                try {
+                    let frame;
+                    try {
+                        frame = decodeVirtualStreamFrame(bytes);
+                    }
+                    catch (errorArg) {
+                        this.closeConnection(connectionArg, 1002, 'invalid virtual-stream-v1 frame');
+                        throw errorArg;
+                    }
+                    await this.handleFrame(connectionArg, frame);
+                }
+                finally {
+                    const processingRawBytes = connectionArg.processingRawBytes;
+                    connectionArg.processingRawBytes = 0;
+                    this.releaseServerRetainedBytes(connectionArg, processingRawBytes);
+                }
+            }
+        }
+        catch {
+            if (!connectionArg.closed) {
+                this.closeConnection(connectionArg, 1002, 'virtual-stream-v1 dispatch failed');
+            }
+        }
+        finally {
+            connectionArg.processingRaw = false;
+        }
+    }
+    async handleFrame(connectionArg, frameArg) {
+        this.pruneTombstones(connectionArg);
+        if (frameArg.type === VIRTUAL_STREAM_FRAME_TYPES.OPEN) {
+            await this.handleOpen(connectionArg, frameArg);
+            return;
+        }
+        const stream = connectionArg.streams.get(frameArg.streamId);
+        if (!stream) {
+            if (frameArg.type !== VIRTUAL_STREAM_FRAME_TYPES.RESET) {
+                await this.sendReset(connectionArg, frameArg.streamId, VIRTUAL_STREAM_RESET_CODES.CAPABILITY_REJECTED, 'Unknown or expired stream capability');
+            }
+            return;
+        }
+        switch (frameArg.type) {
+            case VIRTUAL_STREAM_FRAME_TYPES.OPEN_ACK:
+                await this.handleOpenAck(stream);
+                return;
+            case VIRTUAL_STREAM_FRAME_TYPES.CHUNK:
+                await this.handleChunk(stream, frameArg);
+                return;
+            case VIRTUAL_STREAM_FRAME_TYPES.CHUNK_ACK:
+                this.handleChunkAck(stream, frameArg.sequence);
+                return;
+            case VIRTUAL_STREAM_FRAME_TYPES.FIN:
+                await this.handleFin(stream, frameArg.chunkCount, frameArg.byteLength);
+                return;
+            case VIRTUAL_STREAM_FRAME_TYPES.ACCEPT:
+                await this.handleAccept(stream, frameArg.chunkCount, frameArg.byteLength, frameArg.integrityVerified);
+                return;
+            case VIRTUAL_STREAM_FRAME_TYPES.RESET:
+                await this.handleReset(stream, frameArg.code, frameArg.reason);
+                return;
+        }
+    }
+    async handleOpen(connectionArg, frameArg) {
+        const registration = connectionArg.registrations.get(frameArg.streamId);
+        if (!connectionArg.handshakeReady
+            || !registration
+            || registration.status !== 'registered'
+            || connectionArg.tombstones.has(frameArg.streamId)) {
+            await this.sendReset(connectionArg, frameArg.streamId, VIRTUAL_STREAM_RESET_CODES.CAPABILITY_REJECTED, 'Unknown, replayed, or expired stream capability');
+            return;
+        }
+        this.clearEndpointTimer(registration);
+        connectionArg.registrations.delete(frameArg.streamId);
+        connectionArg.streams.set(frameArg.streamId, registration);
+        registration.status = 'opening';
+        try {
+            if (frameArg.capability !== registration.descriptor.transport.capability
+                || frameArg.descriptorDigest !== createVirtualStreamDescriptorDigest(registration.descriptor)
+                || registration.descriptor.transport.expiresAt <= this.runtime.now()) {
+                throw new TypedSocketVirtualStreamError('OPEN does not match the registered capability');
+            }
+            await this.revalidate(registration, 'open');
+            this.assertEndpointOwned(registration);
+            registration.status = 'open';
+            await this.enqueueFrame(connectionArg, {
+                type: VIRTUAL_STREAM_FRAME_TYPES.OPEN_ACK,
+                streamId: frameArg.streamId,
+            });
+            registration.openedDeferred.resolve();
+            this.refreshProgressTimer(registration);
+        }
+        catch (errorArg) {
+            await this.failEndpoint(registration, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.CAPABILITY_REJECTED));
+        }
+    }
+    async handleOpenAck(stateArg) {
+        if (stateArg.creator || stateArg.status !== 'opening') {
+            await this.failEndpoint(stateArg, new VirtualStreamProtocolError('unexpected OPEN_ACK'), VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR);
+            return;
+        }
+        this.clearEndpointTimer(stateArg);
+        stateArg.status = 'open';
+        stateArg.openedDeferred.resolve();
+        this.refreshProgressTimer(stateArg);
+    }
+    async handleChunk(stateArg, frameArg) {
+        if (stateArg.direction !== 'receive' || stateArg.status !== 'open') {
+            await this.failEndpoint(stateArg, new VirtualStreamProtocolError('unexpected CHUNK'), VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR);
+            return;
+        }
+        try {
+            let reassembly = stateArg.reassembly;
+            if (!reassembly) {
+                if (stateArg.processedChunkCount >= 0xffffffff
+                    ||
+                        frameArg.sequence !== stateArg.processedChunkCount
+                    || frameArg.fragmentOffset !== 0
+                    || stateArg.completedChunks.length >= VIRTUAL_STREAM_MAX_QUEUED_CHUNKS_PER_STREAM
+                    || stateArg.connection.queuedChunks >= VIRTUAL_STREAM_MAX_QUEUED_CHUNKS_PER_CONNECTION
+                    || stateArg.connection.queuedBytes + frameArg.totalLength > VIRTUAL_STREAM_MAX_QUEUED_BYTES_PER_CONNECTION) {
+                    throw new VirtualStreamProtocolError('CHUNK sequence or receiver capacity is invalid');
+                }
+                const retainedForStream = stateArg.completedChunks.reduce((sumArg, chunkArg) => sumArg + chunkArg.payload.byteLength, 0);
+                if (retainedForStream + frameArg.totalLength > VIRTUAL_STREAM_MAX_QUEUED_BYTES_PER_STREAM) {
+                    throw new TypedSocketVirtualStreamError('VirtualStream receiver byte capacity exhausted');
+                }
+                this.reserveServerRetainedBytes(stateArg.connection, frameArg.totalLength);
+                try {
+                    reassembly = {
+                        sequence: frameArg.sequence,
+                        payload: new Uint8Array(new ArrayBuffer(frameArg.totalLength)),
+                        nextOffset: 0,
+                        accountingOwned: true,
+                    };
+                    stateArg.reassembly = reassembly;
+                    stateArg.connection.queuedChunks++;
+                    stateArg.connection.queuedBytes += frameArg.totalLength;
+                }
+                catch (errorArg) {
+                    this.releaseServerRetainedBytes(stateArg.connection, frameArg.totalLength);
+                    throw errorArg;
+                }
+            }
+            if (frameArg.sequence !== reassembly.sequence
+                || frameArg.totalLength !== reassembly.payload.byteLength
+                || frameArg.fragmentOffset !== reassembly.nextOffset) {
+                throw new VirtualStreamProtocolError('CHUNK fragment order is invalid');
+            }
+            reassembly.payload.set(frameArg.payload, frameArg.fragmentOffset);
+            reassembly.nextOffset += frameArg.payload.byteLength;
+            this.refreshProgressTimer(stateArg);
+            if (reassembly.nextOffset !== reassembly.payload.byteLength)
+                return;
+            await this.revalidate(stateArg, 'chunk');
+            this.assertEndpointOwned(stateArg);
+            if (stateArg.reassembly !== reassembly) {
+                throw new TypedSocketVirtualStreamError('VirtualStream changed during chunk revalidation');
+            }
+            const nextByteLength = stateArg.processedByteLength + reassembly.payload.byteLength;
+            if (!Number.isSafeInteger(nextByteLength)
+                || (stateArg.descriptor.integrity && nextByteLength > stateArg.descriptor.integrity.byteLength)) {
+                throw new VirtualStreamProtocolError('CHUNK exceeds declared stream byteLength');
+            }
+            stateArg.completedChunks.push({
+                sequence: reassembly.sequence,
+                payload: reassembly.payload,
+                accountingOwned: true,
+            });
+            stateArg.reassembly = undefined;
+            reassembly.accountingOwned = false;
+            stateArg.hasher?.update(reassembly.payload);
+            stateArg.processedChunkCount++;
+            stateArg.processedByteLength = nextByteLength;
+            this.wakeReceivers(stateArg);
+        }
+        catch (errorArg) {
+            await this.failEndpoint(stateArg, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR));
+        }
+    }
+    handleChunkAck(stateArg, sequenceArg) {
+        if (stateArg.direction !== 'send' || stateArg.status !== 'open') {
+            void this.failEndpoint(stateArg, new VirtualStreamProtocolError('unexpected CHUNK_ACK'), VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR);
+            return;
+        }
+        const awaiting = stateArg.awaitingChunkAck;
+        if (!awaiting || awaiting.sequence !== sequenceArg) {
+            void this.failEndpoint(stateArg, new VirtualStreamProtocolError('CHUNK_ACK does not match the pending logical chunk'), VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR);
+            return;
+        }
+        this.refreshProgressTimer(stateArg);
+        awaiting.deferred.resolve();
+    }
+    async handleFin(stateArg, chunkCountArg, byteLengthArg) {
+        if (stateArg.direction !== 'receive'
+            || stateArg.status !== 'open'
+            || stateArg.reassembly
+            || chunkCountArg !== stateArg.processedChunkCount
+            || byteLengthArg !== stateArg.processedByteLength) {
+            await this.failEndpoint(stateArg, new VirtualStreamProtocolError('FIN does not match the received logical sequence'), VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR);
+            return;
+        }
+        const integrity = stateArg.descriptor.integrity;
+        if (integrity) {
+            const digest = `sha256:${stateArg.hasher.digest()}`;
+            if (byteLengthArg !== integrity.byteLength || digest !== integrity.digest) {
+                await this.failEndpoint(stateArg, new VirtualStreamProtocolError('VirtualStream integrity verification failed'), VIRTUAL_STREAM_RESET_CODES.INTEGRITY_ERROR);
+                return;
+            }
+        }
+        stateArg.finReceived = true;
+        stateArg.status = 'fin-received';
+        this.refreshProgressTimer(stateArg);
+        this.wakeReceivers(stateArg);
+    }
+    async handleAccept(stateArg, chunkCountArg, byteLengthArg, integrityVerifiedArg) {
+        if (stateArg.direction !== 'send'
+            || stateArg.status !== 'closing'
+            || chunkCountArg !== stateArg.processedChunkCount
+            || byteLengthArg !== stateArg.processedByteLength
+            || integrityVerifiedArg !== Boolean(stateArg.descriptor.integrity)) {
+            await this.failEndpoint(stateArg, new VirtualStreamProtocolError('ACCEPT does not match the sent logical sequence'), VIRTUAL_STREAM_RESET_CODES.PROTOCOL_ERROR);
+            return;
+        }
+        try {
+            await this.revalidate(stateArg, 'accept');
+            this.assertEndpointOwned(stateArg);
+            const receipt = createReceipt(stateArg);
+            stateArg.completionDeferred.resolve(receipt);
+            this.cleanupEndpoint(stateArg, undefined, false);
+        }
+        catch (errorArg) {
+            await this.failEndpoint(stateArg, errorArg, this.revalidationResetCode(errorArg, VIRTUAL_STREAM_RESET_CODES.AUTHORITY_REVOKED));
+        }
+    }
+    async handleReset(stateArg, codeArg, reasonArg) {
+        try {
+            await this.revalidate(stateArg, 'reject');
+        }
+        catch { }
+        this.cleanupEndpoint(stateArg, new TypedSocketVirtualStreamError(`virtual-stream-v1 peer reset stream (${codeArg}): ${reasonArg}`), true);
+    }
+    async revalidate(stateArg, operationArg) {
+        if (!stateArg.creator || !stateArg.revalidate)
+            return;
+        this.assertEndpointOwned(stateArg);
+        if (stateArg.connection.retainedRevalidations >= VIRTUAL_STREAM_MAX_REVALIDATIONS_PER_CONNECTION
+            || this.retainedRevalidations >= VIRTUAL_STREAM_MAX_REVALIDATIONS_PER_SERVER) {
+            throw new TypedSocketVirtualStreamError('VirtualStream revalidation capacity exhausted');
+        }
+        const now = this.runtime.now();
+        if (!Number.isSafeInteger(now) || now < 0 || now > Number.MAX_SAFE_INTEGER - VIRTUAL_STREAM_REVALIDATION_TIMEOUT_MS) {
+            throw new VirtualStreamProtocolError('runtime now() cannot create a revalidation deadline');
+        }
+        const controller = new AbortController();
+        stateArg.revalidationControllers.add(controller);
+        stateArg.connection.revalidationControllers.add(controller);
+        stateArg.connection.retainedRevalidations++;
+        this.retainedRevalidations++;
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            stateArg.revalidationControllers.delete(controller);
+            stateArg.connection.revalidationControllers.delete(controller);
+            stateArg.connection.retainedRevalidations--;
+            this.retainedRevalidations--;
+            this.releaseEndpointMetadataAccounting(stateArg);
+        };
+        const outcome = Promise.resolve()
+            .then(() => stateArg.revalidate(Object.freeze({
+            operation: operationArg,
+            descriptor: stateArg.descriptor,
+            connection: stateArg.connection.binding,
+            abortSignal: controller.signal,
+            deadline: now + VIRTUAL_STREAM_REVALIDATION_TIMEOUT_MS,
+        })))
+            .then((allowedArg) => allowedArg === true ? 'allowed' : 'denied', () => 'failed');
+        void outcome.then(release, release);
+        const timeout = this.runtime.setTimer(() => {
+            controller.abort(new TypedSocketVirtualStreamError('VirtualStream revalidation timed out'));
+        }, VIRTUAL_STREAM_REVALIDATION_TIMEOUT_MS);
+        const aborted = new Promise((resolveArg) => {
+            const resolve = () => resolveArg('aborted');
+            controller.signal.addEventListener('abort', resolve, { once: true });
+            if (controller.signal.aborted)
+                resolve();
+        });
+        try {
+            const result = await Promise.race([outcome, aborted]);
+            if (result === 'allowed') {
+                this.assertEndpointOwned(stateArg);
+                return;
+            }
+            if (result === 'aborted') {
+                throw asError(controller.signal.reason, 'VirtualStream revalidation was aborted');
+            }
+            throw new TypedSocketVirtualStreamError(result === 'failed'
+                ? 'VirtualStream revalidation callback failed'
+                : 'VirtualStream authority was revoked');
+        }
+        finally {
+            this.runtime.clearTimer(timeout);
+        }
+    }
+    revalidationResetCode(errorArg, fallbackArg) {
+        if (errorArg instanceof TypedSocketVirtualStreamError) {
+            if (errorArg.message.includes('capacity'))
+                return VIRTUAL_STREAM_RESET_CODES.RESOURCE_LIMIT;
+            if (errorArg.message.includes('timed out'))
+                return VIRTUAL_STREAM_RESET_CODES.TIMEOUT;
+            if (errorArg.message.includes('authority') || errorArg.message.includes('callback')) {
+                return VIRTUAL_STREAM_RESET_CODES.AUTHORITY_REVOKED;
+            }
+        }
+        return fallbackArg;
+    }
+    reserveServerRetainedBytes(connectionArg, additionalBytesArg) {
+        if (connectionArg.binding.side !== 'server' || additionalBytesArg === 0)
+            return;
+        const nextRetainedBytes = this.serverRetainedBytes + additionalBytesArg;
+        if (!Number.isSafeInteger(additionalBytesArg)
+            || additionalBytesArg < 0
+            || !Number.isSafeInteger(nextRetainedBytes)
+            || nextRetainedBytes > VIRTUAL_STREAM_MAX_RETAINED_BYTES_PER_SERVER) {
+            throw new TypedSocketVirtualStreamError('virtual-stream-v1 server retained-byte capacity exhausted');
+        }
+        this.serverRetainedBytes = nextRetainedBytes;
+    }
+    releaseServerRetainedBytes(connectionArg, retainedBytesArg) {
+        if (connectionArg.binding.side !== 'server' || retainedBytesArg === 0)
+            return;
+        if (!Number.isSafeInteger(retainedBytesArg)
+            || retainedBytesArg < 0
+            || this.serverRetainedBytes < retainedBytesArg) {
+            throw new VirtualStreamProtocolError('virtual-stream-v1 server retained-byte accounting underflow');
+        }
+        this.serverRetainedBytes -= retainedBytesArg;
+    }
+    releaseEndpointMetadataAccounting(stateArg) {
+        if (stateArg.status !== 'closed'
+            || stateArg.revalidationControllers.size > 0
+            || !stateArg.metadataAccountingOwned)
+            return;
+        stateArg.metadataAccountingOwned = false;
+        this.releaseServerRetainedBytes(stateArg.connection, stateArg.retainedMetadataBytes);
+    }
+    releaseCompletedChunkAccounting(stateArg, chunkArg) {
+        if (!chunkArg.accountingOwned)
+            return;
+        chunkArg.accountingOwned = false;
+        this.releaseServerRetainedBytes(stateArg.connection, chunkArg.payload.byteLength);
+    }
+    releaseOutboundAccounting(outboundArg) {
+        if (!outboundArg.accountingOwned)
+            return;
+        outboundArg.accountingOwned = false;
+        this.releaseServerRetainedBytes(outboundArg.connection, outboundArg.frame.data.byteLength);
+    }
+    reserveStreamSlot(connectionArg) {
+        if (connectionArg.registrations.size + connectionArg.streams.size
+            >= VIRTUAL_STREAM_MAX_STREAMS_PER_CONNECTION) {
+            throw new TypedSocketVirtualStreamError(`virtual-stream-v1 permits at most ${VIRTUAL_STREAM_MAX_STREAMS_PER_CONNECTION} streams per connection`);
+        }
+        if (this.side === 'server') {
+            let total = 0;
+            for (const connection of this.serverConnections.values()) {
+                total += connection.registrations.size + connection.streams.size;
+            }
+            if (total >= VIRTUAL_STREAM_MAX_STREAMS_PER_SERVER) {
+                throw new TypedSocketVirtualStreamError(`virtual-stream-v1 permits at most ${VIRTUAL_STREAM_MAX_STREAMS_PER_SERVER} server streams`);
+            }
+        }
+    }
+    resolveConnection(targetArg) {
+        const connection = this.resolveConnectionForInspection(targetArg);
+        if (!connection || connection.closed) {
+            throw new TypedSocketVirtualStreamError('No exact virtual-stream-v1 connection is available');
+        }
+        return connection;
+    }
+    resolveConnectionForInspection(targetArg) {
+        if (this.side === 'client') {
+            if (targetArg) {
+                throw new TypedSocketVirtualStreamError('Client VirtualStream APIs do not accept peer targets');
+            }
+            return this.currentClientConnection;
+        }
+        if (!targetArg)
+            return undefined;
+        return this.serverConnections.get(asPeer(targetArg));
+    }
+    requireReadyConnection(connectionArg) {
+        if (!connectionArg.handshakeReady || connectionArg.closed) {
+            throw new TypedSocketVirtualStreamError('virtual-stream-v1 requires a handshake-ready physical peer');
+        }
+        if (connectionArg.binding.side === 'server'
+            && connectionArg.binding.peer.transportOwner !== this.webSocketTransportOwner) {
+            throw new TypedSocketVirtualStreamError('SmartServe peer is not owned by this TypedSocket');
+        }
+    }
+    assertEndpointOwned(stateArg) {
+        const connection = stateArg.connection;
+        if (connection.closed
+            || stateArg.status === 'closed'
+            || (connection.registrations.get(stateArg.descriptor.streamId) !== stateArg
+                && connection.streams.get(stateArg.descriptor.streamId) !== stateArg)
+            || (connection.binding.side === 'client'
+                ? this.currentClientConnection !== connection
+                : this.serverConnections.get(connection.binding.peer) !== connection
+                    || connection.binding.peer.transportOwner !== this.webSocketTransportOwner)) {
+            throw new TypedSocketVirtualStreamError('VirtualStream physical peer authority changed');
+        }
+    }
+    assertEndpointOpen(stateArg, directionArg) {
+        this.assertEndpointOwned(stateArg);
+        if (stateArg.status !== 'open' || stateArg.direction !== directionArg) {
+            throw stateArg.closeError ?? new TypedSocketVirtualStreamError('VirtualStream endpoint is not open');
+        }
+    }
+    validateDescriptor(descriptorArg) {
+        if (!descriptorArg
+            || typeof descriptorArg !== 'object'
+            || descriptorArg._isVirtualStream !== true
+            || descriptorArg.protocol !== VIRTUAL_STREAM_PROTOCOL
+            || (descriptorArg.creatorDirection !== 'send' && descriptorArg.creatorDirection !== 'receive')) {
+            throw new VirtualStreamProtocolError('descriptor protocol or direction is invalid');
+        }
+        const streamId = normalizeVirtualStreamId(descriptorArg.streamId);
+        const contentType = normalizeVirtualStreamContentType(descriptorArg.contentType);
+        const integrity = normalizeVirtualStreamIntegrity(descriptorArg.integrity);
+        const transport = descriptorArg.transport;
+        if (!isPlainRecord(transport)
+            || !hasExactEnumerableDataKeys(transport, ['capability', 'expiresAt'])) {
+            throw new VirtualStreamProtocolError('descriptor transport shape is invalid');
+        }
+        const expiresAt = getOwnEnumerableData(transport, 'expiresAt');
+        if (typeof expiresAt !== 'number' || !Number.isSafeInteger(expiresAt) || expiresAt <= 0) {
+            throw new VirtualStreamProtocolError('descriptor expiresAt is invalid');
+        }
+        return Object.freeze({
+            _isVirtualStream: true,
+            protocol: VIRTUAL_STREAM_PROTOCOL,
+            streamId,
+            creatorDirection: descriptorArg.creatorDirection,
+            ...(contentType === undefined ? {} : { contentType }),
+            ...(integrity === undefined ? {} : { integrity }),
+            transport: Object.freeze({
+                capability: normalizeVirtualStreamCapability(getOwnEnumerableData(transport, 'capability')),
+                expiresAt,
+            }),
+        });
+    }
+    refreshProgressTimer(stateArg) {
+        this.clearEndpointTimer(stateArg);
+        if (stateArg.status === 'closed')
+            return;
+        stateArg.timer = this.runtime.setTimer(() => {
+            void this.failEndpoint(stateArg, new TypedSocketVirtualStreamError('VirtualStream progress timed out'), VIRTUAL_STREAM_RESET_CODES.TIMEOUT);
+        }, VIRTUAL_STREAM_PROGRESS_TIMEOUT_MS);
+    }
+    clearEndpointTimer(stateArg) {
+        if (stateArg.timer !== undefined)
+            this.runtime.clearTimer(stateArg.timer);
+        stateArg.timer = undefined;
+    }
+    clearConnectionTimer(connectionArg, keyArg) {
+        const timer = connectionArg[keyArg];
+        if (timer !== undefined)
+            this.runtime.clearTimer(timer);
+        connectionArg[keyArg] = undefined;
+    }
+    wakeReceivers(stateArg, errorArg) {
+        for (const waiter of [...stateArg.receiveWaiters]) {
+            if (errorArg)
+                waiter.reject(errorArg);
+            else
+                waiter.resolve();
+        }
+        stateArg.receiveWaiters.clear();
+    }
+    async failEndpoint(stateArg, reasonArg, resetCodeArg, sendResetArg = true) {
+        if (stateArg.status === 'closed')
+            return await stateArg.closedDeferred.promise;
+        const shouldReset = sendResetArg
+            && stateArg.status !== 'registered'
+            && stateArg.status !== 'staged'
+            && !stateArg.connection.closed;
+        const error = asError(reasonArg, 'VirtualStream closed');
+        this.cleanupEndpoint(stateArg, error, true, true, false);
+        if (shouldReset) {
+            try {
+                await this.sendReset(stateArg.connection, stateArg.descriptor.streamId, resetCodeArg, 'VirtualStream closed');
+            }
+            catch { }
+        }
+        stateArg.closedDeferred.resolve();
+    }
+    cleanupEndpoint(stateArg, reasonArg, rejectArg = true, addTombstoneArg = true, resolveClosedArg = true) {
+        if (stateArg.status === 'closed')
+            return;
+        const wasActivated = stateArg.status !== 'registered' && stateArg.status !== 'staged';
+        stateArg.status = 'closed';
+        this.clearEndpointTimer(stateArg);
+        for (const controller of stateArg.revalidationControllers) {
+            controller.abort(new TypedSocketVirtualStreamError('VirtualStream closed during revalidation'));
+        }
+        this.removeQueuedFramesForStream(stateArg.connection, stateArg.descriptor.streamId, reasonArg);
+        stateArg.connection.registrations.delete(stateArg.descriptor.streamId);
+        stateArg.connection.streams.delete(stateArg.descriptor.streamId);
+        for (const admission of [...stateArg.admissions]) {
+            this.releaseAdmission(stateArg, admission);
+        }
+        for (const completed of stateArg.completedChunks.splice(0)) {
+            stateArg.connection.queuedChunks--;
+            stateArg.connection.queuedBytes -= completed.payload.byteLength;
+            this.releaseCompletedChunkAccounting(stateArg, completed);
+        }
+        if (stateArg.deliveringChunk) {
+            this.releaseCompletedChunkAccounting(stateArg, stateArg.deliveringChunk);
+            stateArg.deliveringChunk = undefined;
+        }
+        if (stateArg.reassembly?.accountingOwned) {
+            stateArg.reassembly.accountingOwned = false;
+            stateArg.connection.queuedChunks--;
+            stateArg.connection.queuedBytes -= stateArg.reassembly.payload.byteLength;
+            this.releaseServerRetainedBytes(stateArg.connection, stateArg.reassembly.payload.byteLength);
+        }
+        stateArg.reassembly = undefined;
+        if (stateArg.connection.queuedChunks < 0)
+            stateArg.connection.queuedChunks = 0;
+        if (stateArg.connection.queuedBytes < 0)
+            stateArg.connection.queuedBytes = 0;
+        const error = asError(reasonArg, 'VirtualStream closed');
+        stateArg.closeError = error;
+        stateArg.awaitingChunkAck?.deferred.reject(error);
+        stateArg.awaitingChunkAck = undefined;
+        this.wakeReceivers(stateArg, rejectArg ? error : undefined);
+        this.releaseEndpointMetadataAccounting(stateArg);
+        if (addTombstoneArg && wasActivated)
+            this.addTombstone(stateArg.connection, stateArg.descriptor.streamId);
+        if (rejectArg) {
+            stateArg.openedDeferred.reject(error);
+            stateArg.completionDeferred.reject(error);
+        }
+        if (resolveClosedArg)
+            stateArg.closedDeferred.resolve();
+    }
+    addTombstone(connectionArg, streamIdArg) {
+        this.pruneTombstones(connectionArg);
+        const now = this.runtime.now();
+        const expiresAt = Number.isSafeInteger(now) && now >= 0
+            ? Math.min(Number.MAX_SAFE_INTEGER, now + VIRTUAL_STREAM_TOMBSTONE_RETENTION_MS)
+            : Number.MAX_SAFE_INTEGER;
+        const existing = connectionArg.tombstones.get(streamIdArg);
+        if (existing) {
+            connectionArg.tombstones.set(streamIdArg, Object.freeze({
+                streamId: streamIdArg,
+                expiresAt,
+                retainedBytes: existing.retainedBytes,
+            }));
+            return;
+        }
+        const retainedBytes = virtualStreamTextEncoder.encode(streamIdArg).byteLength;
+        try {
+            this.reserveServerRetainedBytes(connectionArg, retainedBytes);
+        }
+        catch {
+            this.closeConnection(connectionArg, 1013, 'virtual-stream-v1 replay accounting capacity exhausted');
+            return;
+        }
+        const evicted = [];
+        try {
+            while (connectionArg.tombstones.size >= VIRTUAL_STREAM_MAX_TOMBSTONES_PER_CONNECTION) {
+                const oldest = connectionArg.tombstones.keys().next();
+                if (oldest.done)
+                    break;
+                const tombstone = connectionArg.tombstones.get(oldest.value);
+                connectionArg.tombstones.delete(oldest.value);
+                if (tombstone)
+                    evicted.push(tombstone);
+            }
+            connectionArg.tombstones.set(streamIdArg, Object.freeze({
+                streamId: streamIdArg,
+                expiresAt,
+                retainedBytes,
+            }));
+        }
+        catch (errorArg) {
+            for (const tombstone of evicted) {
+                connectionArg.tombstones.set(tombstone.streamId, tombstone);
+            }
+            this.releaseServerRetainedBytes(connectionArg, retainedBytes);
+            this.closeConnection(connectionArg, 1011, 'virtual-stream-v1 replay accounting failed');
+            return;
+        }
+        for (const tombstone of evicted) {
+            this.releaseServerRetainedBytes(connectionArg, tombstone.retainedBytes);
+        }
+    }
+    pruneTombstones(connectionArg) {
+        const now = this.runtime.now();
+        for (const [streamId, tombstone] of connectionArg.tombstones) {
+            if (tombstone.expiresAt <= now)
+                this.deleteTombstone(connectionArg, streamId);
+        }
+    }
+    deleteTombstone(connectionArg, streamIdArg) {
+        const tombstone = connectionArg.tombstones.get(streamIdArg);
+        if (!tombstone)
+            return;
+        connectionArg.tombstones.delete(streamIdArg);
+        this.releaseServerRetainedBytes(connectionArg, tombstone.retainedBytes);
+    }
+    sendReset(connectionArg, streamIdArg, codeArg, reasonArg) {
+        if (connectionArg.closed)
+            return Promise.resolve();
+        return this.enqueueFrame(connectionArg, {
+            type: VIRTUAL_STREAM_FRAME_TYPES.RESET,
+            streamId: streamIdArg,
+            code: codeArg,
+            reason: reasonArg,
+        });
+    }
+    enqueueFrame(connectionArg, frameArg) {
+        if (connectionArg.closed) {
+            return Promise.reject(new TypedSocketVirtualStreamError('VirtualStream connection is closed'));
+        }
+        const queued = connectionArg.controlQueue.length
+            + connectionArg.dataQueue.length
+            + (connectionArg.serverInflight ? 1 : 0);
+        if (queued >= VIRTUAL_STREAM_MAX_OUTBOUND_FRAMES_PER_CONNECTION) {
+            return Promise.reject(new TypedSocketVirtualStreamError('VirtualStream outbound frame capacity exhausted'));
+        }
+        let retainedBytes;
+        try {
+            retainedBytes = getVirtualStreamFrameByteLength(frameArg);
+            this.reserveServerRetainedBytes(connectionArg, retainedBytes);
+        }
+        catch (errorArg) {
+            return Promise.reject(errorArg);
+        }
+        let outbound;
+        let queue;
+        try {
+            const encodedFrame = encodeVirtualStreamFrame(frameArg);
+            if (encodedFrame.byteLength !== retainedBytes) {
+                throw new VirtualStreamProtocolError('virtual-stream-v1 frame accounting mismatch');
+            }
+            outbound = {
+                connection: connectionArg,
+                frame: Object.freeze({ type: 'binary', data: encodedFrame }),
+                streamId: frameArg.streamId,
+                settlement: createDeferred(),
+                accountingOwned: true,
+            };
+            outbound.timer = this.runtime.setTimer(() => {
+                this.failConnection(connectionArg, new TypedSocketVirtualStreamError('VirtualStream outbound frame settlement timed out'), true);
+            }, VIRTUAL_STREAM_PROGRESS_TIMEOUT_MS);
+            queue = frameArg.type === VIRTUAL_STREAM_FRAME_TYPES.CHUNK
+                ? connectionArg.dataQueue
+                : connectionArg.controlQueue;
+            queue.push(outbound);
+            this.wakeOutbound(connectionArg);
+            return outbound.settlement.promise;
+        }
+        catch (errorArg) {
+            if (outbound) {
+                const queueIndex = queue?.indexOf(outbound) ?? -1;
+                if (queue && queueIndex >= 0)
+                    queue.splice(queueIndex, 1);
+                this.settleOutbound(outbound, errorArg);
+            }
+            else {
+                this.releaseServerRetainedBytes(connectionArg, retainedBytes);
+            }
+            return Promise.reject(errorArg);
+        }
+    }
+    wakeOutbound(connectionArg) {
+        if (connectionArg.closed)
+            return;
+        if (connectionArg.binding.side === 'server') {
+            connectionArg.binding.peer.rawFrameScheduler?.wake();
+            return;
+        }
+        if (connectionArg.clientTurnScheduled)
+            return;
+        connectionArg.clientTurnScheduled = true;
+        this.runtime.scheduleMacrotask(() => this.runClientOutboundTurn(connectionArg));
+    }
+    runClientOutboundTurn(connectionArg) {
+        connectionArg.clientTurnScheduled = false;
+        if (connectionArg.closed || connectionArg.binding.side !== 'client')
+            return;
+        const outbound = connectionArg.controlQueue.shift() ?? connectionArg.dataQueue.shift();
+        if (!outbound)
+            return;
+        try {
+            connectionArg.binding.webSocket.send(outbound.frame.data);
+            this.settleOutbound(outbound, undefined);
+        }
+        catch (errorArg) {
+            this.settleOutbound(outbound, errorArg);
+            this.failConnection(connectionArg, errorArg, true);
+            return;
+        }
+        if (connectionArg.controlQueue.length > 0 || connectionArg.dataQueue.length > 0) {
+            this.wakeOutbound(connectionArg);
+        }
+    }
+    pullServerBinaryFrame(peerArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (!connection
+            || connection.closed
+            || connection.serverInflight
+            || peerArg.transportOwner !== this.webSocketTransportOwner)
+            return undefined;
+        const outbound = connection.controlQueue.shift() ?? connection.dataQueue.shift();
+        if (!outbound)
+            return undefined;
+        connection.serverInflight = outbound;
+        return outbound.frame;
+    }
+    settleServerOutboundFrame(peerArg, frameArg, settlementArg) {
+        const connection = this.serverSettlementConnections.get(peerArg);
+        const outbound = connection?.serverInflight;
+        if (!connection || !outbound || outbound.frame !== frameArg)
+            return;
+        connection.serverInflight = undefined;
+        if (settlementArg.status === 'sent' || settlementArg.status === 'accepted') {
+            this.settleOutbound(outbound, undefined);
+            if (connection.closed) {
+                if (this.serverSettlementConnections.get(peerArg) === connection) {
+                    this.serverSettlementConnections.delete(peerArg);
+                }
+                return;
+            }
+            if (connection.controlQueue.length > 0 || connection.dataQueue.length > 0) {
+                connection.binding.side === 'server' && connection.binding.peer.rawFrameScheduler?.wake();
+            }
+            return;
+        }
+        const error = settlementArg.error ?? new TypedSocketVirtualStreamError('VirtualStream frame send failed');
+        this.settleOutbound(outbound, error);
+        if (connection.closed) {
+            if (this.serverSettlementConnections.get(peerArg) === connection) {
+                this.serverSettlementConnections.delete(peerArg);
+            }
+            return;
+        }
+        this.failConnection(connection, error, true);
+    }
+    settleOutbound(outboundArg, errorArg) {
+        if (outboundArg.timer !== undefined)
+            this.runtime.clearTimer(outboundArg.timer);
+        outboundArg.timer = undefined;
+        this.releaseOutboundAccounting(outboundArg);
+        if (errorArg)
+            outboundArg.settlement.reject(errorArg);
+        else
+            outboundArg.settlement.resolve();
+    }
+    rejectInflightOutbound(outboundArg, errorArg) {
+        outboundArg.settlement.reject(errorArg);
+    }
+    removeQueuedFramesForStream(connectionArg, streamIdArg, reasonArg) {
+        const error = asError(reasonArg, 'VirtualStream closed');
+        for (const queue of [connectionArg.controlQueue, connectionArg.dataQueue]) {
+            for (let index = queue.length - 1; index >= 0; index--) {
+                if (queue[index].streamId !== streamIdArg)
+                    continue;
+                const [outbound] = queue.splice(index, 1);
+                this.settleOutbound(outbound, error);
+            }
+        }
+        if (connectionArg.serverInflight?.streamId === streamIdArg) {
+            this.rejectInflightOutbound(connectionArg.serverInflight, error);
+        }
+    }
+    failConnection(connectionArg, reasonArg, closeArg) {
+        if (connectionArg.closed)
+            return;
+        connectionArg.closed = true;
+        connectionArg.handshakePending = false;
+        connectionArg.handshakeReady = false;
+        connectionArg.clientTurnScheduled = false;
+        this.clearConnectionTimer(connectionArg, 'handshakeTimer');
+        const error = asError(reasonArg, 'VirtualStream connection failed');
+        for (const controller of connectionArg.revalidationControllers)
+            controller.abort(error);
+        for (const state of [
+            ...connectionArg.registrations.values(),
+            ...connectionArg.streams.values(),
+        ]) {
+            this.cleanupEndpoint(state, error, true, false);
+        }
+        for (const queue of [connectionArg.controlQueue, connectionArg.dataQueue]) {
+            for (const outbound of queue.splice(0))
+                this.settleOutbound(outbound, error);
+        }
+        if (connectionArg.serverInflight) {
+            this.rejectInflightOutbound(connectionArg.serverInflight, error);
+        }
+        const retainedConnectionBytes = connectionArg.rawQueueBytes
+            + connectionArg.processingRawBytes
+            + connectionArg.arrivalStampBytes;
+        connectionArg.rawQueue.length = 0;
+        connectionArg.rawQueueBytes = 0;
+        connectionArg.processingRawBytes = 0;
+        connectionArg.queuedChunks = 0;
+        connectionArg.queuedBytes = 0;
+        connectionArg.arrivalStamps.length = 0;
+        connectionArg.arrivalStampBytes = 0;
+        this.releaseServerRetainedBytes(connectionArg, retainedConnectionBytes);
+        for (const streamId of [...connectionArg.tombstones.keys()]) {
+            this.deleteTombstone(connectionArg, streamId);
+        }
+        connectionArg.authorizedHandshake = undefined;
+        connectionArg.pendingHandshake = undefined;
+        if (connectionArg.binding.side === 'server') {
+            if (this.serverConnections.get(connectionArg.binding.peer) === connectionArg) {
+                this.serverConnections.delete(connectionArg.binding.peer);
+            }
+            if (!connectionArg.serverInflight
+                && this.serverSettlementConnections.get(connectionArg.binding.peer) === connectionArg) {
+                this.serverSettlementConnections.delete(connectionArg.binding.peer);
+            }
+        }
+        if (closeArg)
+            this.closeConnectionTransport(connectionArg, 1011, 'virtual-stream-v1 connection failure');
+    }
+    closeConnection(connectionArg, codeArg, reasonArg) {
+        this.emitDiagnostic({
+            kind: 'connectionClosed',
+            side: connectionArg.binding.side,
+            scope: 'virtualStream',
+            closeCode: codeArg,
+            reason: reasonArg,
+        });
+        this.closeConnectionTransport(connectionArg, codeArg, reasonArg);
+        this.failConnection(connectionArg, new TypedSocketVirtualStreamError(reasonArg), false);
+    }
+    closeConnectionTransport(connectionArg, codeArg, reasonArg) {
+        try {
+            if (connectionArg.binding.side === 'client') {
+                connectionArg.binding.webSocket.close(toClientWebSocketCloseCode(codeArg), reasonArg);
+            }
+            else {
+                connectionArg.binding.peer.close(codeArg, reasonArg);
+            }
+        }
+        catch { }
+    }
+    emitDiagnostic(eventArg) {
+        try {
+            this.onDiagnostic?.(eventArg);
+        }
+        catch { }
+    }
+}
+/** Internal bridge used only by the TypedSocket server authorization facade. */
+export function createAuthorizedServerVirtualStreamRegistration(managerArg, peerArg, optionsArg) {
+    return managerArg[createAuthorizedServerRegistrationSymbol](peerArg, optionsArg);
+}
+/** Internal bridge used only by the TypedSocket server readiness facade. */
+export function setServerHandshakeReadyCallback(managerArg, callbackArg) {
+    managerArg[setServerHandshakeReadyCallbackSymbol](callbackArg);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.virtualstreammanager.js","sourceRoot":"","sources":["../ts/classes.virtualstreammanager.ts"],"names":[],"mappings":"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"}