@api.global/typedsocket 7.0.0 → 8.0.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@api.global/typedsocket',
-    version: '7.0.0',
+    version: '8.0.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.requestcancellationmanager.d.ts

@@ -0,0 +1,61 @@
+import * as plugins from './plugins.js';
+export declare const TYPEDSOCKET_MAX_ACTIVE_REQUEST_HANDLERS_PER_CONNECTION = 64;
+export declare const TYPEDSOCKET_MAX_ACTIVE_REQUEST_HANDLERS = 1024;
+export declare const TYPEDSOCKET_MAX_REQUEST_CANCELLATION_TOMBSTONES_PER_CONNECTION = 1024;
+export declare const TYPEDSOCKET_MAX_REQUEST_CANCELLATION_TOMBSTONES = 16384;
+export declare const TYPEDSOCKET_REQUEST_HANDLER_MAX_LIFETIME_MS: number;
+export declare const TYPEDSOCKET_REQUEST_CANCELLATION_TOMBSTONE_RETENTION_MS = 10000;
+/** Internal control-flow error for an authenticated remote cancellation. */
+export declare class TypedSocketRemoteRequestCancellationError extends plugins.typedrequest.TypedResponseError {
+    constructor();
+}
+export interface IRequestCancellationIdentity {
+    readonly method: string;
+    readonly correlationId: string;
+    readonly requestInstanceId: string;
+}
+export interface IRequestCancellationContext {
+    readonly connection: object;
+    readonly routingSurface: object;
+    readonly generation: number;
+    close(reasonArg: string): void;
+}
+export type TRequestSignalRegistration = plugins.typedrequest.ITypedRouterRequestSignalRegistration;
+export interface IRequestCancellationManagerOptions {
+    readonly maxActivePerConnection?: number;
+    readonly maxActive?: number;
+    readonly maxTombstonesPerConnection?: number;
+    readonly maxTombstones?: number;
+    readonly activeLifetimeMs?: number;
+    readonly tombstoneRetentionMs?: number;
+}
+export declare class RequestCancellationManager {
+    private readonly states;
+    private readonly limits;
+    private activeCount;
+    private detachedActiveCount;
+    private tombstoneCount;
+    private stopped;
+    constructor(optionsArg?: IRequestCancellationManagerOptions);
+    register(contextArg: IRequestCancellationContext, identityArg: IRequestCancellationIdentity): TRequestSignalRegistration;
+    cancel(contextArg: IRequestCancellationContext, identityArg: IRequestCancellationIdentity): void;
+    closeConnection(connectionArg: object, reasonArg: unknown): void;
+    stop(reasonArg: unknown): void;
+    getStats(): Readonly<{
+        /** Registrations that have not called complete(), including detached work. */
+        active: number;
+        /** Aborted registrations detached from their connection but not yet complete. */
+        detachedActive: number;
+        tombstones: number;
+        /** Cancellation states still attached to a physical connection. */
+        connections: number;
+    }>;
+    private getState;
+    private completeActive;
+    private addTombstone;
+    private deleteTombstone;
+    private reclaimGlobalTombstoneCapacity;
+    private failConnection;
+    private createKey;
+    private getValidatedKey;
+}

package/dist_ts/classes.requestcancellationmanager.js

