@api.global/typedsocket 6.1.0 → 6.3.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@api.global/typedsocket',
-    version: '6.1.0',
+    version: '6.3.0',
     description: 'A library for creating typed WebSocket connections, supporting bi-directional communication with type safety.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLCtHQUErRztDQUM3SCxDQUFBIn0=

package/dist_ts/classes.nativebyteerror.d.ts

@@ -11,3 +11,16 @@ export declare class NativeByteCapabilityError extends NativeByteError {
 export declare class NativeByteStreamClosedError extends NativeByteError {
     constructor(messageArg?: string, optionsArg?: ErrorOptions);
 }
+export declare class NativeMessageError extends Error {
+    readonly code: string;
+    constructor(messageArg: string, code: string, optionsArg?: ErrorOptions);
+}
+export declare class NativeMessageProtocolError extends NativeMessageError {
+    constructor(messageArg: string, optionsArg?: ErrorOptions);
+}
+export declare class NativeMessageCapabilityError extends NativeMessageError {
+    constructor(messageArg?: string, optionsArg?: ErrorOptions);
+}
+export declare class NativeMessageChannelClosedError extends NativeMessageError {
+    constructor(messageArg?: string, optionsArg?: ErrorOptions);
+}

package/dist_ts/classes.nativebyteerror.js

@@ -23,4 +23,29 @@ export class NativeByteStreamClosedError extends NativeByteError {
         this.name = 'NativeByteStreamClosedError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5uYXRpdmVieXRlZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLm5hdGl2ZWJ5dGVlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxLQUFLO0lBQ3hDLFlBQ0UsVUFBa0IsRUFDRixJQUFZLEVBQzVCLFVBQXlCO1FBRXpCLEtBQUssQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFIZCxTQUFJLEdBQUosSUFBSSxDQUFRO1FBSTVCLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLHVCQUF3QixTQUFRLGVBQWU7SUFDMUQsWUFBWSxVQUFrQixFQUFFLFVBQXlCO1FBQ3ZELEtBQUssQ0FBQyxVQUFVLEVBQUUsNEJBQTRCLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLElBQUksR0FBRyx5QkFBeUIsQ0FBQztJQUN4QyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8seUJBQTBCLFNBQVEsZUFBZTtJQUM1RCxZQUFZLFVBQVUsR0FBRywrQkFBK0IsRUFBRSxVQUF5QjtRQUNqRixLQUFLLENBQUMsVUFBVSxFQUFFLG9DQUFvQyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ3BFLElBQUksQ0FBQyxJQUFJLEdBQUcsMkJBQTJCLENBQUM7SUFDMUMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDJCQUE0QixTQUFRLGVBQWU7SUFDOUQsWUFBWSxVQUFVLEdBQUcsOEJBQThCLEVBQUUsVUFBeUI7UUFDaEYsS0FBSyxDQUFDLFVBQVUsRUFBRSwyQkFBMkIsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMzRCxJQUFJLENBQUMsSUFBSSxHQUFHLDZCQUE2QixDQUFDO0lBQzVDLENBQUM7Q0FDRiJ9
+export class NativeMessageError extends Error {
+    constructor(messageArg, code, optionsArg) {
+        super(messageArg, optionsArg);
+        this.code = code;
+        this.name = 'NativeMessageError';
+    }
+}
+export class NativeMessageProtocolError extends NativeMessageError {
+    constructor(messageArg, optionsArg) {
+        super(messageArg, 'NATIVE_MESSAGE_PROTOCOL_ERROR', optionsArg);
+        this.name = 'NativeMessageProtocolError';
+    }
+}
+export class NativeMessageCapabilityError extends NativeMessageError {
+    constructor(messageArg = 'native-message-v1 is unavailable', optionsArg) {
+        super(messageArg, 'NATIVE_MESSAGE_CAPABILITY_UNAVAILABLE', optionsArg);
+        this.name = 'NativeMessageCapabilityError';
+    }
+}
+export class NativeMessageChannelClosedError extends NativeMessageError {
+    constructor(messageArg = 'Native message channel is closed', optionsArg) {
+        super(messageArg, 'NATIVE_MESSAGE_CHANNEL_CLOSED', optionsArg);
+        this.name = 'NativeMessageChannelClosedError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.nativebytemanager.d.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
-import { NativeByteStreamClosedError } from './classes.nativebyteerror.js';
+import { NativeByteStreamClosedError, NativeMessageChannelClosedError } from './classes.nativebyteerror.js';
 import type { INativeByteCapabilityStatus, INativeByteCreateReceiveGrantOptions, INativeByteDescriptor, INativeByteOpenSenderOptions, INativeByteReceipt, INativeByteReceiveGrant, INativeByteRuntime, INativeByteStats, TNativeByteCapabilityMode, TNativeByteConnectionBinding, TNativeByteRevalidate } from './interfaces.nativebytes.js';
+import type { INativeMessageCapabilityStatus, INativeMessageCreateReceiveGrantOptions, INativeMessageDescriptor, INativeMessageOpenSenderOptions, INativeMessageReceiveGrant, INativeMessageReceiver, INativeMessageSender, INativeMessageStats, TNativeMessageCapabilityMode, TNativeMessageRevalidate } from './interfaces.nativemessages.js';
 import type { TNativeByteDiagnosticEvent } from './interfaces.diagnostics.js';
 type TNativeStreamTransport = plugins.typedrequestInterfaces.INativeStreamTransport;
 type TNativeStreamEndpoint = plugins.typedrequestInterfaces.INativeStreamTransportEndpoint;
@@ -14,12 +15,28 @@ interface IDeferred<T> {
 interface IOutboundFrame {
     readonly bytes: Uint8Array<ArrayBuffer>;
     readonly streamId: string;
+    readonly protocol: 'nativeByte' | 'nativeMessage';
     readonly producer?: IProducerState;
     readonly payloadBytes: number;
     readonly settlement: IDeferred<void>;
     accountingReleased: boolean;
     timer?: unknown;
 }
+interface INativeMessageCompleted {
+    readonly sequence: number;
+    readonly payload: Uint8Array<ArrayBuffer>;
+}
+interface INativeMessageReassembly {
+    readonly sequence: number;
+    readonly totalLength: number;
+    readonly payload: Uint8Array<ArrayBuffer>;
+    nextOffset: number;
+}
+interface INativeMessageTombstone {
+    readonly channelId: string;
+    readonly expiresAt: number;
+    readonly retainedBytes: number;
+}
 interface IProducerAdmission {
     readonly payload: Uint8Array;
     remainingPayloadBytes: number;
@@ -106,12 +123,71 @@ interface IProducerState {
     closeError?: NativeByteStreamClosedError;
 }
 type TStreamState = IConsumerState | IProducerState;
+type TNativeMessageReceiverStatus = 'grant' | 'validating-open' | 'open' | 'closing' | 'closed';
+type TNativeMessageSenderStatus = 'opening' | 'open' | 'closing' | 'closed';
+interface INativeMessageReceiverState {
+    readonly role: 'messageReceiver';
+    readonly connection: IConnectionState;
+    readonly descriptor: INativeMessageDescriptor;
+    readonly revalidate: TNativeMessageRevalidate;
+    readonly principalId: string;
+    readonly revisions: {
+        readonly credentialRevision: string;
+        readonly configRevision: string;
+        readonly bindingRevision: string;
+    };
+    readonly authorityMetadataBytes: number;
+    readonly endpoint: NativeMessageReceiver;
+    readonly opened: IDeferred<NativeMessageReceiver>;
+    readonly completion: IDeferred<void>;
+    readonly closedSignal: IDeferred<never>;
+    readonly receiveWaiters: Set<IDeferred<void>>;
+    readonly revalidationControllers: Set<AbortController>;
+    status: TNativeMessageReceiverStatus;
+    receiveActive: boolean;
+    nextSequence: number;
+    acceptedMaxMessageBytes: number;
+    reassembly?: INativeMessageReassembly;
+    completed?: INativeMessageCompleted;
+    remoteClosed: boolean;
+    timer?: unknown;
+    closeError?: NativeMessageChannelClosedError;
+}
+interface INativeMessageSenderState {
+    readonly role: 'messageSender';
+    readonly connection: IConnectionState;
+    readonly descriptor: INativeMessageDescriptor;
+    readonly endpoint: NativeMessageSender;
+    readonly opened: IDeferred<NativeMessageSender>;
+    readonly completion: IDeferred<void>;
+    readonly closedSignal: IDeferred<never>;
+    status: TNativeMessageSenderStatus;
+    acceptedMaxMessageBytes: number;
+    operationTail: Promise<void>;
+    nextSequence: number;
+    pendingMessages: number;
+    pendingMessageBytes: number;
+    terminalRequested: boolean;
+    closePromise?: Promise<void>;
+    awaitingAck?: {
+        readonly sequence: number;
+        readonly deferred: IDeferred<void>;
+    };
+    openTimer?: unknown;
+    progressTimer?: unknown;
+    closeTimer?: unknown;
+    closeError?: NativeMessageChannelClosedError;
+}
+type TNativeMessageChannelState = INativeMessageReceiverState | INativeMessageSenderState;
 interface IConnectionState {
     readonly binding: TNativeByteConnectionBinding;
     readonly transport: NativeByteConnectionTransport;
     readonly grants: Map<string, IConsumerState>;
     readonly streams: Map<string, TStreamState>;
     readonly tombstones: Map<string, ITombstone>;
+    readonly messageGrants: Map<string, INativeMessageReceiverState>;
+    readonly messageChannels: Map<string, TNativeMessageChannelState>;
+    readonly messageTombstones: Map<string, INativeMessageTombstone>;
     readonly rawQueue: Uint8Array[];
     readonly controlQueue: IOutboundFrame[];
     readonly dataQueue: IOutboundFrame[];
@@ -122,11 +198,14 @@ interface IConnectionState {
     readonly revalidationControllers: Set<AbortController>;
     negotiated: boolean;
     nativeEnabled: boolean;
+    messageNegotiated: boolean;
+    nativeMessageEnabled: boolean;
     closed: boolean;
     processingRaw: boolean;
     rawQueueBytes: number;
     processingRawBytes: number;
     queuedPayloadBytes: number;
+    nativeMessageQueuedPayloadBytes: number;
     authorityMetadataBytes: number;
     tombstoneBytes: number;
     receiveWindowReservedBytes: number;
@@ -136,6 +215,7 @@ interface IConnectionState {
     clientTurnScheduled: boolean;
     clientBackpressureTimer?: unknown;
     negotiationTimer?: unknown;
+    nativeMessageNegotiationTimer?: unknown;
 }
 export declare class NativeByteReceiver implements TNativeStreamEndpoint {
     private readonly manager;
@@ -175,6 +255,35 @@ export declare class NativeByteSender implements TNativeStreamEndpoint {
     close(_sendClosingBitArg?: boolean): Promise<void>;
     abort(reasonArg?: unknown): Promise<void>;
 }
+export declare class NativeMessageReceiver implements INativeMessageReceiver {
+    private readonly manager;
+    private readonly state;
+    constructor(manager: NativeByteManager, state: INativeMessageReceiverState);
+    get closed(): Promise<void>;
+    receive(): Promise<Uint8Array | undefined>;
+    reject(reasonArg?: unknown): Promise<void>;
+}
+export declare class NativeMessageSender implements INativeMessageSender {
+    private readonly manager;
+    private readonly state;
+    constructor(manager: NativeByteManager, state: INativeMessageSenderState);
+    get closed(): Promise<void>;
+    send(messageArg: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class NativeMessageFacade {
+    #private;
+    constructor(managerArg: NativeByteManager);
+    createReceiveGrant(optionsArg: INativeMessageCreateReceiveGrantOptions): INativeMessageReceiveGrant;
+    openSender(descriptorArg: INativeMessageDescriptor, optionsArg?: INativeMessageOpenSenderOptions): Promise<INativeMessageSender>;
+    getCapability(targetArg?: {
+        readonly peer: plugins.IWebSocketPeer;
+    } | plugins.IWebSocketPeer): INativeMessageCapabilityStatus;
+    getStats(targetArg?: {
+        readonly peer: plugins.IWebSocketPeer;
+    } | plugins.IWebSocketPeer): INativeMessageStats;
+    normalizeMaxMessageBytes(valueArg: unknown): number;
+}
 declare class NativeByteConnectionTransport implements TNativeStreamTransport {
     private readonly manager;
     private readonly connection;
@@ -187,14 +296,17 @@ declare class NativeByteConnectionTransport implements TNativeStreamTransport {
 export interface INativeByteManagerOptions {
     readonly side: 'client' | 'server';
     readonly capabilityMode?: TNativeByteCapabilityMode;
+    readonly nativeMessageCapabilityMode?: TNativeMessageCapabilityMode;
     readonly runtime?: INativeByteRuntime;
     /** Structured close/rejection diagnostics; must not throw, errors are swallowed. */
     readonly onDiagnostic?: (eventArg: TNativeByteDiagnosticEvent) => void;
 }
 export declare class NativeByteManager {
     readonly webSocketTransportOwner: plugins.IWebSocketTransportOwner;
+    readonly messages: NativeMessageFacade;
     private readonly side;
     private readonly capabilityMode;
+    private readonly nativeMessageCapabilityMode;
     private readonly runtime;
     private readonly onDiagnostic?;
     private readonly clientNativeStreamTransport;
@@ -229,6 +341,25 @@ export declare class NativeByteManager {
         capabilities: readonly ['native-byte-v1'] | readonly [];
         required: boolean;
     };
+    getClientNativeMessageNegotiationAdvertisement(): {
+        protocolMajor: 1;
+        capabilities: readonly ['native-message-v1'] | readonly [];
+    };
+    completeClientNativeMessageNegotiation(webSocketArg: WebSocket, generationArg: number, responseArg: {
+        protocolMajor: number;
+        capabilities: readonly string[];
+        required?: boolean;
+    }): void;
+    failOptionalClientNativeMessageNegotiation(webSocketArg: WebSocket, generationArg: number): void;
+    negotiateServerNativeMessages(peerArg: plugins.IWebSocketPeer, requestArg: {
+        protocolMajor: number;
+        capabilities: readonly string[];
+    }): {
+        protocolMajor: 1;
+        capabilities: readonly ['native-message-v1'] | readonly [];
+        required: boolean;
+    };
+    connectionHasNativeMessageCapability(connectionArg: IConnectionState): boolean;
     getClientNativeStreamTransport(): TNativeStreamTransport | undefined;
     getServerNativeStreamTransport(peerArg: plugins.IWebSocketPeer): TNativeStreamTransport | undefined;
     connectionHasCapability(connectionArg: IConnectionState): boolean;
@@ -242,6 +373,14 @@ export declare class NativeByteManager {
     getStats(targetArg?: {
         readonly peer: plugins.IWebSocketPeer;
     } | plugins.IWebSocketPeer): INativeByteStats;
+    createNativeMessageReceiveGrant(optionsArg: INativeMessageCreateReceiveGrantOptions): INativeMessageReceiveGrant;
+    openNativeMessageSender(descriptorArg: INativeMessageDescriptor, optionsArg?: INativeMessageOpenSenderOptions): Promise<NativeMessageSender>;
+    getNativeMessageCapability(targetArg?: {
+        readonly peer: plugins.IWebSocketPeer;
+    } | plugins.IWebSocketPeer): INativeMessageCapabilityStatus;
+    getNativeMessageStats(targetArg?: {
+        readonly peer: plugins.IWebSocketPeer;
+    } | plugins.IWebSocketPeer): INativeMessageStats;
     registerGenericNativeStream(connectionArg: IConnectionState): plugins.typedrequestInterfaces.INativeStreamTransportRegistration;
     openSenderOnConnection(connectionArg: IConnectionState, descriptorArg: plugins.typedrequestInterfaces.TNativeStreamDescriptor): Promise<NativeByteSender>;
     enqueueProducerData(stateArg: IProducerState, dataArg: Uint8Array): Promise<void>;
@@ -251,6 +390,16 @@ export declare class NativeByteManager {
     sendProducerData(stateArg: IProducerState, admissionArg: IProducerAdmission): Promise<void>;
     finishProducer(stateArg: IProducerState): Promise<void>;
     abortProducer(stateArg: IProducerState, reasonArg?: unknown): Promise<void>;
+    sendNativeMessage(stateArg: INativeMessageSenderState, messageArg: Uint8Array): Promise<void>;
+    private admitNativeMessage;
+    private sendNativeMessageAdmission;
+    private releaseNativeMessageAdmission;
+    closeNativeMessageSender(stateArg: INativeMessageSenderState): Promise<void>;
+    private finishNativeMessageSender;
+    receiveNativeMessage(stateArg: INativeMessageReceiverState): Promise<Uint8Array | undefined>;
+    rejectNativeMessageReceiver(stateArg: INativeMessageReceiverState, reasonArg?: unknown): Promise<void>;
+    private refreshNativeMessageSenderProgressTimer;
+    private refreshNativeMessageReceiverProgressTimer;
     private getConsumerQueueLength;
     consumeReceiverData(stateArg: IConsumerState): Promise<Uint8Array | undefined>;
     private consumeReceiverDataOnce;
@@ -266,6 +415,14 @@ export declare class NativeByteManager {
     private enqueueRawFrame;
     private processRawQueue;
     private handleFrame;
+    private handleNativeMessageFrame;
+    private handleNativeMessageOpen;
+    private handleNativeMessageOpenAck;
+    private handleNativeMessageFragment;
+    private handleNativeMessageAck;
+    private handleNativeMessageClose;
+    private handleNativeMessageCloseAck;
+    private handleNativeMessageReset;
     private handleOpen;
     private handleOpenAck;
     private handleData;
@@ -275,6 +432,10 @@ export declare class NativeByteManager {
     private handleReset;
     private createReceiveGrantOnConnection;
     private validateDescriptor;
+    private validateNativeMessageDescriptor;
+    private resolveNativeMessageConnection;
+    private requireNativeMessageCapability;
+    private reserveNativeMessageChannelSlot;
     private resolveConnection;
     private resolveConnectionForInspection;
     private requireConnectionCapability;
@@ -282,12 +443,27 @@ export declare class NativeByteManager {
     private normalizePrincipalId;
     private normalizeAuthorityRevision;
     private getServerConnectionCount;
-    private getServerStreamCount;
+    private getServerNativeByteStreamCount;
+    private getServerAggregateSlotCount;
     private getServerRetainedBytes;
     private getServerReceiveReservationBytes;
     private assertServerRetainedByteCapacity;
     private assertServerReceiveReservationCapacity;
     private maybeReleaseServerAccountingConnection;
+    private revalidateNativeMessageReceiver;
+    private getNativeMessageRevalidationResetCode;
+    private assertNativeMessageReceiverOwned;
+    private assertNativeMessageSenderOpen;
+    private wakeNativeMessageReceiveWaiters;
+    private failNativeMessageChannelProtocol;
+    private failNativeMessageSender;
+    private failNativeMessageReceiver;
+    private cleanupNativeMessageSender;
+    private cleanupNativeMessageReceiver;
+    private tryAddNativeMessageTombstone;
+    private addNativeMessageTombstone;
+    private pruneNativeMessageTombstones;
+    private deleteNativeMessageTombstone;
     private revalidateConsumer;
     private getRevalidationResetCode;
     private assertConsumerOwned;
@@ -310,6 +486,8 @@ export declare class NativeByteManager {
     private pruneTombstones;
     private deleteTombstone;
     private sendReset;
+    private sendNativeMessageReset;
+    private enqueueNativeMessageFrame;
     private enqueueFrame;
     private enqueueEncodedFrame;
     private wakeOutbound;