@zlink-systems/zlink 0.17.3

package/dist/zlink/runtime/errors/error_mapping.js

@@ -0,0 +1,132 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapNativeErrno = mapNativeErrno;
+exports.createError = createError;
+const errors_1 = require("../../contracts/errors/errors");
+const error_state_1 = require("./error_state");
+const ETERM = 156384765;
+function mapNativeErrno(category, errno) {
+    switch (category) {
+        case 'submit':
+            switch (errno) {
+                case 0: return errors_1.SubmitResult.Ok;
+                case 11: return errors_1.SubmitResult.Backpressured;
+                case 107:
+                case 113:
+                case 110: return errors_1.SubmitResult.NotConnected;
+                case 111: return errors_1.SubmitResult.NotAdmitted;
+                case 2: return errors_1.SubmitResult.NotFound;
+                case 125:
+                case 108:
+                case ETERM: return errors_1.SubmitResult.Terminated;
+                case 14: return errors_1.SubmitResult.InvalidHandle;
+                case 22: return errors_1.SubmitResult.InvalidArgument;
+                case 95:
+                case 93: return errors_1.SubmitResult.NotSupported;
+                case 16: return errors_1.SubmitResult.InvalidState;
+                case 35: return errors_1.SubmitResult.ThreadViolation;
+                case 12: return errors_1.SubmitResult.OutOfMemory;
+                case 75: return errors_1.SubmitResult.SeqExhausted;
+                default: return errors_1.SubmitResult.InternalError;
+            }
+        case 'request':
+            switch (errno) {
+                case 0: return errors_1.RequestResult.Ok;
+                case 110: return errors_1.RequestResult.TimedOut;
+                case 2: return errors_1.RequestResult.NotFound;
+                case 125:
+                case ETERM: return errors_1.RequestResult.Terminated;
+                case 111: return errors_1.RequestResult.Rejected;
+                case 17: return errors_1.RequestResult.Conflict;
+                case 16: return errors_1.RequestResult.Busy;
+                case 107:
+                case 113: return errors_1.RequestResult.NotConnected;
+                case 22: return errors_1.RequestResult.InvalidArgument;
+                case 95:
+                case 93: return errors_1.RequestResult.NotSupported;
+                default: return errors_1.RequestResult.ProtocolError;
+            }
+        case 'recv':
+            switch (errno) {
+                case 0: return errors_1.RecvResult.Ok;
+                case 11: return errors_1.RecvResult.NoData;
+                case 4: return errors_1.RecvResult.NoData;
+                case 16: return errors_1.RecvResult.Busy;
+                case 125: return errors_1.RecvResult.Terminated;
+                case 14: return errors_1.RecvResult.InvalidHandle;
+                default: return errors_1.RecvResult.InternalError;
+            }
+        case 'handler':
+            switch (errno) {
+                case 0: return errors_1.HandlerResult.Ok;
+                case 22: return errors_1.HandlerResult.InvalidArgument;
+                case 16: return errors_1.HandlerResult.Busy;
+                case 35: return errors_1.HandlerResult.Deadlock;
+                case 14: return errors_1.HandlerResult.InvalidHandle;
+                default: return errors_1.HandlerResult.InternalError;
+            }
+        case 'close':
+            switch (errno) {
+                case 0: return errors_1.CloseResult.Ok;
+                case 16: return errors_1.CloseResult.Busy;
+                case 108: return errors_1.CloseResult.Shutdown;
+                case 14: return errors_1.CloseResult.InvalidHandle;
+                default: return errors_1.CloseResult.InternalError;
+            }
+        case 'bind':
+            switch (errno) {
+                case 0: return errors_1.BindResult.Ok;
+                case 22: return errors_1.BindResult.InvalidArgument;
+                case 98: return errors_1.BindResult.AddrInUse;
+                case 95:
+                case 93: return errors_1.BindResult.NotSupported;
+                case 14: return errors_1.BindResult.InvalidHandle;
+                default: return errors_1.BindResult.InternalError;
+            }
+        case 'connect':
+            switch (errno) {
+                case 0: return errors_1.ConnectResult.Ok;
+                case 22: return errors_1.ConnectResult.InvalidArgument;
+                case 95:
+                case 93: return errors_1.ConnectResult.NotSupported;
+                case 14: return errors_1.ConnectResult.InvalidHandle;
+                case 2: return errors_1.ConnectResult.NotFound;
+                case 17: return errors_1.ConnectResult.Conflict;
+                case 16: return errors_1.ConnectResult.Busy;
+                default: return errors_1.ConnectResult.InternalError;
+            }
+        case 'config':
+            switch (errno) {
+                case 0: return errors_1.ConfigResult.Ok;
+                case 14: return errors_1.ConfigResult.InvalidHandle;
+                case 22: return errors_1.ConfigResult.InvalidArgument;
+                case 95:
+                case 93: return errors_1.ConfigResult.NotSupported;
+                case 16: return errors_1.ConfigResult.InvalidState;
+                case 2: return errors_1.ConfigResult.NotFound;
+                default: return errors_1.ConfigResult.InternalError;
+            }
+    }
+}
+function createError(category, errno, message) {
+    const code = mapNativeErrno(category, errno);
+    switch (category) {
+        case 'submit':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.SubmitError(code, errno), message);
+        case 'request':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.RequestError(code, errno), message);
+        case 'recv':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.RecvError(code, errno), message);
+        case 'handler':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.HandlerError(code, errno), message);
+        case 'close':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.CloseError(code, errno), message);
+        case 'bind':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.BindError(code, errno), message);
+        case 'connect':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.ConnectError(code, errno), message);
+        case 'config':
+            return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.ConfigError(code, errno), message);
+    }
+}