@@ -0,0 +1,234 @@
+import * as plugins from './plugins.js';
+export const TYPEDSOCKET_MAX_ACTIVE_REQUEST_HANDLERS_PER_CONNECTION = 64;
+export const TYPEDSOCKET_MAX_ACTIVE_REQUEST_HANDLERS = 1024;
+export const TYPEDSOCKET_MAX_REQUEST_CANCELLATION_TOMBSTONES_PER_CONNECTION = 1024;
+export const TYPEDSOCKET_MAX_REQUEST_CANCELLATION_TOMBSTONES = 16_384;
+export const TYPEDSOCKET_REQUEST_HANDLER_MAX_LIFETIME_MS = 5 * 60 * 1000;
+export const TYPEDSOCKET_REQUEST_CANCELLATION_TOMBSTONE_RETENTION_MS = 10_000;
+/** Internal control-flow error for an authenticated remote cancellation. */
+export class TypedSocketRemoteRequestCancellationError extends plugins.typedrequest.TypedResponseError {
+    constructor() {
+        super('TypedSocket remote request cancelled');
+        this.name = 'TypedSocketRemoteRequestCancellationError';
+    }
+}
+export class RequestCancellationManager {
+    constructor(optionsArg = {}) {
+        this.states = new Map();
+        this.activeCount = 0;
+        this.detachedActiveCount = 0;
+        this.tombstoneCount = 0;
+        this.stopped = false;
+        this.limits = {
+            maxActivePerConnection: optionsArg.maxActivePerConnection
+                ?? TYPEDSOCKET_MAX_ACTIVE_REQUEST_HANDLERS_PER_CONNECTION,
+            maxActive: optionsArg.maxActive ?? TYPEDSOCKET_MAX_ACTIVE_REQUEST_HANDLERS,
+            maxTombstonesPerConnection: optionsArg.maxTombstonesPerConnection
+                ?? TYPEDSOCKET_MAX_REQUEST_CANCELLATION_TOMBSTONES_PER_CONNECTION,
+            maxTombstones: optionsArg.maxTombstones
+                ?? TYPEDSOCKET_MAX_REQUEST_CANCELLATION_TOMBSTONES,
+            activeLifetimeMs: optionsArg.activeLifetimeMs
+                ?? TYPEDSOCKET_REQUEST_HANDLER_MAX_LIFETIME_MS,
+            tombstoneRetentionMs: optionsArg.tombstoneRetentionMs
+                ?? TYPEDSOCKET_REQUEST_CANCELLATION_TOMBSTONE_RETENTION_MS,
+        };
+        for (const [name, value] of Object.entries(this.limits)) {
+            if (!Number.isSafeInteger(value) || value < 1) {
+                throw new RangeError(`Request cancellation limit ${name} must be a positive safe integer`);
+            }
+        }
+    }
+    register(contextArg, identityArg) {
+        const state = this.getState(contextArg);
+        const key = this.getValidatedKey(state, identityArg);
+        if (state.active.has(key) || state.tombstones.get(key)?.kind === 'terminal') {
+            this.failConnection(state, 'TypedSocket request instance was replayed');
+            throw new Error('TypedSocket request instance was replayed');
+        }
+        if (state.active.size >= this.limits.maxActivePerConnection
+            || this.activeCount >= this.limits.maxActive) {
+            this.failConnection(state, 'TypedSocket active request handler capacity exhausted');
+            throw new Error('TypedSocket active request handler capacity exhausted');
+        }
+        const earlyCancel = state.tombstones.get(key)?.kind === 'early-cancel';
+        if (earlyCancel)
+            this.deleteTombstone(state, key);
+        const abortController = new AbortController();
+        const activeRequest = {
+            key,
+            context: state.context,
+            abortController,
+            completed: false,
+            timeout: setTimeout(() => {
+                this.failConnection(state, 'TypedSocket request handler lifetime exceeded');
+            }, this.limits.activeLifetimeMs),
+        };
+        activeRequest.timeout.unref?.();
+        state.active.set(key, activeRequest);
+        this.activeCount++;
+        if (earlyCancel) {
+            abortController.abort(new TypedSocketRemoteRequestCancellationError());
+        }
+        return Object.freeze({
+            abortSignal: abortController.signal,
+            complete: () => this.completeActive(state, activeRequest),
+        });
+    }
+    cancel(contextArg, identityArg) {
+        const state = this.getState(contextArg);
+        const key = this.getValidatedKey(state, identityArg);
+        const activeRequest = state.active.get(key);
+        if (activeRequest) {
+            activeRequest.abortController.abort(new TypedSocketRemoteRequestCancellationError());
+            return;
+        }
+        if (state.tombstones.has(key))
+            return;
+        this.addTombstone(state, key, 'early-cancel');
+    }
+    closeConnection(connectionArg, reasonArg) {
+        const state = this.states.get(connectionArg);
+        if (!state)
+            return;
+        state.closed = true;
+        this.states.delete(connectionArg);
+        for (const activeRequest of state.active.values()) {
+            clearTimeout(activeRequest.timeout);
+            this.detachedActiveCount++;
+            activeRequest.abortController.abort(reasonArg);
+        }
+        for (const key of Array.from(state.tombstones.keys())) {
+            this.deleteTombstone(state, key);
+        }
+    }
+    stop(reasonArg) {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        for (const connection of Array.from(this.states.keys())) {
+            this.closeConnection(connection, reasonArg);
+        }
+    }
+    getStats() {
+        return Object.freeze({
+            active: this.activeCount,
+            detachedActive: this.detachedActiveCount,
+            tombstones: this.tombstoneCount,
+            connections: this.states.size,
+        });
+    }
+    getState(contextArg) {
+        if (this.stopped)
+            throw new Error('TypedSocket request cancellation manager stopped');
+        const existing = this.states.get(contextArg.connection);
+        if (existing) {
+            if (existing.closed
+                || existing.context.routingSurface !== contextArg.routingSurface
+                || existing.context.generation !== contextArg.generation) {
+                this.failConnection(existing, 'TypedSocket request cancellation authority mismatch');
+                throw new Error('TypedSocket request cancellation authority mismatch');
+            }
+            return existing;
+        }
+        const state = {
+            context: Object.freeze({ ...contextArg }),
+            active: new Map(),
+            tombstones: new Map(),
+            closed: false,
+        };
+        this.states.set(contextArg.connection, state);
+        return state;
+    }
+    completeActive(stateArg, activeRequestArg) {
+        if (activeRequestArg.completed)
+            return;
+        activeRequestArg.completed = true;
+        clearTimeout(activeRequestArg.timeout);
+        if (stateArg.active.get(activeRequestArg.key) === activeRequestArg) {
+            stateArg.active.delete(activeRequestArg.key);
+            this.activeCount--;
+            if (stateArg.closed)
+                this.detachedActiveCount--;
+        }
+        if (!stateArg.closed) {
+            this.addTombstone(stateArg, activeRequestArg.key, 'terminal');
+        }
+    }
+    addTombstone(stateArg, keyArg, kindArg) {
+        if (stateArg.closed)
+            return;
+        if (stateArg.tombstones.size >= this.limits.maxTombstonesPerConnection) {
+            this.failConnection(stateArg, 'TypedSocket per-connection request cancellation tombstone capacity exhausted');
+            return;
+        }
+        if (this.tombstoneCount >= this.limits.maxTombstones
+            && !this.reclaimGlobalTombstoneCapacity()) {
+            this.failConnection(stateArg, 'TypedSocket global request cancellation tombstone capacity exhausted');
+            return;
+        }
+        if (stateArg.closed)
+            return;
+        const timeout = setTimeout(() => {
+            this.deleteTombstone(stateArg, keyArg);
+        }, this.limits.tombstoneRetentionMs);
+        timeout.unref?.();
+        stateArg.tombstones.set(keyArg, { kind: kindArg, timeout });
+        this.tombstoneCount++;
+    }
+    deleteTombstone(stateArg, keyArg) {
+        const tombstone = stateArg.tombstones.get(keyArg);
+        if (!tombstone)
+            return;
+        clearTimeout(tombstone.timeout);
+        stateArg.tombstones.delete(keyArg);
+        this.tombstoneCount--;
+    }
+    reclaimGlobalTombstoneCapacity() {
+        let largestConsumer;
+        // Map iteration is insertion ordered, so equal shares evict the oldest state.
+        for (const state of this.states.values()) {
+            if (state.closed
+                || state.tombstones.size === 0
+                || (largestConsumer
+                    && state.tombstones.size <= largestConsumer.tombstones.size))
+                continue;
+            largestConsumer = state;
+        }
+        if (!largestConsumer)
+            return false;
+        this.failConnection(largestConsumer, 'TypedSocket global request cancellation tombstone capacity exhausted');
+        return this.tombstoneCount < this.limits.maxTombstones;
+    }
+    failConnection(stateArg, reasonArg) {
+        if (stateArg.closed)
+            return;
+        try {
+            stateArg.context.close(reasonArg);
+        }
+        finally {
+            this.closeConnection(stateArg.context.connection, new Error(reasonArg));
+        }
+    }
+    createKey(identityArg) {
+        return JSON.stringify([
+            identityArg.method,
+            identityArg.correlationId,
+            identityArg.requestInstanceId,
+        ]);
+    }
+    getValidatedKey(stateArg, identityArg) {
+        const values = [
+            identityArg.method,
+            identityArg.correlationId,
+            identityArg.requestInstanceId,
+        ];
+        if (values.some((valueArg) => (typeof valueArg !== 'string'
+            || valueArg.length === 0
+            || new TextEncoder().encode(valueArg).byteLength > 256))) {
+            this.failConnection(stateArg, 'TypedSocket request cancellation identity is malformed');
+            throw new Error('TypedSocket request cancellation identity is malformed');
+        }
+        return this.createKey(identityArg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.requestcancellationmanager.js","sourceRoot":"","sources":["../ts/classes.requestcancellationmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.typedsocket.d.ts

@@ -2,6 +2,7 @@ import * as plugins from './plugins.js';
 import { VirtualStreamManager } from './classes.virtualstreammanager.js';
 export { toClientWebSocketCloseCode } from './helpers.websocket.js';
 export { TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS, TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS_PER_NAME, } from './classes.clienttagreconciler.js';
+export { TYPEDSOCKET_REQUEST_CANCELLATION_METHOD, TYPEDSOCKET_REQUEST_CANCELLATION_PROTOCOL, } from './constants.virtualstream.js';
 import type { TTypedSocketDiagnosticEvent } from './interfaces.diagnostics.js';
 import type { ICreateVirtualStreamOptions, IVirtualStreamAuthorizationAdapter, TVirtualStreamDirection } from './interfaces.virtualstream.js';
 import type { ITypedSocketClientTagPolicy } from './classes.typedsockettagpolicymanager.js';
@@ -68,6 +69,8 @@ export interface ITypedSocketClientOptions {
 export interface ITypedSocketServerOptions {
     virtualStreamAuthorizationAdapter?: IVirtualStreamAuthorizationAdapter;
     clientTagPolicy?: ITypedSocketClientTagPolicy;
+    /** Runs synchronously after the exact server handshake response is settled. */
+    onServerConnectionReady?: (connectionArg: ISmartServeConnectionWrapper) => undefined;
 }
 /**
  * Lifecycle controls for one TypedRequest sent over a TypedSocket.
@@ -158,13 +161,16 @@ export declare class TypedSocket {
     private unsubscribeSmartServeConnectionClose;
     private detachVirtualStreamResolvers;
     private detachIncomingRequestAuthorityGuards;
+    private detachIncomingRequestSignalResolvers;
     private detachResponseAuthorityGuards;
     private pendingServerRequests;
     private pendingServerRequestIdsByPeer;
     private retainedServerInterests;
     private retainedServerInterestsByPeer;
+    private readonly serverReadyCallbackPeers;
     private readonly virtualStreamAuthorizationAdapter;
     private readonly tagPolicyManager;
+    private readonly requestCancellationManager;
     private constructor();
     /**
      * Attaches the SmartServe transport after server router composition.
@@ -189,6 +195,9 @@ export declare class TypedSocket {
     private isCurrentClientConnection;
     private failClientHandshake;
     private abortClientConnectionState;
+    private registerClientRequestSignal;
+    private handleClientCancellation;
+    private createClientCancellationContext;
     /**
      * Handles WebSocket disconnection
      */
@@ -228,7 +237,12 @@ export declare class TypedSocket {
     private sendRequest;
     private normalizeRequestTimeout;
     private requireClientOptions;
+    private sendClientCancellation;
     private cancelPendingServerRequestsForPeer;
+    private registerServerRequestSignal;
+    private handleServerCancellation;
+    private createServerCancellationContext;
+    private sendServerCancellation;
     private retainServerInterestRegistration;
     private authorizeIncomingServerResponse;
     private isAttachedServerPeer;