@zlink-systems/zlink 0.17.3

package/dist/zlink/runtime/native/binding_eventing.d.ts

@@ -0,0 +1,40 @@
+import type { MonitorEventValueRaw, MonitorStatusRaw, NativeHandle } from './binding_types';
+export interface EventingNativeBinding {
+    atomicCounterDec: (counter: NativeHandle) => number;
+    atomicCounterDestroy: (counter: NativeHandle) => void;
+    atomicCounterInc: (counter: NativeHandle) => number;
+    atomicCounterNew: () => NativeHandle;
+    atomicCounterSet: (counter: NativeHandle, value: number) => void;
+    atomicCounterValue: (counter: NativeHandle) => number;
+    monitorClose: (monitor: NativeHandle) => void;
+    monitorRecv: (monitor: NativeHandle) => MonitorEventValueRaw;
+    monitorRecvNoWait: (monitor: NativeHandle) => MonitorEventValueRaw | null;
+    monitorStatus: (monitor: NativeHandle) => MonitorStatusRaw;
+    pollEventsDestroy: (events: NativeHandle) => void;
+    pollEventsFd: (events: NativeHandle, index: number) => number;
+    pollEventsNew: (capacity: number) => NativeHandle;
+    pollEventsRevents: (events: NativeHandle, index: number) => number;
+    pollEventsSlot: (events: NativeHandle, index: number) => number;
+    pollEventsSourceKind: (events: NativeHandle, index: number) => number;
+    pollerAdd: (poller: NativeHandle, handle: NativeHandle, slot: bigint | null, events: number) => void;
+    pollerAddFd: (poller: NativeHandle, fd: number, slot: bigint, events: number) => void;
+    pollerAddTimer: (poller: NativeHandle, timer: NativeHandle, slot: bigint) => void;
+    pollerDestroy: (poller: NativeHandle) => void;
+    pollerModify: (poller: NativeHandle, handle: NativeHandle, events: number) => void;
+    pollerModifyFd: (poller: NativeHandle, fd: number, events: number) => void;
+    pollerNew: () => NativeHandle;
+    pollerRemove: (poller: NativeHandle, handle: NativeHandle) => void;
+    pollerRemoveFd: (poller: NativeHandle, fd: number) => void;
+    pollerRemoveTimer: (poller: NativeHandle, timer: NativeHandle) => void;
+    pollerSize: (poller: NativeHandle) => number;
+    pollerWait: (poller: NativeHandle, timeoutMs: number) => number;
+    pollerWaitInto: (poller: NativeHandle, events: NativeHandle, capacity: number, timeoutMs: number) => number;
+    stopwatchIntermediate: (watch: NativeHandle) => number;
+    stopwatchStart: () => NativeHandle;
+    stopwatchStop: (watch: NativeHandle) => number;
+    timerDestroy: (timer: NativeHandle) => void;
+    timerNew: () => NativeHandle;
+    timerRecv: (timer: NativeHandle, flags: number) => bigint | null;
+    timerStart: (timer: NativeHandle, intervalNs: bigint, repeatCount: bigint) => void;
+    timerStop: (timer: NativeHandle) => void;
+}

package/dist/zlink/runtime/native/binding_eventing.js

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

package/dist/zlink/runtime/native/binding_socket.d.ts