package/dist/zlink/runtime/errors/error_state.d.ts

@@ -0,0 +1 @@
+export declare function withRuntimeErrorMessage<T extends Error>(error: T, message?: string): T;

package/dist/zlink/runtime/errors/error_state.js

@@ -0,0 +1,15 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRuntimeErrorMessage = withRuntimeErrorMessage;
+function withRuntimeErrorMessage(error, message) {
+    if (!message) {
+        return error;
+    }
+    Object.defineProperty(error, 'message', {
+        value: message,
+        configurable: true,
+        writable: true
+    });
+    return error;
+}

package/dist/zlink/runtime/errors/native_errors.d.ts

@@ -0,0 +1,16 @@
+import { RecvFlags, SendFlags } from '../../contracts/sockets/socket_constants';
+import { RecvError, SubmitError, ZlinkError } from '../../contracts/errors/errors';
+import { type NativeErrorCategory } from './error_mapping';
+export declare function readErrno(): number;
+export declare function isWouldBlock(errno?: number): boolean;
+export declare function nativeErrorMessage(error: unknown, fallbackMessage: string): string;
+export declare function lastError(category: NativeErrorCategory, message: string): ZlinkError;
+export declare function nativeCall<T>(category: NativeErrorCategory, fallbackMessage: string, fn: () => T): T;
+export declare function bindCall<T>(fallbackMessage: string, fn: () => T): T;
+export declare function connectCall<T>(fallbackMessage: string, fn: () => T): T;
+export declare function configCall<T>(fallbackMessage: string, fn: () => T): T;
+export declare function handlerCall<T>(fallbackMessage: string, fn: () => T): T;
+export declare function closeCall<T>(fallbackMessage: string, fn: () => T): T;
+export declare function recvNativeError(error: unknown, flags: RecvFlags, fallbackMessage: string): RecvError;
+export declare function submitNativeError(error: unknown, flags: SendFlags, fallbackMessage: string): SubmitError;
+export declare function submitOrBackpressure(error: unknown, flags: SendFlags, fallbackMessage: string): false;

package/dist/zlink/runtime/errors/native_errors.js

