@zlink-systems/zlink 0.17.3

package/dist/zlink/contracts/sockets/socket_options.d.ts

@@ -0,0 +1,105 @@
+import type { Message, MessageLike } from '../messaging';
+import type { RoutingId } from '../core';
+import type { RidDuplicatePolicyValue, StreamRecvMode } from './socket_constants';
+/** Typed facade over the socket options shared by every socket type. */
+export interface CommonSocketOptions {
+    /** How long, in ms, close waits to deliver queued messages. */
+    linger: number;
+    /** Maximum accounted outbound bytes before back-pressure; 0n means unlimited. */
+    sendHwm: bigint;
+    /** Maximum accounted inbound bytes before back-pressure; 0n means unlimited. */
+    recvHwm: bigint;
+    /** How long, in ms, a blocking send waits before failing. */
+    sendTimeout: number;
+    /** How long, in ms, a blocking receive waits before failing. */
+    recvTimeout: number;
+    /** Whether messages queue only to fully established connections. */
+    immediate: boolean;
+    /** How the socket reacts when a peer reuses an existing routing id. */
+    ridDuplicatePolicy: RidDuplicatePolicyValue;
+    /** Time limit, in ms, for a single connection attempt. */
+    connectTimeout: number;
+    /** Whether IPv6 connections are enabled. */
+    ipv6: boolean;
+    /** Whether Nagle's algorithm is disabled (`TCP_NODELAY`). */
+    tcpNoDelay: boolean;
+    /** TCP keep-alive: -1 OS default, 0 off, 1 on. */
+    tcpKeepalive: number;
+    /** Maximum inbound message size in bytes; -1n means no limit. */
+    maxMsgSize: bigint;
+    /** The concrete endpoint the socket last bound to (resolves wildcards). */
+    readonly lastEndpoint: string;
+    /** Maximum length of the pending-connection queue on a bound endpoint. */
+    backlog: number;
+    /** Base delay, in ms, before reconnecting a broken connection. */
+    reconnectInterval: number;
+    /** Maximum reconnect delay, in ms, under exponential backoff. */
+    reconnectIntervalMax: number;
+    /** Whether a submit that fails locally is retried (see RidDuplicatePolicy/SubmitRetryMode constants). */
+    submitRetryMode: number;
+    /** Total time budget, in ms, for submit retries. */
+    submitRetryTimeout: number;
+    /** Maximum number of submit retry attempts. */
+    submitRetryAttempts: number;
+}
+/** Typed facade over DEALER-specific socket options. */
+export interface DealerSocketOptions extends CommonSocketOptions {
+    /** Whether to send an empty probe on connect so the peer learns this socket's routing id. */
+    probe: boolean;
+    /** How long, in ms, a DEALER request waits for a reply. */
+    requestTimeout: number;
+    /** This peer's relative load-balancing weight (0-100). */
+    peerWeight: number;
+}
+/** Typed facade over ROUTER-specific socket options. */
+export interface RouterSocketOptions extends CommonSocketOptions {
+    /** Whether sending to an unknown route raises an error instead of dropping the message. */
+    mandatory: boolean;
+    /** Whether a new peer reusing an existing routing id takes it over. */
+    handover: boolean;
+    /** Whether to send an empty probe on connect so the peer learns this socket's routing id. */
+    probe: boolean;
+    /** The routing id assigned to the next outgoing connection, or null when none is pending. */
+    readonly connectRoutingId: RoutingId | null;
+    /** Assign `routingId` to the next connection this socket initiates. */
+    setConnectRoutingId(routingId: RoutingId): void;
+    /** How long, in ms, a ROUTER request waits for a reply. */
+    requestTimeout: number;
+    /** This peer's relative load-balancing weight (0-100). */
+    peerWeight: number;
+}
+/** Typed facade over STREAM-specific socket options. */
+export interface StreamSocketOptions extends CommonSocketOptions {
+    /** Whether peer connect and disconnect events are delivered as messages. */
+    notify: boolean;
+    /** Select RAW byte records or framed packet receive before bind/connect. */
+    recvMode: StreamRecvMode;
+}
+/** Typed facade over PUB/XPUB-specific socket options. */
+export interface PubSocketOptions extends CommonSocketOptions {
+    /** Whether every subscription message (including duplicates) is delivered. */
+    verbose: boolean;
+    /** Whether every subscription and unsubscription message is delivered. */
+    verboser: boolean;
+    /** Whether a back-pressured send raises an error instead of dropping the message. */
+    noDrop: boolean;
+    /** Whether subscriptions are handled manually via approve/reject. */
+    manual: boolean;
+    /** Manual handling that replays the last cached message per topic to a new subscriber. */
+    manualLastValue: boolean;
+    /** The number of distinct topics currently subscribed across subscribers. */
+    readonly topicsCount: number;
+    /** Return the welcome message sent to new subscribers (caller owns it). */
+    welcomeMessage(): Message;
+    /** Set a message automatically sent to each newly connected subscriber. */
+    setWelcomeMessage(message: MessageLike): void;
+    /** Accept a pending subscription from `routingId`; requires manual mode. */
+    approveSubscribe(routingId: RoutingId): void;
+    /** Decline a pending subscription from `routingId`; requires manual mode. */
+    rejectSubscribe(routingId: RoutingId): void;
+}
+/** Typed facade over SUB-specific socket options. */
+export interface SubSocketOptions extends CommonSocketOptions {
+    /** The number of active subscriptions on this socket. */
+    readonly topicsCount: number;
+}