@@ -0,0 +1,52 @@
+import type { NativeHandle, NativeReceivedRaw, NativeTopicMessageRaw, SubscriptionEntry } from './binding_types';
+import type { NativeCompletion, NativeSubmitResult, NativeSyncRequestResult } from '../messaging/completion_owner';
+export interface SocketNativeBinding {
+    socketSubmitSend: (socket: NativeHandle, parts: unknown, routingId: Buffer | null, flags: number, token: bigint) => NativeSubmitResult;
+    socketSubmitRequest: (socket: NativeHandle, target: Buffer | null, parts: unknown, timeoutMs: number, flags: number, token: bigint) => NativeSubmitResult;
+    socketRequestSync: (socket: NativeHandle, target: Buffer | null, parts: unknown, timeoutMs: number) => NativeSyncRequestResult;
+    socketCompletionRecv: (socket: NativeHandle, flags: number) => NativeCompletion | null;
+    socketReadableWatchStart: (socket: NativeHandle, callback: (status: number) => void) => NativeHandle;
+    socketReadableWatchStop: (watch: NativeHandle) => void;
+    socketReply: (socket: NativeHandle, sourceRid: Buffer, replyToken: bigint, parts: unknown) => void;
+    socketStreamRecvPacket: (socket: NativeHandle, flags: number) => {
+        routingId: Buffer;
+        header: Buffer;
+        body: Buffer;
+    } | null;
+    handleGetRoutingId: (handle: NativeHandle) => Buffer;
+    handleSetRoutingId: (handle: NativeHandle, routingId: Buffer) => void;
+    monitorOpen: (socket: NativeHandle, eventMask: number, monitorHwmBytes: bigint) => NativeHandle;
+    routerRecvMessage: (socket: NativeHandle, flags: number, preferManagedSinglePart?: boolean, routingIdStorage?: Buffer | null) => NativeReceivedRaw | null;
+    routerRecvMessageNoWait: (socket: NativeHandle, preferManagedSinglePart?: boolean, routingIdStorage?: Buffer | null) => NativeReceivedRaw | null;
+    socketBind: (socket: NativeHandle, endpoint: string) => void;
+    socketClose: (socket: NativeHandle) => void;
+    socketConnect: (socket: NativeHandle, endpoint: string) => void;
+    socketDisconnect: (socket: NativeHandle, endpoint: string) => void;
+    socketDisconnectRid: (socket: NativeHandle, routingId: Buffer) => void;
+    socketGetOpt: (socket: NativeHandle, option: number) => Buffer;
+    socketNew: (ctx: NativeHandle, type: number) => NativeHandle;
+    socketPublish: (socket: NativeHandle, topic: string, payload: unknown, flags: number) => number;
+    socketRecvMessage: (socket: NativeHandle, flags: number) => NativeReceivedRaw | null;
+    socketRecvMessageNoWait: (socket: NativeHandle) => NativeReceivedRaw | null;
+    socketSetOpt: (socket: NativeHandle, option: number, value: Buffer) => void;
+    socketSetReceiveFlowState: (socket: NativeHandle, state: number) => void;
+    socketSetSubscription: (socket: NativeHandle, topic: string) => void;
+    socketSetTlsClient: (socket: NativeHandle, ca: string, hostname: string, trustSystem: number) => void;
+    socketSetTlsServer: (socket: NativeHandle, cert: string, key: string, requireClientCert: number) => void;
+    socketSubscribeMessage: (socket: NativeHandle, flags: number) => NativeTopicMessageRaw | null;
+    socketSubscriptionEvent: (socket: NativeHandle, flags: number) => {
+        routingId?: Buffer | null;
+        topic: string;
+        subscribed: boolean;
+    } | null;
+    socketTryPublish: (socket: NativeHandle, topic: string, payload: unknown) => number;
+    socketTrySubscribeMessage: (socket: NativeHandle) => NativeTopicMessageRaw | null;
+    socketTrySubscriptionEvent: (socket: NativeHandle) => {
+        routingId?: Buffer | null;
+        topic: string;
+        subscribed: boolean;
+    } | null;
+    socketUnbind: (socket: NativeHandle, endpoint: string) => void;
+    socketUnsetSubscription: (socket: NativeHandle, topic: string) => void;
+    subscriptionAt: (socket: NativeHandle, index: number) => SubscriptionEntry | null;
+}

package/dist/zlink/runtime/native/binding_socket.js

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

package/dist/zlink/runtime/native/binding_types.d.ts

@@ -0,0 +1,8 @@
+import type { NativeReceivedRaw, NativeTopicMessageRaw } from '../messaging/message_materializer';
+import type { MonitorEventValueRaw, MonitorStatusRaw } from '../eventing/monitor_raw';
+import type { SubscriptionEntry } from '../../contracts/messaging';
+export type NativeHandle = unknown;
+export type NativeBuffer = Buffer;
+export type NullableNativeHandle = NativeHandle | null;
+export type NativeVersion = [number, number, number];
+export type { MonitorEventValueRaw, MonitorStatusRaw, NativeReceivedRaw, NativeTopicMessageRaw, SubscriptionEntry };

