@api.global/typedsocket 6.0.0 → 6.2.0

package/dist_ts/00_commitinfo_data.js

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

@@ -0,0 +1,51 @@
+import type { TTypedSocketTagMutationResponse } from './classes.typedsockettagpolicymanager.js';
+import type { ITypedSocketTagMutationDeniedDiagnostic } from './interfaces.diagnostics.js';
+export declare const TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS_PER_NAME = 8;
+export declare const TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS = 64;
+/**
+ * Transport surface the reconciler needs from its owning TypedSocket client.
+ * The connection state type stays opaque; the reconciler only compares and
+ * forwards it.
+ */
+export interface IClientTagTransportAdapter<TConnectionState> {
+    isCurrentConnection(stateArg: TConnectionState): boolean;
+    getCurrentConnectionState(): TConnectionState | null;
+    getConnectionGeneration(stateArg: TConnectionState): number;
+    getCurrentGeneration(): number;
+    fireSetTag(nameArg: string, payloadArg: unknown): Promise<TTypedSocketTagMutationResponse>;
+    fireRemoveTag(nameArg: string): Promise<TTypedSocketTagMutationResponse>;
+    emitDiagnostic(eventArg: ITypedSocketTagMutationDeniedDiagnostic): void;
+}
+/**
+ * Client-side tag state machine: separates desired tag state (survives
+ * transport failure, reconciled on every connection) from acknowledged state
+ * (bound to one physical connection generation), serializes mutations per
+ * name, and bounds retained mutation work.
+ */
+export declare class ClientTagReconciler<TConnectionState> {
+    private readonly transport;
+    private clientTags;
+    private clientTagRevisions;
+    private desiredClientTags;
+    private clientTagDesiredMutationQueues;
+    private clientTagMutationSequence;
+    private clientTagMutationTails;
+    private retainedClientTagMutations;
+    private retainedClientTagMutationsByName;
+    constructor(transport: IClientTagTransportAdapter<TConnectionState>);
+    setTag(nameArg: string, payloadArg: unknown): Promise<void>;
+    removeTag(nameArg: string): Promise<void>;
+    /**
+     * Re-applies all client tags after a reconnect, since server-side tags are
+     * bound to the previous connection.
+     */
+    reapplyTags(stateArg: TConnectionState | null): Promise<void>;
+    private emitDeniedDiagnostic;
+    private retainClientTagMutation;
+    private setDesiredClientTag;
+    private settleDesiredClientTag;
+    private serializeClientTagMutation;
+    private submitDesiredClientTag;
+    private requireTagMutationSuccess;
+    private applyClientTagMutation;
+}

package/dist_ts/classes.clienttagreconciler.js