package/dist/zlink/contracts/sockets/socket_options.js

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

package/dist/zlink/contracts/sockets/stream_socket.d.ts

@@ -0,0 +1,31 @@
+import type { RoutingId } from '../core';
+import type { Received, SendOperation, StreamPacket } from '../messaging';
+import type { RecvFlags } from './socket_constants';
+import type { StreamSocketOptions } from './socket_options';
+import type { Socket } from './socket';
+/**
+ * STREAM socket: exchanges framed packets with raw TCP peers addressed by
+ * routing id.
+ */
+export interface StreamSocket extends Socket {
+    /** The STREAM-specific typed options facade. */
+    readonly options: StreamSocketOptions;
+    /**
+     * Begin an exact-target managed send. `submit()` resolves only after Core
+     * accepts the record for the routing id captured by this builder.
+     */
+    send(routingId: RoutingId): SendOperation;
+    /** Receive a message into `result`; false when `RecvFlags.DontWait` is set and none is available. */
+    recv(result: Received, flags?: RecvFlags): boolean;
+    /** Receive one packet into reusable storage; false for non-blocking no-data. */
+    recvPacket(result: StreamPacket, flags?: RecvFlags): boolean;
+    /**
+     * Set the routing id that identifies this socket to its peers. Apply before
+     * connecting so peers observe it from the first packet.
+     */
+    setRoutingId(routingId: RoutingId): void;
+    /** Return the routing id that identifies this socket to its peers. */
+    getRoutingId(): RoutingId;
+    /** Disconnect the peer identified by `routingId`. */
+    disconnectRid(routingId: RoutingId): void;
+}

package/dist/zlink/contracts/sockets/stream_socket.js

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

package/dist/zlink/runtime/buffers/message_conversion.d.ts

@@ -0,0 +1,6 @@
+import { Message, type MessageLike } from '../../contracts';
+import { type MessageSnapshot } from '../messaging/message_snapshot';
+export declare function toMessageParts(parts: readonly MessageLike[]): Array<Buffer | MessageSnapshot>;
+export declare function normalizeOperationPayload(parts: MessageLike | readonly MessageLike[]): Buffer | MessageSnapshot | Array<Buffer | MessageSnapshot>;
+export { normalizeOperationPayload as normalizeMessageLikePayload };
+export declare function messageFromNativeBuffer(buffer: Buffer | null | undefined): Message;

package/dist/zlink/runtime/buffers/message_conversion.js