@@ -0,0 +1,86 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readErrno = readErrno;
+exports.isWouldBlock = isWouldBlock;
+exports.nativeErrorMessage = nativeErrorMessage;
+exports.lastError = lastError;
+exports.nativeCall = nativeCall;
+exports.bindCall = bindCall;
+exports.connectCall = connectCall;
+exports.configCall = configCall;
+exports.handlerCall = handlerCall;
+exports.closeCall = closeCall;
+exports.recvNativeError = recvNativeError;
+exports.submitNativeError = submitNativeError;
+exports.submitOrBackpressure = submitOrBackpressure;
+const native_1 = require("../native/native");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+const errors_1 = require("../../contracts/errors/errors");
+const error_mapping_1 = require("./error_mapping");
+const error_state_1 = require("./error_state");
+function readErrno() {
+    const native = (0, native_1.requireNative)();
+    return typeof native.errno === 'function' ? native.errno() : 0;
+}
+function isWouldBlock(errno = readErrno()) {
+    return errno === 11;
+}
+function nativeErrorMessage(error, fallbackMessage) {
+    return error instanceof Error && error.message ? error.message : fallbackMessage;
+}
+function lastError(category, message) {
+    return (0, error_mapping_1.createError)(category, readErrno(), message);
+}
+function nativeCall(category, fallbackMessage, fn) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        throw (0, error_mapping_1.createError)(category, readErrno(), nativeErrorMessage(error, fallbackMessage));
+    }
+}
+function bindCall(fallbackMessage, fn) {
+    return nativeCall('bind', fallbackMessage, fn);
+}
+function connectCall(fallbackMessage, fn) {
+    return nativeCall('connect', fallbackMessage, fn);
+}
+function configCall(fallbackMessage, fn) {
+    return nativeCall('config', fallbackMessage, fn);
+}
+function handlerCall(fallbackMessage, fn) {
+    return nativeCall('handler', fallbackMessage, fn);
+}
+function closeCall(fallbackMessage, fn) {
+    return nativeCall('close', fallbackMessage, fn);
+}
+function recvNativeError(error, flags, fallbackMessage) {
+    const message = nativeErrorMessage(error, fallbackMessage);
+    const errno = readErrno();
+    if ((flags & socket_constants_1.RecvFlags.DontWait) !== 0 && isWouldBlock(errno)) {
+        return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.RecvError(errors_1.RecvResult.NoData, errno), message);
+    }
+    return (0, error_mapping_1.createError)('recv', errno, message);
+}
+function submitNativeError(error, flags, fallbackMessage) {
+    const message = nativeErrorMessage(error, fallbackMessage);
+    const errno = readErrno();
+    const nativeResult = typeof error === 'object' && error !== null
+        ? error.nativeResult
+        : undefined;
+    if (typeof nativeResult === 'number') {
+        return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.SubmitError(nativeResult, errno), message);
+    }
+    if ((flags & socket_constants_1.SendFlags.DontWait) !== 0 && isWouldBlock(errno)) {
+        return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.SubmitError(errors_1.SubmitResult.Backpressured, errno), message);
+    }
+    return (0, error_mapping_1.createError)('submit', errno, message);
+}
+function submitOrBackpressure(error, flags, fallbackMessage) {
+    const submitError = submitNativeError(error, flags, fallbackMessage);
+    if (((flags | 0) & (socket_constants_1.SendFlags.DontWait | 0)) && submitError.result === errors_1.SubmitResult.Backpressured) {
+        return false;
+    }
+    throw submitError;
+}

package/dist/zlink/runtime/eventing/counters.d.ts

@@ -0,0 +1,16 @@
+import { NativeHandle } from '../handles/native_handle';
+export declare class Stopwatch extends NativeHandle {
+    constructor();
+    intermediate(): number;
+    stop(): number;
+    close(): void;
+}
+export declare class AtomicCounter {
+    private _native;
+    constructor(initialValue?: number);
+    set(value: number): void;
+    inc(): number;
+    dec(): number;
+    value(): number;
+    close(): void;
+}

package/dist/zlink/runtime/eventing/counters.js

@@ -0,0 +1,33 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomicCounter = exports.Stopwatch = void 0;
+const native_1 = require("../native/native");
+const native_handle_1 = require("../handles/native_handle");
+class Stopwatch extends native_handle_1.NativeHandle {
+    constructor() { super((0, native_1.requireNative)().stopwatchStart()); }
+    intermediate() { return (0, native_1.requireNative)().stopwatchIntermediate(this._native); }
+    stop() { return (0, native_1.requireNative)().stopwatchStop(this._native); }
+    close() { this._native = null; }
+}
+exports.Stopwatch = Stopwatch;
+class AtomicCounter {
+    _native;
+    constructor(initialValue = 0) {
+        this._native = (0, native_1.requireNative)().atomicCounterNew();
+        if ((initialValue | 0) !== 0) {
+            this.set(initialValue);
+        }
+    }
+    set(value) { (0, native_1.requireNative)().atomicCounterSet(this._native, value | 0); }
+    inc() { return (0, native_1.requireNative)().atomicCounterInc(this._native); }
+    dec() { return (0, native_1.requireNative)().atomicCounterDec(this._native); }
+    value() { return (0, native_1.requireNative)().atomicCounterValue(this._native); }
+    close() {
+        if (this._native) {
+            (0, native_1.requireNative)().atomicCounterDestroy(this._native);
+            this._native = null;
+        }
+    }
+}
+exports.AtomicCounter = AtomicCounter;