package/dist/zlink/runtime/native/binding_types.js

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

package/dist/zlink/runtime/native/native.d.ts

@@ -0,0 +1,2 @@
+import type { NativeBinding } from './binding';
+export declare function requireNative(): NativeBinding;

package/dist/zlink/runtime/native/native.js

@@ -0,0 +1,40 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNative = requireNative;
+const native_load_paths_1 = require("./native_load_paths");
+function loadNative() {
+    const paths = (0, native_load_paths_1.nativeLoadPaths)();
+    const failures = [];
+    try {
+        (0, native_load_paths_1.prepareDevelopmentRuntimeLink)(paths.packageRoot);
+        return (0, native_load_paths_1.requireNativeAt)(paths.buildAddon);
+    }
+    catch (error) {
+        failures.push({ target: paths.buildAddon, error });
+        try {
+            (0, native_load_paths_1.preparePrebuiltRuntimePath)(paths.prebuiltDir);
+            return (0, native_load_paths_1.requireNativeAt)(paths.prebuiltAddon);
+        }
+        catch (error) {
+            failures.push({ target: paths.prebuiltAddon, error });
+        }
+    }
+    throw new Error([
+        'zlink native addon not found. Build with node-gyp.',
+        ...failures.map((failure) => `- ${(0, native_load_paths_1.describeLoadFailure)(failure)}`)
+    ].join('\n'));
+}
+let native = null;
+let loadError = null;
+try {
+    native = loadNative();
+}
+catch (error) {
+    loadError = error instanceof Error ? error : new Error(String(error));
+}
+function requireNative() {
+    if (!native)
+        throw loadError ?? new Error('zlink native addon not found. Build with node-gyp.');
+    return native;
+}

package/dist/zlink/runtime/native/native_load_paths.d.ts

@@ -0,0 +1,16 @@
+import type { NativeBinding } from './binding';
+export interface NativeLoadFailure {
+    target: string;
+    error: unknown;
+}
+export interface NativeLoadPaths {
+    packageRoot: string;
+    buildAddon: string;
+    prebuiltDir: string;
+    prebuiltAddon: string;
+}
+export declare function nativeLoadPaths(): NativeLoadPaths;
+export declare function describeLoadFailure(failure: NativeLoadFailure): string;
+export declare function prepareDevelopmentRuntimeLink(packageRoot: string): void;
+export declare function preparePrebuiltRuntimePath(prebuiltDir: string): void;
+export declare function requireNativeAt(target: string): NativeBinding;

package/dist/zlink/runtime/native/native_load_paths.js