@@ -0,0 +1,49 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMessageParts = toMessageParts;
+exports.normalizeOperationPayload = normalizeOperationPayload;
+exports.normalizeMessageLikePayload = normalizeOperationPayload;
+exports.messageFromNativeBuffer = messageFromNativeBuffer;
+const contracts_1 = require("../../contracts");
+const message_snapshot_1 = require("../messaging/message_snapshot");
+function normalizeBufferLike(value, label = 'value') {
+    if (Buffer.isBuffer(value))
+        return value;
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (typeof value === 'string')
+        return Buffer.from(value);
+    throw new TypeError(`${typeof label === 'number' ? `parts[${label}]` : label} must be Buffer, Uint8Array, or string`);
+}
+function toMessageParts(parts) {
+    let converted;
+    for (let index = 0; index < parts.length; ++index) {
+        const part = parts[index];
+        const normalized = part instanceof contracts_1.Message
+            ? (0, message_snapshot_1.messageToSnapshot)(part) : normalizeBufferLike(part, index);
+        if (converted === undefined && normalized !== part) {
+            converted = parts.slice(0, index);
+        }
+        converted?.push(normalized);
+    }
+    // Native submit only reads the list and copies Buffer bytes synchronously.
+    // Allocate a replacement list only when an element actually needs conversion.
+    return converted ?? parts;
+}
+function normalizeOperationPayload(parts) {
+    if (!Array.isArray(parts)) {
+        const scalar = parts;
+        return scalar instanceof contracts_1.Message ? (0, message_snapshot_1.messageToSnapshot)(scalar) : normalizeBufferLike(scalar, 'message');
+    }
+    if (parts.length === 1) {
+        const part = parts[0];
+        return part instanceof contracts_1.Message ? (0, message_snapshot_1.messageToSnapshot)(part) : normalizeBufferLike(part, 'message');
+    }
+    return toMessageParts(parts);
+}
+function messageFromNativeBuffer(buffer) {
+    // HOT PATH: the addon already transfers payload ownership to a JS Buffer.
+    return (0, message_snapshot_1.messageFromOwnedBuffer)(buffer ?? Buffer.alloc(0));
+}

package/dist/zlink/runtime/core/context.d.ts

@@ -0,0 +1,43 @@
+import type { AutoHwmProfileValue, CoreHwmBudgetSnapshot } from '../../contracts/core';
+import { NativeHandle } from '../handles/native_handle';
+export declare class ContextOptions {
+    private _threadNamePrefix;
+    get ioThreads(): number;
+    set ioThreads(value: number);
+    get maxSockets(): number;
+    set maxSockets(value: number);
+    get socketLimit(): number;
+    get maxMsgSize(): number;
+    set maxMsgSize(value: number);
+    get msgTSize(): number;
+    get threadPriority(): number;
+    set threadPriority(value: number);
+    get threadSchedulingPolicy(): number;
+    set threadSchedulingPolicy(value: number);
+    get blocky(): boolean;
+    set blocky(value: boolean);
+    get autoHwmEnabled(): boolean;
+    set autoHwmEnabled(value: boolean);
+    get autoHwmRecalcDebounceMs(): number;
+    set autoHwmRecalcDebounceMs(value: number);
+    get coreHwmProfile(): AutoHwmProfileValue;
+    set coreHwmProfile(value: AutoHwmProfileValue);
+    get coreHwmMemoryLimitBytes(): bigint;
+    set coreHwmMemoryLimitBytes(value: bigint);
+    get coreHwmBudgetBytes(): bigint;
+    set coreHwmBudgetBytes(value: bigint);
+    get threadNamePrefix(): string;
+    set threadNamePrefix(value: string);
+    addThreadAffinity(cpu: number): void;
+    removeThreadAffinity(cpu: number): void;
+}
+export declare class Context extends NativeHandle {
+    readonly options: ContextOptions;
+    constructor();
+    shutdown(): void;
+    recalculateAutoHwm(): void;
+    getCoreHwmBudgetSnapshot(): CoreHwmBudgetSnapshot;
+    resetCoreHwmBudgetMetrics(): void;
+    close(): void;
+}
+export { Context as RuntimeContext, ContextOptions as RuntimeContextOptions, };

package/dist/zlink/runtime/core/context.js

