@api.global/typedsocket 5.1.2 → 6.1.0

package/dist_ts/classes.typedsockettagpolicymanager.js

@@ -0,0 +1,549 @@
+import * as plugins from './plugins.js';
+export const TYPEDSOCKET_MAX_TAG_NAME_BYTES = 128;
+export const TYPEDSOCKET_MAX_TAG_PAYLOAD_BYTES = 4 * 1024;
+export const TYPEDSOCKET_MAX_CLIENT_TAGS_PER_PEER = 16;
+export const TYPEDSOCKET_MAX_CLIENT_TAG_RETAINED_BYTES_PER_PEER = 16 * 1024;
+export const TYPEDSOCKET_MAX_RETAINED_TAG_MUTATIONS_PER_PEER = 8;
+export const TYPEDSOCKET_MAX_RETAINED_TAG_MUTATIONS_PER_RULE = 32;
+export const TYPEDSOCKET_MAX_RETAINED_TAG_MUTATIONS_PER_SERVER = 256;
+export const TYPEDSOCKET_MAX_TAG_AUTHORIZATION_TIMEOUT_MS = 5_000;
+export const TYPEDSOCKET_MAX_SERVER_TAG_NAMES_PER_PEER = 64;
+export const TYPEDSOCKET_MAX_SERVER_TAG_RETAINED_BYTES_PER_PEER = 64 * 1024;
+const TAG_PREFIX = '__typedsocket_tag__';
+const textEncoder = new TextEncoder();
+/**
+ * The exhaustive runtime set of denial codes. Clients validate remote denial
+ * responses against this set so no server-controlled string can reach typed
+ * consumers or the diagnostics channel.
+ */
+export const TYPEDSOCKET_TAG_DENIAL_CODES = Object.freeze([
+    'CLIENT_TAGS_DISABLED',
+    'INVALID_TAG_NAME',
+    'TAG_NAME_TOO_LARGE',
+    'TAG_NOT_ALLOWED',
+    'INVALID_TAG_PAYLOAD',
+    'TAG_PAYLOAD_TOO_LARGE',
+    'TAG_AUTHORIZATION_DENIED',
+    'TAG_AUTHORIZATION_TIMEOUT',
+    'TAG_MUTATION_CAPACITY_EXCEEDED',
+    'TAG_COUNT_LIMIT_EXCEEDED',
+    'TAG_RETAINED_BYTES_EXCEEDED',
+    'TAG_SERVER_OWNED',
+    'TAG_CONNECTION_CLOSED',
+    'MALFORMED_TAG_RESPONSE',
+]);
+export class TypedSocketClientTagDeniedError extends Error {
+    constructor(codeArg, messageArg) {
+        super(messageArg);
+        this.name = 'TypedSocketClientTagDeniedError';
+        this.code = codeArg;
+    }
+}
+function deny(codeArg, messageArg) {
+    return {
+        success: false,
+        code: codeArg,
+        message: messageArg,
+    };
+}
+export function assertBoundedTextIdentifier(valueArg, labelArg, maximumBytesArg) {
+    if (typeof valueArg !== 'string'
+        || valueArg.length === 0
+        || textEncoder.encode(valueArg).byteLength > maximumBytesArg) {
+        throw new Error(`TypedSocket ${labelArg} must be a non-empty string of at most ${maximumBytesArg} UTF-8 bytes.`);
+    }
+}
+function validateTagName(nameArg) {
+    if (typeof nameArg !== 'string' || nameArg.length === 0) {
+        return deny('INVALID_TAG_NAME', 'TypedSocket tag names must be non-empty strings.');
+    }
+    if (textEncoder.encode(nameArg).byteLength > TYPEDSOCKET_MAX_TAG_NAME_BYTES) {
+        return deny('TAG_NAME_TOO_LARGE', `TypedSocket tag names must not exceed ${TYPEDSOCKET_MAX_TAG_NAME_BYTES} UTF-8 bytes.`);
+    }
+    return undefined;
+}
+export function createTypedSocketTagPayloadSnapshot(payloadArg) {
+    let encoded;
+    let payload;
+    try {
+        encoded = plugins.smartjson.stringify({ value: payloadArg });
+        const parsed = plugins.smartjson.parse(encoded);
+        payload = typeof parsed === 'object' && parsed !== null
+            ? Reflect.get(parsed, 'value')
+            : undefined;
+    }
+    catch {
+        throw new TypedSocketClientTagDeniedError('INVALID_TAG_PAYLOAD', 'TypedSocket tag payloads must be SmartJSON-serializable.');
+    }
+    const byteLength = textEncoder.encode(encoded).byteLength;
+    if (byteLength > TYPEDSOCKET_MAX_TAG_PAYLOAD_BYTES) {
+        throw new TypedSocketClientTagDeniedError('TAG_PAYLOAD_TOO_LARGE', `TypedSocket tag payloads must not exceed ${TYPEDSOCKET_MAX_TAG_PAYLOAD_BYTES} serialized bytes.`);
+    }
+    return { payload, encoded, byteLength };
+}
+function cloneTagPayload(payloadArg) {
+    return createTypedSocketTagPayloadSnapshot(payloadArg).payload;
+}
+export class TypedSocketTagPolicyManager {
+    constructor(policyArg) {
+        this.rules = new Map();
+        this.peerStates = new WeakMap();
+        this.ruleStates = new Map();
+        this.connectionAuthorityIds = new WeakMap();
+        this.routingSurfaceAuthorityIds = new WeakMap();
+        this.closedPeers = new WeakSet();
+        this.retainedMutationWork = 0;
+        this.stopping = false;
+        const timeoutMs = policyArg?.authorizationTimeoutMs
+            ?? TYPEDSOCKET_MAX_TAG_AUTHORIZATION_TIMEOUT_MS;
+        if (!Number.isSafeInteger(timeoutMs)
+            || timeoutMs < 1
+            || timeoutMs > TYPEDSOCKET_MAX_TAG_AUTHORIZATION_TIMEOUT_MS) {
+            throw new Error(`clientTagPolicy.authorizationTimeoutMs must be an integer from 1 to ${TYPEDSOCKET_MAX_TAG_AUTHORIZATION_TIMEOUT_MS}.`);
+        }
+        this.authorizationTimeoutMs = timeoutMs;
+        for (const rule of policyArg?.rules ?? []) {
+            const nameDenial = validateTagName(rule?.name);
+            if (nameDenial)
+                throw new Error(nameDenial.message);
+            if (rule.owner !== 'client' && rule.owner !== 'server') {
+                throw new Error(`TypedSocket client tag rule "${rule.name}" has an invalid owner.`);
+            }
+            if (typeof rule.validateAndAuthorize !== 'function') {
+                throw new Error(`TypedSocket client tag rule "${rule.name}" requires validateAndAuthorize().`);
+            }
+            if (this.rules.has(rule.name)) {
+                throw new Error(`TypedSocket client tag rule "${rule.name}" is duplicated.`);
+            }
+            this.rules.set(rule.name, Object.freeze({ ...rule }));
+            this.ruleStates.set(rule.name, { retainedWork: 0, orphanedAuthorizations: 0 });
+        }
+    }
+    async setClientTag(peerArg, nameArg, payloadArg) {
+        const common = this.validateClientMutation(peerArg, nameArg);
+        if ('success' in common)
+            return common;
+        let payloadSnapshot;
+        try {
+            payloadSnapshot = createTypedSocketTagPayloadSnapshot(payloadArg);
+        }
+        catch (errorArg) {
+            return errorArg instanceof TypedSocketClientTagDeniedError
+                ? deny(errorArg.code, errorArg.message)
+                : deny('INVALID_TAG_PAYLOAD', 'TypedSocket tag payload validation failed.');
+        }
+        return this.enqueueMutation(common.peer, common.rule, common.name, async (stateArg, executionArg) => {
+            return this.executeSet(common.peer, stateArg, common.rule, common.name, payloadSnapshot, executionArg);
+        });
+    }
+    async removeClientTag(peerArg, nameArg) {
+        const common = this.validateClientMutation(peerArg, nameArg);
+        if ('success' in common)
+            return common;
+        return this.enqueueMutation(common.peer, common.rule, common.name, async (stateArg, executionArg) => {
+            return this.executeRemove(common.peer, stateArg, common.rule, common.name, executionArg);
+        });
+    }
+    setServerTag(peerArg, nameArg, payloadArg) {
+        this.assertServerMutationName(nameArg);
+        if (!this.isPeerLive(peerArg)) {
+            throw new Error('Cannot set a TypedSocket server tag on a detached or closed connection.');
+        }
+        const payloadSnapshot = createTypedSocketTagPayloadSnapshot(payloadArg);
+        const state = this.getPeerState(peerArg);
+        this.retainServerTag(state, nameArg, payloadSnapshot.byteLength);
+        this.releaseAdmission(state, nameArg);
+        state.protectedServerNames.add(nameArg);
+        peerArg.tags.add(nameArg);
+        peerArg.data.set(`${TAG_PREFIX}${nameArg}`, payloadSnapshot.payload);
+    }
+    removeServerTag(peerArg, nameArg) {
+        this.assertServerMutationName(nameArg);
+        if (!this.isPeerLive(peerArg)) {
+            throw new Error('Cannot remove a TypedSocket server tag from a detached or closed connection.');
+        }
+        const state = this.getPeerState(peerArg);
+        this.retainServerTag(state, nameArg, 0);
+        this.releaseAdmission(state, nameArg);
+        state.protectedServerNames.add(nameArg);
+        peerArg.tags.delete(nameArg);
+        peerArg.data.delete(`${TAG_PREFIX}${nameArg}`);
+    }
+    handlePeerClose(peerArg) {
+        this.closedPeers.add(peerArg);
+        const state = this.peerStates.get(peerArg);
+        if (!state)
+            return;
+        for (const controller of state.authorizationControllers) {
+            controller.abort(new Error('TypedSocket connection closed.'));
+        }
+    }
+    setAttachedPeersProvider(providerArg) {
+        this.attachedPeersProvider = providerArg;
+    }
+    stop(peersArg) {
+        this.stopping = true;
+        for (const peer of peersArg)
+            this.handlePeerClose(peer);
+        this.attachedPeersProvider = undefined;
+    }
+    getRetainedMutationWork() {
+        return this.retainedMutationWork;
+    }
+    getRetainedMutationWorkForRule(nameArg) {
+        return this.ruleStates.get(nameArg)?.retainedWork ?? 0;
+    }
+    validateClientMutation(peerArg, nameArg) {
+        const nameDenial = validateTagName(nameArg);
+        if (nameDenial)
+            return nameDenial;
+        if (!peerArg) {
+            return deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag mutation has no live connection.');
+        }
+        if (!this.isPeerLive(peerArg)) {
+            return deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag mutation connection is not attached and live.');
+        }
+        if (this.rules.size === 0) {
+            return deny('CLIENT_TAGS_DISABLED', 'TypedSocket client tag mutation is disabled.');
+        }
+        if (typeof nameArg !== 'string') {
+            return deny('INVALID_TAG_NAME', 'TypedSocket tag names must be non-empty strings.');
+        }
+        const rule = this.rules.get(nameArg);
+        if (!rule) {
+            return deny('TAG_NOT_ALLOWED', 'TypedSocket client tag name is not allowed.');
+        }
+        return { peer: peerArg, name: nameArg, rule };
+    }
+    async enqueueMutation(peerArg, ruleArg, nameArg, operationArg) {
+        const state = this.getPeerState(peerArg);
+        const ruleState = this.ruleStates.get(ruleArg.name);
+        if (!ruleState) {
+            return deny('TAG_NOT_ALLOWED', 'TypedSocket client tag rule state is unavailable.');
+        }
+        if (state.activeMutationOperations + state.orphanedAuthorizations
+            >= TYPEDSOCKET_MAX_RETAINED_TAG_MUTATIONS_PER_PEER
+            || ruleState.retainedWork >= TYPEDSOCKET_MAX_RETAINED_TAG_MUTATIONS_PER_RULE
+            || this.retainedMutationWork >= TYPEDSOCKET_MAX_RETAINED_TAG_MUTATIONS_PER_SERVER) {
+            return deny('TAG_MUTATION_CAPACITY_EXCEEDED', 'TypedSocket client tag mutation capacity is exhausted.');
+        }
+        state.activeMutationOperations++;
+        ruleState.retainedWork++;
+        this.retainedMutationWork++;
+        const previousTail = state.mutationTails.get(nameArg) ?? Promise.resolve();
+        const execution = {};
+        const operation = previousTail.then(() => operationArg(state, execution));
+        const tail = operation.then(() => undefined, () => undefined);
+        state.mutationTails.set(nameArg, tail);
+        try {
+            return await operation;
+        }
+        finally {
+            state.activeMutationOperations--;
+            if (execution.orphanOutcome) {
+                state.orphanedAuthorizations++;
+                ruleState.orphanedAuthorizations++;
+                void execution.orphanOutcome.then(() => {
+                    state.orphanedAuthorizations--;
+                    ruleState.orphanedAuthorizations--;
+                    ruleState.retainedWork--;
+                    this.retainedMutationWork--;
+                });
+            }
+            else {
+                ruleState.retainedWork--;
+                this.retainedMutationWork--;
+            }
+            if (state.mutationTails.get(nameArg) === tail) {
+                state.mutationTails.delete(nameArg);
+            }
+        }
+    }
+    async executeSet(peerArg, stateArg, ruleArg, nameArg, payloadSnapshotArg, executionArg) {
+        if (!this.isPeerLive(peerArg)) {
+            return deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag connection is closed.');
+        }
+        const existing = this.reconcileName(peerArg, stateArg, nameArg);
+        if (stateArg.protectedServerNames.has(nameArg) || existing?.owner === 'server') {
+            return deny('TAG_SERVER_OWNED', 'TypedSocket server-owned tags cannot be overwritten.');
+        }
+        if (existing && ruleArg.owner !== 'client') {
+            return deny('TAG_SERVER_OWNED', 'TypedSocket server-owned tag proposals are one-time.');
+        }
+        const fingerprint = this.createFingerprint(existing);
+        const routingSurface = peerArg.routingSurface;
+        const authorization = await this.authorize(peerArg, stateArg, ruleArg, {
+            operation: 'set',
+            name: nameArg,
+            payload: payloadSnapshotArg.payload,
+            existing,
+        }, executionArg);
+        if (!authorization.allowed)
+            return authorization.denial;
+        if (!this.isPeerLive(peerArg)) {
+            return deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag connection closed during authorization.');
+        }
+        const current = this.reconcileName(peerArg, stateArg, nameArg);
+        if (!routingSurface
+            || peerArg.routingSurface !== routingSurface
+            || stateArg.protectedServerNames.has(nameArg)
+            || this.createFingerprint(current) !== fingerprint) {
+            return deny('TAG_SERVER_OWNED', 'TypedSocket tag ownership changed during authorization.');
+        }
+        const retainedBytes = textEncoder.encode(nameArg).byteLength + payloadSnapshotArg.byteLength;
+        const nextCount = stateArg.admissions.size + (current ? 0 : 1);
+        const nextBytes = stateArg.admittedBytes - (current?.retainedBytes ?? 0) + retainedBytes;
+        if (nextCount > TYPEDSOCKET_MAX_CLIENT_TAGS_PER_PEER) {
+            return deny('TAG_COUNT_LIMIT_EXCEEDED', `TypedSocket clients may retain at most ${TYPEDSOCKET_MAX_CLIENT_TAGS_PER_PEER} tags per connection.`);
+        }
+        if (nextBytes > TYPEDSOCKET_MAX_CLIENT_TAG_RETAINED_BYTES_PER_PEER) {
+            return deny('TAG_RETAINED_BYTES_EXCEEDED', `TypedSocket client tags may retain at most ${TYPEDSOCKET_MAX_CLIENT_TAG_RETAINED_BYTES_PER_PEER} bytes per connection.`);
+        }
+        if (current)
+            this.releaseAdmission(stateArg, nameArg);
+        const admission = {
+            ...payloadSnapshotArg,
+            owner: ruleArg.owner,
+            retainedBytes,
+        };
+        stateArg.admissions.set(nameArg, admission);
+        stateArg.admittedBytes += retainedBytes;
+        if (ruleArg.owner === 'server')
+            stateArg.protectedServerNames.add(nameArg);
+        peerArg.tags.add(nameArg);
+        peerArg.data.set(`${TAG_PREFIX}${nameArg}`, payloadSnapshotArg.payload);
+        return this.createSuccess(peerArg, stateArg, nameArg);
+    }
+    async executeRemove(peerArg, stateArg, ruleArg, nameArg, executionArg) {
+        if (!this.isPeerLive(peerArg)) {
+            return deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag connection is closed.');
+        }
+        const existing = this.reconcileName(peerArg, stateArg, nameArg);
+        if (stateArg.protectedServerNames.has(nameArg) || existing?.owner === 'server') {
+            return deny('TAG_SERVER_OWNED', 'TypedSocket server-owned tags cannot be removed.');
+        }
+        if (!existing)
+            return this.createSuccess(peerArg, stateArg, nameArg, false);
+        if (ruleArg.owner !== 'client') {
+            return deny('TAG_SERVER_OWNED', 'TypedSocket server-owned tags cannot be removed.');
+        }
+        const fingerprint = this.createFingerprint(existing);
+        const routingSurface = peerArg.routingSurface;
+        const authorization = await this.authorize(peerArg, stateArg, ruleArg, {
+            operation: 'remove',
+            name: nameArg,
+            payload: existing.payload,
+            existing,
+        }, executionArg);
+        if (!authorization.allowed)
+            return authorization.denial;
+        if (!this.isPeerLive(peerArg)) {
+            return deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag connection closed during authorization.');
+        }
+        const current = this.reconcileName(peerArg, stateArg, nameArg);
+        if (!routingSurface
+            || peerArg.routingSurface !== routingSurface
+            || stateArg.protectedServerNames.has(nameArg)
+            || this.createFingerprint(current) !== fingerprint) {
+            return deny('TAG_SERVER_OWNED', 'TypedSocket tag ownership changed during authorization.');
+        }
+        this.releaseAdmission(stateArg, nameArg);
+        peerArg.tags.delete(nameArg);
+        peerArg.data.delete(`${TAG_PREFIX}${nameArg}`);
+        return this.createSuccess(peerArg, stateArg, nameArg, false);
+    }
+    async authorize(peerArg, stateArg, ruleArg, contextArg, executionArg) {
+        const routingSurface = peerArg.routingSurface;
+        if (!routingSurface) {
+            return {
+                allowed: false,
+                denial: deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag authorization requires an exact routing surface.'),
+            };
+        }
+        const controller = new AbortController();
+        stateArg.authorizationControllers.add(controller);
+        const authority = Object.freeze({
+            connectionId: this.getConnectionAuthorityId(peerArg),
+            routingSurfaceId: this.getRoutingSurfaceAuthorityId(routingSurface),
+        });
+        const existing = contextArg.existing
+            ? Object.freeze({
+                owner: 'client',
+                payload: cloneTagPayload(contextArg.existing.payload),
+            })
+            : undefined;
+        const validationContext = Object.freeze({
+            operation: contextArg.operation,
+            name: contextArg.name,
+            payload: cloneTagPayload(contextArg.payload),
+            existing,
+            authority,
+            abortSignal: controller.signal,
+        });
+        let callbackSettled = false;
+        const outcome = Promise.resolve()
+            .then(() => ruleArg.validateAndAuthorize(validationContext))
+            .then((allowedArg) => {
+            callbackSettled = true;
+            return allowedArg === true;
+        }, () => {
+            callbackSettled = true;
+            return false;
+        });
+        let timeout;
+        let abortListener;
+        const timeoutResult = new Promise((resolveArg) => {
+            timeout = setTimeout(() => {
+                resolveArg('timeout');
+                controller.abort(new Error('TypedSocket tag authorization timed out.'));
+            }, this.authorizationTimeoutMs);
+        });
+        const abortResult = new Promise((resolveArg) => {
+            abortListener = () => resolveArg('aborted');
+            controller.signal.addEventListener('abort', abortListener, { once: true });
+        });
+        try {
+            const result = await Promise.race([
+                outcome.then((allowedArg) => allowedArg ? 'allowed' : 'denied'),
+                timeoutResult,
+                abortResult,
+            ]);
+            if (result === 'allowed')
+                return { allowed: true };
+            if (!callbackSettled)
+                executionArg.orphanOutcome = outcome;
+            if (result === 'timeout') {
+                return {
+                    allowed: false,
+                    denial: deny('TAG_AUTHORIZATION_TIMEOUT', 'TypedSocket tag authorization timed out.'),
+                };
+            }
+            if (result === 'aborted') {
+                return {
+                    allowed: false,
+                    denial: deny('TAG_CONNECTION_CLOSED', 'TypedSocket tag authorization was cancelled.'),
+                };
+            }
+            return {
+                allowed: false,
+                denial: deny('TAG_AUTHORIZATION_DENIED', 'TypedSocket tag authorization was denied.'),
+            };
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            if (abortListener)
+                controller.signal.removeEventListener('abort', abortListener);
+            stateArg.authorizationControllers.delete(controller);
+        }
+    }
+    reconcileName(peerArg, stateArg, nameArg) {
+        const tracked = stateArg.admissions.get(nameArg);
+        const dataKey = `${TAG_PREFIX}${nameArg}`;
+        const hasTag = peerArg.tags.has(nameArg);
+        const hasPayload = peerArg.data.has(dataKey);
+        if (tracked) {
+            let matches = hasTag && hasPayload;
+            if (matches) {
+                try {
+                    matches = createTypedSocketTagPayloadSnapshot(peerArg.data.get(dataKey)).encoded
+                        === tracked.encoded;
+                }
+                catch {
+                    matches = false;
+                }
+            }
+            if (matches)
+                return tracked;
+            this.releaseAdmission(stateArg, nameArg);
+            stateArg.protectedServerNames.add(nameArg);
+            return undefined;
+        }
+        if (hasTag || hasPayload)
+            stateArg.protectedServerNames.add(nameArg);
+        return undefined;
+    }
+    releaseAdmission(stateArg, nameArg) {
+        const existing = stateArg.admissions.get(nameArg);
+        if (!existing)
+            return;
+        stateArg.admissions.delete(nameArg);
+        stateArg.admittedBytes -= existing.retainedBytes;
+    }
+    createFingerprint(admissionArg) {
+        return admissionArg ? `${admissionArg.owner}:${admissionArg.encoded}` : 'absent';
+    }
+    createSuccess(peerArg, stateArg, nameArg, retainRevisionArg = true) {
+        const tagRevision = (stateArg.successfulRevisionByName.get(nameArg) ?? 0) + 1;
+        if (retainRevisionArg)
+            stateArg.successfulRevisionByName.set(nameArg, tagRevision);
+        else
+            stateArg.successfulRevisionByName.delete(nameArg);
+        return {
+            success: true,
+            connectionId: this.getConnectionAuthorityId(peerArg),
+            tagRevision,
+        };
+    }
+    getPeerState(peerArg) {
+        let state = this.peerStates.get(peerArg);
+        if (state)
+            return state;
+        state = {
+            admissions: new Map(),
+            protectedServerNames: new Set(),
+            successfulRevisionByName: new Map(),
+            mutationTails: new Map(),
+            authorizationControllers: new Set(),
+            serverRetainedBytesByName: new Map(),
+            activeMutationOperations: 0,
+            orphanedAuthorizations: 0,
+            admittedBytes: 0,
+            serverRetainedBytes: 0,
+        };
+        this.peerStates.set(peerArg, state);
+        return state;
+    }
+    isPeerLive(peerArg) {
+        return !this.stopping
+            && !this.closedPeers.has(peerArg)
+            && peerArg.readyState === 1
+            && (!this.attachedPeersProvider || this.attachedPeersProvider().includes(peerArg));
+    }
+    getConnectionAuthorityId(peerArg) {
+        let id = this.connectionAuthorityIds.get(peerArg);
+        if (!id) {
+            id = plugins.smartstring.create.createCryptoRandomString();
+            this.connectionAuthorityIds.set(peerArg, id);
+        }
+        return id;
+    }
+    getRoutingSurfaceAuthorityId(routingSurfaceArg) {
+        let id = this.routingSurfaceAuthorityIds.get(routingSurfaceArg);
+        if (!id) {
+            id = plugins.smartstring.create.createCryptoRandomString();
+            this.routingSurfaceAuthorityIds.set(routingSurfaceArg, id);
+        }
+        return id;
+    }
+    assertServerMutationName(nameArg) {
+        const denial = validateTagName(nameArg);
+        if (denial)
+            throw new Error(denial.message);
+    }
+    retainServerTag(stateArg, nameArg, payloadBytesArg) {
+        const previousBytes = stateArg.serverRetainedBytesByName.get(nameArg) ?? 0;
+        if (previousBytes === 0
+            && stateArg.serverRetainedBytesByName.size >= TYPEDSOCKET_MAX_SERVER_TAG_NAMES_PER_PEER) {
+            throw new Error(`TypedSocket servers may protect at most ${TYPEDSOCKET_MAX_SERVER_TAG_NAMES_PER_PEER} tag names per connection.`);
+        }
+        const retainedBytes = textEncoder.encode(nameArg).byteLength + payloadBytesArg;
+        const nextTotal = stateArg.serverRetainedBytes - previousBytes + retainedBytes;
+        if (nextTotal > TYPEDSOCKET_MAX_SERVER_TAG_RETAINED_BYTES_PER_PEER) {
+            throw new Error(`TypedSocket server tags may retain at most ${TYPEDSOCKET_MAX_SERVER_TAG_RETAINED_BYTES_PER_PEER} bytes per connection.`);
+        }
+        stateArg.serverRetainedBytesByName.set(nameArg, retainedBytes);
+        stateArg.serverRetainedBytes = nextTotal;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.typedsockettagpolicymanager.js","sourceRoot":"","sources":["../ts/classes.typedsockettagpolicymanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/constants.nativebytes.d.ts

@@ -0,0 +1,59 @@
+export declare const NATIVE_BYTE_PROTOCOL: "native-byte-v1";
+export declare const NATIVE_BYTE_PROTOCOL_MAJOR: 6;
+export declare const NATIVE_BYTE_FRAME_MAGIC: "TSB1";
+export declare const NATIVE_BYTE_FRAME_TYPES: {
+    readonly OPEN: 1;
+    readonly OPEN_ACK: 2;
+    readonly DATA: 3;
+    readonly ACK: 4;
+    readonly FIN: 5;
+    readonly FIN_ACK: 6;
+    readonly RESET: 7;
+};
+export declare const NATIVE_BYTE_RESET_CODES: {
+    readonly PROTOCOL_ERROR: 1;
+    readonly CAPABILITY_REJECTED: 2;
+    readonly RESOURCE_LIMIT: 3;
+    readonly TIMEOUT: 4;
+    readonly ABORTED: 5;
+    readonly INTEGRITY_ERROR: 6;
+    readonly AUTHORITY_REVOKED: 7;
+    readonly INTERNAL_ERROR: 8;
+};
+export declare const NATIVE_BYTE_COMMON_HEADER_BYTES = 32;
+export declare const NATIVE_BYTE_OPEN_FIXED_HEADER_BYTES = 116;
+export declare const NATIVE_BYTE_OPEN_ACK_HEADER_BYTES = 48;
+export declare const NATIVE_BYTE_DATA_HEADER_BYTES = 48;
+export declare const NATIVE_BYTE_ACK_HEADER_BYTES = 48;
+export declare const NATIVE_BYTE_FIN_HEADER_BYTES = 72;
+export declare const NATIVE_BYTE_FIN_ACK_HEADER_BYTES = 72;
+export declare const NATIVE_BYTE_RESET_FIXED_HEADER_BYTES = 40;
+export declare const NATIVE_BYTE_MAX_FRAME_BYTES: number;
+export declare const NATIVE_BYTE_MAX_DATA_PAYLOAD_BYTES: number;
+export declare const NATIVE_BYTE_MAX_STREAM_BYTES: number;
+export declare const NATIVE_BYTE_MAX_CONTENT_TYPE_BYTES = 255;
+export declare const NATIVE_BYTE_MAX_RESET_REASON_BYTES = 256;
+export declare const NATIVE_BYTE_DEFAULT_INITIAL_WINDOW_BYTES: number;
+export declare const NATIVE_BYTE_MAX_WINDOW_BYTES: number;
+export declare const NATIVE_BYTE_MAX_QUEUED_PAYLOAD_BYTES_PER_STREAM: number;
+export declare const NATIVE_BYTE_MAX_QUEUED_PAYLOAD_BYTES_PER_CONNECTION: number;
+export declare const NATIVE_BYTE_MAX_RECEIVE_QUEUE_CHUNKS = 4096;
+export declare const NATIVE_BYTE_MAX_STREAMS_PER_CONNECTION = 32;
+export declare const NATIVE_BYTE_MAX_PENDING_DATA_OPERATIONS_PER_CONNECTION = 64;
+export declare const NATIVE_BYTE_MAX_RAW_QUEUE_FRAMES = 64;
+export declare const NATIVE_BYTE_MAX_RAW_QUEUE_BYTES: number;
+export declare const NATIVE_BYTE_GRANT_OPEN_TIMEOUT_MS = 10000;
+export declare const NATIVE_BYTE_PROGRESS_TIMEOUT_MS = 30000;
+export declare const NATIVE_BYTE_TOMBSTONE_RETENTION_MS = 60000;
+export declare const NATIVE_BYTE_MAX_TOMBSTONES = 64;
+export declare const NATIVE_BYTE_MAX_PRINCIPAL_ID_BYTES = 256;
+export declare const NATIVE_BYTE_MAX_AUTHORITY_REVISION_BYTES = 256;
+export declare const NATIVE_BYTE_REVALIDATION_TIMEOUT_MS = 5000;
+export declare const NATIVE_BYTE_MAX_REVALIDATIONS_PER_PEER = 4;
+export declare const NATIVE_BYTE_MAX_REVALIDATIONS_PER_PRINCIPAL = 16;
+export declare const NATIVE_BYTE_MAX_REVALIDATIONS_PER_SERVER = 128;
+export declare const NATIVE_BYTE_MAX_CONNECTIONS_PER_SERVER = 1024;
+export declare const NATIVE_BYTE_MAX_STREAMS_PER_SERVER = 1024;
+export declare const NATIVE_BYTE_MAX_RETAINED_BYTES_PER_SERVER: number;
+export type TNativeByteFrameType = (typeof NATIVE_BYTE_FRAME_TYPES)[keyof typeof NATIVE_BYTE_FRAME_TYPES];
+export type TNativeByteResetCode = (typeof NATIVE_BYTE_RESET_CODES)[keyof typeof NATIVE_BYTE_RESET_CODES];