@api.global/typedsocket 5.1.2 → 6.1.0

package/dist_ts/classes.nativebytemanager.d.ts

@@ -0,0 +1,327 @@
+import * as plugins from './plugins.js';
+import { NativeByteStreamClosedError } from './classes.nativebyteerror.js';
+import type { INativeByteCapabilityStatus, INativeByteCreateReceiveGrantOptions, INativeByteDescriptor, INativeByteOpenSenderOptions, INativeByteReceipt, INativeByteReceiveGrant, INativeByteRuntime, INativeByteStats, TNativeByteCapabilityMode, TNativeByteConnectionBinding, TNativeByteRevalidate } from './interfaces.nativebytes.js';
+import type { TNativeByteDiagnosticEvent } from './interfaces.diagnostics.js';
+type TNativeStreamTransport = plugins.typedrequestInterfaces.INativeStreamTransport;
+type TNativeStreamEndpoint = plugins.typedrequestInterfaces.INativeStreamTransportEndpoint;
+type TSha256Hasher = ReturnType<typeof plugins.smarthash.createSha256Hasher>;
+interface IDeferred<T> {
+    readonly promise: Promise<T>;
+    readonly settled: boolean;
+    resolve(valueArg: T): void;
+    reject(errorArg: unknown): void;
+}
+interface IOutboundFrame {
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly streamId: string;
+    readonly producer?: IProducerState;
+    readonly payloadBytes: number;
+    readonly settlement: IDeferred<void>;
+    accountingReleased: boolean;
+    timer?: unknown;
+}
+interface IProducerAdmission {
+    readonly payload: Uint8Array;
+    remainingPayloadBytes: number;
+    sourceAccountingOwned: boolean;
+    pendingOperationOwned: boolean;
+}
+interface ITombstone {
+    readonly streamId: string;
+    readonly expiresAt: number;
+    readonly confirmedFin: boolean;
+    readonly byteLength: number;
+    readonly sha256: string;
+    readonly finAck?: Uint8Array<ArrayBuffer>;
+    readonly retainedBytes: number;
+}
+type TConsumerStatus = 'grant' | 'validating-open' | 'open' | 'fin-validated' | 'awaiting-confirmation' | 'closed';
+type TProducerStatus = 'opening' | 'open' | 'finishing' | 'closed';
+type TConsumerTerminalOperation = {
+    readonly kind: 'confirm';
+    readonly promise: Promise<INativeByteReceipt>;
+} | {
+    readonly kind: 'reject';
+    readonly promise: Promise<void>;
+};
+interface IConsumerState {
+    readonly role: 'consumer';
+    readonly connection: IConnectionState;
+    readonly descriptor: INativeByteDescriptor;
+    readonly revalidate: TNativeByteRevalidate;
+    readonly principalId: string;
+    readonly revisions: {
+        readonly credentialRevision: string;
+        readonly configRevision: string;
+        readonly bindingRevision: string;
+    };
+    readonly endpoint: NativeByteReceiver;
+    readonly completion: IDeferred<INativeByteReceipt>;
+    readonly opened: IDeferred<NativeByteReceiver>;
+    readonly closedSignal: IDeferred<never>;
+    readonly revalidationControllers: Set<AbortController>;
+    readonly authorityMetadataBytes: number;
+    readonly receiveQueue: Array<Uint8Array | undefined>;
+    receiveQueueHead: number;
+    readonly receiveWaiters: Set<IDeferred<void>>;
+    readonly hasher: TSha256Hasher;
+    status: TConsumerStatus;
+    consumerReadActive: boolean;
+    timer?: unknown;
+    nextSequence: number;
+    receivedOffset: number;
+    consumedOffset: number;
+    receiveLimitOffset: number;
+    windowReservationBytes: number;
+    queuedPayloadBytes: number;
+    terminalOperation?: TConsumerTerminalOperation;
+    finalSha256?: string;
+    closeError?: NativeByteStreamClosedError;
+}
+interface IProducerState {
+    readonly role: 'producer';
+    readonly connection: IConnectionState;
+    readonly descriptor: INativeByteDescriptor;
+    readonly endpoint: NativeByteSender;
+    readonly completion: IDeferred<INativeByteReceipt>;
+    readonly opened: IDeferred<NativeByteSender>;
+    readonly closedSignal: IDeferred<never>;
+    readonly windowWaiters: Set<IDeferred<void>>;
+    readonly hasher: TSha256Hasher;
+    status: TProducerStatus;
+    operationTail: Promise<void>;
+    terminalRequested: boolean;
+    terminalPromise?: Promise<void>;
+    openTimer?: unknown;
+    idleTimer?: unknown;
+    ackTimer?: unknown;
+    finAckTimer?: unknown;
+    nextSequence: number;
+    sentOffset: number;
+    admittedOffset: number;
+    acknowledgedOffset: number;
+    receiveLimitOffset: number;
+    queuedPayloadBytes: number;
+    finalSha256?: string;
+    closeError?: NativeByteStreamClosedError;
+}
+type TStreamState = IConsumerState | IProducerState;
+interface IConnectionState {
+    readonly binding: TNativeByteConnectionBinding;
+    readonly transport: NativeByteConnectionTransport;
+    readonly grants: Map<string, IConsumerState>;
+    readonly streams: Map<string, TStreamState>;
+    readonly tombstones: Map<string, ITombstone>;
+    readonly rawQueue: Uint8Array[];
+    readonly controlQueue: IOutboundFrame[];
+    readonly dataQueue: IOutboundFrame[];
+    serverInflightFrame?: IOutboundFrame;
+    serverInflightTransportFrame?: Extract<plugins.TWebSocketOutboundRawFrame, {
+        type: 'binary';
+    }>;
+    readonly revalidationControllers: Set<AbortController>;
+    negotiated: boolean;
+    nativeEnabled: boolean;
+    closed: boolean;
+    processingRaw: boolean;
+    rawQueueBytes: number;
+    processingRawBytes: number;
+    queuedPayloadBytes: number;
+    authorityMetadataBytes: number;
+    tombstoneBytes: number;
+    receiveWindowReservedBytes: number;
+    pendingProducerDataOperations: number;
+    retainedRevalidations: number;
+    serverWakeOutstanding: boolean;
+    clientTurnScheduled: boolean;
+    clientBackpressureTimer?: unknown;
+    negotiationTimer?: unknown;
+}
+export declare class NativeByteReceiver implements TNativeStreamEndpoint {
+    private readonly manager;
+    private readonly state;
+    readonly protocol: "native-byte-v1";
+    readonly direction: "receive";
+    readonly readable: ReadableStream<Uint8Array>;
+    private manifestInternal;
+    constructor(manager: NativeByteManager, state: IConsumerState);
+    get closed(): Promise<void>;
+    get manifest(): plugins.typedrequestInterfaces.INativeByteStreamManifest;
+    get completion(): Promise<INativeByteReceipt>;
+    sendData(_dataArg: Uint8Array): Promise<void>;
+    fetchData(): Promise<Uint8Array>;
+    readFromWebstream(_readableStreamArg: ReadableStream<Uint8Array>): Promise<void>;
+    writeToWebstream(writableStreamArg: WritableStream<Uint8Array>): Promise<void>;
+    close(_sendClosingBitArg?: boolean): Promise<void>;
+    abort(reasonArg?: unknown): Promise<void>;
+    reject(reasonArg?: unknown): Promise<void>;
+    confirmDurable(): Promise<INativeByteReceipt>;
+}
+export declare class NativeByteSender implements TNativeStreamEndpoint {
+    private readonly manager;
+    private readonly state;
+    readonly protocol: "native-byte-v1";
+    readonly direction: "send";
+    readonly writable: WritableStream<Uint8Array>;
+    private manifestInternal;
+    constructor(manager: NativeByteManager, state: IProducerState);
+    get closed(): Promise<void>;
+    get manifest(): plugins.typedrequestInterfaces.INativeByteStreamManifest;
+    get completion(): Promise<INativeByteReceipt>;
+    sendData(dataArg: Uint8Array): Promise<void>;
+    fetchData(): Promise<Uint8Array>;
+    readFromWebstream(readableStreamArg: ReadableStream<Uint8Array>, closeAfterReadingArg?: boolean): Promise<void>;
+    writeToWebstream(_writableStreamArg: WritableStream<Uint8Array>): Promise<void>;
+    close(_sendClosingBitArg?: boolean): Promise<void>;
+    abort(reasonArg?: unknown): Promise<void>;
+}
+declare class NativeByteConnectionTransport implements TNativeStreamTransport {
+    private readonly manager;
+    private readonly connection;
+    constructor(manager: NativeByteManager, connection: IConnectionState);
+    get capabilities(): readonly ['native-byte-v1'] | readonly [];
+    requireCapability(requirementArg: plugins.typedrequestInterfaces.INativeStreamCapabilityRequirement): void;
+    registerNativeStream(): plugins.typedrequestInterfaces.INativeStreamTransportRegistration;
+    openNativeStream(descriptorArg: plugins.typedrequestInterfaces.TNativeStreamDescriptor): Promise<TNativeStreamEndpoint>;
+}
+export interface INativeByteManagerOptions {
+    readonly side: 'client' | 'server';
+    readonly capabilityMode?: TNativeByteCapabilityMode;
+    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;
+    private readonly side;
+    private readonly capabilityMode;
+    private readonly runtime;
+    private readonly onDiagnostic?;
+    private readonly clientNativeStreamTransport;
+    private readonly serverConnections;
+    private readonly serverSettlementConnections;
+    private readonly serverAccountingConnections;
+    private currentClientConnection;
+    private serverAttached;
+    private retainedRevalidations;
+    private readonly retainedRevalidationsByPrincipal;
+    constructor(optionsArg: INativeByteManagerOptions);
+    attachServer(): void;
+    detachServer(): void;
+    bindClientConnection(webSocketArg: WebSocket, generationArg: number): void;
+    unbindClientConnection(webSocketArg: WebSocket, generationArg: number, reasonArg?: unknown): void;
+    enqueueClientRawFrame(webSocketArg: WebSocket, generationArg: number, dataArg: ArrayBuffer | ArrayBufferView): void;
+    getClientNegotiationAdvertisement(): {
+        protocolMajor: 6;
+        capabilities: readonly ['native-byte-v1'] | readonly [];
+    };
+    completeClientNegotiation(webSocketArg: WebSocket, generationArg: number, responseArg: {
+        protocolMajor: number;
+        capabilities: readonly string[];
+        required?: boolean;
+    }): void;
+    failOptionalClientNegotiation(webSocketArg: WebSocket, generationArg: number): void;
+    negotiateServerPeer(peerArg: plugins.IWebSocketPeer, requestArg: {
+        protocolMajor: number;
+        capabilities: readonly string[];
+    }): {
+        protocolMajor: 6;
+        capabilities: readonly ['native-byte-v1'] | readonly [];
+        required: boolean;
+    };
+    getClientNativeStreamTransport(): TNativeStreamTransport | undefined;
+    getServerNativeStreamTransport(peerArg: plugins.IWebSocketPeer): TNativeStreamTransport | undefined;
+    connectionHasCapability(connectionArg: IConnectionState): boolean;
+    createReceiveGrant(optionsArg: INativeByteCreateReceiveGrantOptions): INativeByteReceiveGrant;
+    normalizeManifest(manifestArg: plugins.typedrequestInterfaces.INativeByteStreamManifest): plugins.typedrequestInterfaces.INativeByteStreamManifest;
+    createReceiveRegistration(optionsArg: INativeByteCreateReceiveGrantOptions): plugins.typedrequestInterfaces.INativeByteStreamTransportRegistration;
+    openSender(descriptorArg: INativeByteDescriptor, optionsArg?: INativeByteOpenSenderOptions): Promise<NativeByteSender>;
+    getCapability(targetArg?: {
+        readonly peer: plugins.IWebSocketPeer;
+    } | plugins.IWebSocketPeer): INativeByteCapabilityStatus;
+    getStats(targetArg?: {
+        readonly peer: plugins.IWebSocketPeer;
+    } | plugins.IWebSocketPeer): INativeByteStats;
+    registerGenericNativeStream(connectionArg: IConnectionState): plugins.typedrequestInterfaces.INativeStreamTransportRegistration;
+    openSenderOnConnection(connectionArg: IConnectionState, descriptorArg: plugins.typedrequestInterfaces.TNativeStreamDescriptor): Promise<NativeByteSender>;
+    enqueueProducerData(stateArg: IProducerState, dataArg: Uint8Array): Promise<void>;
+    closeProducer(stateArg: IProducerState): Promise<void>;
+    private admitProducerData;
+    private releaseProducerAdmission;
+    sendProducerData(stateArg: IProducerState, admissionArg: IProducerAdmission): Promise<void>;
+    finishProducer(stateArg: IProducerState): Promise<void>;
+    abortProducer(stateArg: IProducerState, reasonArg?: unknown): Promise<void>;
+    private getConsumerQueueLength;
+    consumeReceiverData(stateArg: IConsumerState): Promise<Uint8Array | undefined>;
+    private consumeReceiverDataOnce;
+    getConsumerCloseError(stateArg: IConsumerState, messageArg?: string): NativeByteStreamClosedError;
+    confirmConsumerDurable(stateArg: IConsumerState): Promise<INativeByteReceipt>;
+    private confirmConsumerDurableOnce;
+    rejectConsumer(stateArg: IConsumerState, reasonArg?: unknown): Promise<void>;
+    private rejectConsumerOnce;
+    private createConnection;
+    private bindServerPeer;
+    private unbindServerPeer;
+    private enqueueServerRawFrame;
+    private enqueueRawFrame;
+    private processRawQueue;
+    private handleFrame;
+    private handleOpen;
+    private handleOpenAck;
+    private handleData;
+    private handleAck;
+    private handleFin;
+    private handleFinAck;
+    private handleReset;
+    private createReceiveGrantOnConnection;
+    private validateDescriptor;
+    private resolveConnection;
+    private resolveConnectionForInspection;
+    private requireConnectionCapability;
+    private reserveStreamSlot;
+    private normalizePrincipalId;
+    private normalizeAuthorityRevision;
+    private getServerConnectionCount;
+    private getServerStreamCount;
+    private getServerRetainedBytes;
+    private getServerReceiveReservationBytes;
+    private assertServerRetainedByteCapacity;
+    private assertServerReceiveReservationCapacity;
+    private maybeReleaseServerAccountingConnection;
+    private revalidateConsumer;
+    private getRevalidationResetCode;
+    private assertConsumerOwned;
+    private assertProducerOpen;
+    private waitForProducerWindow;
+    private wakeProducerWindowWaiters;
+    private wakeConsumerReceiveWaiters;
+    private refreshProducerIdleTimer;
+    private refreshProducerAckTimer;
+    private refreshConsumerIdleTimer;
+    private enterAwaitingConfirmation;
+    private clearProducerProgressTimers;
+    private failStreamProtocol;
+    private failProducer;
+    private failConsumer;
+    private cleanupProducer;
+    private cleanupConsumer;
+    private tryAddCleanupTombstone;
+    private addTombstone;
+    private pruneTombstones;
+    private deleteTombstone;
+    private sendReset;
+    private enqueueFrame;
+    private enqueueEncodedFrame;
+    private wakeOutbound;
+    private runClientOutboundTurn;
+    private pullServerBinaryFrame;
+    private settleServerOutboundFrame;
+    private settleOutboundFrame;
+    private releaseOutboundQueueBytes;
+    private releaseProducerPayloadAccounting;
+    private removeQueuedFramesForStream;
+    private emitDiagnostic;
+    private closeConnection;
+    private failConnection;
+}
+export {};