@@ -0,0 +1,150 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeContextOptions = exports.RuntimeContext = exports.Context = exports.ContextOptions = void 0;
+const node_v8_1 = require("node:v8");
+const error_mapping_1 = require("../errors/error_mapping");
+const native_errors_1 = require("../errors/native_errors");
+const validation_1 = require("../options/validation");
+const native_1 = require("../native/native");
+const native_handle_1 = require("../handles/native_handle");
+const context_options_1 = require("./context_options");
+const byte_values_1 = require("../options/byte_values");
+const OPTION_CREATE_TOKEN = Symbol('OptionFacade.create');
+class ContextOptions {
+    /** @internal */
+    _context;
+    _threadNamePrefix = '';
+    /** @internal */
+    constructor(token, context) {
+        if (token !== OPTION_CREATE_TOKEN) {
+            throw new TypeError('context options are created by contexts');
+        }
+        this._context = context;
+    }
+    /** @internal */
+    static create(context) {
+        return new ContextOptions(OPTION_CREATE_TOKEN, context);
+    }
+    get ioThreads() { return getContextOptionRaw(this._context, context_options_1.ContextOption.IO_THREADS); }
+    set ioThreads(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.IO_THREADS, value | 0); }
+    get maxSockets() { return getContextOptionRaw(this._context, context_options_1.ContextOption.MAX_SOCKETS); }
+    set maxSockets(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.MAX_SOCKETS, value | 0); }
+    get socketLimit() { return getContextOptionRaw(this._context, context_options_1.ContextOption.SOCKET_LIMIT); }
+    get maxMsgSize() { return getContextOptionRaw(this._context, context_options_1.ContextOption.MAX_MSGSZ); }
+    set maxMsgSize(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.MAX_MSGSZ, value | 0); }
+    get msgTSize() { return getContextOptionRaw(this._context, context_options_1.ContextOption.MSG_T_SIZE); }
+    get threadPriority() { return getContextOptionRaw(this._context, context_options_1.ContextOption.THREAD_PRIORITY); }
+    set threadPriority(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.THREAD_PRIORITY, value | 0); }
+    get threadSchedulingPolicy() { return getContextOptionRawStrict(this._context, context_options_1.ContextOption.THREAD_SCHED_POLICY); }
+    set threadSchedulingPolicy(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.THREAD_SCHED_POLICY, value | 0); }
+    get blocky() { return getContextOptionRaw(this._context, context_options_1.ContextOption.BLOCKY) !== 0; }
+    set blocky(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.BLOCKY, value ? 1 : 0); }
+    get autoHwmEnabled() { return getContextOptionRaw(this._context, context_options_1.ContextOption.AUTO_HWM_ENABLE) !== 0; }
+    set autoHwmEnabled(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.AUTO_HWM_ENABLE, value ? 1 : 0); }
+    get autoHwmRecalcDebounceMs() { return getContextOptionRaw(this._context, context_options_1.ContextOption.AUTO_HWM_RECALC_DEBOUNCE_MS); }
+    set autoHwmRecalcDebounceMs(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.AUTO_HWM_RECALC_DEBOUNCE_MS, value | 0); }
+    get coreHwmProfile() { return getContextOptionRaw(this._context, context_options_1.ContextOption.AUTO_HWM_PROFILE); }
+    set coreHwmProfile(value) { setContextOptionRaw(this._context, context_options_1.ContextOption.AUTO_HWM_PROFILE, value | 0); }
+    get coreHwmMemoryLimitBytes() { return getContextUInt64(this._context, context_options_1.ContextOption.AUTO_HWM_MEMORY_LIMIT_BYTES, 'coreHwmMemoryLimitBytes'); }
+    set coreHwmMemoryLimitBytes(value) { setContextUInt64(this._context, context_options_1.ContextOption.AUTO_HWM_MEMORY_LIMIT_BYTES, value, 'coreHwmMemoryLimitBytes'); }
+    get coreHwmBudgetBytes() { return getContextUInt64(this._context, context_options_1.ContextOption.AUTO_HWM_CORE_BUDGET_BYTES, 'coreHwmBudgetBytes'); }
+    set coreHwmBudgetBytes(value) { setContextUInt64(this._context, context_options_1.ContextOption.AUTO_HWM_CORE_BUDGET_BYTES, value, 'coreHwmBudgetBytes'); }
+    get threadNamePrefix() { return this._threadNamePrefix; }
+    set threadNamePrefix(value) {
+        const normalized = (0, validation_1.validateCString)(value, 'threadNamePrefix');
+        setContextOptionRaw(this._context, context_options_1.ContextOption.THREAD_NAME_PREFIX, Buffer.from(normalized));
+        this._threadNamePrefix = normalized;
+    }
+    addThreadAffinity(cpu) { setContextOptionRaw(this._context, context_options_1.ContextOption.THREAD_AFFINITY_CPU_ADD, cpu | 0); }
+    removeThreadAffinity(cpu) { setContextOptionRaw(this._context, context_options_1.ContextOption.THREAD_AFFINITY_CPU_REMOVE, cpu | 0); }
+}
+exports.ContextOptions = ContextOptions;
+exports.RuntimeContextOptions = ContextOptions;
+function setContextOptionRaw(context, option, value) {
+    (0, native_errors_1.configCall)('context option set failed', () => {
+        (0, native_1.requireNative)().ctxSetOpt((0, native_handle_1.getNativeHandle)(context), option | 0, typeof value === 'number' ? value | 0 : value);
+    });
+}
+function getContextOptionRaw(context, option) {
+    try {
+        return (0, native_1.requireNative)().ctxGetOpt((0, native_handle_1.getNativeHandle)(context), option | 0);
+    }
+    catch (error) {
+        if ((option | 0) === context_options_1.ContextOption.THREAD_PRIORITY ||
+            (option | 0) === context_options_1.ContextOption.THREAD_SCHED_POLICY) {
+            return -1;
+        }
+        throw (0, error_mapping_1.createError)('config', (0, native_errors_1.readErrno)(), (0, native_errors_1.nativeErrorMessage)(error, 'context option get failed'));
+    }
+}
+function getContextOptionRawStrict(context, option) {
+    try {
+        return (0, native_1.requireNative)().ctxGetOpt((0, native_handle_1.getNativeHandle)(context), option | 0);
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message
+            ? error.message
+            : 'ctx_getopt failed';
+        throw (0, error_mapping_1.createError)('config', (0, native_errors_1.readErrno)(), message);
+    }
+}
+function getContextUInt64(context, option, name) {
+    const value = (0, native_1.requireNative)().ctxGetOptData((0, native_handle_1.getNativeHandle)(context), option | 0);
+    if (value.length !== 8)
+        throw new Error(`${name} option returned an invalid payload`);
+    return value.readBigUInt64LE(0);
+}
+function setContextUInt64(context, option, value, name) {
+    setContextOptionRaw(context, option, (0, byte_values_1.uint64Buffer)(value, name));
+}
+class Context extends native_handle_1.NativeHandle {
+    options;
+    constructor() {
+        super((0, native_1.requireNative)().ctxNew());
+        if (!this._native)
+            throw (0, native_errors_1.lastError)('config', 'context creation failed');
+        this.options = ContextOptions.create(this);
+        const heapLimitBytes = BigInt(Math.trunc((0, node_v8_1.getHeapStatistics)().heap_size_limit));
+        if (heapLimitBytes > 0n) {
+            setContextUInt64(this, context_options_1.ContextOption.AUTO_HWM_RUNTIME_MEMORY_LIMIT_BYTES, heapLimitBytes, 'runtimeMemoryLimitBytes');
+        }
+    }
+    shutdown() {
+        (0, native_errors_1.closeCall)('context shutdown failed', () => {
+            (0, native_1.requireNative)().ctxShutdown(this._native);
+        });
+    }
+    recalculateAutoHwm() {
+        (0, native_errors_1.configCall)('context auto HWM recalculation failed', () => {
+            (0, native_1.requireNative)().ctxRecalculateAutoHwm(this._native);
+        });
+    }
+    getCoreHwmBudgetSnapshot() {
+        const snapshot = (0, native_1.requireNative)().ctxGetAutoHwmBudgetSnapshot(this._native);
+        const flags = snapshot.flags >>> 0;
+        return Object.freeze({
+            ...snapshot,
+            reservedUInt64: Object.freeze([...snapshot.reservedUInt64]),
+            budgetPlanningActive: (flags & (1 << 0)) !== 0,
+            budgetInsufficient: (flags & (1 << 1)) !== 0,
+            aggregateHwmValid: (flags & (1 << 2)) !== 0,
+            aggregateOverflow: (flags & (1 << 3)) !== 0
+        });
+    }
+    resetCoreHwmBudgetMetrics() {
+        (0, native_errors_1.configCall)('context auto HWM metric reset failed', () => {
+            (0, native_1.requireNative)().ctxResetAutoHwmBudgetMetrics(this._native);
+        });
+    }
+    close() {
+        if (!this._native)
+            return;
+        (0, native_errors_1.closeCall)('context close failed', () => {
+            (0, native_1.requireNative)().ctxTerm(this._native);
+        });
+        this._native = null;
+    }
+}
+exports.Context = Context;
+exports.RuntimeContext = Context;