@@ -0,0 +1,165 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeLoadPaths = nativeLoadPaths;
+exports.describeLoadFailure = describeLoadFailure;
+exports.prepareDevelopmentRuntimeLink = prepareDevelopmentRuntimeLink;
+exports.preparePrebuiltRuntimePath = preparePrebuiltRuntimePath;
+exports.requireNativeAt = requireNativeAt;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const LINUX_SONAME = 'libzlink.so.0';
+function nativeLoadPaths() {
+    const packageRoot = path.join(__dirname, '..', '..', '..', '..');
+    const prebuiltDir = path.join(packageRoot, 'prebuilds', `${process.platform}-${process.arch}`);
+    return {
+        packageRoot,
+        buildAddon: path.join(packageRoot, 'build', 'Release', 'zlink.node'),
+        prebuiltDir,
+        prebuiltAddon: path.join(prebuiltDir, 'zlink.node')
+    };
+}
+function describeLoadFailure(failure) {
+    const message = failure.error instanceof Error
+        ? failure.error.message
+        : String(failure.error);
+    return `${failure.target}: ${message}`;
+}
+function prepareDevelopmentRuntimeLink(packageRoot) {
+    if (process.platform !== 'linux') {
+        return;
+    }
+    const addonDir = path.join(packageRoot, 'build', 'Release');
+    const coreDir = path.join(packageRoot, '..', '..', 'core', 'build', 'lib');
+    const coreAltDir = path.join(packageRoot, '..', 'build_cpp', 'lib');
+    const releaseDir = process.env.ZLINK_CORE_SOURCE === 'release'
+        && process.env.ZLINK_CORE_PACKAGE_PREFIX
+        ? path.join(process.env.ZLINK_CORE_PACKAGE_PREFIX, 'lib')
+        : undefined;
+    const localDir = process.env.ZLINK_CORE_SOURCE === 'local'
+        ? process.env.ZLINK_CORE_LIB_DIR
+        : undefined;
+    const runtimeDirs = [localDir, releaseDir, coreDir, coreAltDir].filter((entry) => entry !== undefined);
+    refreshAddonRuntimeLink(path.join(addonDir, LINUX_SONAME), runtimeDirs.map((entry) => path.join(entry, LINUX_SONAME)));
+    prependLibraryPath([...runtimeDirs, addonDir]);
+}
+function preparePrebuiltRuntimePath(prebuiltDir) {
+    if (process.platform === 'linux') {
+        const soname = path.join(prebuiltDir, LINUX_SONAME);
+        if (!fs.existsSync(soname)) {
+            const packageRoot = path.dirname(path.dirname(prebuiltDir));
+            let versionedLibrary;
+            try {
+                const provenance = JSON.parse(fs.readFileSync(path.join(packageRoot, 'provenance', 'core-package-provenance.json'), 'utf8'));
+                if (provenance.version !== undefined) {
+                    const candidate = path.join(prebuiltDir, `libzlink.so.${provenance.version}`);
+                    if (fs.existsSync(candidate))
+                        versionedLibrary = candidate;
+                }
+            }
+            catch {
+                // The normal package path has Core provenance. If it is unavailable,
+                // leave native loading to the development fallback below.
+            }
+            if (versionedLibrary !== undefined)
+                fs.symlinkSync(versionedLibrary, soname);
+        }
+        prependLibraryPath([prebuiltDir]);
+        return;
+    }
+    if (process.platform !== 'win32') {
+        return;
+    }
+    prependPathEntries([
+        prebuiltDir,
+        windowsRuntimePath(process.env.ZLINK_LIBRARY_PATH),
+        process.env.ZLINK_CORE_PREFIX
+            ? path.join(process.env.ZLINK_CORE_PREFIX, 'bin')
+            : undefined,
+        process.env.ZLINK_CORE_PREFIX,
+        process.env.ZLINK_OPENSSL_BIN,
+        process.env.OPENSSL_BIN,
+        'C:\\Program Files\\OpenSSL-Win64\\bin',
+        'C:\\Program Files\\Git\\mingw64\\bin',
+        'C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\Common7\\IDE\\CommonExtensions\\Microsoft\\TeamFoundation\\Team Explorer\\Git\\mingw64\\bin'
+    ]);
+}
+function windowsRuntimePath(entry) {
+    if (!entry)
+        return undefined;
+    try {
+        if (fs.statSync(entry).isFile())
+            return path.dirname(entry);
+    }
+    catch {
+        // Let the native loader report a missing runtime with its normal error.
+    }
+    return entry;
+}
+function requireNativeAt(target) {
+    return require(target);
+}
+function refreshAddonRuntimeLink(addonLib, sourceLibs) {
+    for (const sourceLib of sourceLibs) {
+        if (!fs.existsSync(sourceLib))
+            continue;
+        const sourceReal = fs.realpathSync(sourceLib);
+        const currentReal = fs.existsSync(addonLib) ? fs.realpathSync(addonLib) : null;
+        if (currentReal === sourceReal)
+            return;
+        fs.rmSync(addonLib, { force: true });
+        fs.symlinkSync(sourceLib, addonLib);
+        return;
+    }
+}
+function prependLibraryPath(entries) {
+    const existing = (process.env.LD_LIBRARY_PATH || '').split(':').filter(Boolean);
+    for (const entry of entries) {
+        if (!existing.includes(entry))
+            existing.unshift(entry);
+    }
+    process.env.LD_LIBRARY_PATH = existing.join(':');
+}
+function prependPathEntries(entries) {
+    const existing = (process.env.PATH || '').split(';').filter(Boolean);
+    for (const entry of entries) {
+        if (!entry || !fs.existsSync(entry))
+            continue;
+        if (!existing.includes(entry))
+            existing.unshift(entry);
+    }
+    process.env.PATH = existing.join(';');
+}

