@zlink-systems/framework 0.10.0

package/dist/runtime/channels/channel-receive-loops.js

@@ -0,0 +1,728 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRouteReceiveLoop = exports.ZLinkSubscriberReceiveLoop = exports.ZLinkChannelReceiveLoop = exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT = exports.ZLinkReceiveRoundRobinCoordinator = void 0;
+const channel_envelope_1 = require("./channel-envelope");
+const channel_envelope_inspection_1 = require("./channel-envelope-inspection");
+const channel_receive_task_tracker_1 = require("./channel-receive-task-tracker");
+const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
+//  The loop awaits between reads and the signal can abort in that gap. Reading
+//  through a function keeps the later check honest; an inline read stays
+//  narrowed by the loop condition and the comparison is rejected as dead.
+function signalAborted(signal) {
+    return signal?.aborted === true;
+}
+class ZLinkReceiveRoundRobinCoordinator {
+    owners = [];
+    cursor = 0;
+    active;
+    rawReceiveReservations = new ZLinkRawReceiveReservationPool(exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT);
+    register() {
+        const token = Symbol('receive-owner');
+        this.owners.push({ token, ready: false });
+        return token;
+    }
+    setReady(token, ready) {
+        const owner = this.owners.find(candidate => candidate.token === token);
+        if (owner !== undefined)
+            owner.ready = ready;
+    }
+    tryAcquire(token) {
+        if (this.active !== undefined)
+            return this.active === token;
+        const selected = this.nextReadyOwner();
+        if (selected?.token !== token)
+            return false;
+        this.active = token;
+        return true;
+    }
+    release(token) {
+        if (this.active !== token)
+            return;
+        const index = this.owners.findIndex(owner => owner.token === token);
+        this.active = undefined;
+        if (this.owners.length > 0)
+            this.cursor = (index + 1) % this.owners.length;
+    }
+    tryAcquireRawReceiveReservation() {
+        return this.rawReceiveReservations.tryAcquire();
+    }
+    unregister(token) {
+        const index = this.owners.findIndex(owner => owner.token === token);
+        if (index < 0)
+            return;
+        if (this.active === token)
+            this.active = undefined;
+        this.owners.splice(index, 1);
+        if (this.owners.length === 0) {
+            this.cursor = 0;
+        }
+        else if (index < this.cursor) {
+            this.cursor -= 1;
+        }
+        else if (this.cursor >= this.owners.length) {
+            this.cursor = 0;
+        }
+    }
+    nextReadyOwner() {
+        for (let offset = 0; offset < this.owners.length; offset += 1) {
+            const owner = this.owners[(this.cursor + offset) % this.owners.length];
+            if (owner.ready)
+                return owner;
+        }
+        return undefined;
+    }
+}
+exports.ZLinkReceiveRoundRobinCoordinator = ZLinkReceiveRoundRobinCoordinator;
+exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT = 16;
+class ZLinkRawReceiveReservationPool {
+    limit;
+    active = 0;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    tryAcquire() {
+        if (this.active >= this.limit)
+            return undefined;
+        this.active += 1;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.active -= 1;
+        };
+    }
+}
+class ZLinkChannelReceiveLoop {
+    channelName;
+    router;
+    dispatcher;
+    spotRouteBridge;
+    infrastructureHandler;
+    poller;
+    applicationJobQueue;
+    roundRobin;
+    //  The loop awaits between the two reads and stop() can land in that gap.
+    //  Reading through a method keeps the second check honest; a field read stays
+    //  narrowed to false across the await and is treated as dead code.
+    stoppedFlag = false;
+    isStopped() {
+        return this.stoppedFlag;
+    }
+    running;
+    inFlight;
+    receiveOwner;
+    rawReceiveReservations;
+    capacityStop = new AbortController();
+    constructor(channelName, router, dispatcher, spotRouteBridge, infrastructureHandler, poller, applicationJobQueue, reportError, roundRobin) {
+        this.channelName = channelName;
+        this.router = router;
+        this.dispatcher = dispatcher;
+        this.spotRouteBridge = spotRouteBridge;
+        this.infrastructureHandler = infrastructureHandler;
+        this.poller = poller;
+        this.applicationJobQueue = applicationJobQueue;
+        this.roundRobin = roundRobin;
+        this.inFlight = new channel_receive_task_tracker_1.ZLinkReceiveTaskTracker(reportError);
+        this.receiveOwner = roundRobin?.register() ?? Symbol('channel-receive-owner');
+        this.rawReceiveReservations = new ZLinkRawReceiveReservationPool(exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT);
+    }
+    async run(signal) {
+        if (this.running !== undefined) {
+            return this.running;
+        }
+        const running = this.runLoop(signal);
+        this.running = running;
+        try {
+            await running;
+        }
+        finally {
+            if (this.running === running) {
+                this.running = undefined;
+            }
+        }
+    }
+    async runLoop(signal) {
+        const batch = new ZLinkReceiveBatchBudget();
+        const capacitySignal = signal === undefined
+            ? this.capacityStop.signal
+            : AbortSignal.any([signal, this.capacityStop.signal]);
+        while (!this.isStopped() && signal?.aborted !== true) {
+            if (!this.poller.wait(0)) {
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            const applicationJobPermit = await this.acquirePermit(capacitySignal);
+            if (applicationJobPermit === undefined)
+                break;
+            if (!this.poller.wait(0)) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            this.roundRobin?.setReady(this.receiveOwner, true);
+            if (this.roundRobin?.tryAcquire(this.receiveOwner) === false) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                await waitReceiveLoopTurn();
+                continue;
+            }
+            const releaseRawReceive = this.roundRobin === undefined
+                ? this.rawReceiveReservations.tryAcquire()
+                : this.roundRobin.tryAcquireRawReceiveReservation();
+            if (releaseRawReceive === undefined) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                this.roundRobin?.release(this.receiveOwner);
+                await waitReceiveLoopTurn();
+                continue;
+            }
+            const received = this.router.recv(1);
+            if (received == null) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            const receivedBytes = messageBytes(received.parts);
+            let classification;
+            try {
+                classification = this.classify(received);
+            }
+            catch (error) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                received.close();
+                this.inFlight.track(Promise.reject(error));
+                continue;
+            }
+            if (classification.kind === 'consumed') {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                if (classification.closeReceived)
+                    received.close();
+                if (batch.record(receivedBytes)) {
+                    this.roundRobin?.release(this.receiveOwner);
+                    await batch.yieldAndReset();
+                }
+                continue;
+            }
+            if (this.isStopped() || signalAborted(signal)) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                received.close();
+                break;
+            }
+            applicationJobPermit.markApplicationQueued();
+            const task = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, () => this.dispatchAndClose(received, signal, classification.decodedHeader, true));
+            releaseRawReceive();
+            this.inFlight.track(task);
+            if (batch.record(receivedBytes)) {
+                this.roundRobin?.release(this.receiveOwner);
+                await batch.yieldAndReset();
+            }
+        }
+    }
+    async stop() {
+        this.stoppedFlag = true;
+        this.capacityStop.abort();
+        try {
+            await this.running;
+            await this.inFlight.waitForAll();
+        }
+        finally {
+            this.roundRobin?.unregister(this.receiveOwner);
+            this.poller.dispose();
+        }
+    }
+    async acquirePermit(signal) {
+        try {
+            return await this.applicationJobQueue.acquire(signal);
+        }
+        catch (error) {
+            if (this.isStopped() || signal.aborted)
+                return undefined;
+            throw error;
+        }
+    }
+    async dispatchAndClose(received, signal, decodedHeader, infrastructureChecked = false, releaseRawReceive) {
+        let closeReceived = true;
+        try {
+            if (!infrastructureChecked) {
+                const classification = this.classify(received);
+                if (classification.kind === 'consumed') {
+                    closeReceived = classification.closeReceived;
+                    return;
+                }
+                decodedHeader = classification.decodedHeader;
+            }
+            const consumed = await this.dispatcher.dispatch(received, this.router, signal, decodedHeader);
+            if (consumed === true) {
+                closeReceived = false;
+            }
+        }
+        finally {
+            releaseRawReceive?.();
+            if (closeReceived) {
+                received.close();
+            }
+        }
+    }
+    classify(received) {
+        if (this.infrastructureHandler?.(received, this.router) === true) {
+            return { kind: 'consumed', closeReceived: true };
+        }
+        const decodedHeader = (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(received.parts, this.dispatcher.flowEnabled?.() ?? true);
+        if (decodedHeader === undefined
+            && this.spotRouteBridge?.handleRouterReceived(this.channelName, received.routingId, 0n, received.parts) === true) {
+            return { kind: 'consumed', closeReceived: false };
+        }
+        return { kind: 'application', decodedHeader };
+    }
+}
+exports.ZLinkChannelReceiveLoop = ZLinkChannelReceiveLoop;
+class ZLinkSubscriberReceiveLoop {
+    adapter;
+    subscriber;
+    dispatcher;
+    applicationJobQueue;
+    infrastructureHandler;
+    roundRobin;
+    //  The loop awaits between the two reads and stop() can land in that gap.
+    //  Reading through a method keeps the second check honest; a field read stays
+    //  narrowed to false across the await and is treated as dead code.
+    stoppedFlag = false;
+    isStopped() {
+        return this.stoppedFlag;
+    }
+    running;
+    inFlight;
+    receiveOwner;
+    rawReceiveReservations;
+    capacityStop = new AbortController();
+    constructor(adapter, subscriber, dispatcher, applicationJobQueue, infrastructureHandler, roundRobin, reportError) {
+        this.adapter = adapter;
+        this.subscriber = subscriber;
+        this.dispatcher = dispatcher;
+        this.applicationJobQueue = applicationJobQueue;
+        this.infrastructureHandler = infrastructureHandler;
+        this.roundRobin = roundRobin;
+        this.inFlight = new channel_receive_task_tracker_1.ZLinkReceiveTaskTracker(reportError);
+        this.poller = adapter.createReadablePoller(subscriber);
+        this.receiveOwner = roundRobin?.register() ?? Symbol('subscriber-receive-owner');
+        this.rawReceiveReservations = new ZLinkRawReceiveReservationPool(exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT);
+    }
+    poller;
+    async run(signal) {
+        if (this.running !== undefined) {
+            return this.running;
+        }
+        const running = this.runLoop(signal);
+        this.running = running;
+        try {
+            await running;
+        }
+        finally {
+            if (this.running === running) {
+                this.running = undefined;
+            }
+        }
+    }
+    async runLoop(signal) {
+        const batch = new ZLinkReceiveBatchBudget();
+        const capacitySignal = signal === undefined
+            ? this.capacityStop.signal
+            : AbortSignal.any([signal, this.capacityStop.signal]);
+        while (!this.isStopped() && signal?.aborted !== true) {
+            if (!this.poller.wait(0)) {
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            const applicationJobPermit = await this.acquirePermit(capacitySignal);
+            if (applicationJobPermit === undefined)
+                break;
+            if (!this.poller.wait(0)) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            this.roundRobin?.setReady(this.receiveOwner, true);
+            if (this.roundRobin?.tryAcquire(this.receiveOwner) === false) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                await waitReceiveLoopTurn();
+                continue;
+            }
+            const releaseRawReceive = this.roundRobin === undefined
+                ? this.rawReceiveReservations.tryAcquire()
+                : this.roundRobin.tryAcquireRawReceiveReservation();
+            if (releaseRawReceive === undefined) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                this.roundRobin?.release(this.receiveOwner);
+                await waitReceiveLoopTurn();
+                continue;
+            }
+            const topicMessage = this.adapter.createTopicMessage();
+            if (!this.subscriber.subscribe(topicMessage)) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                topicMessage.close();
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            const receivedBytes = messageBytes(topicMessage.parts);
+            let classification;
+            try {
+                classification = this.classify(topicMessage);
+            }
+            catch (error) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                (0, channel_envelope_1.closeMessages)(topicMessage.parts);
+                this.inFlight.track(Promise.reject(error));
+                continue;
+            }
+            if (classification.kind === 'consumed') {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                (0, channel_envelope_1.closeMessages)(topicMessage.parts);
+                if (batch.record(receivedBytes)) {
+                    this.roundRobin?.release(this.receiveOwner);
+                    await batch.yieldAndReset();
+                }
+                continue;
+            }
+            if (this.isStopped() || signalAborted(signal)) {
+                applicationJobPermit.releaseAfterInternalProcessing();
+                releaseRawReceive();
+                (0, channel_envelope_1.closeMessages)(topicMessage.parts);
+                break;
+            }
+            applicationJobPermit.markApplicationQueued();
+            const task = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, () => this.dispatchAndClose(topicMessage, signal, classification.decodedHeader, true));
+            releaseRawReceive();
+            this.inFlight.track(task);
+            if (batch.record(receivedBytes)) {
+                this.roundRobin?.release(this.receiveOwner);
+                await batch.yieldAndReset();
+            }
+        }
+    }
+    async stop() {
+        this.stoppedFlag = true;
+        this.capacityStop.abort();
+        try {
+            await this.running;
+            await this.inFlight.waitForAll();
+        }
+        finally {
+            this.roundRobin?.unregister(this.receiveOwner);
+            this.poller.dispose();
+        }
+    }
+    async acquirePermit(signal) {
+        try {
+            return await this.applicationJobQueue.acquire(signal);
+        }
+        catch (error) {
+            if (this.isStopped() || signal.aborted)
+                return undefined;
+            throw error;
+        }
+    }
+    async dispatchAndClose(topicMessage, signal, decodedHeader, infrastructureChecked = false, releaseRawReceive) {
+        try {
+            if (!infrastructureChecked) {
+                const classification = this.classify(topicMessage);
+                if (classification.kind === 'consumed')
+                    return;
+                decodedHeader = classification.decodedHeader;
+            }
+            await this.dispatcher.dispatch(topicMessage, signal, decodedHeader);
+        }
+        finally {
+            releaseRawReceive?.();
+            (0, channel_envelope_1.closeMessages)(topicMessage.parts);
+        }
+    }
+    classify(topicMessage) {
+        const infrastructureResult = this.infrastructureHandler?.(topicMessage);
+        const decodedHeader = typeof infrastructureResult === 'object'
+            ? infrastructureResult.decodedHeader
+            : undefined;
+        if (infrastructureResult === true
+            || (typeof infrastructureResult === 'object' && infrastructureResult.consumed)) {
+            return { kind: 'consumed' };
+        }
+        return { kind: 'application', decodedHeader };
+    }
+}
+exports.ZLinkSubscriberReceiveLoop = ZLinkSubscriberReceiveLoop;
+class ZLinkRouteReceiveLoop {
+    router;
+    dispatcher;
+    poller;
+    applicationJobQueue;
+    roundRobin;
+    //  The loop awaits between the two reads and stop() can land in that gap.
+    //  Reading through a method keeps the second check honest; a field read stays
+    //  narrowed to false across the await and is treated as dead code.
+    stoppedFlag = false;
+    isStopped() {
+        return this.stoppedFlag;
+    }
+    running;
+    inFlight;
+    receiveOwner;
+    rawReceiveReservations;
+    capacityStop = new AbortController();
+    constructor(router, dispatcher, poller, applicationJobQueue, roundRobin, reportError) {
+        this.router = router;
+        this.dispatcher = dispatcher;
+        this.poller = poller;
+        this.applicationJobQueue = applicationJobQueue;
+        this.roundRobin = roundRobin;
+        this.inFlight = new channel_receive_task_tracker_1.ZLinkReceiveTaskTracker(reportError);
+        this.receiveOwner = roundRobin?.register() ?? Symbol('route-receive-owner');
+        this.rawReceiveReservations = new ZLinkRawReceiveReservationPool(exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT);
+    }
+    async run(signal) {
+        if (this.running !== undefined) {
+            return this.running;
+        }
+        const running = this.runLoop(signal);
+        this.running = running;
+        try {
+            await running;
+        }
+        finally {
+            if (this.running === running) {
+                this.running = undefined;
+            }
+        }
+    }
+    async runLoop(signal) {
+        const batch = new ZLinkReceiveBatchBudget();
+        const capacitySignal = signal === undefined
+            ? this.capacityStop.signal
+            : AbortSignal.any([signal, this.capacityStop.signal]);
+        while (!this.isStopped() && signal?.aborted !== true) {
+            if (!this.poller.wait(0)) {
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            if (!this.poller.wait(0)) {
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            this.roundRobin?.setReady(this.receiveOwner, true);
+            if (this.roundRobin?.tryAcquire(this.receiveOwner) === false) {
+                await waitReceiveLoopTurn();
+                continue;
+            }
+            const releaseRawReceive = this.roundRobin === undefined
+                ? this.rawReceiveReservations.tryAcquire()
+                : this.roundRobin.tryAcquireRawReceiveReservation();
+            if (releaseRawReceive === undefined) {
+                this.roundRobin?.release(this.receiveOwner);
+                await waitReceiveLoopTurn();
+                continue;
+            }
+            const received = this.router.recv(1);
+            if (received == null) {
+                releaseRawReceive();
+                this.roundRobin?.setReady(this.receiveOwner, false);
+                this.roundRobin?.release(this.receiveOwner);
+                batch.reset();
+                await waitReceiveLoopIdle();
+                continue;
+            }
+            const receivedBytes = messageBytes(received.parts);
+            let infrastructure;
+            try {
+                infrastructure = this.dispatcher.dispatchInfrastructure?.(received);
+            }
+            catch (error) {
+                releaseRawReceive();
+                received.close();
+                this.inFlight.track(Promise.reject(error));
+                continue;
+            }
+            if (infrastructure !== undefined && infrastructure !== false) {
+                if (infrastructure === true) {
+                    releaseRawReceive();
+                }
+                else {
+                    // submit() transfers the parts to Core before returning its admission
+                    // Promise. Track that terminal without serializing the single route
+                    // receiver; the held reservation bounds pending infrastructure sends.
+                    this.inFlight.track(infrastructure
+                        .catch(error => {
+                        received.close();
+                        throw error;
+                    })
+                        .finally(releaseRawReceive));
+                }
+                if (batch.record(receivedBytes)) {
+                    this.roundRobin?.release(this.receiveOwner);
+                    await batch.yieldAndReset();
+                }
+                continue;
+            }
+            if (this.isStopped() || signalAborted(signal)) {
+                releaseRawReceive();
+                received.close();
+                break;
+            }
+            let applicationJobPermit;
+            try {
+                applicationJobPermit = await this.acquirePermit(capacitySignal);
+            }
+            catch (error) {
+                releaseRawReceive();
+                received.close();
+                throw error;
+            }
+            if (applicationJobPermit === undefined) {
+                releaseRawReceive();
+                received.close();
+                break;
+            }
+            applicationJobPermit.markApplicationQueued();
+            const task = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, () => this.dispatchAndClose(received, signal, true));
+            releaseRawReceive();
+            this.inFlight.track(task);
+            if (batch.record(receivedBytes)) {
+                this.roundRobin?.release(this.receiveOwner);
+                await batch.yieldAndReset();
+            }
+        }
+    }
+    async stop() {
+        this.stoppedFlag = true;
+        this.capacityStop.abort();
+        try {
+            await this.running;
+            await this.inFlight.waitForAll();
+        }
+        finally {
+            this.roundRobin?.unregister(this.receiveOwner);
+            this.poller.dispose();
+        }
+    }
+    async acquirePermit(signal) {
+        try {
+            return await this.applicationJobQueue.acquire(signal);
+        }
+        catch (error) {
+            if (this.isStopped() || signal.aborted)
+                return undefined;
+            throw error;
+        }
+    }
+    async dispatchAndClose(received, signal, infrastructureChecked = false, releaseRawReceive) {
+        let closeReceived = true;
+        try {
+            const consumed = await this.dispatcher.dispatch(received, this.router, signal, (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(received.parts, this.dispatcher.flowEnabled?.() ?? true), infrastructureChecked);
+            if (consumed === true) {
+                closeReceived = false;
+            }
+        }
+        finally {
+            releaseRawReceive?.();
+            if (closeReceived) {
+                received.close();
+            }
+        }
+    }
+}
+exports.ZLinkRouteReceiveLoop = ZLinkRouteReceiveLoop;
+const RECEIVE_BATCH_MESSAGE_LIMIT = 64;
+const RECEIVE_BATCH_BYTE_LIMIT = 4n * 1024n * 1024n;
+const RECEIVE_BATCH_TIME_LIMIT_MS = 2;
+class ZLinkReceiveBatchBudget {
+    messages = 0;
+    bytes = 0n;
+    startedAt = performance.now();
+    record(bytes) {
+        this.messages += 1;
+        this.bytes += bytes;
+        return this.messages >= RECEIVE_BATCH_MESSAGE_LIMIT
+            || this.bytes >= RECEIVE_BATCH_BYTE_LIMIT
+            || performance.now() - this.startedAt >= RECEIVE_BATCH_TIME_LIMIT_MS;
+    }
+    async yieldAndReset() {
+        await new Promise(resolve => setImmediate(resolve));
+        this.reset();
+    }
+    reset() {
+        this.messages = 0;
+        this.bytes = 0n;
+        this.startedAt = performance.now();
+    }
+}
+class ZLinkSharedIdleWaiter {
+    delayMs;
+    pending;
+    resolvePending;
+    wake = () => {
+        const resolve = this.resolvePending;
+        this.pending = undefined;
+        this.resolvePending = undefined;
+        resolve?.();
+    };
+    constructor(delayMs) {
+        this.delayMs = delayMs;
+    }
+    wait() {
+        if (this.pending !== undefined)
+            return this.pending;
+        this.pending = new Promise((resolve) => {
+            this.resolvePending = resolve;
+        });
+        setTimeout(this.wake, this.delayMs);
+        return this.pending;
+    }
+}
+const CHANNEL_RECEIVE_IDLE_POLL_INTERVAL_MS = 5;
+const receiveLoopIdleWaiter = new ZLinkSharedIdleWaiter(CHANNEL_RECEIVE_IDLE_POLL_INTERVAL_MS);
+function waitReceiveLoopIdle() {
+    return receiveLoopIdleWaiter.wait();
+}
+function waitReceiveLoopTurn() {
+    return new Promise(resolve => setImmediate(resolve));
+}
+function messageBytes(parts) {
+    return parts.reduce((sum, part) => sum + messagePartBytes(part), 0n);
+}
+function messagePartBytes(part) {
+    if (part === undefined) {
+        return 0n;
+    }
+    const size = part.size;
+    if (typeof size === 'function') {
+        return BigInt(size.call(part));
+    }
+    return BigInt(part.data().byteLength);
+}