package/dist/zlink/runtime/core/context_options.d.ts

@@ -0,0 +1,19 @@
+export declare const ContextOption: Readonly<{
+    readonly IO_THREADS: 1;
+    readonly MAX_SOCKETS: 2;
+    readonly SOCKET_LIMIT: 3;
+    readonly THREAD_PRIORITY: 3;
+    readonly THREAD_SCHED_POLICY: 4;
+    readonly MAX_MSGSZ: 5;
+    readonly MSG_T_SIZE: 6;
+    readonly THREAD_AFFINITY_CPU_ADD: 7;
+    readonly THREAD_AFFINITY_CPU_REMOVE: 8;
+    readonly THREAD_NAME_PREFIX: 9;
+    readonly BLOCKY: 10;
+    readonly AUTO_HWM_ENABLE: 12;
+    readonly AUTO_HWM_RECALC_DEBOUNCE_MS: 14;
+    readonly AUTO_HWM_PROFILE: 17;
+    readonly AUTO_HWM_MEMORY_LIMIT_BYTES: 19;
+    readonly AUTO_HWM_RUNTIME_MEMORY_LIMIT_BYTES: 20;
+    readonly AUTO_HWM_CORE_BUDGET_BYTES: 21;
+}>;

package/dist/zlink/runtime/core/context_options.js