package/dist/zlink/runtime/eventing/index.d.ts

@@ -0,0 +1,6 @@
+export { AtomicCounter, AtomicCounter as RuntimeAtomicCounter, Stopwatch, Stopwatch as RuntimeStopwatch, } from './counters';
+export { sleep } from '../core/runtime_info';
+export { Thread as RuntimeThread } from './thread';
+export { Poller, Poller as RuntimePoller, } from './poller';
+export { PollEvents, PollEvents as RuntimePollEvents, } from './poll_events';
+export { Timer, Timer as RuntimeTimer } from './timer';

package/dist/zlink/runtime/eventing/index.js

@@ -0,0 +1,22 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeTimer = exports.Timer = exports.RuntimePollEvents = exports.PollEvents = exports.RuntimePoller = exports.Poller = exports.RuntimeThread = exports.sleep = exports.RuntimeStopwatch = exports.Stopwatch = exports.RuntimeAtomicCounter = exports.AtomicCounter = void 0;
+var counters_1 = require("./counters");
+Object.defineProperty(exports, "AtomicCounter", { enumerable: true, get: function () { return counters_1.AtomicCounter; } });
+Object.defineProperty(exports, "RuntimeAtomicCounter", { enumerable: true, get: function () { return counters_1.AtomicCounter; } });
+Object.defineProperty(exports, "Stopwatch", { enumerable: true, get: function () { return counters_1.Stopwatch; } });
+Object.defineProperty(exports, "RuntimeStopwatch", { enumerable: true, get: function () { return counters_1.Stopwatch; } });
+var runtime_info_1 = require("../core/runtime_info");
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return runtime_info_1.sleep; } });
+var thread_1 = require("./thread");
+Object.defineProperty(exports, "RuntimeThread", { enumerable: true, get: function () { return thread_1.Thread; } });
+var poller_1 = require("./poller");
+Object.defineProperty(exports, "Poller", { enumerable: true, get: function () { return poller_1.Poller; } });
+Object.defineProperty(exports, "RuntimePoller", { enumerable: true, get: function () { return poller_1.Poller; } });
+var poll_events_1 = require("./poll_events");
+Object.defineProperty(exports, "PollEvents", { enumerable: true, get: function () { return poll_events_1.PollEvents; } });
+Object.defineProperty(exports, "RuntimePollEvents", { enumerable: true, get: function () { return poll_events_1.PollEvents; } });
+var timer_1 = require("./timer");
+Object.defineProperty(exports, "Timer", { enumerable: true, get: function () { return timer_1.Timer; } });
+Object.defineProperty(exports, "RuntimeTimer", { enumerable: true, get: function () { return timer_1.Timer; } });

package/dist/zlink/runtime/eventing/monitor_event_state.d.ts

@@ -0,0 +1,3 @@
+import { MonitorEvent } from '../../contracts/eventing/monitor';
+import type { MonitorEventValueRaw } from './monitor_raw';
+export declare function createMonitorEvent(raw: MonitorEventValueRaw): MonitorEvent;

package/dist/zlink/runtime/eventing/monitor_event_state.js

@@ -0,0 +1,19 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMonitorEvent = createMonitorEvent;
+const monitor_1 = require("../../contracts/eventing/monitor");
+const core_1 = require("../../contracts/core");
+function createMonitorEvent(raw) {
+    const event = Object.create(monitor_1.MonitorEvent.prototype);
+    const state = event;
+    state.event = raw.event;
+    state.value = raw.value ?? 0n;
+    state.routingId = raw.routingId && raw.routingId.length > 0 ? core_1.RoutingId.from(raw.routingId) : null;
+    state.localAddr = raw.localAddr ?? raw.local ?? '';
+    state.remoteAddr = raw.remoteAddr ?? raw.remote ?? '';
+    state.connectionId = raw.connectionId ?? 0n;
+    state.transportLane = raw.transportLane ?? 0;
+    state.flags = raw.flags ?? 0;
+    return event;
+}

