@agentplat/mesh 0.3.0-alpha.1

package/dist/loopback.d.ts

@@ -0,0 +1,99 @@
+import { type MeshProtocolOptions, type SignedMeshEnvelope } from '@agentplat/mesh-protocol';
+import type { MeshCryptoPolicy, MeshEnvelopeSigner, MeshEnvelopeVerifier, MeshKeyResolver } from '@agentplat/mesh-crypto';
+import type { MeshAdmissionPolicy, MeshLogicalTime, MeshPeerEffect, MeshPeerInput, MeshPeerState } from './contracts.js';
+/** Exact transport route; peer IDs are never global lookup keys. */
+export interface MeshLoopbackAddress {
+    readonly tenantId: string;
+    readonly meshId: string;
+    readonly peerId: string;
+}
+/** One coherent wall-clock and logical-time sample supplied by a driver. */
+export interface MeshLoopbackTime {
+    readonly logicalTime: MeshLogicalTime;
+    readonly timestamp: string;
+}
+/** Explicit clock used by loopback and deterministic tests. */
+export interface MeshLoopbackClock {
+    now(): MeshLoopbackTime;
+}
+/** Injectable canonical message-ID source. */
+export interface MeshLoopbackMessageIdSource {
+    nextMessageId(): string;
+}
+/** Redacted queue entry returned by inspection. */
+export interface MeshLoopbackQueueEntry {
+    readonly insertionSequence: number;
+    readonly messageId: string;
+    readonly target: MeshLoopbackAddress;
+}
+/** Delivery result at the in-memory transport boundary. */
+export type MeshLoopbackReceipt = {
+    readonly accepted: true;
+    readonly messageId: string;
+    readonly target: MeshLoopbackAddress;
+} | {
+    readonly accepted: false;
+    readonly messageId?: string;
+    readonly reasonCode: string;
+    readonly target?: MeshLoopbackAddress;
+};
+/** State and immediate effects returned after one local peer input. */
+export interface MeshLoopbackDispatchResult {
+    readonly state: MeshPeerState;
+    readonly effects: readonly MeshPeerEffect[];
+    readonly receipts: readonly MeshLoopbackReceipt[];
+}
+/** External commands; interpreted effect results remain driver-owned. */
+export type MeshLoopbackPeerCommand = Exclude<MeshPeerInput, {
+    readonly kind: 'effect.result';
+}>;
+/** Restart-safe snapshot owned by one registered loopback peer. */
+export interface MeshLoopbackPeerSnapshot {
+    readonly state: MeshPeerState;
+    readonly outboundSequence: number;
+}
+/** Complete dependencies for one signed loopback peer. */
+export interface MeshLoopbackPeerOptions {
+    readonly state: MeshPeerState;
+    readonly signer: MeshEnvelopeSigner;
+    readonly verifier: MeshEnvelopeVerifier;
+    readonly resolver: MeshKeyResolver;
+    readonly cryptoPolicy: MeshCryptoPolicy;
+    readonly privateKey: CryptoKey;
+    readonly clock: MeshLoopbackClock;
+    readonly messageIds?: MeshLoopbackMessageIdSource;
+    readonly admissionPolicy?: MeshAdmissionPolicy;
+    readonly outboundSequence?: number;
+    readonly crypto?: Crypto;
+    readonly protocolOptions?: MeshProtocolOptions;
+    readonly supportedCriticalExtensions?: readonly string[];
+    readonly onEffect?: (effect: MeshPeerEffect) => void;
+}
+/** Mutable driver handle around immutable peer snapshots. */
+export interface MeshLoopbackPeer {
+    readonly address: MeshLoopbackAddress;
+    getState(): MeshPeerState;
+    snapshot(): MeshLoopbackPeerSnapshot;
+    dispatch(input: MeshLoopbackPeerCommand): Promise<MeshLoopbackDispatchResult>;
+}
+/** Construction bounds for one explicit in-memory transport. */
+export interface MeshLoopbackTransportOptions {
+    readonly maximumPeers?: number;
+    readonly maximumQueueDepth?: number;
+    readonly maximumQueuedBytes?: number;
+    readonly maximumDuplicateCopies?: number;
+    readonly maximumInternalStepsPerTransition?: number;
+}
+/** Signed, bounded and explicitly scoped local transport. */
+export interface MeshLoopbackTransport {
+    register(options: MeshLoopbackPeerOptions): MeshLoopbackPeer;
+    unregister(address: MeshLoopbackAddress): void;
+    deliver(envelope: SignedMeshEnvelope): Promise<MeshLoopbackReceipt>;
+    injectDuplicate(envelope: SignedMeshEnvelope, additionalDeliveries?: number): Promise<readonly MeshLoopbackReceipt[]>;
+    inspectQueue(): readonly MeshLoopbackQueueEntry[];
+    idle(): Promise<void>;
+    close(): Promise<void>;
+}
+/** Creates an isolated loopback bus with no process-global registry. */
+export declare function createMeshLoopbackTransport(options?: MeshLoopbackTransportOptions): MeshLoopbackTransport;
+//# sourceMappingURL=loopback.d.ts.map