@@ -0,0 +1,23 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextOption = void 0;
+exports.ContextOption = Object.freeze({
+    IO_THREADS: 1,
+    MAX_SOCKETS: 2,
+    SOCKET_LIMIT: 3,
+    THREAD_PRIORITY: 3,
+    THREAD_SCHED_POLICY: 4,
+    MAX_MSGSZ: 5,
+    MSG_T_SIZE: 6,
+    THREAD_AFFINITY_CPU_ADD: 7,
+    THREAD_AFFINITY_CPU_REMOVE: 8,
+    THREAD_NAME_PREFIX: 9,
+    BLOCKY: 10,
+    AUTO_HWM_ENABLE: 12,
+    AUTO_HWM_RECALC_DEBOUNCE_MS: 14,
+    AUTO_HWM_PROFILE: 17,
+    AUTO_HWM_MEMORY_LIMIT_BYTES: 19,
+    AUTO_HWM_RUNTIME_MEMORY_LIMIT_BYTES: 20,
+    AUTO_HWM_CORE_BUDGET_BYTES: 21
+});

package/dist/zlink/runtime/core/routing_id.d.ts

@@ -0,0 +1,3 @@
+import { RoutingId } from '../../contracts/core';
+export declare function normalizeRoutingId(routingId: RoutingId, name?: string): Buffer;
+export declare function routingIdFromOwnedBuffer(bytes: Buffer): RoutingId;

package/dist/zlink/runtime/core/routing_id.js