package/dist/zlink/runtime/eventing/monitor_raw.d.ts

@@ -0,0 +1,50 @@
+export interface MonitorStatusRaw {
+    abiVersion: number;
+    structSize: number;
+    sourceKind: number;
+    stateFlags: number;
+    detailFlags: number;
+    sndPendingMsgs: bigint;
+    rcvPendingMsgs: bigint;
+    sndPendingBytes: bigint;
+    rcvPendingBytes: bigint;
+    autoHwmEnabled: boolean;
+    autoHwmProfile: number;
+    autoHwmRole: number;
+    autoHwmPolicyClass: number;
+    autoHwmPlannedSndHwmBytes: bigint;
+    autoHwmPlannedRcvHwmBytes: bigint;
+    autoHwmAppliedSndHwmBytes: bigint;
+    autoHwmAppliedRcvHwmBytes: bigint;
+    autoHwmEffectiveSndBuf?: number;
+    autoHwmEffectiveRcvBuf?: number;
+    autoHwmLastRecalcMs: bigint;
+    autoHwmLastRecalcReason: number;
+    autoHwmSendBlockedRatioPpm: number;
+    autoHwmDeferredSndHwmBytes: bigint;
+    autoHwmDeferredRcvHwmBytes: bigint;
+    autoHwmDeferredSndHwmValid: boolean;
+    autoHwmDeferredRcvHwmValid: boolean;
+    sndBytesInFlight: bigint;
+    rcvBytesInFlight: bigint;
+    minimumCoreMessageChargeBytes: bigint;
+    oversizeMessageAdmissionCount: bigint;
+    oversizeMessageAdmissionMaxBytes: bigint;
+    flowPausedConnections: bigint;
+    flowPauseAppliedTotal: bigint;
+    flowResumeAppliedTotal: bigint;
+    flowStateStaleTotal: bigint;
+    flowPauseDurationMs: bigint;
+}
+export interface MonitorEventValueRaw {
+    event: number;
+    value: bigint;
+    routingId?: Buffer | null;
+    local?: string;
+    remote?: string;
+    localAddr?: string;
+    remoteAddr?: string;
+    connectionId?: bigint;
+    transportLane?: number;
+    flags?: number;
+}

package/dist/zlink/runtime/eventing/monitor_raw.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/zlink/runtime/eventing/monitor_socket.d.ts

@@ -0,0 +1,9 @@
+import { NativeHandle } from '../handles/native_handle';
+import { RecvFlags } from '../../contracts/sockets/socket_constants';
+import { MonitorEvent, type MonitorStatus } from '../../contracts/eventing';
+export declare class MonitorSocket extends NativeHandle {
+    constructor(native: unknown);
+    recv(flags?: RecvFlags): MonitorEvent | null;
+    status(): MonitorStatus;
+    close(): void;
+}

package/dist/zlink/runtime/eventing/monitor_socket.js

@@ -0,0 +1,39 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitorSocket = void 0;
+const native_handle_1 = require("../handles/native_handle");
+const native_1 = require("../native/native");
+const native_errors_1 = require("../errors/native_errors");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+const monitor_event_state_1 = require("./monitor_event_state");
+const monitor_status_1 = require("./monitor_status");
+class MonitorSocket extends native_handle_1.NativeHandle {
+    constructor(native) {
+        super(native);
+    }
+    recv(flags = socket_constants_1.RecvFlags.None) {
+        try {
+            if ((flags | 0) & (socket_constants_1.RecvFlags.DontWait | 0)) {
+                const raw = (0, native_1.requireNative)().monitorRecvNoWait(this._native);
+                return raw ? (0, monitor_event_state_1.createMonitorEvent)(raw) : null;
+            }
+            return (0, monitor_event_state_1.createMonitorEvent)((0, native_1.requireNative)().monitorRecv(this._native));
+        }
+        catch (error) {
+            throw (0, native_errors_1.recvNativeError)(error, flags, 'monitor recv failed');
+        }
+    }
+    status() {
+        return (0, monitor_status_1.materializeMonitorStatus)((0, native_errors_1.configCall)('monitor status failed', () => (0, native_1.requireNative)().monitorStatus(this._native)));
+    }
+    close() {
+        if (this._native) {
+            (0, native_errors_1.closeCall)('monitor close failed', () => {
+                (0, native_1.requireNative)().monitorClose(this._native);
+            });
+            this._native = null;
+        }
+    }
+}
+exports.MonitorSocket = MonitorSocket;