package/dist/zlink/runtime/options/byte_values.d.ts

@@ -0,0 +1,3 @@
+export declare function validateUInt64(value: bigint, name: string): bigint;
+export declare function uint64Buffer(value: bigint, name: string): Buffer;
+export declare function readUInt64Option(buffer: Buffer, name: string): bigint;

package/dist/zlink/runtime/options/byte_values.js

@@ -0,0 +1,27 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUInt64 = validateUInt64;
+exports.uint64Buffer = uint64Buffer;
+exports.readUInt64Option = readUInt64Option;
+function validateUInt64(value, name) {
+    if (typeof value !== 'bigint') {
+        throw new TypeError(`${name} must be a bigint`);
+    }
+    const max = (1n << 64n) - 1n;
+    if (value < 0n || value > max) {
+        throw new RangeError(`${name} must fit in uint64`);
+    }
+    return value;
+}
+function uint64Buffer(value, name) {
+    validateUInt64(value, name);
+    const buf = Buffer.allocUnsafe(8);
+    buf.writeBigUInt64LE(value, 0);
+    return buf;
+}
+function readUInt64Option(buffer, name) {
+    if (buffer.length !== 8)
+        throw new Error(`${name} option returned an invalid payload`);
+    return buffer.readBigUInt64LE(0);
+}

package/dist/zlink/runtime/options/option_mapping.d.ts

@@ -0,0 +1,72 @@
+export declare const SocketOption: Readonly<{
+    readonly AFFINITY: 12289;
+    readonly RATE: 12291;
+    readonly RECOVERY_IVL: 12292;
+    readonly SNDBUF: 12293;
+    readonly RCVBUF: 12294;
+    readonly FD: 12295;
+    readonly EVENTS: 12296;
+    readonly TYPE: 12297;
+    readonly LINGER: 12298;
+    readonly RECONNECT_IVL: 12299;
+    readonly BACKLOG: 12300;
+    readonly RECONNECT_IVL_MAX: 12301;
+    readonly MAXMSGSIZE: 12302;
+    readonly SNDHWM: 12303;
+    readonly RCVHWM: 12304;
+    readonly MULTICAST_HOPS: 12305;
+    readonly RCVTIMEO: 12306;
+    readonly SNDTIMEO: 12307;
+    readonly LAST_ENDPOINT: 12308;
+    readonly TCP_KEEPALIVE: 12309;
+    readonly TCP_KEEPALIVE_CNT: 12310;
+    readonly TCP_KEEPALIVE_IDLE: 12311;
+    readonly TCP_KEEPALIVE_INTVL: 12312;
+    readonly IMMEDIATE: 12313;
+    readonly IPV6: 12314;
+    readonly CONFLATE: 12315;
+    readonly TOS: 12316;
+    readonly HANDSHAKE_IVL: 12317;
+    readonly BLOCKY: 12318;
+    readonly INVERT_MATCHING: 12320;
+    readonly CONNECT_TIMEOUT: 12324;
+    readonly TCP_MAXRT: 12325;
+    readonly MULTICAST_MAXTPDU: 12326;
+    readonly BINDTODEVICE: 12327;
+    readonly TLS_CERT: 12328;
+    readonly TLS_KEY: 12329;
+    readonly TLS_CA: 12330;
+    readonly TLS_VERIFY: 12331;
+    readonly TLS_REQUIRE_CLIENT_CERT: 12332;
+    readonly TLS_HOSTNAME: 12333;
+    readonly TLS_TRUST_SYSTEM: 12334;
+    readonly TLS_PASSWORD: 12335;
+    readonly ZMP_METADATA: 12336;
+    readonly TCP_NODELAY: 12337;
+    readonly RID_DUPLICATE_POLICY: 12339;
+    readonly SUBMIT_RETRY_MODE: 12343;
+    readonly SUBMIT_RETRY_TIMEOUT: 12344;
+    readonly SUBMIT_RETRY_ATTEMPTS: 12345;
+    readonly PENDING_MAX_MSGS: 12346;
+    readonly PENDING_MAX_BYTES: 12347;
+    readonly ROUTER_MANDATORY: 12545;
+    readonly PROBE_ROUTER: 12547;
+    readonly CONNECT_ROUTING_ID: 12548;
+    readonly ROUTER_REQUEST_TIMEOUT_MS: 12549;
+    readonly ROUTER_WEIGHT: 12550;
+    readonly DEALER_PROBE: 12801;
+    readonly DEALER_REQUEST_TIMEOUT_MS: 12802;
+    readonly DEALER_WEIGHT: 12803;
+    readonly XPUB_VERBOSE: 13057;
+    readonly XPUB_VERBOSER: 13058;
+    readonly XPUB_MANUAL: 13059;
+    readonly XPUB_MANUAL_LAST_VALUE: 13060;
+    readonly XPUB_NODROP: 13061;
+    readonly XPUB_WELCOME_MSG: 13062;
+    readonly XPUB_TOPICS_COUNT: 13063;
+    readonly XPUB_APPROVE_SUBSCRIBE: 13064;
+    readonly XPUB_REJECT_SUBSCRIBE: 13065;
+    readonly SUB_TOPICS_COUNT: 13312;
+    readonly STREAM_NOTIFY: 13569;
+    readonly STREAM_RECV_MODE: 13570;
+}>;