@@ -0,0 +1,30 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRoutingId = normalizeRoutingId;
+exports.routingIdFromOwnedBuffer = routingIdFromOwnedBuffer;
+const core_1 = require("../../contracts/core");
+const errors_1 = require("../../contracts/errors/errors");
+const error_state_1 = require("../errors/error_state");
+const ROUTING_ID_MAX_LENGTH = 255;
+function requireRoutingId(routingId, name = 'routingId') {
+    if (!(routingId instanceof core_1.RoutingId)) {
+        throw new TypeError(`${name} must be a RoutingId`);
+    }
+    return routingId._bytes;
+}
+function normalizeRoutingId(routingId, name = 'routingId') {
+    return requireRoutingId(routingId, name);
+}
+function routingIdFromOwnedBuffer(bytes) {
+    if (!Buffer.isBuffer(bytes)) {
+        throw new TypeError('bytes must be a Buffer');
+    }
+    if (bytes.length === 0 || bytes.length > ROUTING_ID_MAX_LENGTH) {
+        throw (0, error_state_1.withRuntimeErrorMessage)(new errors_1.ConfigError(errors_1.ConfigResult.InvalidArgument, 0), `bytes must be 1..${ROUTING_ID_MAX_LENGTH} bytes`);
+    }
+    const routingId = Object.create(core_1.RoutingId.prototype);
+    routingId._bytes = bytes;
+    Object.freeze(routingId);
+    return routingId;
+}

package/dist/zlink/runtime/core/routing_id_conversion.d.ts

@@ -0,0 +1,2 @@
+import { RoutingId } from '../../contracts/core';
+export declare function wrapRoutingId(routingId: Buffer | Uint8Array | null | undefined): RoutingId | null;

package/dist/zlink/runtime/core/routing_id_conversion.js

@@ -0,0 +1,11 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapRoutingId = wrapRoutingId;
+const core_1 = require("../../contracts/core");
+function wrapRoutingId(routingId) {
+    if (!routingId || routingId.length === 0) {
+        return null;
+    }
+    return core_1.RoutingId.from(routingId);
+}

package/dist/zlink/runtime/core/runtime_info.d.ts

@@ -0,0 +1,8 @@
+import type { Message } from '../../contracts';
+import type { RuntimeBaseSocket as BaseSocket } from '../sockets';
+export declare function version(): [number, number, number];
+export declare function strerror(code: number): string;
+export declare function has(capability: string): boolean;
+export declare function proxy(frontend: BaseSocket, backend: BaseSocket, capture?: BaseSocket): void;
+export declare function sleep(seconds: number): void;
+export declare function multipartClose(parts: Message[]): void;

package/dist/zlink/runtime/core/runtime_info.js

@@ -0,0 +1,39 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = version;
+exports.strerror = strerror;
+exports.has = has;
+exports.proxy = proxy;
+exports.sleep = sleep;
+exports.multipartClose = multipartClose;
+const validation_1 = require("../options/validation");
+const native_errors_1 = require("../errors/native_errors");
+const native_handle_1 = require("../handles/native_handle");
+const native_1 = require("../native/native");
+function version() {
+    return (0, native_1.requireNative)().version();
+}
+function strerror(code) {
+    return (0, native_1.requireNative)().strerror(code);
+}
+function has(capability) {
+    const normalized = (0, validation_1.validateCString)(capability, 'capability', Number.MAX_SAFE_INTEGER);
+    return (0, native_1.requireNative)().has(normalized);
+}
+function proxy(frontend, backend, capture) {
+    if (capture === null) {
+        throw new TypeError('capture must be a socket or undefined');
+    }
+    (0, native_errors_1.configCall)('proxy failed', () => {
+        (0, native_1.requireNative)().proxy((0, native_handle_1.getNativeHandle)(frontend), (0, native_handle_1.getNativeHandle)(backend), capture ? (0, native_handle_1.getNativeHandle)(capture) : null);
+    });
+}
+function sleep(seconds) {
+    (0, native_1.requireNative)().sleep(seconds | 0);
+}
+function multipartClose(parts) {
+    for (const part of parts) {
+        part.close();
+    }
+}

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

@@ -0,0 +1,4 @@
+import { ZlinkError } from '../../contracts/errors/errors';
+export type NativeErrorCategory = 'submit' | 'request' | 'recv' | 'handler' | 'close' | 'bind' | 'connect' | 'config';
+export declare function mapNativeErrno(category: NativeErrorCategory, errno: number): number;
+export declare function createError(category: NativeErrorCategory, errno: number, message?: string): ZlinkError;