package/dist/zlink/runtime/eventing/monitor_status.d.ts

@@ -0,0 +1,3 @@
+import { type MonitorStatus } from '../../contracts/eventing';
+import type { MonitorStatusRaw } from './monitor_raw';
+export declare function materializeMonitorStatus(raw: MonitorStatusRaw): MonitorStatus;

package/dist/zlink/runtime/eventing/monitor_status.js

@@ -0,0 +1,52 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializeMonitorStatus = materializeMonitorStatus;
+const MONITOR_STATE_READY = 1 << 0;
+const MONITOR_STATUS_DETAIL_FLOW_STATE = 1 << 5;
+function materializeMonitorStatus(raw) {
+    return {
+        abiVersion: raw.abiVersion,
+        structSize: raw.structSize,
+        sourceKind: raw.sourceKind,
+        stateFlags: raw.stateFlags,
+        detailFlags: raw.detailFlags,
+        sndPendingMsgs: raw.sndPendingMsgs,
+        rcvPendingMsgs: raw.rcvPendingMsgs,
+        sndPendingBytes: raw.sndPendingBytes,
+        rcvPendingBytes: raw.rcvPendingBytes,
+        autoHwmEnabled: raw.autoHwmEnabled,
+        autoHwmProfile: raw.autoHwmProfile,
+        autoHwmRole: raw.autoHwmRole,
+        autoHwmPolicyClass: raw.autoHwmPolicyClass,
+        autoHwmPlannedSndHwmBytes: raw.autoHwmPlannedSndHwmBytes,
+        autoHwmPlannedRcvHwmBytes: raw.autoHwmPlannedRcvHwmBytes,
+        autoHwmAppliedSndHwmBytes: raw.autoHwmAppliedSndHwmBytes,
+        autoHwmAppliedRcvHwmBytes: raw.autoHwmAppliedRcvHwmBytes,
+        autoHwmEffectiveSndBuf: raw.autoHwmEffectiveSndBuf ?? 0,
+        autoHwmEffectiveRcvBuf: raw.autoHwmEffectiveRcvBuf ?? 0,
+        autoHwmLastRecalcMs: raw.autoHwmLastRecalcMs,
+        autoHwmLastRecalcReason: raw.autoHwmLastRecalcReason,
+        autoHwmSendBlockedRatioPpm: raw.autoHwmSendBlockedRatioPpm,
+        autoHwmDeferredSndHwmBytes: raw.autoHwmDeferredSndHwmBytes,
+        autoHwmDeferredRcvHwmBytes: raw.autoHwmDeferredRcvHwmBytes,
+        autoHwmDeferredSndHwmValid: raw.autoHwmDeferredSndHwmValid,
+        autoHwmDeferredRcvHwmValid: raw.autoHwmDeferredRcvHwmValid,
+        sndBytesInFlight: raw.sndBytesInFlight,
+        rcvBytesInFlight: raw.rcvBytesInFlight,
+        minimumCoreMessageChargeBytes: raw.minimumCoreMessageChargeBytes,
+        oversizeMessageAdmissionCount: raw.oversizeMessageAdmissionCount,
+        oversizeMessageAdmissionMaxBytes: raw.oversizeMessageAdmissionMaxBytes,
+        flowPausedConnections: raw.flowPausedConnections,
+        flowPauseAppliedTotal: raw.flowPauseAppliedTotal,
+        flowResumeAppliedTotal: raw.flowResumeAppliedTotal,
+        flowStateStaleTotal: raw.flowStateStaleTotal,
+        flowPauseDurationMs: raw.flowPauseDurationMs,
+        isReady() {
+            return (this.stateFlags & MONITOR_STATE_READY) !== 0;
+        },
+        isFlowStateDetailPopulated() {
+            return (this.detailFlags & MONITOR_STATUS_DETAIL_FLOW_STATE) !== 0;
+        }
+    };
+}

package/dist/zlink/runtime/eventing/poll_events.d.ts