package/dist/zlink/runtime/options/option_mapping.js

@@ -0,0 +1,41 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketOption = void 0;
+exports.SocketOption = Object.freeze({
+    AFFINITY: 0x3001, RATE: 0x3003, RECOVERY_IVL: 0x3004,
+    SNDBUF: 0x3005, RCVBUF: 0x3006, FD: 0x3007, EVENTS: 0x3008,
+    TYPE: 0x3009, LINGER: 0x300A, RECONNECT_IVL: 0x300B,
+    BACKLOG: 0x300C, RECONNECT_IVL_MAX: 0x300D, MAXMSGSIZE: 0x300E,
+    SNDHWM: 0x300F, RCVHWM: 0x3010, MULTICAST_HOPS: 0x3011,
+    RCVTIMEO: 0x3012, SNDTIMEO: 0x3013, LAST_ENDPOINT: 0x3014,
+    TCP_KEEPALIVE: 0x3015, TCP_KEEPALIVE_CNT: 0x3016,
+    TCP_KEEPALIVE_IDLE: 0x3017, TCP_KEEPALIVE_INTVL: 0x3018,
+    IMMEDIATE: 0x3019, IPV6: 0x301A, CONFLATE: 0x301B,
+    TOS: 0x301C, HANDSHAKE_IVL: 0x301D, BLOCKY: 0x301E,
+    INVERT_MATCHING: 0x3020,
+    CONNECT_TIMEOUT: 0x3024, TCP_MAXRT: 0x3025,
+    MULTICAST_MAXTPDU: 0x3026, BINDTODEVICE: 0x3027,
+    TLS_CERT: 0x3028, TLS_KEY: 0x3029, TLS_CA: 0x302A,
+    TLS_VERIFY: 0x302B, TLS_REQUIRE_CLIENT_CERT: 0x302C,
+    TLS_HOSTNAME: 0x302D, TLS_TRUST_SYSTEM: 0x302E,
+    TLS_PASSWORD: 0x302F, ZMP_METADATA: 0x3030,
+    TCP_NODELAY: 0x3031, RID_DUPLICATE_POLICY: 0x3033,
+    SUBMIT_RETRY_MODE: 0x3037,
+    SUBMIT_RETRY_TIMEOUT: 0x3038,
+    SUBMIT_RETRY_ATTEMPTS: 0x3039,
+    // ABI-stable legacy values. Core stores them but SEND and REQUEST ignore them.
+    PENDING_MAX_MSGS: 0x303A,
+    PENDING_MAX_BYTES: 0x303B,
+    ROUTER_MANDATORY: 0x3101,
+    PROBE_ROUTER: 0x3103, CONNECT_ROUTING_ID: 0x3104,
+    ROUTER_REQUEST_TIMEOUT_MS: 0x3105, ROUTER_WEIGHT: 0x3106,
+    DEALER_PROBE: 0x3201, DEALER_REQUEST_TIMEOUT_MS: 0x3202,
+    DEALER_WEIGHT: 0x3203,
+    XPUB_VERBOSE: 0x3301, XPUB_VERBOSER: 0x3302, XPUB_MANUAL: 0x3303,
+    XPUB_MANUAL_LAST_VALUE: 0x3304, XPUB_NODROP: 0x3305,
+    XPUB_WELCOME_MSG: 0x3306, XPUB_TOPICS_COUNT: 0x3307,
+    XPUB_APPROVE_SUBSCRIBE: 0x3308, XPUB_REJECT_SUBSCRIBE: 0x3309,
+    SUB_TOPICS_COUNT: 0x3400,
+    STREAM_NOTIFY: 0x3501, STREAM_RECV_MODE: 0x3502
+});

