@api.global/typedsocket 6.1.0 → 6.3.0

package/dist_ts/classes.nativebytemanager.js

@@ -1,7 +1,9 @@
 import * as plugins from './plugins.js';
 import { NATIVE_BYTE_DEFAULT_INITIAL_WINDOW_BYTES, NATIVE_BYTE_FRAME_TYPES, NATIVE_BYTE_GRANT_OPEN_TIMEOUT_MS, NATIVE_BYTE_MAX_FRAME_BYTES, NATIVE_BYTE_MAX_DATA_PAYLOAD_BYTES, NATIVE_BYTE_MAX_QUEUED_PAYLOAD_BYTES_PER_CONNECTION, NATIVE_BYTE_MAX_QUEUED_PAYLOAD_BYTES_PER_STREAM, NATIVE_BYTE_MAX_RECEIVE_QUEUE_CHUNKS, NATIVE_BYTE_MAX_RAW_QUEUE_BYTES, NATIVE_BYTE_MAX_RAW_QUEUE_FRAMES, NATIVE_BYTE_MAX_PENDING_DATA_OPERATIONS_PER_CONNECTION, NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION, NATIVE_BYTE_MAX_TOMBSTONES, NATIVE_BYTE_MAX_PRINCIPAL_ID_BYTES, NATIVE_BYTE_MAX_AUTHORITY_REVISION_BYTES, NATIVE_BYTE_REVALIDATION_TIMEOUT_MS, NATIVE_BYTE_MAX_REVALIDATIONS_PER_PEER, NATIVE_BYTE_MAX_REVALIDATIONS_PER_PRINCIPAL, NATIVE_BYTE_MAX_REVALIDATIONS_PER_SERVER, NATIVE_BYTE_MAX_CONNECTIONS_PER_SERVER, NATIVE_BYTE_MAX_STREAMS_PER_SERVER, NATIVE_BYTE_MAX_RETAINED_BYTES_PER_SERVER, NATIVE_BYTE_MAX_WINDOW_BYTES, NATIVE_BYTE_PROGRESS_TIMEOUT_MS, NATIVE_BYTE_PROTOCOL, NATIVE_BYTE_PROTOCOL_MAJOR, NATIVE_BYTE_RESET_CODES, NATIVE_BYTE_TOMBSTONE_RETENTION_MS, } from './constants.nativebytes.js';
+import { NATIVE_MESSAGE_DEFAULT_MAX_LOGICAL_MESSAGE_BYTES, NATIVE_MESSAGE_FRAME_MAGIC, NATIVE_MESSAGE_FRAME_TYPES, NATIVE_MESSAGE_MAX_CHANNELS_PER_CONNECTION, NATIVE_MESSAGE_MAX_FRAGMENT_PAYLOAD_BYTES, NATIVE_MESSAGE_MAX_PENDING_BYTES_PER_CHANNEL, NATIVE_MESSAGE_MAX_PENDING_MESSAGES_PER_CHANNEL, NATIVE_MESSAGE_MAX_TOMBSTONES_PER_CONNECTION, NATIVE_MESSAGE_NEGOTIATION_TIMEOUT_MS, NATIVE_MESSAGE_OPEN_TIMEOUT_MS, NATIVE_MESSAGE_PROGRESS_TIMEOUT_MS, NATIVE_MESSAGE_PROTOCOL, NATIVE_MESSAGE_PROTOCOL_MAJOR, NATIVE_MESSAGE_RESET_CODES, NATIVE_MESSAGE_TOMBSTONE_RETENTION_MS, } from './constants.nativemessages.js';
 import { assertNativeByteLength, decodeNativeByteFrame, encodeNativeByteFrame, normalizeNativeByteCapability, normalizeNativeByteContentType, normalizeNativeByteSha256, normalizeNativeByteStreamId, } from './helpers.nativebytecodec.js';
-import { NativeByteCapabilityError, NativeByteError, NativeByteProtocolError, NativeByteStreamClosedError, } from './classes.nativebyteerror.js';
+import { assertNativeMessageLength, decodeNativeMessageFrame, encodeNativeMessageFrame, normalizeNativeMessageCapability, normalizeNativeMessageChannelId, } from './helpers.nativemessagecodec.js';
+import { NativeByteCapabilityError, NativeByteError, NativeByteProtocolError, NativeByteStreamClosedError, NativeMessageCapabilityError, NativeMessageChannelClosedError, NativeMessageError, NativeMessageProtocolError, } from './classes.nativebyteerror.js';
 import { toClientWebSocketCloseCode } from './helpers.websocket.js';
 const CLIENT_BACKPRESSURE_RETRY_MS = 10;
 const textEncoder = new TextEncoder();
@@ -267,6 +269,57 @@ export class NativeByteSender {
         await this.manager.abortProducer(this.state, reasonArg);
     }
 }