@@ -0,0 +1,20 @@
+import type { PollEventFlagValue } from '../../contracts/sockets/socket_constants';
+import type { Pollable } from '../../contracts/eventing/poller';
+import { NativeHandle } from '../handles/native_handle';
+export declare class PollEvents extends NativeHandle {
+    private _readyCount;
+    private _nativeReadyCount;
+    private _synthetic;
+    readonly capacity: number;
+    constructor(capacity: number);
+    get readyCount(): number;
+    source(index: number): Pollable;
+    sourceKind(index: number): number;
+    slot(index: number): number;
+    revents(index: number): number;
+    fd(index: number): number;
+    hasEvent(index: number, event: PollEventFlagValue): boolean;
+    close(): void;
+    private checkReadyIndex;
+}
+export { PollEvents as RuntimePollEvents };

package/dist/zlink/runtime/eventing/poll_events.js

@@ -0,0 +1,92 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimePollEvents = exports.PollEvents = void 0;
+const native_errors_1 = require("../errors/native_errors");
+const native_handle_1 = require("../handles/native_handle");
+const native_1 = require("../native/native");
+class PollEvents extends native_handle_1.NativeHandle {
+    _readyCount = 0;
+    _nativeReadyCount = 0;
+    _synthetic = [];
+    capacity;
+    constructor(capacity) {
+        if (!Number.isInteger(capacity) || capacity <= 0) {
+            throw new RangeError('capacity must be a positive integer');
+        }
+        super((0, native_1.requireNative)().pollEventsNew(capacity));
+        this.capacity = capacity;
+    }
+    get readyCount() { return this._readyCount; }
+    source(index) {
+        this.checkReadyIndex(index);
+        return this._synthetic[index].source;
+    }
+    sourceKind(index) {
+        this.checkReadyIndex(index);
+        if (index >= this._nativeReadyCount) {
+            return this._synthetic[index - this._nativeReadyCount].sourceKind;
+        }
+        return (0, native_1.requireNative)().pollEventsSourceKind(this._native, index | 0);
+    }
+    slot(index) {
+        this.checkReadyIndex(index);
+        if (index >= this._nativeReadyCount) {
+            return this._synthetic[index - this._nativeReadyCount].slot;
+        }
+        return (0, native_1.requireNative)().pollEventsSlot(this._native, index | 0);
+    }
+    revents(index) {
+        this.checkReadyIndex(index);
+        if (index >= this._nativeReadyCount) {
+            return this._synthetic[index - this._nativeReadyCount].revents;
+        }
+        return (0, native_1.requireNative)().pollEventsRevents(this._native, index | 0);
+    }
+    fd(index) {
+        this.checkReadyIndex(index);
+        if (index >= this._nativeReadyCount) {
+            return this._synthetic[index - this._nativeReadyCount].fd;
+        }
+        return Number((0, native_1.requireNative)().pollEventsFd(this._native, index | 0));
+    }
+    hasEvent(index, event) {
+        return (this.revents(index) & event) !== 0;
+    }
+    /** @internal */
+    markReadyCount(count) {
+        if (count < 0 || count > this.capacity) {
+            throw new RangeError('ready count out of range');
+        }
+        this._readyCount = count;
+        this._nativeReadyCount = count;
+        this._synthetic = [];
+    }
+    /** @internal */
+    markCombined(nativeCount, entries) {
+        if (nativeCount < 0 || nativeCount + entries.length > this.capacity) {
+            throw new RangeError('ready count out of range');
+        }
+        this._nativeReadyCount = nativeCount;
+        this._synthetic = entries;
+        this._readyCount = nativeCount + entries.length;
+    }
+    close() {
+        if (!this._native)
+            return;
+        (0, native_errors_1.closeCall)('poll events close failed', () => {
+            (0, native_1.requireNative)().pollEventsDestroy(this._native);
+        });
+        this._native = null;
+        this._readyCount = 0;
+        this._nativeReadyCount = 0;
+        this._synthetic = [];
+    }
+    checkReadyIndex(index) {
+        if (!Number.isInteger(index) || index < 0 || index >= this._readyCount) {
+            throw new RangeError(`ready index ${index}`);
+        }
+    }
+}
+exports.PollEvents = PollEvents;
+exports.RuntimePollEvents = PollEvents;