package/dist/zlink/runtime/options/validation.d.ts

@@ -0,0 +1 @@
+export declare function validateCString(value: string, name: string, maxLength?: number): string;

package/dist/zlink/runtime/options/validation.js

@@ -0,0 +1,17 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCString = validateCString;
+const FIXED_C_STRING_MAX_LENGTH = 255;
+function validateCString(value, name, maxLength = FIXED_C_STRING_MAX_LENGTH) {
+    if (typeof value !== 'string') {
+        throw new TypeError(`${name} must be a string`);
+    }
+    if (value.includes('\0')) {
+        throw new RangeError(`${name} must not contain embedded null characters`);
+    }
+    if (Buffer.byteLength(value, 'utf8') > maxLength) {
+        throw new RangeError(`${name} must be at most ${maxLength} bytes`);
+    }
+    return value;
+}

package/dist/zlink/runtime/public_bridge.d.ts

@@ -0,0 +1,6 @@
+import type { BaseSocket, Context } from '../contracts';
+import type { RuntimeContext } from './core/context';
+import type { RuntimeBaseSocket } from './sockets';
+export declare function asRuntimeContext(ctx: Context): RuntimeContext;
+export declare function asRuntimeSocket(socket: BaseSocket): RuntimeBaseSocket;
+export declare function asPublicContract<T>(value: unknown): T;

package/dist/zlink/runtime/public_bridge.js

@@ -0,0 +1,23 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asRuntimeContext = asRuntimeContext;
+exports.asRuntimeSocket = asRuntimeSocket;
+exports.asPublicContract = asPublicContract;
+const native_handle_1 = require("./handles/native_handle");
+function assertRuntimeHandle(value, name) {
+    if (!(value instanceof native_handle_1.NativeHandle)) {
+        throw new TypeError(`${name} must be created by this zlink package`);
+    }
+}
+function asRuntimeContext(ctx) {
+    assertRuntimeHandle(ctx, 'context');
+    return ctx;
+}
+function asRuntimeSocket(socket) {
+    assertRuntimeHandle(socket, 'socket');
+    return socket;
+}
+function asPublicContract(value) {
+    return value;
+}

package/dist/zlink/runtime/sockets/dealer_socket.d.ts

@@ -0,0 +1,16 @@
+import { RoutingId } from '../../contracts';
+import type { Received, RequestOperation, SendOperation } from '../../contracts/messaging';
+import { RecvFlags } from '../../contracts/sockets/socket_constants';
+import type { RuntimeContext as Context } from '../core/context';
+import { ReceiveSocket } from './socket_operations';
+import { DealerSocketOptions } from './socket_options';
+export declare class DealerSocket extends ReceiveSocket {
+    readonly options: DealerSocketOptions;
+    constructor(ctx: Context);
+    setRoutingId(routingId: RoutingId): void;
+    getRoutingId(): RoutingId;
+    send(): SendOperation;
+    request(): RequestOperation;
+    recv(result: Received, flags?: RecvFlags): boolean;
+    private resolveRequestTimeout;
+}

package/dist/zlink/runtime/sockets/dealer_socket.js