@@ -0,0 +1,290 @@
+import { assertBoundedTextIdentifier, createTypedSocketTagPayloadSnapshot, TYPEDSOCKET_MAX_CLIENT_TAG_RETAINED_BYTES_PER_PEER, TYPEDSOCKET_MAX_CLIENT_TAGS_PER_PEER, TYPEDSOCKET_MAX_TAG_NAME_BYTES, TYPEDSOCKET_TAG_DENIAL_CODES, TypedSocketClientTagDeniedError, } from './classes.typedsockettagpolicymanager.js';
+export const TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS_PER_NAME = 8;
+export const TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS = 64;
+const textEncoder = new TextEncoder();
+/**
+ * Client-side tag state machine: separates desired tag state (survives
+ * transport failure, reconciled on every connection) from acknowledged state
+ * (bound to one physical connection generation), serializes mutations per
+ * name, and bounds retained mutation work.
+ */
+export class ClientTagReconciler {
+    constructor(transport) {
+        this.transport = transport;
+        // Acknowledged state is diagnostic state for the current server connection.
+        this.clientTags = new Map();
+        this.clientTagRevisions = new Map();
+        // Desired state survives transport failure and is reconciled on every connection.
+        this.desiredClientTags = new Map();
+        this.clientTagDesiredMutationQueues = new Map();
+        this.clientTagMutationSequence = 0;
+        this.clientTagMutationTails = new Map();
+        this.retainedClientTagMutations = 0;
+        this.retainedClientTagMutationsByName = new Map();
+    }
+    async setTag(nameArg, payloadArg) {
+        let releaseMutation;
+        try {
+            releaseMutation = this.retainClientTagMutation(nameArg);
+            const snapshot = createTypedSocketTagPayloadSnapshot(payloadArg);
+            const desired = this.setDesiredClientTag(nameArg, 'set', snapshot.payload, snapshot.byteLength);
+            return await this.serializeClientTagMutation(nameArg, async () => {
+                let applied;
+                try {
+                    applied = await this.submitDesiredClientTag(nameArg, desired);
+                }
+                catch (errorArg) {
+                    this.settleDesiredClientTag(nameArg, desired, errorArg instanceof TypedSocketClientTagDeniedError ? 'denied' : 'retained');
+                    throw errorArg;
+                }
+                this.settleDesiredClientTag(nameArg, desired, applied ? 'accepted' : 'retained');
+            });
+        }
+        catch (errorArg) {
+            this.emitDeniedDiagnostic('set', nameArg, errorArg);
+            throw errorArg;
+        }
+        finally {
+            releaseMutation?.();
+        }
+    }
+    async removeTag(nameArg) {
+        let releaseMutation;
+        try {
+            releaseMutation = this.retainClientTagMutation(nameArg);
+            const desired = this.setDesiredClientTag(nameArg, 'remove', undefined, 0);
+            return await this.serializeClientTagMutation(nameArg, async () => {
+                let applied;
+                try {
+                    applied = await this.submitDesiredClientTag(nameArg, desired);
+                }
+                catch (errorArg) {
+                    this.settleDesiredClientTag(nameArg, desired, errorArg instanceof TypedSocketClientTagDeniedError ? 'denied' : 'retained');
+                    throw errorArg;
+                }
+                this.settleDesiredClientTag(nameArg, desired, applied ? 'accepted' : 'retained');
+            });
+        }
+        catch (errorArg) {
+            this.emitDeniedDiagnostic('remove', nameArg, errorArg);
+            throw errorArg;
+        }
+        finally {
+            releaseMutation?.();
+        }
+    }
+    /**
+     * Re-applies all client tags after a reconnect, since server-side tags are
+     * bound to the previous connection.
+     */
+    async reapplyTags(stateArg) {
+        if (!stateArg || !this.transport.isCurrentConnection(stateArg)) {
+            throw new Error('TypedSocket has no active connection for tag restoration.');
+        }
+        this.clientTags.clear();
+        this.clientTagRevisions.clear();
+        while (this.transport.isCurrentConnection(stateArg)) {
+            const snapshot = Array.from(this.desiredClientTags.entries());
+            for (const [name, desired] of snapshot) {
+                try {
+                    const applied = await this.submitDesiredClientTag(name, desired, stateArg);
+                    if (applied
+                        && desired.operation === 'remove'
+                        && this.desiredClientTags.get(name)?.sequence === desired.sequence) {
+                        this.desiredClientTags.delete(name);
+                    }
+                }
+                catch (errorArg) {
+                    if (errorArg instanceof TypedSocketClientTagDeniedError
+                        && this.desiredClientTags.get(name)?.sequence === desired.sequence) {
+                        this.desiredClientTags.delete(name);
+                    }
+                    this.emitDeniedDiagnostic(desired.operation, name, errorArg);
+                    throw errorArg;
+                }
+            }
+            const stable = snapshot.length === this.desiredClientTags.size
+                && snapshot.every(([name, desired]) => {
+                    return this.desiredClientTags.get(name)?.sequence === desired.sequence;
+                });
+            if (stable)
+                return;
+        }
+        throw new Error('TypedSocket connection changed while restoring client tags.');
+    }
+    emitDeniedDiagnostic(operationArg, nameArg, errorArg) {
+        if (!(errorArg instanceof TypedSocketClientTagDeniedError))
+            return;
+        let name = '';
+        try {
+            assertBoundedTextIdentifier(nameArg, 'tag name', TYPEDSOCKET_MAX_TAG_NAME_BYTES);
+            name = nameArg;
+        }
+        catch { }
+        this.transport.emitDiagnostic({
+            kind: 'tagMutationDenied',
+            side: 'client',
+            operation: operationArg,
+            name,
+            code: errorArg.code,
+        });
+    }
+    retainClientTagMutation(nameArg) {
+        assertBoundedTextIdentifier(nameArg, 'tag name', TYPEDSOCKET_MAX_TAG_NAME_BYTES);
+        const retainedForName = this.retainedClientTagMutationsByName.get(nameArg) ?? 0;
+        if (retainedForName >= TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS_PER_NAME
+            || this.retainedClientTagMutations >= TYPEDSOCKET_MAX_RETAINED_CLIENT_TAG_MUTATIONS) {
+            throw new TypedSocketClientTagDeniedError('TAG_MUTATION_CAPACITY_EXCEEDED', 'TypedSocket retained client tag mutation capacity exceeded.');
+        }
+        this.retainedClientTagMutations++;
+        this.retainedClientTagMutationsByName.set(nameArg, retainedForName + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.retainedClientTagMutations--;
+            const currentForName = this.retainedClientTagMutationsByName.get(nameArg);
+            if (currentForName === undefined || currentForName < 1) {
+                throw new Error('TypedSocket client tag mutation accounting underflow.');
+            }
+            if (currentForName === 1) {
+                this.retainedClientTagMutationsByName.delete(nameArg);
+            }
+            else {
+                this.retainedClientTagMutationsByName.set(nameArg, currentForName - 1);
+            }
+        };
+    }
+    setDesiredClientTag(nameArg, operationArg, payloadArg, payloadBytesArg) {
+        assertBoundedTextIdentifier(nameArg, 'tag name', TYPEDSOCKET_MAX_TAG_NAME_BYTES);
+        const retainedBytes = textEncoder.encode(nameArg).byteLength + payloadBytesArg;
+        const desired = Object.freeze({
+            sequence: ++this.clientTagMutationSequence,
+            operation: operationArg,
+            payload: operationArg === 'set' ? payloadArg : undefined,
+            retainedBytes,
+        });
+        const alreadyPresent = this.desiredClientTags.has(nameArg);
+        if (!alreadyPresent && this.desiredClientTags.size >= TYPEDSOCKET_MAX_CLIENT_TAGS_PER_PEER) {
+            throw new TypedSocketClientTagDeniedError('TAG_COUNT_LIMIT_EXCEEDED', 'TypedSocket desired client tag count limit exceeded.');
+        }
+        let retainedTotal = retainedBytes;
+        for (const [name, entry] of this.desiredClientTags) {
+            if (name !== nameArg)
+                retainedTotal += entry.retainedBytes;
+        }
+        if (retainedTotal > TYPEDSOCKET_MAX_CLIENT_TAG_RETAINED_BYTES_PER_PEER) {
+            throw new TypedSocketClientTagDeniedError('TAG_RETAINED_BYTES_EXCEEDED', 'TypedSocket desired client tag retained-byte limit exceeded.');
+        }
+        let queue = this.clientTagDesiredMutationQueues.get(nameArg);
+        if (!queue) {
+            queue = {
+                baseline: this.desiredClientTags.get(nameArg),
+                pending: [],
+            };
+            this.clientTagDesiredMutationQueues.set(nameArg, queue);
+        }
+        queue.pending.push(desired);
+        this.desiredClientTags.set(nameArg, desired);
+        return desired;
+    }
+    settleDesiredClientTag(nameArg, desiredArg, outcomeArg) {
+        const queue = this.clientTagDesiredMutationQueues.get(nameArg);
+        const settled = queue?.pending.shift();
+        if (!queue || settled !== desiredArg) {
+            throw new Error('TypedSocket desired client tag mutation order changed unexpectedly.');
+        }
+        if (outcomeArg === 'accepted') {
+            queue.baseline = desiredArg.operation === 'set' ? desiredArg : undefined;
+        }
+        else if (outcomeArg === 'retained') {
+            queue.baseline = desiredArg;
+        }
+        const current = queue.pending.at(-1) ?? queue.baseline;
+        if (current)
+            this.desiredClientTags.set(nameArg, current);
+        else
+            this.desiredClientTags.delete(nameArg);
+        if (queue.pending.length === 0)
+            this.clientTagDesiredMutationQueues.delete(nameArg);
+    }
+    async serializeClientTagMutation(nameArg, mutationArg) {
+        const previous = this.clientTagMutationTails.get(nameArg) ?? Promise.resolve();
+        const operation = previous.catch(() => { }).then(mutationArg);
+        const tail = operation.then(() => { }, () => { });
+        this.clientTagMutationTails.set(nameArg, tail);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.clientTagMutationTails.get(nameArg) === tail) {
+                this.clientTagMutationTails.delete(nameArg);
+            }
+        }
+    }
+    async submitDesiredClientTag(nameArg, desiredArg, stateArg = this.transport.getCurrentConnectionState()) {
+        if (!stateArg || !this.transport.isCurrentConnection(stateArg)) {
+            throw new Error('WebSocket not connected');
+        }
+        const connectionGeneration = this.transport.getConnectionGeneration(stateArg);
+        const response = desiredArg.operation === 'set'
+            ? this.requireTagMutationSuccess(await this.transport.fireSetTag(nameArg, desiredArg.payload))
+            : this.requireTagMutationSuccess(await this.transport.fireRemoveTag(nameArg));
+        const applied = this.applyClientTagMutation(nameArg, desiredArg.payload, response, connectionGeneration, desiredArg.operation);
+        return applied;
+    }
+    requireTagMutationSuccess(responseArg) {
+        if (!responseArg || typeof responseArg.success !== 'boolean') {
+            throw new TypedSocketClientTagDeniedError('MALFORMED_TAG_RESPONSE', 'TypedSocket server returned a malformed tag mutation response.');
+        }
+        if (!responseArg.success) {
+            // The denial code is server-controlled data: anything outside the
+            // package-defined set collapses to MALFORMED_TAG_RESPONSE so no
+            // free-form string reaches typed consumers or diagnostics.
+            if (typeof responseArg.code !== 'string'
+                || typeof responseArg.message !== 'string'
+                || !TYPEDSOCKET_TAG_DENIAL_CODES.includes(responseArg.code)) {
+                throw new TypedSocketClientTagDeniedError('MALFORMED_TAG_RESPONSE', 'TypedSocket server returned a malformed tag denial response.');
+            }
+            throw new TypedSocketClientTagDeniedError(responseArg.code, responseArg.message);
+        }
+        if (typeof responseArg.connectionId !== 'string'
+            || responseArg.connectionId.length === 0
+            || !Number.isSafeInteger(responseArg.tagRevision)
+            || responseArg.tagRevision < 1) {
+            throw new TypedSocketClientTagDeniedError('MALFORMED_TAG_RESPONSE', 'TypedSocket server returned malformed tag mutation ordering metadata.');
+        }
+        return responseArg;
+    }
+    applyClientTagMutation(nameArg, payloadArg, responseArg, connectionGenerationArg, operationArg) {
+        if (connectionGenerationArg !== this.transport.getCurrentGeneration())
+            return false;
+        const current = this.clientTagRevisions.get(nameArg);
+        if (current) {
+            if (connectionGenerationArg < current.connectionGeneration)
+                return false;
+            if (connectionGenerationArg === current.connectionGeneration) {
+                if (responseArg.connectionId !== current.connectionId) {
+                    throw new TypedSocketClientTagDeniedError('MALFORMED_TAG_RESPONSE', 'TypedSocket server changed tag mutation connection identity within one connection generation.');
+                }
+                if (responseArg.tagRevision <= current.tagRevision)
+                    return false;
+            }
+        }
+        if (operationArg === 'set') {
+            this.clientTagRevisions.set(nameArg, {
+                connectionGeneration: connectionGenerationArg,
+                connectionId: responseArg.connectionId,
+                tagRevision: responseArg.tagRevision,
+            });
+            this.clientTags.set(nameArg, createTypedSocketTagPayloadSnapshot(payloadArg).payload);
+        }
+        else {
+            this.clientTags.delete(nameArg);
+            this.clientTagRevisions.delete(nameArg);
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.clienttagreconciler.js","sourceRoot":"","sources":["../ts/classes.clienttagreconciler.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.nativebyteerror.js

@@ -0,0 +1,26 @@
+export class NativeByteError extends Error {
+    constructor(messageArg, code, optionsArg) {
+        super(messageArg, optionsArg);
+        this.code = code;
+        this.name = 'NativeByteError';
+    }
+}
+export class NativeByteProtocolError extends NativeByteError {
+    constructor(messageArg, optionsArg) {
+        super(messageArg, 'NATIVE_BYTE_PROTOCOL_ERROR', optionsArg);
+        this.name = 'NativeByteProtocolError';
+    }
+}
+export class NativeByteCapabilityError extends NativeByteError {
+    constructor(messageArg = 'native-byte-v1 is unavailable', optionsArg) {
+        super(messageArg, 'NATIVE_BYTE_CAPABILITY_UNAVAILABLE', optionsArg);
+        this.name = 'NativeByteCapabilityError';
+    }
+}
+export class NativeByteStreamClosedError extends NativeByteError {
+    constructor(messageArg = 'Native byte stream is closed', optionsArg) {
+        super(messageArg, 'NATIVE_BYTE_STREAM_CLOSED', optionsArg);
+        this.name = 'NativeByteStreamClosedError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5uYXRpdmVieXRlZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLm5hdGl2ZWJ5dGVlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxLQUFLO0lBQ3hDLFlBQ0UsVUFBa0IsRUFDRixJQUFZLEVBQzVCLFVBQXlCO1FBRXpCLEtBQUssQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFIZCxTQUFJLEdBQUosSUFBSSxDQUFRO1FBSTVCLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLHVCQUF3QixTQUFRLGVBQWU7SUFDMUQsWUFBWSxVQUFrQixFQUFFLFVBQXlCO1FBQ3ZELEtBQUssQ0FBQyxVQUFVLEVBQUUsNEJBQTRCLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLElBQUksR0FBRyx5QkFBeUIsQ0FBQztJQUN4QyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8seUJBQTBCLFNBQVEsZUFBZTtJQUM1RCxZQUFZLFVBQVUsR0FBRywrQkFBK0IsRUFBRSxVQUF5QjtRQUNqRixLQUFLLENBQUMsVUFBVSxFQUFFLG9DQUFvQyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ3BFLElBQUksQ0FBQyxJQUFJLEdBQUcsMkJBQTJCLENBQUM7SUFDMUMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDJCQUE0QixTQUFRLGVBQWU7SUFDOUQsWUFBWSxVQUFVLEdBQUcsOEJBQThCLEVBQUUsVUFBeUI7UUFDaEYsS0FBSyxDQUFDLFVBQVUsRUFBRSwyQkFBMkIsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMzRCxJQUFJLENBQUMsSUFBSSxHQUFHLDZCQUE2QixDQUFDO0lBQzVDLENBQUM7Q0FDRiJ9

package/dist_ts/{nativebytes.manager.d.ts → classes.nativebytemanager.d.ts}

@@ -1,6 +1,7 @@
-import * as plugins from './typedsocket.plugins.js';
-import { NativeByteStreamClosedError } from './nativebytes.errors.js';
-import type { INativeByteCapabilityStatus, INativeByteCreateReceiveGrantOptions, INativeByteDescriptor, INativeByteOpenSenderOptions, INativeByteReceipt, INativeByteReceiveGrant, INativeByteRuntime, INativeByteStats, TNativeByteCapabilityMode, TNativeByteConnectionBinding, TNativeByteRevalidate } from './nativebytes.types.js';
+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>;
@@ -187,12 +188,15 @@ 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;
@@ -316,6 +320,7 @@ export declare class NativeByteManager {
     private releaseOutboundQueueBytes;
     private releaseProducerPayloadAccounting;
     private removeQueuedFramesForStream;
+    private emitDiagnostic;
     private closeConnection;
     private failConnection;
 }