+export class NativeMessageReceiver {
+    constructor(manager, state) {
+        this.manager = manager;
+        this.state = state;
+    }
+    get closed() {
+        return this.state.completion.promise;
+    }
+    async receive() {
+        return await this.manager.receiveNativeMessage(this.state);
+    }
+    async reject(reasonArg) {
+        await this.manager.rejectNativeMessageReceiver(this.state, reasonArg);
+    }
+}
+export class NativeMessageSender {
+    constructor(manager, state) {
+        this.manager = manager;
+        this.state = state;
+    }
+    get closed() {
+        return this.state.completion.promise;
+    }
+    async send(messageArg) {
+        await this.manager.sendNativeMessage(this.state, messageArg);
+    }
+    async close() {
+        await this.manager.closeNativeMessageSender(this.state);
+    }
+}
+export class NativeMessageFacade {
+    #manager;
+    constructor(managerArg) {
+        this.#manager = managerArg;
+    }
+    createReceiveGrant(optionsArg) {
+        return this.#manager.createNativeMessageReceiveGrant(optionsArg);
+    }
+    async openSender(descriptorArg, optionsArg = {}) {
+        return await this.#manager.openNativeMessageSender(descriptorArg, optionsArg);
+    }
+    getCapability(targetArg) {
+        return this.#manager.getNativeMessageCapability(targetArg);
+    }
+    getStats(targetArg) {
+        return this.#manager.getNativeMessageStats(targetArg);
+    }
+    normalizeMaxMessageBytes(valueArg) {
+        return assertNativeMessageLength(valueArg);
+    }
+}
 class NativeByteConnectionTransport {
     constructor(manager, connection) {
         this.manager = manager;
@@ -311,8 +364,16 @@ export class NativeByteManager {
         }
         this.side = optionsArg.side;
         this.capabilityMode = optionsArg.capabilityMode ?? 'optional';
+        if (optionsArg.nativeMessageCapabilityMode !== undefined
+            && optionsArg.nativeMessageCapabilityMode !== 'disabled'
+            && optionsArg.nativeMessageCapabilityMode !== 'optional'
+            && optionsArg.nativeMessageCapabilityMode !== 'required') {
+            throw new NativeMessageProtocolError('native-message-v1 capability mode must be disabled, optional, or required');
+        }
+        this.nativeMessageCapabilityMode = optionsArg.nativeMessageCapabilityMode ?? 'optional';
         this.runtime = optionsArg.runtime ?? defaultRuntime();
         this.onDiagnostic = optionsArg.onDiagnostic;
+        this.messages = new NativeMessageFacade(this);
         const manager = this;
         this.clientNativeStreamTransport = Object.freeze({
             get capabilities() {
@@ -503,6 +564,109 @@ export class NativeByteManager {
             required: this.capabilityMode === 'required',
         };
     }
+    getClientNativeMessageNegotiationAdvertisement() {
+        const connection = this.currentClientConnection;
+        const ready = Boolean(connection
+            && !connection.closed
+            && this.nativeMessageCapabilityMode !== 'disabled');
+        return {
+            protocolMajor: NATIVE_MESSAGE_PROTOCOL_MAJOR,
+            capabilities: ready ? [NATIVE_MESSAGE_PROTOCOL] : [],
+        };
+    }
+    completeClientNativeMessageNegotiation(webSocketArg, generationArg, responseArg) {
+        const connection = this.currentClientConnection;
+        if (!connection
+            || connection.binding.side !== 'client'
+            || connection.binding.webSocket !== webSocketArg
+            || connection.binding.generation !== generationArg) {
+            throw new NativeMessageCapabilityError('TypedSocket client generation changed during native-message-v1 negotiation');
+        }
+        if (connection.messageNegotiated) {
+            throw new NativeMessageCapabilityError('TypedSocket native-message-v1 capabilities are negotiated once per physical connection');
+        }
+        const nativeMessageEnabled = responseArg.protocolMajor === NATIVE_MESSAGE_PROTOCOL_MAJOR
+            && responseArg.capabilities.length === 1
+            && responseArg.capabilities[0] === NATIVE_MESSAGE_PROTOCOL
+            && this.nativeMessageCapabilityMode !== 'disabled';
+        if ((this.nativeMessageCapabilityMode === 'required' || responseArg.required === true)
+            && !nativeMessageEnabled) {
+            throw new NativeMessageCapabilityError('TypedSocket server did not negotiate required native-message-v1');
+        }
+        connection.messageNegotiated = true;
+        connection.nativeMessageEnabled = nativeMessageEnabled;
+    }
+    failOptionalClientNativeMessageNegotiation(webSocketArg, generationArg) {
+        const connection = this.currentClientConnection;
+        if (!connection
+            || connection.binding.side !== 'client'
+            || connection.binding.webSocket !== webSocketArg
+            || connection.binding.generation !== generationArg) {
+            throw new NativeMessageCapabilityError('TypedSocket client generation changed during native-message-v1 negotiation');
+        }
+        if (connection.messageNegotiated) {
+            throw new NativeMessageCapabilityError('TypedSocket native-message-v1 capabilities are negotiated once per physical connection');
+        }
+        connection.messageNegotiated = true;
+        connection.nativeMessageEnabled = false;
+    }
+    negotiateServerNativeMessages(peerArg, requestArg) {
+        const connection = this.serverConnections.get(peerArg);
+        if (connection?.messageNegotiated) {
+            return {
+                protocolMajor: NATIVE_MESSAGE_PROTOCOL_MAJOR,
+                capabilities: connection.nativeMessageEnabled ? [NATIVE_MESSAGE_PROTOCOL] : [],
+                required: this.nativeMessageCapabilityMode === 'required',
+            };
+        }
+        const clientAdvertised = requestArg.protocolMajor === NATIVE_MESSAGE_PROTOCOL_MAJOR
+            && requestArg.capabilities.length === 1
+            && requestArg.capabilities[0] === NATIVE_MESSAGE_PROTOCOL;
+        const nativeMessageEnabled = Boolean(this.serverAttached
+            && connection
+            && !connection.closed
+            && peerArg.transportOwner === this.webSocketTransportOwner
+            && this.nativeMessageCapabilityMode !== 'disabled'
+            && clientAdvertised);
+        if (connection) {
+            if (connection.nativeMessageNegotiationTimer !== undefined) {
+                this.runtime.clearTimer(connection.nativeMessageNegotiationTimer);
+                connection.nativeMessageNegotiationTimer = undefined;
+            }
+            connection.messageNegotiated = true;
+            connection.nativeMessageEnabled = nativeMessageEnabled;
+        }
+        if (this.nativeMessageCapabilityMode === 'required' && !nativeMessageEnabled) {
+            this.runtime.scheduleMacrotask(() => {
+                const current = this.serverConnections.get(peerArg);
+                if (current && !current.closed && !current.nativeMessageEnabled) {
+                    this.closeConnection(current, 1008, 'native-message-v1 capability is required', 'nativeMessage');
+                }
+                else if (!current) {
+                    this.emitDiagnostic({
+                        kind: 'peerRejected',
+                        side: 'server',
+                        closeCode: 1008,
+                        reason: 'native-message-v1 capability is required',
+                    });
+                    try {
+                        peerArg.close(1008, 'native-message-v1 capability is required');
+                    }
+                    catch { }
+                }
+            });
+        }
+        return {
+            protocolMajor: NATIVE_MESSAGE_PROTOCOL_MAJOR,
+            capabilities: nativeMessageEnabled ? [NATIVE_MESSAGE_PROTOCOL] : [],
+            required: this.nativeMessageCapabilityMode === 'required',
+        };
+    }
+    connectionHasNativeMessageCapability(connectionArg) {
+        return !connectionArg.closed
+            && connectionArg.messageNegotiated
+            && connectionArg.nativeMessageEnabled;
+    }
     getClientNativeStreamTransport() {
         return this.side === 'client' ? this.clientNativeStreamTransport : undefined;
     }
@@ -569,7 +733,7 @@ export class NativeByteManager {
                 tombstones: 0,
                 retainedRevalidations: 0,
                 serverConnections: this.getServerConnectionCount(),
-                serverStreams: this.getServerStreamCount(),
+                serverStreams: this.getServerNativeByteStreamCount(),
                 serverRetainedBytes: this.getServerRetainedBytes(),
                 serverRetainedRevalidations: this.retainedRevalidations,
             };
@@ -580,16 +744,262 @@ export class NativeByteManager {
             negotiated: connection.negotiated && connection.nativeEnabled,
             activeStreams: connection.streams.size,
             receiveGrants: connection.grants.size,
-            queuedPayloadBytes: connection.queuedPayloadBytes,
+            queuedPayloadBytes: connection.queuedPayloadBytes - connection.nativeMessageQueuedPayloadBytes,
             rawQueueFrames: connection.rawQueue.length,
             rawQueueBytes: connection.rawQueueBytes,
             processingRawBytes: connection.processingRawBytes,
-            outboundControlFrames: connection.controlQueue.length,
-            outboundDataFrames: connection.dataQueue.length,
+            outboundControlFrames: connection.controlQueue.filter((frameArg) => frameArg.protocol === 'nativeByte').length,
+            outboundDataFrames: connection.dataQueue.filter((frameArg) => frameArg.protocol === 'nativeByte').length,
             tombstones: connection.tombstones.size,
             retainedRevalidations: connection.retainedRevalidations,
             serverConnections: this.getServerConnectionCount(),
-            serverStreams: this.getServerStreamCount(),
+            serverStreams: this.getServerNativeByteStreamCount(),
+            serverRetainedBytes: this.getServerRetainedBytes(),
+            serverRetainedRevalidations: this.retainedRevalidations,
+        };
+    }
+    createNativeMessageReceiveGrant(optionsArg) {
+        if (typeof optionsArg.revalidate !== 'function') {
+            throw new NativeMessageProtocolError('explicit native-message-v1 receive grants require revalidate(context)');
+        }
+        const connection = this.resolveNativeMessageConnection(optionsArg.target);
+        this.requireNativeMessageCapability(connection);
+        this.reserveNativeMessageChannelSlot(connection);
+        const maxMessageBytes = assertNativeMessageLength(optionsArg.maxMessageBytes ?? NATIVE_MESSAGE_DEFAULT_MAX_LOGICAL_MESSAGE_BYTES);
+        const principalId = this.normalizePrincipalId(optionsArg.principalId);
+        const revisions = Object.freeze({
+            credentialRevision: this.normalizeAuthorityRevision('credentialRevision', optionsArg.credentialRevision),
+            configRevision: this.normalizeAuthorityRevision('configRevision', optionsArg.configRevision),
+            bindingRevision: this.normalizeAuthorityRevision('bindingRevision', optionsArg.bindingRevision),
+        });
+        const authorityMetadataBytes = textEncoder.encode(principalId).byteLength
+            + textEncoder.encode(revisions.credentialRevision).byteLength
+            + textEncoder.encode(revisions.configRevision).byteLength
+            + textEncoder.encode(revisions.bindingRevision).byteLength;
+        this.assertServerRetainedByteCapacity(connection, authorityMetadataBytes);
+        const now = this.runtime.now();
+        if (!Number.isSafeInteger(now)
+            || now < 0
+            || now > Number.MAX_SAFE_INTEGER - NATIVE_MESSAGE_OPEN_TIMEOUT_MS) {
+            throw new NativeMessageProtocolError('native-message-v1 runtime now() must return a usable non-negative safe integer');
+        }
+        this.pruneNativeMessageTombstones(connection);
+        let channelId = '';
+        for (let attempt = 0; attempt < 8; attempt++) {
+            const candidate = randomStreamId(this.runtime);
+            if (!connection.messageGrants.has(candidate)
+                && !connection.messageChannels.has(candidate)
+                && !connection.messageTombstones.has(candidate)
+                && !connection.grants.has(candidate)
+                && !connection.streams.has(candidate)
+                && !connection.tombstones.has(candidate)) {
+                channelId = candidate;
+                break;
+            }
+        }
+        if (!channelId) {
+            throw new NativeMessageError('native-message-v1 runtime repeatedly generated an occupied channel ID', 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+        }
+        const transport = Object.freeze({
+            protocolMajor: NATIVE_MESSAGE_PROTOCOL_MAJOR,
+            channelId,
+            capability: randomCapability(this.runtime),
+            expiresAt: now + NATIVE_MESSAGE_OPEN_TIMEOUT_MS,
+            maxMessageBytes,
+        });
+        const descriptor = Object.freeze({
+            protocol: NATIVE_MESSAGE_PROTOCOL,
+            transport,
+        });
+        const opened = createDeferred();
+        const completion = createDeferred();
+        const closedSignal = createDeferred();
+        let endpoint;
+        const state = {
+            role: 'messageReceiver',
+            connection,
+            descriptor,
+            revalidate: optionsArg.revalidate,
+            principalId,
+            revisions,
+            authorityMetadataBytes,
+            get endpoint() {
+                if (!endpoint) {
+                    throw new NativeMessageProtocolError('native message receiver is not initialized');
+                }
+                return endpoint;
+            },
+            opened,
+            completion,
+            closedSignal,
+            receiveWaiters: new Set(),
+            revalidationControllers: new Set(),
+            status: 'grant',
+            receiveActive: false,
+            nextSequence: 0,
+            acceptedMaxMessageBytes: maxMessageBytes,
+            remoteClosed: false,
+        };
+        endpoint = new NativeMessageReceiver(this, state);
+        connection.messageGrants.set(channelId, state);
+        connection.authorityMetadataBytes += authorityMetadataBytes;
+        state.timer = this.runtime.setTimer(() => {
+            this.cleanupNativeMessageReceiver(state, new NativeMessageError('native-message-v1 receive grant expired', 'NATIVE_MESSAGE_GRANT_TIMEOUT'), true);
+        }, NATIVE_MESSAGE_OPEN_TIMEOUT_MS);
+        let disposed = false;
+        return Object.freeze({
+            descriptor,
+            receiver: endpoint,
+            opened: opened.promise,
+            revoke: async (reasonArg) => {
+                await this.rejectNativeMessageReceiver(state, reasonArg);
+            },
+            dispose: () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                if (state.status !== 'grant')
+                    return;
+                this.cleanupNativeMessageReceiver(state, new NativeMessageChannelClosedError('native-message-v1 receive grant disposed before publication'), true, false);
+            },
+        });
+    }
+    async openNativeMessageSender(descriptorArg, optionsArg = {}) {
+        const connection = this.resolveNativeMessageConnection(optionsArg.target);
+        this.requireNativeMessageCapability(connection);
+        const descriptor = this.validateNativeMessageDescriptor(descriptorArg);
+        this.pruneNativeMessageTombstones(connection);
+        const channelId = descriptor.transport.channelId;
+        if (connection.messageGrants.has(channelId)
+            || connection.messageChannels.has(channelId)
+            || connection.messageTombstones.has(channelId)) {
+            throw new NativeMessageCapabilityError('native-message-v1 descriptor channel ID is already active or consumed on this connection');
+        }
+        this.reserveNativeMessageChannelSlot(connection);
+        const opened = createDeferred();
+        const completion = createDeferred();
+        const closedSignal = createDeferred();
+        let endpoint;
+        const state = {
+            role: 'messageSender',
+            connection,
+            descriptor,
+            get endpoint() {
+                if (!endpoint) {
+                    throw new NativeMessageProtocolError('native message sender is not initialized');
+                }
+                return endpoint;
+            },
+            opened,
+            completion,
+            closedSignal,
+            status: 'opening',
+            acceptedMaxMessageBytes: 0,
+            operationTail: Promise.resolve(),
+            nextSequence: 0,
+            pendingMessages: 0,
+            pendingMessageBytes: 0,
+            terminalRequested: false,
+        };
+        endpoint = new NativeMessageSender(this, state);
+        connection.messageChannels.set(channelId, state);
+        state.openTimer = this.runtime.setTimer(() => {
+            void this.failNativeMessageSender(state, new NativeMessageError('native-message-v1 OPEN timed out', 'NATIVE_MESSAGE_OPEN_TIMEOUT'), NATIVE_MESSAGE_RESET_CODES.TIMEOUT);
+        }, NATIVE_MESSAGE_OPEN_TIMEOUT_MS);
+        try {
+            await Promise.race([
+                this.enqueueNativeMessageFrame(connection, {
+                    type: NATIVE_MESSAGE_FRAME_TYPES.OPEN,
+                    channelId,
+                    capability: descriptor.transport.capability,
+                    maxMessageBytes: descriptor.transport.maxMessageBytes,
+                }),
+                state.closedSignal.promise,
+            ]);
+            return await opened.promise;
+        }
+        catch (errorArg) {
+            await this.failNativeMessageSender(state, errorArg, NATIVE_MESSAGE_RESET_CODES.ABORTED, false);
+            throw errorArg;
+        }
+    }
+    getNativeMessageCapability(targetArg) {
+        const connection = this.resolveConnectionForInspection(targetArg);
+        return {
+            protocolMajor: NATIVE_MESSAGE_PROTOCOL_MAJOR,
+            capabilities: connection && this.connectionHasNativeMessageCapability(connection)
+                ? [NATIVE_MESSAGE_PROTOCOL]
+                : [],
+            connection: connection?.binding.side ?? 'none',
+        };
+    }
+    getNativeMessageStats(targetArg) {
+        const connection = this.resolveConnectionForInspection(targetArg);
+        let serverChannels = 0;
+        if (this.side === 'server') {
+            for (const current of this.serverConnections.values()) {
+                serverChannels += current.messageGrants.size + current.messageChannels.size;
+            }
+        }
+        if (!connection) {
+            return {
+                connection: 'none',
+                negotiated: false,
+                activeChannels: 0,
+                receiveGrants: 0,
+                pendingMessages: 0,
+                pendingMessageBytes: 0,
+                reassemblyBytes: 0,
+                completedMessages: 0,
+                sharedQueuedPayloadBytes: 0,
+                rawQueueFrames: 0,
+                rawQueueBytes: 0,
+                processingRawBytes: 0,
+                outboundControlFrames: 0,
+                outboundMessageFrames: 0,
+                tombstones: 0,
+                retainedRevalidations: 0,
+                serverConnections: this.getServerConnectionCount(),
+                serverChannels,
+                serverRetainedBytes: this.getServerRetainedBytes(),
+                serverRetainedRevalidations: this.retainedRevalidations,
+            };
+        }
+        this.pruneNativeMessageTombstones(connection);
+        let pendingMessages = 0;
+        let pendingMessageBytes = 0;
+        let reassemblyBytes = 0;
+        let completedMessages = 0;
+        for (const channel of connection.messageChannels.values()) {
+            if (channel.role === 'messageSender') {
+                pendingMessages += channel.pendingMessages;
+                pendingMessageBytes += channel.pendingMessageBytes;
+            }
+            else {
+                reassemblyBytes += channel.reassembly?.payload.byteLength ?? 0;
+                if (channel.completed)
+                    completedMessages++;
+            }
+        }
+        return {
+            connection: connection.binding.side,
+            negotiated: this.connectionHasNativeMessageCapability(connection),
+            activeChannels: connection.messageChannels.size,
+            receiveGrants: connection.messageGrants.size,
+            pendingMessages,
+            pendingMessageBytes,
+            reassemblyBytes,
+            completedMessages,
+            sharedQueuedPayloadBytes: connection.queuedPayloadBytes,
+            rawQueueFrames: connection.rawQueue.length,
+            rawQueueBytes: connection.rawQueueBytes,
+            processingRawBytes: connection.processingRawBytes,
+            outboundControlFrames: connection.controlQueue.length,
+            outboundMessageFrames: connection.dataQueue.filter((frameArg) => frameArg.protocol === 'nativeMessage').length,
+            tombstones: connection.messageTombstones.size,
+            retainedRevalidations: connection.retainedRevalidations,
+            serverConnections: this.getServerConnectionCount(),
+            serverChannels,
             serverRetainedBytes: this.getServerRetainedBytes(),
             serverRetainedRevalidations: this.retainedRevalidations,
         };
@@ -825,6 +1235,259 @@ export class NativeByteManager {
             return;
         await this.failProducer(stateArg, asError(reasonArg, 'Native byte producer aborted'), NATIVE_BYTE_RESET_CODES.ABORTED);
     }
+    sendNativeMessage(stateArg, messageArg) {
+        let admission;
+        try {
+            admission = this.admitNativeMessage(stateArg, messageArg);
+        }
+        catch (errorArg) {
+            if (errorArg instanceof NativeMessageProtocolError
+                && errorArg.message.includes('sequence exhausted')) {
+                void this.closeNativeMessageSender(stateArg).catch(() => { });
+            }
+            return Promise.reject(errorArg);
+        }
+        const result = stateArg.operationTail.then(async () => this.sendNativeMessageAdmission(stateArg, admission));
+        stateArg.operationTail = result.then(() => undefined, () => undefined);
+        return result.finally(() => this.releaseNativeMessageAdmission(stateArg, admission));
+    }
+    admitNativeMessage(stateArg, messageArg) {
+        if (!(messageArg instanceof Uint8Array)) {
+            throw new TypeError('native-message-v1 send accepts only Uint8Array');
+        }
+        this.assertNativeMessageSenderOpen(stateArg);
+        if (stateArg.terminalRequested) {
+            throw new NativeMessageChannelClosedError('Native message sender is closing');
+        }
+        if (messageArg.byteLength > stateArg.acceptedMaxMessageBytes) {
+            throw new NativeMessageProtocolError('outbound logical message exceeds the accepted maxMessageBytes');
+        }
+        if (stateArg.nextSequence > 0xffffffff) {
+            throw new NativeMessageProtocolError('outbound logical message sequence exhausted uint32 range');
+        }
+        if (stateArg.pendingMessages >= NATIVE_MESSAGE_MAX_PENDING_MESSAGES_PER_CHANNEL) {
+            throw new NativeMessageError('native-message-v1 pending message count exhausted', 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+        }
+        if (stateArg.pendingMessageBytes + messageArg.byteLength
+            > NATIVE_MESSAGE_MAX_PENDING_BYTES_PER_CHANNEL) {
+            throw new NativeMessageError('native-message-v1 pending message byte budget exhausted', 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+        }
+        if (stateArg.connection.queuedPayloadBytes + messageArg.byteLength
+            > NATIVE_BYTE_MAX_QUEUED_PAYLOAD_BYTES_PER_CONNECTION) {
+            throw new NativeMessageError('native-byte streams and native-message channels share an exhausted connection payload budget', 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+        }
+        this.assertServerRetainedByteCapacity(stateArg.connection, messageArg.byteLength);
+        const payload = copyBytes(messageArg);
+        const admission = {
+            payload,
+            sequence: stateArg.nextSequence++,
+            accountingOwned: true,
+            pendingOwned: true,
+        };
+        stateArg.pendingMessages++;
+        stateArg.pendingMessageBytes += payload.byteLength;
+        stateArg.connection.queuedPayloadBytes += payload.byteLength;
+        stateArg.connection.nativeMessageQueuedPayloadBytes += payload.byteLength;
+        return admission;
+    }
+    async sendNativeMessageAdmission(stateArg, admissionArg) {
+        this.assertNativeMessageSenderOpen(stateArg);
+        const acknowledgement = createDeferred();
+        stateArg.awaitingAck = {
+            sequence: admissionArg.sequence,
+            deferred: acknowledgement,
+        };
+        try {
+            const payload = admissionArg.payload;
+            if (payload.byteLength === 0) {
+                await Promise.race([
+                    this.enqueueNativeMessageFrame(stateArg.connection, {
+                        type: NATIVE_MESSAGE_FRAME_TYPES.MESSAGE,
+                        channelId: stateArg.descriptor.transport.channelId,
+                        sequence: admissionArg.sequence,
+                        totalLength: 0,
+                        fragmentOffset: 0,
+                        payload,
+                    }),
+                    stateArg.closedSignal.promise,
+                ]);
+            }
+            else {
+                let offset = 0;
+                while (offset < payload.byteLength) {
+                    this.assertNativeMessageSenderOpen(stateArg);
+                    const fragmentLength = Math.min(NATIVE_MESSAGE_MAX_FRAGMENT_PAYLOAD_BYTES, payload.byteLength - offset);
+                    const fragment = payload.subarray(offset, offset + fragmentLength);
+                    await Promise.race([
+                        this.enqueueNativeMessageFrame(stateArg.connection, {
+                            type: NATIVE_MESSAGE_FRAME_TYPES.MESSAGE,
+                            channelId: stateArg.descriptor.transport.channelId,
+                            sequence: admissionArg.sequence,
+                            totalLength: payload.byteLength,
+                            fragmentOffset: offset,
+                            payload: fragment,
+                        }),
+                        stateArg.closedSignal.promise,
+                    ]);
+                    offset += fragmentLength;
+                    this.refreshNativeMessageSenderProgressTimer(stateArg, 'MESSAGE_ACK');
+                }
+            }
+            this.refreshNativeMessageSenderProgressTimer(stateArg, 'MESSAGE_ACK');
+            await acknowledgement.promise;
+        }
+        catch (errorArg) {
+            await this.failNativeMessageSender(stateArg, errorArg, NATIVE_MESSAGE_RESET_CODES.ABORTED, !stateArg.connection.closed);
+            throw errorArg;
+        }
+        finally {
+            if (stateArg.awaitingAck?.deferred === acknowledgement) {
+                stateArg.awaitingAck = undefined;
+            }
+            if (stateArg.progressTimer !== undefined) {
+                this.runtime.clearTimer(stateArg.progressTimer);
+                stateArg.progressTimer = undefined;
+            }
+        }
+        if (stateArg.status === 'open') {
+            this.refreshNativeMessageSenderProgressTimer(stateArg, 'progress');
+        }
+    }
+    releaseNativeMessageAdmission(stateArg, admissionArg) {
+        if (admissionArg.accountingOwned) {
+            if (stateArg.pendingMessageBytes < admissionArg.payload.byteLength
+                || stateArg.connection.queuedPayloadBytes < admissionArg.payload.byteLength
+                || stateArg.connection.nativeMessageQueuedPayloadBytes < admissionArg.payload.byteLength) {
+                throw new NativeMessageProtocolError('native message payload accounting underflow');
+            }
+            stateArg.pendingMessageBytes -= admissionArg.payload.byteLength;
+            stateArg.connection.queuedPayloadBytes -= admissionArg.payload.byteLength;
+            stateArg.connection.nativeMessageQueuedPayloadBytes -= admissionArg.payload.byteLength;
+            admissionArg.accountingOwned = false;
+        }
+        if (admissionArg.pendingOwned) {
+            if (stateArg.pendingMessages <= 0) {
+                throw new NativeMessageProtocolError('native message count accounting underflow');
+            }
+            stateArg.pendingMessages--;
+            admissionArg.pendingOwned = false;
+        }
+        this.maybeReleaseServerAccountingConnection(stateArg.connection);
+    }
+    closeNativeMessageSender(stateArg) {
+        if (stateArg.closePromise)
+            return stateArg.closePromise;
+        try {
+            this.assertNativeMessageSenderOpen(stateArg);
+            stateArg.terminalRequested = true;
+        }
+        catch (errorArg) {
+            return Promise.reject(errorArg);
+        }
+        const result = stateArg.operationTail.then(async () => this.finishNativeMessageSender(stateArg));
+        stateArg.operationTail = result.then(() => undefined, () => undefined);
+        stateArg.closePromise = result;
+        return result;
+    }
+    async finishNativeMessageSender(stateArg) {
+        this.assertNativeMessageSenderOpen(stateArg);
+        stateArg.status = 'closing';
+        if (stateArg.progressTimer !== undefined) {
+            this.runtime.clearTimer(stateArg.progressTimer);
+            stateArg.progressTimer = undefined;
+        }
+        stateArg.closeTimer = this.runtime.setTimer(() => {
+            void this.failNativeMessageSender(stateArg, new NativeMessageError('native-message-v1 CLOSE_ACK timed out', 'NATIVE_MESSAGE_CLOSE_TIMEOUT'), NATIVE_MESSAGE_RESET_CODES.TIMEOUT);
+        }, NATIVE_MESSAGE_PROGRESS_TIMEOUT_MS);
+        await Promise.race([
+            this.enqueueNativeMessageFrame(stateArg.connection, {
+                type: NATIVE_MESSAGE_FRAME_TYPES.CLOSE,
+                channelId: stateArg.descriptor.transport.channelId,
+            }),
+            stateArg.closedSignal.promise,
+        ]);
+        await stateArg.completion.promise;
+    }
+    async receiveNativeMessage(stateArg) {
+        if (stateArg.receiveActive) {
+            throw new NativeMessageProtocolError('native-message-v1 receiver permits only one active receive');
+        }
+        stateArg.receiveActive = true;
+        try {
+            while (!stateArg.completed) {
+                if (stateArg.remoteClosed)
+                    return undefined;
+                if (stateArg.status === 'closed') {
+                    throw stateArg.closeError
+                        ?? new NativeMessageChannelClosedError('Native message receiver is closed');
+                }
+                const waiter = createDeferred();
+                stateArg.receiveWaiters.add(waiter);
+                try {
+                    await waiter.promise;
+                }
+                finally {
+                    stateArg.receiveWaiters.delete(waiter);
+                }
+            }
+            const completed = stateArg.completed;
+            stateArg.completed = undefined;
+            try {
+                await Promise.race([
+                    this.enqueueNativeMessageFrame(stateArg.connection, {
+                        type: NATIVE_MESSAGE_FRAME_TYPES.MESSAGE_ACK,
+                        channelId: stateArg.descriptor.transport.channelId,
+                        sequence: completed.sequence,
+                    }),
+                    stateArg.closedSignal.promise,
+                ]);
+            }
+            finally {
+                if (stateArg.connection.queuedPayloadBytes < completed.payload.byteLength
+                    || stateArg.connection.nativeMessageQueuedPayloadBytes < completed.payload.byteLength) {
+                    throw new NativeMessageProtocolError('native message receive accounting underflow');
+                }
+                stateArg.connection.queuedPayloadBytes -= completed.payload.byteLength;
+                stateArg.connection.nativeMessageQueuedPayloadBytes -= completed.payload.byteLength;
+                this.maybeReleaseServerAccountingConnection(stateArg.connection);
+            }
+            this.refreshNativeMessageReceiverProgressTimer(stateArg, 'receive progress');
+            return completed.payload;
+        }
+        finally {
+            stateArg.receiveActive = false;
+        }
+    }
+    async rejectNativeMessageReceiver(stateArg, reasonArg) {
+        if (stateArg.status === 'closed')
+            return;
+        try {
+            await this.revalidateNativeMessageReceiver(stateArg, 'reject');
+        }
+        catch { }
+        if (stateArg.completion.settled)
+            return;
+        const shouldReset = stateArg.status !== 'grant' && stateArg.status !== 'validating-open';
+        const error = asError(reasonArg, 'Native message receiver rejected channel');
+        this.cleanupNativeMessageReceiver(stateArg, error, true);
+        if (shouldReset) {
+            void this.sendNativeMessageReset(stateArg.connection, stateArg.descriptor.transport.channelId, NATIVE_MESSAGE_RESET_CODES.ABORTED, 'Receiver rejected channel').catch(() => { });
+        }
+    }
+    refreshNativeMessageSenderProgressTimer(stateArg, phaseArg) {
+        if (stateArg.progressTimer !== undefined)
+            this.runtime.clearTimer(stateArg.progressTimer);
+        stateArg.progressTimer = this.runtime.setTimer(() => {
+            void this.failNativeMessageSender(stateArg, new NativeMessageError(`native-message-v1 ${phaseArg} timed out`, 'NATIVE_MESSAGE_PROGRESS_TIMEOUT'), NATIVE_MESSAGE_RESET_CODES.TIMEOUT);
+        }, NATIVE_MESSAGE_PROGRESS_TIMEOUT_MS);
+    }
+    refreshNativeMessageReceiverProgressTimer(stateArg, _phaseArg) {
+        if (stateArg.timer !== undefined)
+            this.runtime.clearTimer(stateArg.timer);
+        stateArg.timer = this.runtime.setTimer(() => {
+            void this.failNativeMessageReceiver(stateArg, new NativeMessageError('native-message-v1 receiver made no progress', 'NATIVE_MESSAGE_PROGRESS_TIMEOUT'), NATIVE_MESSAGE_RESET_CODES.TIMEOUT);
+        }, NATIVE_MESSAGE_PROGRESS_TIMEOUT_MS);
+    }
     getConsumerQueueLength(stateArg) {
         return stateArg.receiveQueue.length - stateArg.receiveQueueHead;
     }
@@ -987,17 +1650,23 @@ export class NativeByteManager {
             grants: new Map(),
             streams: new Map(),
             tombstones: new Map(),
+            messageGrants: new Map(),
+            messageChannels: new Map(),
+            messageTombstones: new Map(),
             rawQueue: [],
             controlQueue: [],
             dataQueue: [],
             revalidationControllers: new Set(),
             negotiated: false,
             nativeEnabled: false,
+            messageNegotiated: false,
+            nativeMessageEnabled: false,
             closed: false,
             processingRaw: false,
             rawQueueBytes: 0,
             processingRawBytes: 0,
             queuedPayloadBytes: 0,
+            nativeMessageQueuedPayloadBytes: 0,
             authorityMetadataBytes: 0,
             tombstoneBytes: 0,
             receiveWindowReservedBytes: 0,
@@ -1045,6 +1714,13 @@ export class NativeByteManager {
                 }
             }, NATIVE_BYTE_GRANT_OPEN_TIMEOUT_MS);
         }
+        if (this.nativeMessageCapabilityMode === 'required') {
+            connection.nativeMessageNegotiationTimer = this.runtime.setTimer(() => {
+                if (!connection.closed && !connection.messageNegotiated) {
+                    this.closeConnection(connection, 1008, 'native-message-v1 negotiation is required', 'nativeMessage');
+                }
+            }, NATIVE_MESSAGE_NEGOTIATION_TIMEOUT_MS);
+        }
     }
     unbindServerPeer(peerArg, reasonArg) {
         const connection = this.serverConnections.get(peerArg);
@@ -1095,19 +1771,41 @@ export class NativeByteManager {
                 connectionArg.rawQueueBytes -= bytes.byteLength;
                 connectionArg.processingRawBytes += bytes.byteLength;
                 try {
-                    let frame;
-                    try {
-                        frame = decodeNativeByteFrame(bytes);
-                    }
-                    catch (errorArg) {
-                        this.closeConnection(connectionArg, 1002, 'invalid native-byte-v1 frame');
-                        throw errorArg;
+                    const isNativeMessageFrame = bytes.byteLength >= 4
+                        && bytes[0] === NATIVE_MESSAGE_FRAME_MAGIC.charCodeAt(0)
+                        && bytes[1] === NATIVE_MESSAGE_FRAME_MAGIC.charCodeAt(1)
+                        && bytes[2] === NATIVE_MESSAGE_FRAME_MAGIC.charCodeAt(2)
+                        && bytes[3] === NATIVE_MESSAGE_FRAME_MAGIC.charCodeAt(3);
+                    if (isNativeMessageFrame) {
+                        let frame;
+                        try {
+                            frame = decodeNativeMessageFrame(bytes);
+                        }
+                        catch (errorArg) {
+                            this.closeConnection(connectionArg, 1002, 'invalid native-message-v1 frame', 'nativeMessage');
+                            throw errorArg;
+                        }
+                        if (!this.connectionHasNativeMessageCapability(connectionArg)) {
+                            this.closeConnection(connectionArg, 1002, 'native-message-v1 frame received before negotiation', 'nativeMessage');
+                            return;
+                        }
+                        await this.handleNativeMessageFrame(connectionArg, frame);
                     }
-                    if (!this.connectionHasCapability(connectionArg)) {
-                        this.closeConnection(connectionArg, 1002, 'native-byte-v1 frame received before negotiation');
-                        return;
+                    else {
+                        let frame;
+                        try {
+                            frame = decodeNativeByteFrame(bytes);
+                        }
+                        catch (errorArg) {
+                            this.closeConnection(connectionArg, 1002, 'invalid native-byte-v1 frame');
+                            throw errorArg;
+                        }
+                        if (!this.connectionHasCapability(connectionArg)) {
+                            this.closeConnection(connectionArg, 1002, 'native-byte-v1 frame received before negotiation');
+                            return;
+                        }
+                        await this.handleFrame(connectionArg, frame);
                     }
-                    await this.handleFrame(connectionArg, frame);
                 }
                 finally {
                     connectionArg.processingRawBytes -= bytes.byteLength;
@@ -1152,25 +1850,253 @@ export class NativeByteManager {
             await this.sendReset(connectionArg, frameArg.streamId, NATIVE_BYTE_RESET_CODES.CAPABILITY_REJECTED, 'Unknown or expired stream capability');
             return;
         }
-        switch (frameArg.type) {
-            case NATIVE_BYTE_FRAME_TYPES.OPEN_ACK:
-                await this.handleOpenAck(stream, frameArg.receiveLimitOffset);
-                return;
-            case NATIVE_BYTE_FRAME_TYPES.DATA:
-                await this.handleData(stream, frameArg);
-                return;
-            case NATIVE_BYTE_FRAME_TYPES.ACK:
-                await this.handleAck(stream, frameArg.acknowledgedOffset, frameArg.receiveLimitOffset);
-                return;
-            case NATIVE_BYTE_FRAME_TYPES.FIN:
-                await this.handleFin(stream, frameArg.byteLength, frameArg.sha256);
-                return;
-            case NATIVE_BYTE_FRAME_TYPES.FIN_ACK:
-                await this.handleFinAck(stream, frameArg.byteLength, frameArg.sha256);
-                return;
-            case NATIVE_BYTE_FRAME_TYPES.RESET:
-                this.handleReset(stream, frameArg.code, frameArg.reason);
-                return;
+        switch (frameArg.type) {
+            case NATIVE_BYTE_FRAME_TYPES.OPEN_ACK:
+                await this.handleOpenAck(stream, frameArg.receiveLimitOffset);
+                return;
+            case NATIVE_BYTE_FRAME_TYPES.DATA:
+                await this.handleData(stream, frameArg);
+                return;
+            case NATIVE_BYTE_FRAME_TYPES.ACK:
+                await this.handleAck(stream, frameArg.acknowledgedOffset, frameArg.receiveLimitOffset);
+                return;
+            case NATIVE_BYTE_FRAME_TYPES.FIN:
+                await this.handleFin(stream, frameArg.byteLength, frameArg.sha256);
+                return;
+            case NATIVE_BYTE_FRAME_TYPES.FIN_ACK:
+                await this.handleFinAck(stream, frameArg.byteLength, frameArg.sha256);
+                return;
+            case NATIVE_BYTE_FRAME_TYPES.RESET:
+                this.handleReset(stream, frameArg.code, frameArg.reason);
+                return;
+        }
+    }
+    async handleNativeMessageFrame(connectionArg, frameArg) {
+        this.pruneNativeMessageTombstones(connectionArg);
+        if (frameArg.type === NATIVE_MESSAGE_FRAME_TYPES.OPEN) {
+            await this.handleNativeMessageOpen(connectionArg, frameArg);
+            return;
+        }
+        const channel = connectionArg.messageChannels.get(frameArg.channelId);
+        if (!channel) {
+            if (frameArg.type === NATIVE_MESSAGE_FRAME_TYPES.RESET)
+                return;
+            await this.sendNativeMessageReset(connectionArg, frameArg.channelId, NATIVE_MESSAGE_RESET_CODES.CAPABILITY_REJECTED, 'Unknown or expired channel capability');
+            return;
+        }
+        switch (frameArg.type) {
+            case NATIVE_MESSAGE_FRAME_TYPES.OPEN_ACK:
+                await this.handleNativeMessageOpenAck(channel, frameArg.acceptedMaxMessageBytes);
+                return;
+            case NATIVE_MESSAGE_FRAME_TYPES.MESSAGE:
+                await this.handleNativeMessageFragment(channel, frameArg);
+                return;
+            case NATIVE_MESSAGE_FRAME_TYPES.MESSAGE_ACK:
+                await this.handleNativeMessageAck(channel, frameArg.sequence);
+                return;
+            case NATIVE_MESSAGE_FRAME_TYPES.CLOSE:
+                await this.handleNativeMessageClose(channel);
+                return;
+            case NATIVE_MESSAGE_FRAME_TYPES.CLOSE_ACK:
+                await this.handleNativeMessageCloseAck(channel);
+                return;
+            case NATIVE_MESSAGE_FRAME_TYPES.RESET:
+                this.handleNativeMessageReset(channel, frameArg.code, frameArg.reason);
+                return;
+        }
+    }
+    async handleNativeMessageOpen(connectionArg, frameArg) {
+        const grant = connectionArg.messageGrants.get(frameArg.channelId);
+        if (!grant || grant.status !== 'grant') {
+            await this.sendNativeMessageReset(connectionArg, frameArg.channelId, NATIVE_MESSAGE_RESET_CODES.CAPABILITY_REJECTED, 'Unknown, replayed, or expired channel capability');
+            return;
+        }
+        grant.status = 'validating-open';
+        try {
+            await this.revalidateNativeMessageReceiver(grant, 'open');
+            this.assertNativeMessageReceiverOwned(grant);
+            const descriptor = grant.descriptor.transport;
+            if (connectionArg.closed
+                || connectionArg.messageGrants.get(frameArg.channelId) !== grant
+                || grant.status !== 'validating-open'
+                || descriptor.expiresAt <= this.runtime.now()) {
+                throw new NativeMessageCapabilityError('native message receive grant changed during OPEN revalidation');
+            }
+            if (frameArg.capability !== descriptor.capability
+                || frameArg.maxMessageBytes !== descriptor.maxMessageBytes) {
+                throw new NativeMessageCapabilityError('native-message-v1 OPEN does not exactly match the receive grant');
+            }
+            if (grant.timer !== undefined)
+                this.runtime.clearTimer(grant.timer);
+            grant.timer = undefined;
+            connectionArg.messageGrants.delete(frameArg.channelId);
+            connectionArg.messageChannels.set(frameArg.channelId, grant);
+            grant.status = 'open';
+            grant.acceptedMaxMessageBytes = frameArg.maxMessageBytes;
+            grant.opened.resolve(grant.endpoint);
+            this.refreshNativeMessageReceiverProgressTimer(grant, 'receive progress');
+            await Promise.race([
+                this.enqueueNativeMessageFrame(connectionArg, {
+                    type: NATIVE_MESSAGE_FRAME_TYPES.OPEN_ACK,
+                    channelId: frameArg.channelId,
+                    acceptedMaxMessageBytes: grant.acceptedMaxMessageBytes,
+                }),
+                grant.closedSignal.promise,
+            ]);
+        }
+        catch (errorArg) {
+            const resetCode = this.getNativeMessageRevalidationResetCode(errorArg, NATIVE_MESSAGE_RESET_CODES.AUTHORITY_REVOKED);
+            this.cleanupNativeMessageReceiver(grant, errorArg, true);
+            void this.sendNativeMessageReset(connectionArg, frameArg.channelId, resetCode, 'Receive grant rejected OPEN').catch(() => { });
+        }
+    }
+    async handleNativeMessageOpenAck(channelArg, acceptedMaxMessageBytesArg) {
+        if (channelArg.role !== 'messageSender' || channelArg.status !== 'opening') {
+            await this.failNativeMessageChannelProtocol(channelArg, 'unexpected OPEN_ACK');
+            return;
+        }
+        if (acceptedMaxMessageBytesArg > channelArg.descriptor.transport.maxMessageBytes
+            || acceptedMaxMessageBytesArg < 0) {
+            await this.failNativeMessageChannelProtocol(channelArg, 'OPEN_ACK accepted max is outside the requested bound');
+            return;
+        }
+        if (channelArg.openTimer !== undefined)
+            this.runtime.clearTimer(channelArg.openTimer);
+        channelArg.openTimer = undefined;
+        channelArg.acceptedMaxMessageBytes = acceptedMaxMessageBytesArg;
+        channelArg.status = 'open';
+        channelArg.opened.resolve(channelArg.endpoint);
+        this.refreshNativeMessageSenderProgressTimer(channelArg, 'progress');
+    }
+    async handleNativeMessageFragment(channelArg, frameArg) {
+        if (channelArg.role !== 'messageReceiver' || channelArg.status !== 'open') {
+            await this.failNativeMessageChannelProtocol(channelArg, 'unexpected MESSAGE');
+            return;
+        }
+        try {
+            this.assertNativeMessageReceiverOwned(channelArg);
+            if (channelArg.completed) {
+                throw new NativeMessageProtocolError('MESSAGE arrived before the completed application slot was dequeued');
+            }
+            let reassembly = channelArg.reassembly;
+            if (!reassembly) {
+                if (frameArg.sequence !== channelArg.nextSequence
+                    || frameArg.fragmentOffset !== 0
+                    || frameArg.totalLength > channelArg.acceptedMaxMessageBytes) {
+                    throw new NativeMessageProtocolError('MESSAGE sequence, initial offset, or total length is invalid');
+                }
+                if (channelArg.connection.queuedPayloadBytes + frameArg.totalLength
+                    > NATIVE_BYTE_MAX_QUEUED_PAYLOAD_BYTES_PER_CONNECTION) {
+                    throw new NativeMessageError('native-byte streams and native-message channels share an exhausted connection payload budget', 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+                }
+                this.assertServerRetainedByteCapacity(channelArg.connection, frameArg.totalLength);
+                reassembly = {
+                    sequence: frameArg.sequence,
+                    totalLength: frameArg.totalLength,
+                    payload: new Uint8Array(new ArrayBuffer(frameArg.totalLength)),
+                    nextOffset: 0,
+                };
+                channelArg.reassembly = reassembly;
+                channelArg.connection.queuedPayloadBytes += frameArg.totalLength;
+                channelArg.connection.nativeMessageQueuedPayloadBytes += frameArg.totalLength;
+            }
+            if (frameArg.sequence !== reassembly.sequence
+                || frameArg.totalLength !== reassembly.totalLength
+                || frameArg.fragmentOffset !== reassembly.nextOffset) {
+                throw new NativeMessageProtocolError('MESSAGE fragment sequence, total length, or next offset is not exact');
+            }
+            reassembly.payload.set(frameArg.payload, frameArg.fragmentOffset);
+            reassembly.nextOffset += frameArg.payload.byteLength;
+            if (reassembly.nextOffset > reassembly.totalLength) {
+                throw new NativeMessageProtocolError('MESSAGE fragment exceeds total logical length');
+            }
+            this.refreshNativeMessageReceiverProgressTimer(channelArg, 'fragment progress');
+            if (reassembly.nextOffset !== reassembly.totalLength)
+                return;
+            await this.revalidateNativeMessageReceiver(channelArg, 'message');
+            this.assertNativeMessageReceiverOwned(channelArg);
+            if (channelArg.reassembly !== reassembly || channelArg.completed) {
+                throw new NativeMessageCapabilityError('native message receiver changed during message revalidation');
+            }
+            channelArg.reassembly = undefined;
+            channelArg.completed = {
+                sequence: reassembly.sequence,
+                payload: reassembly.payload,
+            };
+            channelArg.nextSequence++;
+            this.wakeNativeMessageReceiveWaiters(channelArg);
+        }
+        catch (errorArg) {
+            await this.failNativeMessageReceiver(channelArg, errorArg, this.getNativeMessageRevalidationResetCode(errorArg, NATIVE_MESSAGE_RESET_CODES.PROTOCOL_ERROR));
+        }
+    }
+    async handleNativeMessageAck(channelArg, sequenceArg) {
+        if (channelArg.role !== 'messageSender' || channelArg.status !== 'open') {
+            await this.failNativeMessageChannelProtocol(channelArg, 'unexpected MESSAGE_ACK');
+            return;
+        }
+        const awaiting = channelArg.awaitingAck;
+        if (!awaiting || awaiting.sequence !== sequenceArg) {
+            await this.failNativeMessageChannelProtocol(channelArg, 'MESSAGE_ACK does not exactly match the pending logical message');
+            return;
+        }
+        if (channelArg.progressTimer !== undefined) {
+            this.runtime.clearTimer(channelArg.progressTimer);
+            channelArg.progressTimer = undefined;
+        }
+        awaiting.deferred.resolve();
+        if (sequenceArg === 0xffffffff) {
+            void this.closeNativeMessageSender(channelArg).catch(() => { });
+        }
+    }
+    async handleNativeMessageClose(channelArg) {
+        if (channelArg.role !== 'messageReceiver'
+            || channelArg.status !== 'open'
+            || channelArg.reassembly
+            || channelArg.completed) {
+            await this.failNativeMessageChannelProtocol(channelArg, 'unexpected CLOSE');
+            return;
+        }
+        try {
+            await this.revalidateNativeMessageReceiver(channelArg, 'close');
+            this.assertNativeMessageReceiverOwned(channelArg);
+            channelArg.status = 'closing';
+            channelArg.remoteClosed = true;
+            if (channelArg.timer !== undefined)
+                this.runtime.clearTimer(channelArg.timer);
+            channelArg.timer = this.runtime.setTimer(() => {
+                void this.failNativeMessageReceiver(channelArg, new NativeMessageError('native-message-v1 CLOSE_ACK settlement timed out', 'NATIVE_MESSAGE_CLOSE_TIMEOUT'), NATIVE_MESSAGE_RESET_CODES.TIMEOUT);
+            }, NATIVE_MESSAGE_PROGRESS_TIMEOUT_MS);
+            this.wakeNativeMessageReceiveWaiters(channelArg);
+            await Promise.race([
+                this.enqueueNativeMessageFrame(channelArg.connection, {
+                    type: NATIVE_MESSAGE_FRAME_TYPES.CLOSE_ACK,
+                    channelId: channelArg.descriptor.transport.channelId,
+                }),
+                channelArg.closedSignal.promise,
+            ]);
+            this.cleanupNativeMessageReceiver(channelArg, undefined, false);
+            channelArg.completion.resolve();
+        }
+        catch (errorArg) {
+            await this.failNativeMessageReceiver(channelArg, errorArg, this.getNativeMessageRevalidationResetCode(errorArg, NATIVE_MESSAGE_RESET_CODES.AUTHORITY_REVOKED));
+        }
+    }
+    async handleNativeMessageCloseAck(channelArg) {
+        if (channelArg.role !== 'messageSender' || channelArg.status !== 'closing') {
+            await this.failNativeMessageChannelProtocol(channelArg, 'unexpected CLOSE_ACK');
+            return;
+        }
+        this.cleanupNativeMessageSender(channelArg, undefined, false);
+        channelArg.completion.resolve();
+    }
+    handleNativeMessageReset(channelArg, codeArg, reasonArg) {
+        const error = new NativeMessageChannelClosedError(`native-message-v1 peer reset channel (${codeArg}): ${reasonArg}`);
+        if (channelArg.role === 'messageSender') {
+            this.cleanupNativeMessageSender(channelArg, error, true);
+        }
+        else {
+            this.cleanupNativeMessageReceiver(channelArg, error, true);
         }
     }
     async handleOpen(connectionArg, frameArg) {
@@ -1553,6 +2479,78 @@ export class NativeByteManager {
             }),
         });
     }
+    validateNativeMessageDescriptor(descriptorArg) {
+        if (!descriptorArg
+            || typeof descriptorArg !== 'object'
+            || descriptorArg.protocol !== NATIVE_MESSAGE_PROTOCOL) {
+            throw new NativeMessageProtocolError('descriptor protocol must be native-message-v1');
+        }
+        const transport = descriptorArg.transport;
+        if (!transport || typeof transport !== 'object' || Array.isArray(transport)) {
+            throw new NativeMessageProtocolError('descriptor transport payload must be an object');
+        }
+        const exactKeys = [
+            'protocolMajor',
+            'channelId',
+            'capability',
+            'expiresAt',
+            'maxMessageBytes',
+        ];
+        if (Object.keys(transport).length !== exactKeys.length
+            || exactKeys.some((keyArg) => !Object.hasOwn(transport, keyArg))
+            || Reflect.get(transport, 'protocolMajor') !== NATIVE_MESSAGE_PROTOCOL_MAJOR) {
+            throw new NativeMessageProtocolError('descriptor transport shape or version is invalid');
+        }
+        const expiresAt = Reflect.get(transport, 'expiresAt');
+        if (typeof expiresAt !== 'number' || !Number.isSafeInteger(expiresAt) || expiresAt <= 0) {
+            throw new NativeMessageProtocolError('descriptor expiresAt must be a positive safe integer');
+        }
+        return Object.freeze({
+            protocol: NATIVE_MESSAGE_PROTOCOL,
+            transport: Object.freeze({
+                protocolMajor: NATIVE_MESSAGE_PROTOCOL_MAJOR,
+                channelId: normalizeNativeMessageChannelId(Reflect.get(transport, 'channelId')),
+                capability: normalizeNativeMessageCapability(Reflect.get(transport, 'capability')),
+                expiresAt,
+                maxMessageBytes: assertNativeMessageLength(Reflect.get(transport, 'maxMessageBytes')),
+            }),
+        });
+    }
+    resolveNativeMessageConnection(targetArg) {
+        if (this.side === 'server' && targetArg === undefined) {
+            throw new NativeMessageCapabilityError('Server native-message-v1 APIs require an exact peer target');
+        }
+        const connection = this.resolveConnectionForInspection(targetArg);
+        if (!connection || connection.closed) {
+            throw new NativeMessageCapabilityError('No exact native-message-v1 connection is available');
+        }
+        return connection;
+    }
+    requireNativeMessageCapability(connectionArg) {
+        if (!this.connectionHasNativeMessageCapability(connectionArg)) {
+            throw new NativeMessageCapabilityError();
+        }
+        if (connectionArg.binding.side === 'server'
+            && connectionArg.binding.peer.transportOwner !== this.webSocketTransportOwner) {
+            throw new NativeMessageCapabilityError('SmartServe peer is not owned by this TypedSocket');
+        }
+    }
+    reserveNativeMessageChannelSlot(connectionArg) {
+        this.requireNativeMessageCapability(connectionArg);
+        if (connectionArg.messageGrants.size + connectionArg.messageChannels.size
+            >= NATIVE_MESSAGE_MAX_CHANNELS_PER_CONNECTION
+            || connectionArg.grants.size
+                + connectionArg.streams.size
+                + connectionArg.messageGrants.size
+                + connectionArg.messageChannels.size
+                >= NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION) {
+            throw new NativeMessageError(`native-byte streams and native-message channels share a ${NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION} slot connection limit`, 'NATIVE_MESSAGE_CHANNEL_LIMIT');
+        }
+        if (connectionArg.binding.side === 'server'
+            && this.getServerAggregateSlotCount() >= NATIVE_BYTE_MAX_STREAMS_PER_SERVER) {
+            throw new NativeMessageError(`native-byte streams and native-message channels share a ${NATIVE_BYTE_MAX_STREAMS_PER_SERVER} slot server limit`, 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+        }
+    }
     resolveConnection(targetArg) {
         const connection = this.resolveConnectionForInspection(targetArg);
         if (!connection || connection.closed) {
@@ -1585,11 +2583,15 @@ export class NativeByteManager {
     }
     reserveStreamSlot(connectionArg) {
         this.requireConnectionCapability(connectionArg);
-        if (connectionArg.grants.size + connectionArg.streams.size >= NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION) {
+        if (connectionArg.grants.size
+            + connectionArg.streams.size
+            + connectionArg.messageGrants.size
+            + connectionArg.messageChannels.size
+            >= NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION) {
             throw new NativeByteError(`native-byte-v1 permits at most ${NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION} streams per connection`, 'NATIVE_BYTE_STREAM_LIMIT');
         }
         if (connectionArg.binding.side === 'server'
-            && this.getServerStreamCount() >= NATIVE_BYTE_MAX_STREAMS_PER_SERVER) {
+            && this.getServerAggregateSlotCount() >= NATIVE_BYTE_MAX_STREAMS_PER_SERVER) {
             throw new NativeByteError(`native-byte-v1 server permits at most ${NATIVE_BYTE_MAX_STREAMS_PER_SERVER} streams`, 'NATIVE_BYTE_RESOURCE_LIMIT');
         }
     }
@@ -1612,7 +2614,7 @@ export class NativeByteManager {
     getServerConnectionCount() {
         return this.side === 'server' ? this.serverConnections.size : 0;
     }
-    getServerStreamCount() {
+    getServerNativeByteStreamCount() {
         if (this.side !== 'server')
             return 0;
         let count = 0;
@@ -1621,6 +2623,18 @@ export class NativeByteManager {
         }
         return count;
     }
+    getServerAggregateSlotCount() {
+        if (this.side !== 'server')
+            return 0;
+        let count = 0;
+        for (const connection of this.serverConnections.values()) {
+            count += connection.grants.size
+                + connection.streams.size
+                + connection.messageGrants.size
+                + connection.messageChannels.size;
+        }
+        return count;
+    }
     getServerRetainedBytes() {
         if (this.side !== 'server')
             return 0;
@@ -1688,6 +2702,297 @@ export class NativeByteManager {
             this.serverSettlementConnections.delete(connectionArg.binding.peer);
         }
     }
+    async revalidateNativeMessageReceiver(stateArg, operationArg) {
+        const principalCount = this.retainedRevalidationsByPrincipal.get(stateArg.principalId) ?? 0;
+        if (stateArg.connection.retainedRevalidations >= NATIVE_BYTE_MAX_REVALIDATIONS_PER_PEER
+            || principalCount >= NATIVE_BYTE_MAX_REVALIDATIONS_PER_PRINCIPAL
+            || this.retainedRevalidations >= NATIVE_BYTE_MAX_REVALIDATIONS_PER_SERVER) {
+            throw new NativeMessageError('native-message-v1 revalidation capacity exhausted', 'NATIVE_MESSAGE_RESOURCE_LIMIT');
+        }
+        const now = this.runtime.now();
+        if (!Number.isSafeInteger(now)
+            || now < 0
+            || now > Number.MAX_SAFE_INTEGER - NATIVE_BYTE_REVALIDATION_TIMEOUT_MS) {
+            throw new NativeMessageProtocolError('native-message-v1 runtime now() cannot produce a revalidation deadline');
+        }
+        const controller = new AbortController();
+        stateArg.connection.revalidationControllers.add(controller);
+        stateArg.revalidationControllers.add(controller);
+        stateArg.connection.retainedRevalidations++;
+        this.retainedRevalidations++;
+        this.retainedRevalidationsByPrincipal.set(stateArg.principalId, principalCount + 1);
+        const revalidationDescriptor = Object.freeze({
+            protocol: stateArg.descriptor.protocol,
+            transport: Object.freeze({
+                protocolMajor: stateArg.descriptor.transport.protocolMajor,
+                channelId: stateArg.descriptor.transport.channelId,
+                expiresAt: stateArg.descriptor.transport.expiresAt,
+                maxMessageBytes: stateArg.descriptor.transport.maxMessageBytes,
+            }),
+        });
+        const context = Object.freeze({
+            operation: operationArg,
+            descriptor: revalidationDescriptor,
+            connection: stateArg.connection.binding,
+            abortSignal: controller.signal,
+            deadline: now + NATIVE_BYTE_REVALIDATION_TIMEOUT_MS,
+            ...stateArg.revisions,
+        });
+        let accountingReleased = false;
+        const releaseAccounting = () => {
+            if (accountingReleased)
+                return;
+            accountingReleased = true;
+            stateArg.connection.revalidationControllers.delete(controller);
+            stateArg.revalidationControllers.delete(controller);
+            stateArg.connection.retainedRevalidations--;
+            this.retainedRevalidations--;
+            const retainedForPrincipal = this.retainedRevalidationsByPrincipal.get(stateArg.principalId);
+            if (retainedForPrincipal === undefined || retainedForPrincipal <= 0) {
+                throw new NativeMessageProtocolError('native-message-v1 principal revalidation accounting underflow');
+            }
+            if (retainedForPrincipal === 1) {
+                this.retainedRevalidationsByPrincipal.delete(stateArg.principalId);
+            }
+            else {
+                this.retainedRevalidationsByPrincipal.set(stateArg.principalId, retainedForPrincipal - 1);
+            }
+            this.maybeReleaseServerAccountingConnection(stateArg.connection);
+        };
+        const outcome = Promise.resolve()
+            .then(() => stateArg.revalidate(context))
+            .then((resultArg) => resultArg === true ? 'allowed' : 'denied', () => 'failed');
+        void outcome.then(releaseAccounting, releaseAccounting).catch(() => { });
+        const abortOutcome = new Promise((resolveArg) => {
+            const resolveAborted = () => {
+                const reason = controller.signal.reason;
+                resolveArg(reason instanceof NativeMessageError
+                    && reason.code === 'NATIVE_MESSAGE_REVALIDATION_TIMEOUT'
+                    ? 'timeout'
+                    : 'cancelled');
+            };
+            controller.signal.addEventListener('abort', resolveAborted, { once: true });
+            if (controller.signal.aborted)
+                resolveAborted();
+        });
+        const deadlineTimer = this.runtime.setTimer(() => {
+            controller.abort(new NativeMessageError('native message authorization revalidation timed out', 'NATIVE_MESSAGE_REVALIDATION_TIMEOUT'));
+        }, NATIVE_BYTE_REVALIDATION_TIMEOUT_MS);
+        try {
+            const result = await Promise.race([outcome, abortOutcome]);
+            if (result === 'allowed')
+                return;
+            if (result === 'timeout') {
+                throw new NativeMessageError('native message authorization revalidation timed out', 'NATIVE_MESSAGE_REVALIDATION_TIMEOUT');
+            }
+            if (result === 'cancelled') {
+                throw new NativeMessageError('native message authorization revalidation was cancelled', 'NATIVE_MESSAGE_REVALIDATION_CANCELLED');
+            }
+            throw new NativeMessageCapabilityError(result === 'failed'
+                ? 'native message authorization revalidation callback failed'
+                : 'native message authorization revalidation rejected authority');
+        }
+        finally {
+            this.runtime.clearTimer(deadlineTimer);
+        }
+    }
+    getNativeMessageRevalidationResetCode(errorArg, fallbackArg) {
+        if (errorArg instanceof NativeMessageError) {
+            if (errorArg.code === 'NATIVE_MESSAGE_RESOURCE_LIMIT') {
+                return NATIVE_MESSAGE_RESET_CODES.RESOURCE_LIMIT;
+            }
+            if (errorArg.code === 'NATIVE_MESSAGE_REVALIDATION_TIMEOUT') {
+                return NATIVE_MESSAGE_RESET_CODES.TIMEOUT;
+            }
+            if (errorArg.code === 'NATIVE_MESSAGE_REVALIDATION_CANCELLED') {
+                return NATIVE_MESSAGE_RESET_CODES.ABORTED;
+            }
+        }
+        if (errorArg instanceof NativeMessageCapabilityError) {
+            return NATIVE_MESSAGE_RESET_CODES.AUTHORITY_REVOKED;
+        }
+        return fallbackArg;
+    }
+    assertNativeMessageReceiverOwned(stateArg) {
+        if (stateArg.connection.closed
+            || (stateArg.connection.messageGrants.get(stateArg.descriptor.transport.channelId) !== stateArg
+                && stateArg.connection.messageChannels.get(stateArg.descriptor.transport.channelId) !== stateArg)
+            || stateArg.status === 'closed'
+            || (stateArg.connection.binding.side === 'client'
+                ? this.currentClientConnection !== stateArg.connection
+                : stateArg.connection.binding.peer.transportOwner !== this.webSocketTransportOwner
+                    || this.serverConnections.get(stateArg.connection.binding.peer) !== stateArg.connection)) {
+            throw new NativeMessageCapabilityError('native message receive grant owner changed during revalidation');
+        }
+    }
+    assertNativeMessageSenderOpen(stateArg) {
+        if (stateArg.status !== 'open'
+            || stateArg.connection.closed
+            || stateArg.connection.messageChannels.get(stateArg.descriptor.transport.channelId) !== stateArg) {
+            throw stateArg.closeError
+                ?? new NativeMessageChannelClosedError('Native message sender is not open');
+        }
+    }
+    wakeNativeMessageReceiveWaiters(stateArg, errorArg) {
+        for (const waiter of [...stateArg.receiveWaiters]) {
+            if (errorArg)
+                waiter.reject(errorArg);
+            else
+                waiter.resolve();
+        }
+        stateArg.receiveWaiters.clear();
+    }
+    async failNativeMessageChannelProtocol(channelArg, messageArg) {
+        const error = new NativeMessageProtocolError(messageArg);
+        if (channelArg.role === 'messageSender') {
+            await this.failNativeMessageSender(channelArg, error, NATIVE_MESSAGE_RESET_CODES.PROTOCOL_ERROR);
+        }
+        else {
+            await this.failNativeMessageReceiver(channelArg, error, NATIVE_MESSAGE_RESET_CODES.PROTOCOL_ERROR);
+        }
+    }
+    async failNativeMessageSender(stateArg, reasonArg, resetCodeArg, sendResetArg = true) {
+        if (stateArg.status === 'closed')
+            return;
+        const error = asError(reasonArg, 'Native message sender closed');
+        const shouldReset = sendResetArg && !stateArg.connection.closed;
+        this.cleanupNativeMessageSender(stateArg, error, true);
+        if (shouldReset) {
+            void this.sendNativeMessageReset(stateArg.connection, stateArg.descriptor.transport.channelId, resetCodeArg, 'Sender closed channel').catch(() => { });
+        }
+    }
+    async failNativeMessageReceiver(stateArg, reasonArg, resetCodeArg) {
+        if (stateArg.status === 'closed')
+            return;
+        const error = asError(reasonArg, 'Native message receiver closed');
+        const shouldReset = !stateArg.connection.closed;
+        this.cleanupNativeMessageReceiver(stateArg, error, true);
+        if (shouldReset) {
+            void this.sendNativeMessageReset(stateArg.connection, stateArg.descriptor.transport.channelId, resetCodeArg, 'Receiver closed channel').catch(() => { });
+        }
+    }
+    cleanupNativeMessageSender(stateArg, reasonArg, rejectArg = true, addTombstoneArg = true) {
+        if (stateArg.status === 'closed')
+            return;
+        stateArg.status = 'closed';
+        for (const timer of [stateArg.openTimer, stateArg.progressTimer, stateArg.closeTimer]) {
+            if (timer !== undefined)
+                this.runtime.clearTimer(timer);
+        }
+        stateArg.openTimer = undefined;
+        stateArg.progressTimer = undefined;
+        stateArg.closeTimer = undefined;
+        const error = asError(reasonArg, 'Native message sender closed');
+        stateArg.closeError = new NativeMessageChannelClosedError(error.message, { cause: error });
+        stateArg.awaitingAck?.deferred.reject(stateArg.closeError);
+        stateArg.awaitingAck = undefined;
+        this.removeQueuedFramesForStream(stateArg.connection, stateArg.descriptor.transport.channelId, reasonArg, 'nativeMessage');
+        stateArg.connection.messageChannels.delete(stateArg.descriptor.transport.channelId);
+        stateArg.closedSignal.reject(stateArg.closeError);
+        const tombstoneRetained = !addTombstoneArg || this.tryAddNativeMessageTombstone(stateArg.connection, stateArg.descriptor.transport.channelId);
+        if (rejectArg) {
+            stateArg.opened.reject(stateArg.closeError);
+            stateArg.completion.reject(stateArg.closeError);
+        }
+        if (!tombstoneRetained && !stateArg.connection.closed) {
+            this.closeConnection(stateArg.connection, 1013, 'native-message-v1 tombstone capacity exhausted', 'nativeMessage');
+        }
+        this.maybeReleaseServerAccountingConnection(stateArg.connection);
+    }
+    cleanupNativeMessageReceiver(stateArg, reasonArg, rejectArg = true, addTombstoneArg = true) {
+        if (stateArg.status === 'closed')
+            return;
+        stateArg.status = 'closed';
+        for (const controller of stateArg.revalidationControllers) {
+            controller.abort(new NativeMessageCapabilityError('native message receive grant closed during revalidation'));
+        }
+        if (stateArg.timer !== undefined)
+            this.runtime.clearTimer(stateArg.timer);
+        stateArg.timer = undefined;
+        this.removeQueuedFramesForStream(stateArg.connection, stateArg.descriptor.transport.channelId, reasonArg, 'nativeMessage');
+        stateArg.connection.messageGrants.delete(stateArg.descriptor.transport.channelId);
+        stateArg.connection.messageChannels.delete(stateArg.descriptor.transport.channelId);
+        if (stateArg.connection.authorityMetadataBytes < stateArg.authorityMetadataBytes) {
+            throw new NativeMessageProtocolError('native message authority accounting underflow');
+        }
+        stateArg.connection.authorityMetadataBytes -= stateArg.authorityMetadataBytes;
+        const retainedPayload = stateArg.reassembly?.payload ?? stateArg.completed?.payload;
+        if (retainedPayload) {
+            if (stateArg.connection.queuedPayloadBytes < retainedPayload.byteLength
+                || stateArg.connection.nativeMessageQueuedPayloadBytes < retainedPayload.byteLength) {
+                throw new NativeMessageProtocolError('native message receive accounting underflow');
+            }
+            stateArg.connection.queuedPayloadBytes -= retainedPayload.byteLength;
+            stateArg.connection.nativeMessageQueuedPayloadBytes -= retainedPayload.byteLength;
+        }
+        stateArg.reassembly = undefined;
+        stateArg.completed = undefined;
+        const error = asError(reasonArg, 'Native message receiver closed');
+        stateArg.closeError = new NativeMessageChannelClosedError(error.message, { cause: error });
+        if (rejectArg) {
+            stateArg.closedSignal.reject(stateArg.closeError);
+            this.wakeNativeMessageReceiveWaiters(stateArg, stateArg.closeError);
+        }
+        else {
+            this.wakeNativeMessageReceiveWaiters(stateArg);
+        }
+        const tombstoneRetained = !addTombstoneArg || this.tryAddNativeMessageTombstone(stateArg.connection, stateArg.descriptor.transport.channelId);
+        if (rejectArg) {
+            stateArg.opened.reject(stateArg.closeError);
+            stateArg.completion.reject(stateArg.closeError);
+        }
+        if (!tombstoneRetained && !stateArg.connection.closed) {
+            this.closeConnection(stateArg.connection, 1013, 'native-message-v1 tombstone capacity exhausted', 'nativeMessage');
+        }
+        this.maybeReleaseServerAccountingConnection(stateArg.connection);
+    }
+    tryAddNativeMessageTombstone(connectionArg, channelIdArg) {
+        try {
+            this.addNativeMessageTombstone(connectionArg, channelIdArg);
+            return true;
+        }
+        catch (errorArg) {
+            if (errorArg instanceof NativeByteError
+                && errorArg.code === 'NATIVE_BYTE_RESOURCE_LIMIT')
+                return false;
+            throw errorArg;
+        }
+    }
+    addNativeMessageTombstone(connectionArg, channelIdArg) {
+        this.deleteNativeMessageTombstone(connectionArg, channelIdArg);
+        this.pruneNativeMessageTombstones(connectionArg);
+        while (connectionArg.messageTombstones.size >= NATIVE_MESSAGE_MAX_TOMBSTONES_PER_CONNECTION) {
+            const oldest = connectionArg.messageTombstones.keys().next();
+            if (oldest.done)
+                break;
+            this.deleteNativeMessageTombstone(connectionArg, oldest.value);
+        }
+        const retainedBytes = textEncoder.encode(channelIdArg).byteLength;
+        this.assertServerRetainedByteCapacity(connectionArg, retainedBytes);
+        const tombstone = Object.freeze({
+            channelId: channelIdArg,
+            expiresAt: this.runtime.now() + NATIVE_MESSAGE_TOMBSTONE_RETENTION_MS,
+            retainedBytes,
+        });
+        connectionArg.messageTombstones.set(channelIdArg, tombstone);
+        connectionArg.tombstoneBytes += retainedBytes;
+    }
+    pruneNativeMessageTombstones(connectionArg) {
+        const now = this.runtime.now();
+        for (const [channelId, tombstone] of connectionArg.messageTombstones) {
+            if (tombstone.expiresAt > now)
+                break;
+            this.deleteNativeMessageTombstone(connectionArg, channelId);
+        }
+        this.maybeReleaseServerAccountingConnection(connectionArg);
+    }
+    deleteNativeMessageTombstone(connectionArg, channelIdArg) {
+        const tombstone = connectionArg.messageTombstones.get(channelIdArg);
+        if (!tombstone)
+            return;
+        connectionArg.messageTombstones.delete(channelIdArg);
+        connectionArg.tombstoneBytes -= tombstone.retainedBytes;
+    }
     async revalidateConsumer(stateArg, operationArg) {
         const principalCount = this.retainedRevalidationsByPrincipal.get(stateArg.principalId) ?? 0;
         if (stateArg.connection.retainedRevalidations >= NATIVE_BYTE_MAX_REVALIDATIONS_PER_PEER
@@ -2056,10 +3361,23 @@ export class NativeByteManager {
             reason: reasonArg,
         });
     }
+    async sendNativeMessageReset(connectionArg, channelIdArg, codeArg, reasonArg) {
+        if (connectionArg.closed)
+            return;
+        await this.enqueueNativeMessageFrame(connectionArg, {
+            type: NATIVE_MESSAGE_FRAME_TYPES.RESET,
+            channelId: channelIdArg,
+            code: codeArg,
+            reason: reasonArg,
+        });
+    }
+    enqueueNativeMessageFrame(connectionArg, frameArg) {
+        return this.enqueueEncodedFrame(connectionArg, encodeNativeMessageFrame(frameArg), frameArg.type === NATIVE_MESSAGE_FRAME_TYPES.MESSAGE, frameArg.channelId, undefined, 0, undefined, 'nativeMessage');
+    }
     enqueueFrame(connectionArg, frameArg, producerArg, payloadBytesArg = 0, admissionArg) {
         return this.enqueueEncodedFrame(connectionArg, encodeNativeByteFrame(frameArg), frameArg.type === NATIVE_BYTE_FRAME_TYPES.DATA, frameArg.streamId, producerArg, payloadBytesArg, admissionArg);
     }
-    enqueueEncodedFrame(connectionArg, bytesArg, dataArg, streamIdArg, producerArg, payloadBytesArg = 0, admissionArg) {
+    enqueueEncodedFrame(connectionArg, bytesArg, dataArg, streamIdArg, producerArg, payloadBytesArg = 0, admissionArg, protocolArg = 'nativeByte') {
         if (connectionArg.closed)
             throw new NativeByteStreamClosedError('Connection is closed');
         this.assertServerRetainedByteCapacity(connectionArg, bytesArg.byteLength + (admissionArg ? 0 : payloadBytesArg));
@@ -2090,6 +3408,7 @@ export class NativeByteManager {
         const outbound = {
             bytes: bytesArg,
             streamId: streamIdArg,
+            protocol: protocolArg,
             producer: producerArg,
             payloadBytes: admissionArg ? 0 : payloadBytesArg,
             settlement: createDeferred(),
@@ -2100,7 +3419,9 @@ export class NativeByteManager {
             admissionArg.remainingPayloadBytes -= payloadBytesArg;
         try {
             outbound.timer = this.runtime.setTimer(() => {
-                this.failConnection(connectionArg, new NativeByteError('native-byte-v1 outbound frame made no progress', 'NATIVE_BYTE_OUTBOUND_TIMEOUT'), true);
+                this.failConnection(connectionArg, protocolArg === 'nativeMessage'
+                    ? new NativeMessageError('native-message-v1 outbound frame made no progress', 'NATIVE_MESSAGE_OUTBOUND_TIMEOUT')
+                    : new NativeByteError('native-byte-v1 outbound frame made no progress', 'NATIVE_BYTE_OUTBOUND_TIMEOUT'), true);
             }, NATIVE_BYTE_PROGRESS_TIMEOUT_MS);
             queue.push(outbound);
             this.wakeOutbound(connectionArg);
@@ -2240,12 +3561,12 @@ export class NativeByteManager {
         connectionArg.queuedPayloadBytes -= payloadBytesArg;
         producerArg.queuedPayloadBytes -= payloadBytesArg;
     }
-    removeQueuedFramesForStream(connectionArg, streamIdArg, reasonArg) {
+    removeQueuedFramesForStream(connectionArg, streamIdArg, reasonArg, protocolArg = 'nativeByte') {
         const error = asError(reasonArg, 'Native byte stream closed before frame settlement');
         for (const queue of [connectionArg.controlQueue, connectionArg.dataQueue]) {
             for (let index = queue.length - 1; index >= 0; index--) {
                 const outbound = queue[index];
-                if (outbound.streamId !== streamIdArg)
+                if (outbound.streamId !== streamIdArg || outbound.protocol !== protocolArg)
                     continue;
                 queue.splice(index, 1);
                 this.settleOutboundFrame(connectionArg, outbound, error);
@@ -2258,17 +3579,19 @@ export class NativeByteManager {
         }
         catch { }
     }
-    closeConnection(connectionArg, codeArg, reasonArg) {
+    closeConnection(connectionArg, codeArg, reasonArg, scopeArg = 'nativeByte') {
         if (connectionArg.closed)
             return;
         this.emitDiagnostic({
             kind: 'connectionClosed',
             side: this.side,
-            scope: 'nativeByte',
+            scope: scopeArg,
             closeCode: codeArg,
             reason: reasonArg,
         });
-        this.failConnection(connectionArg, new NativeByteProtocolError(reasonArg), false);
+        this.failConnection(connectionArg, scopeArg === 'nativeMessage'
+            ? new NativeMessageProtocolError(reasonArg)
+            : new NativeByteProtocolError(reasonArg), false);
         try {
             if (connectionArg.binding.side === 'client') {
                 connectionArg.binding.webSocket.close(toClientWebSocketCloseCode(codeArg), reasonArg);
@@ -2283,26 +3606,35 @@ export class NativeByteManager {
         if (connectionArg.closed)
             return;
         if (closeArg) {
+            const nativeMessageFailure = reasonArg instanceof NativeMessageError;
             this.emitDiagnostic({
                 kind: 'connectionClosed',
                 side: this.side,
-                scope: 'nativeByte',
+                scope: nativeMessageFailure ? 'nativeMessage' : 'nativeByte',
                 closeCode: 1011,
-                reason: 'native-byte-v1 connection failure',
-                errorCode: reasonArg instanceof NativeByteError ? reasonArg.code : undefined,
+                reason: nativeMessageFailure
+                    ? 'native-message-v1 connection failure'
+                    : 'native-byte-v1 connection failure',
+                errorCode: reasonArg instanceof NativeByteError || reasonArg instanceof NativeMessageError
+                    ? reasonArg.code
+                    : undefined,
             });
+            const closeReason = nativeMessageFailure
+                ? 'native-message-v1 connection failure'
+                : 'native-byte-v1 connection failure';
             try {
                 if (connectionArg.binding.side === 'client') {
-                    connectionArg.binding.webSocket.close(toClientWebSocketCloseCode(1011), 'native-byte-v1 connection failure');
+                    connectionArg.binding.webSocket.close(toClientWebSocketCloseCode(1011), closeReason);
                 }
                 else {
-                    connectionArg.binding.peer.close(1011, 'native-byte-v1 connection failure');
+                    connectionArg.binding.peer.close(1011, closeReason);
                 }
             }
             catch { }
         }
         connectionArg.closed = true;
         connectionArg.nativeEnabled = false;
+        connectionArg.nativeMessageEnabled = false;
         for (const controller of connectionArg.revalidationControllers) {
             controller.abort(new NativeByteCapabilityError('native-byte-v1 connection closed'));
         }
@@ -2314,6 +3646,10 @@ export class NativeByteManager {
             this.runtime.clearTimer(connectionArg.negotiationTimer);
             connectionArg.negotiationTimer = undefined;
         }
+        if (connectionArg.nativeMessageNegotiationTimer !== undefined) {
+            this.runtime.clearTimer(connectionArg.nativeMessageNegotiationTimer);
+            connectionArg.nativeMessageNegotiationTimer = undefined;
+        }
         if (connectionArg.clientBackpressureTimer !== undefined) {
             this.runtime.clearTimer(connectionArg.clientBackpressureTimer);
             connectionArg.clientBackpressureTimer = undefined;
@@ -2327,6 +3663,17 @@ export class NativeByteManager {
             else
                 this.cleanupConsumer(stream, reasonArg, true, false);
         }
+        for (const grant of [...connectionArg.messageGrants.values()]) {
+            this.cleanupNativeMessageReceiver(grant, reasonArg, true, false);
+        }
+        for (const channel of [...connectionArg.messageChannels.values()]) {
+            if (channel.role === 'messageSender') {
+                this.cleanupNativeMessageSender(channel, reasonArg, true, false);
+            }
+            else {
+                this.cleanupNativeMessageReceiver(channel, reasonArg, true, false);
+            }
+        }
         for (const queue of [connectionArg.controlQueue, connectionArg.dataQueue]) {
             for (const outbound of queue.splice(0)) {
                 this.settleOutboundFrame(connectionArg, outbound, reasonArg);
@@ -2336,8 +3683,9 @@ export class NativeByteManager {
         connectionArg.rawQueueBytes = 0;
         connectionArg.receiveWindowReservedBytes = 0;
         connectionArg.tombstones.clear();
+        connectionArg.messageTombstones.clear();
         connectionArg.tombstoneBytes = 0;
         this.maybeReleaseServerAccountingConnection(connectionArg);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nativebytemanager.js","sourceRoot":"","sources":["../ts/classes.nativebytemanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nativebytemanager.js","sourceRoot":"","sources":["../ts/classes.nativebytemanager.ts"],"names":[],"mappings":"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"}