@@ -0,0 +1,56 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DealerSocket = void 0;
+const contracts_1 = require("../../contracts");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+const routing_id_1 = require("../core/routing_id");
+const native_errors_1 = require("../errors/native_errors");
+const native_handle_1 = require("../handles/native_handle");
+const completion_owner_1 = require("../messaging/completion_owner");
+const message_materializer_1 = require("../messaging/message_materializer");
+const native_1 = require("../native/native");
+const socket_operations_1 = require("./socket_operations");
+const socket_options_1 = require("./socket_options");
+const native = (0, native_1.requireNative)();
+class DealerSocket extends socket_operations_1.ReceiveSocket {
+    options;
+    constructor(ctx) {
+        super(ctx, socket_constants_1.SocketType.DEALER);
+        this.options = socket_options_1.DealerSocketOptions.create(this);
+    }
+    setRoutingId(routingId) {
+        const normalized = (0, routing_id_1.normalizeRoutingId)(routingId);
+        (0, native_errors_1.configCall)('routing id set failed', () => native.handleSetRoutingId((0, native_handle_1.getNativeHandle)(this), normalized));
+    }
+    getRoutingId() {
+        return contracts_1.RoutingId.from((0, native_errors_1.configCall)('routing id get failed', () => native.handleGetRoutingId((0, native_handle_1.getNativeHandle)(this))));
+    }
+    send() {
+        return new socket_operations_1.RuntimeSendOperation((parts) => (0, completion_owner_1.completionOwnerOf)(this).submitSend(parts, null), (parts) => (0, completion_owner_1.completionOwnerOf)(this).sendSync(parts, null));
+    }
+    request() {
+        return new socket_operations_1.RuntimeRequestOperation((parts, timeoutMs) => (0, completion_owner_1.completionOwnerOf)(this).submitRequest(parts, null, this.resolveRequestTimeout(timeoutMs)), (parts, timeoutMs) => (0, completion_owner_1.completionOwnerOf)(this).requestSync(parts, null, this.resolveRequestTimeout(timeoutMs)));
+    }
+    recv(result, flags = socket_constants_1.RecvFlags.None) {
+        let raw;
+        try {
+            raw = ((flags | 0) & (socket_constants_1.RecvFlags.DontWait | 0))
+                ? native.socketRecvMessageNoWait((0, native_handle_1.getNativeHandle)(this))
+                : native.socketRecvMessage((0, native_handle_1.getNativeHandle)(this), flags | 0);
+        }
+        catch (error) {
+            throw (0, native_errors_1.recvNativeError)(error, flags, 'recv failed');
+        }
+        if (raw == null)
+            return false;
+        (0, message_materializer_1.materializeReceivedInto)(result, raw);
+        return true;
+    }
+    resolveRequestTimeout(timeoutMs) {
+        return timeoutMs === 0
+            ? (this.options.requestTimeout === 0 ? 5_000 : this.options.requestTimeout)
+            : timeoutMs;
+    }
+}
+exports.DealerSocket = DealerSocket;

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

@@ -0,0 +1,19 @@
+import type { PairSocket } from './pair_socket';
+import type { PubSocket } from './pub_socket';
+import type { XPubSocket } from './xpub_socket';
+import type { SubSocket } from './sub_socket';
+import type { XSubSocket } from './xsub_socket';
+import type { DealerSocket } from './dealer_socket';
+import type { RouterSocket } from './router_socket';
+import type { StreamSocket } from './stream_socket';
+export { CommonSocketOptions as RuntimeCommonSocketOptions, DealerSocketOptions as RuntimeDealerSocketOptions, PubSocketOptions as RuntimePubSocketOptions, RouterSocketOptions as RuntimeRouterSocketOptions, StreamSocketOptions as RuntimeStreamSocketOptions, SubSocketOptions as RuntimeSubSocketOptions, } from './socket_options';
+export { PairSocket as RuntimePairSocket } from './pair_socket';
+export { PubSocket as RuntimePubSocket } from './pub_socket';
+export { XPubSocket as RuntimeXPubSocket } from './xpub_socket';
+export { SubSocket as RuntimeSubSocket } from './sub_socket';
+export { XSubSocket as RuntimeXSubSocket } from './xsub_socket';
+export { DealerSocket as RuntimeDealerSocket } from './dealer_socket';
+export { RouterSocket as RuntimeRouterSocket } from './router_socket';
+export { StreamSocket as RuntimeStreamSocket } from './stream_socket';
+export type BaseSocket = PairSocket | PubSocket | XPubSocket | SubSocket | XSubSocket | DealerSocket | RouterSocket | StreamSocket;
+export type { BaseSocket as RuntimeBaseSocket };