package/dist/loopback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopback.d.ts","sourceRoot":"","sources":["../src/loopback.ts"],"names":[],"mappings":"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"}

package/dist/loopback.js

@@ -0,0 +1,580 @@
+import { MESH_PROTOCOL, MESH_SIGNATURE_ALGORITHM, MESH_WIRE_VERSION, } from '@agentplat/mesh-protocol';
+import { ALLOW_PREPROVISIONED_MESH_ADMISSION, processMeshEnvelope, } from './inbound.js';
+import { reduceMeshPeer } from './reducer.js';
+const defaultMaximumQueueDepth = 1_024;
+const defaultMaximumQueuedBytes = 16 * 1_024 * 1_024;
+/** Creates an isolated loopback bus with no process-global registry. */
+export function createMeshLoopbackTransport(options = {}) {
+    return new InMemoryMeshLoopbackTransport(options);
+}
+class InMemoryMeshLoopbackTransport {
+    #maximumQueueDepth;
+    #maximumPeers;
+    #maximumQueuedBytes;
+    #maximumDuplicateCopies;
+    #maximumInternalStepsPerTransition;
+    #peers = new Map();
+    #seenInstances = new Set();
+    #queue = [];
+    #idleWaiters = [];
+    #insertionSequence = 0;
+    #queuedBytes = 0;
+    #inFlight = 0;
+    #inFlightBytes = 0;
+    #draining = false;
+    #activeDispatches = 0;
+    #closed = false;
+    #closePromise;
+    #resolveClose;
+    constructor(options) {
+        const maximumQueueDepth = options.maximumQueueDepth ?? defaultMaximumQueueDepth;
+        const limits = {
+            maximumPeers: options.maximumPeers ?? 256,
+            maximumQueueDepth,
+            maximumQueuedBytes: options.maximumQueuedBytes ?? defaultMaximumQueuedBytes,
+            maximumDuplicateCopies: options.maximumDuplicateCopies ?? 16,
+            maximumInternalStepsPerTransition: options.maximumInternalStepsPerTransition ?? 1_024,
+        };
+        for (const [name, value] of Object.entries(limits)) {
+            if (!Number.isSafeInteger(value) || value < 1) {
+                throw new RangeError(`Mesh loopback ${name} must be a positive safe integer`);
+            }
+        }
+        this.#maximumQueueDepth = maximumQueueDepth;
+        this.#maximumPeers = limits.maximumPeers;
+        this.#maximumQueuedBytes = limits.maximumQueuedBytes;
+        this.#maximumDuplicateCopies = limits.maximumDuplicateCopies;
+        this.#maximumInternalStepsPerTransition =
+            limits.maximumInternalStepsPerTransition;
+    }
+    register(options) {
+        if (this.#closed)
+            throw new Error('Mesh loopback transport is closed');
+        if (this.#peers.size >= this.#maximumPeers) {
+            throw new RangeError('Mesh loopback peer capacity exceeded');
+        }
+        const peer = new LoopbackPeer(this, options);
+        const key = addressKey(peer.address);
+        if (this.#peers.has(key)) {
+            throw new TypeError('Duplicate Mesh loopback peer registration');
+        }
+        const instanceKey = JSON.stringify([
+            ...JSON.parse(key),
+            options.state.identity.instanceId,
+        ]);
+        if (this.#seenInstances.has(instanceKey)) {
+            throw new TypeError('Mesh loopback peer instance cannot be re-registered');
+        }
+        this.#seenInstances.add(instanceKey);
+        this.#peers.set(key, peer);
+        return peer;
+    }
+    unregister(address) {
+        const key = addressKey(freezeAddress(address));
+        this.#peers.get(key)?.dispose();
+        this.#peers.delete(key);
+    }
+    deliver(envelope) {
+        const target = directTarget(envelope);
+        if (!target) {
+            return Promise.resolve(Object.freeze({
+                accepted: false,
+                messageId: envelope?.messageId,
+                reasonCode: 'audience_not_direct',
+            }));
+        }
+        return this.#enqueue(envelope, target);
+    }
+    injectDuplicate(envelope, additionalDeliveries = 1) {
+        if (!Number.isSafeInteger(additionalDeliveries) ||
+            additionalDeliveries < 1 ||
+            additionalDeliveries > this.#maximumDuplicateCopies) {
+            throw new RangeError('Mesh loopback additionalDeliveries must be a positive safe integer');
+        }
+        const target = directTarget(envelope);
+        if (!target) {
+            return Promise.resolve(Object.freeze([
+                Object.freeze({
+                    accepted: false,
+                    messageId: envelope?.messageId,
+                    reasonCode: 'audience_not_direct',
+                }),
+            ]));
+        }
+        const byteLength = envelopeByteLength(envelope);
+        const batchSize = additionalDeliveries + 1;
+        if (this.#closed ||
+            this.#queue.length + this.#inFlight + batchSize >
+                this.#maximumQueueDepth ||
+            this.#queuedBytes +
+                this.#inFlightBytes +
+                byteLength * batchSize >
+                this.#maximumQueuedBytes) {
+            return Promise.resolve(Object.freeze([
+                Object.freeze({
+                    accepted: false,
+                    messageId: envelope.messageId,
+                    reasonCode: this.#closed
+                        ? 'transport_closed'
+                        : 'queue_capacity_exceeded',
+                    target,
+                }),
+            ]));
+        }
+        return Promise.all(Array.from({ length: additionalDeliveries + 1 }, () => this.#enqueue(envelope, target))).then((receipts) => Object.freeze(receipts));
+    }
+    inspectQueue() {
+        return Object.freeze(this.#queue.map((job) => Object.freeze({
+            insertionSequence: job.insertionSequence,
+            messageId: job.envelope.messageId,
+            target: job.target,
+        })));
+    }
+    idle() {
+        if (!this.#draining && this.#queue.length === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.#idleWaiters.push(resolve));
+    }
+    close() {
+        if (this.#closePromise)
+            return this.#closePromise;
+        this.#closed = true;
+        this.#closePromise = new Promise((resolve) => {
+            this.#resolveClose = resolve;
+        }).then(() => {
+            for (const peer of this.#peers.values())
+                peer.dispose();
+            this.#peers.clear();
+        });
+        this.#resolveCloseIfQuiescent();
+        return this.#closePromise;
+    }
+    async dispatchFrom(peer, input) {
+        if (this.#closed)
+            throw new Error('Mesh loopback transport is closed');
+        this.#activeDispatches += 1;
+        try {
+            const result = await peer.applyLocal(input);
+            const receipts = await Promise.all(result.outgoing.map((envelope) => {
+                const target = directTarget(envelope);
+                return target
+                    ? this.#enqueue(envelope, target, true)
+                    : Promise.resolve(Object.freeze({
+                        accepted: false,
+                        messageId: envelope.messageId,
+                        reasonCode: 'audience_not_direct',
+                    }));
+            }));
+            return Object.freeze({
+                state: result.state,
+                effects: result.effects,
+                receipts: Object.freeze(receipts),
+            });
+        }
+        finally {
+            this.#activeDispatches -= 1;
+            this.#resolveCloseIfQuiescent();
+        }
+    }
+    #enqueue(envelope, target, internal = false) {
+        if (this.#closed && !internal) {
+            return Promise.resolve(Object.freeze({
+                accepted: false,
+                messageId: envelope.messageId,
+                reasonCode: 'transport_closed',
+                target,
+            }));
+        }
+        const byteLength = envelopeByteLength(envelope);
+        if (this.#queue.length + this.#inFlight >= this.#maximumQueueDepth ||
+            this.#queuedBytes + this.#inFlightBytes + byteLength >
+                this.#maximumQueuedBytes) {
+            return Promise.resolve(Object.freeze({
+                accepted: false,
+                messageId: envelope.messageId,
+                reasonCode: 'queue_capacity_exceeded',
+                target,
+            }));
+        }
+        return new Promise((resolve) => {
+            this.#insertionSequence += 1;
+            this.#queue.push({
+                insertionSequence: this.#insertionSequence,
+                envelope,
+                target,
+                byteLength,
+                resolve,
+            });
+            this.#queuedBytes += byteLength;
+            this.#scheduleDrain();
+        });
+    }
+    #scheduleDrain() {
+        if (this.#draining)
+            return;
+        this.#draining = true;
+        void Promise.resolve().then(() => this.#drain());
+    }
+    async #drain() {
+        try {
+            while (this.#queue.length > 0) {
+                const job = this.#queue.shift();
+                if (!job)
+                    break;
+                this.#queuedBytes -= job.byteLength;
+                this.#inFlight = 1;
+                this.#inFlightBytes = job.byteLength;
+                const peer = this.#peers.get(addressKey(job.target));
+                if (!peer) {
+                    job.resolve(Object.freeze({
+                        accepted: false,
+                        messageId: job.envelope.messageId,
+                        reasonCode: 'endpoint_not_found',
+                        target: job.target,
+                    }));
+                    this.#inFlight = 0;
+                    this.#inFlightBytes = 0;
+                    continue;
+                }
+                let result;
+                try {
+                    result = await peer.accept(job.envelope);
+                }
+                catch {
+                    result = {
+                        receipt: Object.freeze({
+                            accepted: false,
+                            messageId: job.envelope.messageId,
+                            reasonCode: 'endpoint_failed',
+                            target: job.target,
+                        }),
+                        outgoing: Object.freeze([]),
+                    };
+                }
+                // Acceptance has completed, so its bounded processing slot can be
+                // handed directly to any causal descendant produced by that
+                // transition (for example, a ping acknowledgement).
+                this.#inFlight = 0;
+                this.#inFlightBytes = 0;
+                job.resolve(result.receipt);
+                for (const outgoing of result.outgoing) {
+                    const target = directTarget(outgoing);
+                    if (target)
+                        void this.#enqueue(outgoing, target, true);
+                }
+            }
+        }
+        finally {
+            this.#draining = false;
+            if (this.#queue.length > 0) {
+                this.#scheduleDrain();
+            }
+            else {
+                for (const resolve of this.#idleWaiters.splice(0))
+                    resolve();
+            }
+            this.#resolveCloseIfQuiescent();
+        }
+    }
+    get maximumInternalStepsPerTransition() {
+        return this.#maximumInternalStepsPerTransition;
+    }
+    #resolveCloseIfQuiescent() {
+        if (this.#closed &&
+            this.#activeDispatches === 0 &&
+            !this.#draining &&
+            this.#queue.length === 0) {
+            this.#resolveClose?.();
+            this.#resolveClose = undefined;
+        }
+    }
+}
+class LoopbackPeer {
+    address;
+    #transport;
+    #options;
+    #prepared = new Map();
+    #state;
+    #outboundSequence;
+    #tail = Promise.resolve();
+    constructor(transport, options) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('Mesh loopback peer options are required');
+        }
+        this.#transport = transport;
+        this.#options = options;
+        this.#state = options.state;
+        this.address = freezeAddress(options.state.identity);
+        this.#outboundSequence = options.outboundSequence ?? 0;
+        if (!Number.isSafeInteger(this.#outboundSequence) ||
+            this.#outboundSequence < 0) {
+            throw new RangeError('Invalid Mesh loopback outbound sequence');
+        }
+    }
+    getState() {
+        return this.#state;
+    }
+    snapshot() {
+        return Object.freeze({
+            state: this.#state,
+            outboundSequence: this.#outboundSequence,
+        });
+    }
+    dispatch(input) {
+        return this.#transport.dispatchFrom(this, input);
+    }
+    applyLocal(input) {
+        return this.#exclusive(async () => {
+            const time = freezeTime(this.#options.clock.now());
+            const transition = reduceMeshPeer(this.#state, input, time.logicalTime);
+            this.#state = transition.state;
+            const interpreted = await this.#interpret(transition.effects, time);
+            return Object.freeze({
+                state: this.#state,
+                effects: transition.effects,
+                outgoing: interpreted,
+            });
+        });
+    }
+    accept(envelope) {
+        return this.#exclusive(async () => {
+            const time = freezeTime(this.#options.clock.now());
+            const decision = await processMeshEnvelope(this.#state, {
+                envelope,
+                verifiedAt: time.timestamp,
+                receivedAt: time.logicalTime,
+                verifier: this.#options.verifier,
+                resolver: this.#options.resolver,
+                cryptoPolicy: this.#options.cryptoPolicy,
+                admissionPolicy: this.#options.admissionPolicy ??
+                    ALLOW_PREPROVISIONED_MESH_ADMISSION,
+                crypto: this.#options.crypto,
+                protocolOptions: this.#options.protocolOptions,
+                supportedCriticalExtensions: this.#options.supportedCriticalExtensions,
+            });
+            if (!decision.accepted) {
+                return Object.freeze({
+                    receipt: Object.freeze({
+                        accepted: false,
+                        messageId: envelope.messageId,
+                        reasonCode: decision.code,
+                        target: this.address,
+                    }),
+                    outgoing: Object.freeze([]),
+                });
+            }
+            this.#state = decision.state;
+            const outgoing = await this.#interpret(decision.effects, time);
+            return Object.freeze({
+                receipt: Object.freeze({
+                    accepted: true,
+                    messageId: envelope.messageId,
+                    target: this.address,
+                }),
+                outgoing,
+            });
+        });
+    }
+    async #interpret(initialEffects, time) {
+        const effects = [...initialEffects];
+        const outgoing = [];
+        for (let index = 0; index < effects.length; index += 1) {
+            if (index >= this.#transport.maximumInternalStepsPerTransition) {
+                throw new RangeError('Mesh loopback internal step limit exceeded');
+            }
+            const effect = effects[index];
+            this.#observe(effect);
+            if (effect.kind === 'message.prepare') {
+                let transition;
+                try {
+                    const envelope = await this.#prepare(effect, time);
+                    this.#prepared.set(effect.effectId, envelope);
+                    transition = reduceMeshPeer(this.#state, Object.freeze({
+                        kind: 'effect.result',
+                        effectId: effect.effectId,
+                        status: 'succeeded',
+                        preparedMessage: Object.freeze({
+                            messageId: envelope.messageId,
+                            type: envelope.type,
+                            audiencePeerId: effect.intent.audiencePeerId,
+                            expiresAt: time.logicalTime + effect.intent.maximumLifetimeMs,
+                        }),
+                    }), time.logicalTime);
+                }
+                catch {
+                    transition = reduceMeshPeer(this.#state, Object.freeze({
+                        kind: 'effect.result',
+                        effectId: effect.effectId,
+                        status: 'failed',
+                        errorCode: 'preparation_failed',
+                    }), time.logicalTime);
+                }
+                this.#state = transition.state;
+                effects.push(...transition.effects);
+            }
+            else if (effect.kind === 'message.deliver') {
+                const envelope = this.#prepared.get(effect.preparationEffectId);
+                if (!envelope ||
+                    envelope.messageId !== effect.messageId ||
+                    envelope.audience.kind !== 'peer' ||
+                    envelope.audience.peerId !== effect.audiencePeerId) {
+                    throw new TypeError('Mesh loopback delivery lacks prepared bytes');
+                }
+                this.#prepared.delete(effect.preparationEffectId);
+                outgoing.push(envelope);
+            }
+        }
+        return Object.freeze(outgoing);
+    }
+    dispose() {
+        this.#prepared.clear();
+    }
+    async #prepare(effect, time) {
+        if (this.#outboundSequence >= Number.MAX_SAFE_INTEGER) {
+            throw new RangeError('Mesh loopback outbound sequence exhausted');
+        }
+        if (time.logicalTime >
+            Number.MAX_SAFE_INTEGER - effect.intent.maximumLifetimeMs) {
+            throw new RangeError('Mesh loopback logical expiry overflow');
+        }
+        this.#outboundSequence += 1;
+        const messageId = (this.#options.messageIds ?? defaultMessageIdSource(this.#options.crypto)).nextMessageId();
+        const sentAtMilliseconds = Date.parse(time.timestamp);
+        if (!Number.isFinite(sentAtMilliseconds)) {
+            throw new TypeError('Invalid Mesh loopback timestamp');
+        }
+        const expiresAt = new Date(sentAtMilliseconds + effect.intent.maximumLifetimeMs).toISOString();
+        const intent = effect.intent;
+        const unsigned = {
+            protocol: MESH_PROTOCOL,
+            wireVersion: MESH_WIRE_VERSION,
+            messageId,
+            tenantId: this.#state.identity.tenantId,
+            meshId: this.#state.identity.meshId,
+            type: intent.type,
+            sender: Object.freeze({
+                peerId: this.#state.identity.peerId,
+                instanceId: this.#state.identity.instanceId,
+            }),
+            audience: Object.freeze({
+                kind: 'peer',
+                peerId: intent.audiencePeerId,
+            }),
+            sequence: this.#outboundSequence,
+            sentAt: time.timestamp,
+            expiresAt,
+            payload: intent.payload,
+            proof: Object.freeze({
+                algorithm: MESH_SIGNATURE_ALGORITHM,
+                keyId: this.#state.identity.keyId,
+            }),
+            ...(intent.objectiveId === undefined
+                ? {}
+                : { objectiveId: intent.objectiveId }),
+            ...(intent.causationId === undefined
+                ? {}
+                : { causationId: intent.causationId }),
+            ...(intent.correlationId === undefined
+                ? {}
+                : { correlationId: intent.correlationId }),
+        };
+        return this.#options.signer.sign({
+            envelope: unsigned,
+            privateKey: this.#options.privateKey,
+            crypto: this.#options.crypto,
+            protocolOptions: this.#options.protocolOptions,
+        });
+    }
+    #observe(effect) {
+        try {
+            this.#options.onEffect?.(effect);
+        }
+        catch {
+            // Observability cannot reverse a committed peer decision.
+        }
+    }
+    #exclusive(operation) {
+        const result = this.#tail.then(operation, operation);
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}
+function directTarget(envelope) {
+    if (!envelope ||
+        typeof envelope !== 'object' ||
+        envelope.audience?.kind !== 'peer') {
+        return undefined;
+    }
+    return Object.freeze({
+        tenantId: envelope.tenantId,
+        meshId: envelope.meshId,
+        peerId: envelope.audience.peerId,
+    });
+}
+function freezeAddress(value) {
+    if (!value ||
+        typeof value.tenantId !== 'string' ||
+        typeof value.meshId !== 'string' ||
+        typeof value.peerId !== 'string') {
+        throw new TypeError('Invalid Mesh loopback address');
+    }
+    return Object.freeze({
+        tenantId: value.tenantId,
+        meshId: value.meshId,
+        peerId: value.peerId,
+    });
+}
+function freezeTime(value) {
+    if (!value ||
+        !Number.isSafeInteger(value.logicalTime) ||
+        value.logicalTime < 0 ||
+        typeof value.timestamp !== 'string') {
+        throw new TypeError('Invalid Mesh loopback time sample');
+    }
+    return Object.freeze({
+        logicalTime: value.logicalTime,
+        timestamp: value.timestamp,
+    });
+}
+function addressKey(address) {
+    return JSON.stringify([address.tenantId, address.meshId, address.peerId]);
+}
+function defaultMessageIdSource(cryptoOverride) {
+    const cryptoProvider = cryptoOverride ?? globalThis.crypto;
+    return {
+        nextMessageId() {
+            if (!cryptoProvider?.getRandomValues) {
+                throw new Error('Mesh loopback message ID source is unavailable');
+            }
+            const bytes = cryptoProvider.getRandomValues(new Uint8Array(16));
+            return encodeBase64Url(bytes);
+        },
+    };
+}
+function encodeBase64Url(bytes) {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+    let output = '';
+    for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index];
+        const second = bytes[index + 1];
+        const third = bytes[index + 2];
+        const combined = (first << 16) | ((second ?? 0) << 8) | (third ?? 0);
+        output += alphabet[(combined >>> 18) & 63];
+        output += alphabet[(combined >>> 12) & 63];
+        if (second !== undefined)
+            output += alphabet[(combined >>> 6) & 63];
+        if (third !== undefined)
+            output += alphabet[combined & 63];
+    }
+    return output;
+}
+const envelopeEncoder = new TextEncoder();
+function envelopeByteLength(envelope) {
+    try {
+        return envelopeEncoder.encode(JSON.stringify(envelope)).byteLength;
+    }
+    catch {
+        return Number.MAX_SAFE_INTEGER;
+    }
+}
+//# sourceMappingURL=loopback.js.map