@zlink-systems/zlink 0.17.3

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

@@ -0,0 +1,104 @@
+import { Message, RoutingId, type MessageLike } from '../../contracts';
+import { type PollEventFlagValue, type RidDuplicatePolicy as RidDuplicatePolicyValue, type StreamRecvMode as StreamRecvModeValue } from '../../contracts/sockets/socket_constants';
+export declare function int32Buffer(value: number, name: string): Buffer;
+export declare function int64Buffer(value: bigint, name: string): Buffer;
+export declare function boolBuffer(value: boolean): Buffer;
+export declare function flagsToMask(events: readonly PollEventFlagValue[]): number;
+export declare function readBoolOption(buffer: Buffer, name: string): boolean;
+export declare function readInt32Option(buffer: Buffer, name: string): number;
+export declare function readInt64Option(buffer: Buffer, name: string): bigint;
+export declare function readRoutingIdOption(buffer: Buffer): RoutingId | null;
+export declare function readStringOption(buffer: Buffer): string;
+export declare const OPTION_CREATE_TOKEN: unique symbol;
+export declare class CommonSocketOptions {
+    protected readInt32(option: number, name: string): number;
+    protected writeInt32(option: number, value: number, name: string): void;
+    protected readBool(option: number, name: string): boolean;
+    protected writeBool(option: number, value: boolean): void;
+    get linger(): number;
+    set linger(value: number);
+    get sendHwm(): bigint;
+    set sendHwm(value: bigint);
+    get recvHwm(): bigint;
+    set recvHwm(value: bigint);
+    get sendTimeout(): number;
+    set sendTimeout(value: number);
+    get recvTimeout(): number;
+    set recvTimeout(value: number);
+    get immediate(): boolean;
+    set immediate(value: boolean);
+    get ridDuplicatePolicy(): RidDuplicatePolicyValue;
+    set ridDuplicatePolicy(value: RidDuplicatePolicyValue);
+    get connectTimeout(): number;
+    set connectTimeout(value: number);
+    get ipv6(): boolean;
+    set ipv6(value: boolean);
+    get tcpNoDelay(): boolean;
+    set tcpNoDelay(value: boolean);
+    get tcpKeepalive(): number;
+    set tcpKeepalive(value: number);
+    get maxMsgSize(): bigint;
+    set maxMsgSize(value: bigint);
+    get lastEndpoint(): string;
+    get backlog(): number;
+    set backlog(value: number);
+    get reconnectInterval(): number;
+    set reconnectInterval(value: number);
+    get reconnectIntervalMax(): number;
+    set reconnectIntervalMax(value: number);
+    get submitRetryMode(): number;
+    set submitRetryMode(value: number);
+    get submitRetryTimeout(): number;
+    set submitRetryTimeout(value: number);
+    get submitRetryAttempts(): number;
+    set submitRetryAttempts(value: number);
+}
+export declare class DealerSocketOptions extends CommonSocketOptions {
+    get probe(): boolean;
+    set probe(value: boolean);
+    get requestTimeout(): number;
+    set requestTimeout(value: number);
+    get peerWeight(): number;
+    set peerWeight(value: number);
+}
+export declare class RouterSocketOptions extends CommonSocketOptions {
+    get mandatory(): boolean;
+    set mandatory(value: boolean);
+    get handover(): boolean;
+    set handover(value: boolean);
+    get probe(): boolean;
+    set probe(value: boolean);
+    get connectRoutingId(): RoutingId | null;
+    setConnectRoutingId(routingId: RoutingId): void;
+    get requestTimeout(): number;
+    set requestTimeout(value: number);
+    get peerWeight(): number;
+    set peerWeight(value: number);
+}
+export declare class StreamSocketOptions extends CommonSocketOptions {
+    get notify(): boolean;
+    set notify(value: boolean);
+    get recvMode(): StreamRecvModeValue;
+    set recvMode(value: StreamRecvModeValue);
+}
+export declare class PubSocketOptions extends CommonSocketOptions {
+    private _welcomeMessage;
+    get verbose(): boolean;
+    set verbose(value: boolean);
+    get verboser(): boolean;
+    set verboser(value: boolean);
+    get noDrop(): boolean;
+    set noDrop(value: boolean);
+    get manual(): boolean;
+    set manual(value: boolean);
+    get manualLastValue(): boolean;
+    set manualLastValue(value: boolean);
+    get topicsCount(): number;
+    welcomeMessage(): Message;
+    setWelcomeMessage(message: MessageLike): void;
+    approveSubscribe(routingId: RoutingId): void;
+    rejectSubscribe(routingId: RoutingId): void;
+}
+export declare class SubSocketOptions extends CommonSocketOptions {
+    get topicsCount(): number;
+}

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

@@ -0,0 +1,259 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubSocketOptions = exports.PubSocketOptions = exports.StreamSocketOptions = exports.RouterSocketOptions = exports.DealerSocketOptions = exports.CommonSocketOptions = exports.OPTION_CREATE_TOKEN = void 0;
+exports.int32Buffer = int32Buffer;
+exports.int64Buffer = int64Buffer;
+exports.boolBuffer = boolBuffer;
+exports.flagsToMask = flagsToMask;
+exports.readBoolOption = readBoolOption;
+exports.readInt32Option = readInt32Option;
+exports.readInt64Option = readInt64Option;
+exports.readRoutingIdOption = readRoutingIdOption;
+exports.readStringOption = readStringOption;
+const contracts_1 = require("../../contracts");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+const message_conversion_1 = require("../buffers/message_conversion");
+const routing_id_1 = require("../core/routing_id");
+const option_mapping_1 = require("../options/option_mapping");
+const byte_values_1 = require("../options/byte_values");
+function int32Buffer(value, name) {
+    if (!Number.isInteger(value))
+        throw new TypeError(`${name} must be an integer`);
+    if (value < -2147483648 || value > 2147483647) {
+        throw new RangeError(`${name} must fit in int32`);
+    }
+    const buf = Buffer.allocUnsafe(4);
+    buf.writeInt32LE(value, 0);
+    return buf;
+}
+function int64Buffer(value, name) {
+    if (typeof value !== 'bigint') {
+        throw new TypeError(`${name} must be a bigint`);
+    }
+    const normalized = value;
+    const min = -(1n << 63n);
+    const max = (1n << 63n) - 1n;
+    if (normalized < min || normalized > max) {
+        throw new RangeError(`${name} must fit in int64`);
+    }
+    const buf = Buffer.allocUnsafe(8);
+    buf.writeBigInt64LE(normalized, 0);
+    return buf;
+}
+function boolBuffer(value) {
+    const buf = Buffer.allocUnsafe(4);
+    buf.writeUInt32LE(value ? 1 : 0, 0);
+    return buf;
+}
+function flagsToMask(events) {
+    if (!Array.isArray(events)) {
+        throw new TypeError('events must be an array');
+    }
+    return events.reduce((mask, event) => mask | (event | 0), 0);
+}
+function readBoolOption(buffer, name) {
+    if (buffer.length < 4)
+        throw new Error(`${name} option returned an invalid payload`);
+    return buffer.readUInt32LE(0) !== 0;
+}
+function readInt32Option(buffer, name) {
+    if (buffer.length < 4)
+        throw new Error(`${name} option returned an invalid payload`);
+    return buffer.readInt32LE(0);
+}
+function readInt64Option(buffer, name) {
+    if (buffer.length < 8)
+        throw new Error(`${name} option returned an invalid payload`);
+    return buffer.readBigInt64LE(0);
+}
+function readRoutingIdOption(buffer) {
+    return buffer.length === 0 ? null : contracts_1.RoutingId.from(buffer);
+}
+function readStringOption(buffer) {
+    const nul = buffer.indexOf(0);
+    return buffer.subarray(0, nul >= 0 ? nul : buffer.length).toString();
+}
+exports.OPTION_CREATE_TOKEN = Symbol('OptionFacade.create');
+class CommonSocketOptions {
+    /** @internal */
+    _socket;
+    /** @internal */
+    constructor(token, socket) {
+        if (token !== exports.OPTION_CREATE_TOKEN) {
+            throw new TypeError('socket options are created by sockets');
+        }
+        this._socket = socket;
+    }
+    /** @internal */
+    static create(socket) {
+        return new CommonSocketOptions(exports.OPTION_CREATE_TOKEN, socket);
+    }
+    readInt32(option, name) {
+        return readInt32Option(this._socket.getSockOptRaw(option), name);
+    }
+    writeInt32(option, value, name) {
+        this._socket.setSockOptRaw(option, int32Buffer(value, name));
+    }
+    readBool(option, name) {
+        return readBoolOption(this._socket.getSockOptRaw(option), name);
+    }
+    writeBool(option, value) {
+        this._socket.setSockOptRaw(option, boolBuffer(value));
+    }
+    get linger() { return this.readInt32(option_mapping_1.SocketOption.LINGER, 'linger'); }
+    set linger(value) { this.writeInt32(option_mapping_1.SocketOption.LINGER, value, 'linger'); }
+    get sendHwm() { return (0, byte_values_1.readUInt64Option)(this._socket.getSockOptRaw(option_mapping_1.SocketOption.SNDHWM), 'sendHwm'); }
+    set sendHwm(value) { this._socket.setSockOptRaw(option_mapping_1.SocketOption.SNDHWM, (0, byte_values_1.uint64Buffer)(value, 'sendHwm')); }
+    get recvHwm() { return (0, byte_values_1.readUInt64Option)(this._socket.getSockOptRaw(option_mapping_1.SocketOption.RCVHWM), 'recvHwm'); }
+    set recvHwm(value) { this._socket.setSockOptRaw(option_mapping_1.SocketOption.RCVHWM, (0, byte_values_1.uint64Buffer)(value, 'recvHwm')); }
+    get sendTimeout() { return this.readInt32(option_mapping_1.SocketOption.SNDTIMEO, 'sendTimeout'); }
+    set sendTimeout(value) { this.writeInt32(option_mapping_1.SocketOption.SNDTIMEO, value, 'sendTimeout'); }
+    get recvTimeout() { return this.readInt32(option_mapping_1.SocketOption.RCVTIMEO, 'recvTimeout'); }
+    set recvTimeout(value) { this.writeInt32(option_mapping_1.SocketOption.RCVTIMEO, value, 'recvTimeout'); }
+    get immediate() { return this.readBool(option_mapping_1.SocketOption.IMMEDIATE, 'immediate'); }
+    set immediate(value) { this.writeBool(option_mapping_1.SocketOption.IMMEDIATE, value); }
+    get ridDuplicatePolicy() { return this.readInt32(option_mapping_1.SocketOption.RID_DUPLICATE_POLICY, 'ridDuplicatePolicy'); }
+    set ridDuplicatePolicy(value) { this.writeInt32(option_mapping_1.SocketOption.RID_DUPLICATE_POLICY, value, 'ridDuplicatePolicy'); }
+    get connectTimeout() { return this.readInt32(option_mapping_1.SocketOption.CONNECT_TIMEOUT, 'connectTimeout'); }
+    set connectTimeout(value) { this.writeInt32(option_mapping_1.SocketOption.CONNECT_TIMEOUT, value, 'connectTimeout'); }
+    get ipv6() { return this.readBool(option_mapping_1.SocketOption.IPV6, 'ipv6'); }
+    set ipv6(value) { this.writeBool(option_mapping_1.SocketOption.IPV6, value); }
+    get tcpNoDelay() { return this.readBool(option_mapping_1.SocketOption.TCP_NODELAY, 'tcpNoDelay'); }
+    set tcpNoDelay(value) { this.writeBool(option_mapping_1.SocketOption.TCP_NODELAY, value); }
+    get tcpKeepalive() { return this.readInt32(option_mapping_1.SocketOption.TCP_KEEPALIVE, 'tcpKeepalive'); }
+    set tcpKeepalive(value) { this.writeInt32(option_mapping_1.SocketOption.TCP_KEEPALIVE, value, 'tcpKeepalive'); }
+    get maxMsgSize() { return readInt64Option(this._socket.getSockOptRaw(option_mapping_1.SocketOption.MAXMSGSIZE), 'maxMsgSize'); }
+    set maxMsgSize(value) { this._socket.setSockOptRaw(option_mapping_1.SocketOption.MAXMSGSIZE, int64Buffer(value, 'maxMsgSize')); }
+    get lastEndpoint() { return readStringOption(this._socket.getSockOptRaw(option_mapping_1.SocketOption.LAST_ENDPOINT)); }
+    get backlog() { return this.readInt32(option_mapping_1.SocketOption.BACKLOG, 'backlog'); }
+    set backlog(value) { this.writeInt32(option_mapping_1.SocketOption.BACKLOG, value, 'backlog'); }
+    get reconnectInterval() { return this.readInt32(option_mapping_1.SocketOption.RECONNECT_IVL, 'reconnectInterval'); }
+    set reconnectInterval(value) { this.writeInt32(option_mapping_1.SocketOption.RECONNECT_IVL, value, 'reconnectInterval'); }
+    get reconnectIntervalMax() { return this.readInt32(option_mapping_1.SocketOption.RECONNECT_IVL_MAX, 'reconnectIntervalMax'); }
+    set reconnectIntervalMax(value) { this.writeInt32(option_mapping_1.SocketOption.RECONNECT_IVL_MAX, value, 'reconnectIntervalMax'); }
+    get submitRetryMode() { return this.readInt32(option_mapping_1.SocketOption.SUBMIT_RETRY_MODE, 'submitRetryMode'); }
+    set submitRetryMode(value) { this.writeInt32(option_mapping_1.SocketOption.SUBMIT_RETRY_MODE, value, 'submitRetryMode'); }
+    get submitRetryTimeout() { return this.readInt32(option_mapping_1.SocketOption.SUBMIT_RETRY_TIMEOUT, 'submitRetryTimeout'); }
+    set submitRetryTimeout(value) { this.writeInt32(option_mapping_1.SocketOption.SUBMIT_RETRY_TIMEOUT, value, 'submitRetryTimeout'); }
+    get submitRetryAttempts() { return this.readInt32(option_mapping_1.SocketOption.SUBMIT_RETRY_ATTEMPTS, 'submitRetryAttempts'); }
+    set submitRetryAttempts(value) { this.writeInt32(option_mapping_1.SocketOption.SUBMIT_RETRY_ATTEMPTS, value, 'submitRetryAttempts'); }
+}
+exports.CommonSocketOptions = CommonSocketOptions;
+class DealerSocketOptions extends CommonSocketOptions {
+    /** @internal */
+    constructor(token, socket) { super(token, socket); }
+    /** @internal */
+    static create(socket) {
+        return new DealerSocketOptions(exports.OPTION_CREATE_TOKEN, socket);
+    }
+    get probe() { return this.readBool(option_mapping_1.SocketOption.DEALER_PROBE, 'probe'); }
+    set probe(value) { this.writeBool(option_mapping_1.SocketOption.DEALER_PROBE, value); }
+    get requestTimeout() { return this.readInt32(option_mapping_1.SocketOption.DEALER_REQUEST_TIMEOUT_MS, 'requestTimeout'); }
+    set requestTimeout(value) { this.writeInt32(option_mapping_1.SocketOption.DEALER_REQUEST_TIMEOUT_MS, value, 'requestTimeout'); }
+    get peerWeight() { return this.readInt32(option_mapping_1.SocketOption.DEALER_WEIGHT, 'peerWeight'); }
+    set peerWeight(value) { this.writeInt32(option_mapping_1.SocketOption.DEALER_WEIGHT, value, 'peerWeight'); }
+}
+exports.DealerSocketOptions = DealerSocketOptions;
+class RouterSocketOptions extends CommonSocketOptions {
+    /** @internal */
+    constructor(token, socket) { super(token, socket); }
+    /** @internal */
+    static create(socket) {
+        return new RouterSocketOptions(exports.OPTION_CREATE_TOKEN, socket);
+    }
+    get mandatory() { return this.readBool(option_mapping_1.SocketOption.ROUTER_MANDATORY, 'mandatory'); }
+    set mandatory(value) { this.writeBool(option_mapping_1.SocketOption.ROUTER_MANDATORY, value); }
+    get handover() { return this.ridDuplicatePolicy === socket_constants_1.RidDuplicatePolicy.Handover; }
+    set handover(value) { this.ridDuplicatePolicy = value ? socket_constants_1.RidDuplicatePolicy.Handover : socket_constants_1.RidDuplicatePolicy.Reject; }
+    get probe() { return this.readBool(option_mapping_1.SocketOption.PROBE_ROUTER, 'probe'); }
+    set probe(value) { this.writeBool(option_mapping_1.SocketOption.PROBE_ROUTER, value); }
+    get connectRoutingId() { return readRoutingIdOption(this._socket.getSockOptRaw(option_mapping_1.SocketOption.CONNECT_ROUTING_ID)); }
+    setConnectRoutingId(routingId) {
+        this._socket.setSockOptRaw(option_mapping_1.SocketOption.CONNECT_ROUTING_ID, (0, routing_id_1.normalizeRoutingId)(routingId, 'routingId'));
+    }
+    get requestTimeout() { return this.readInt32(option_mapping_1.SocketOption.ROUTER_REQUEST_TIMEOUT_MS, 'requestTimeout'); }
+    set requestTimeout(value) { this.writeInt32(option_mapping_1.SocketOption.ROUTER_REQUEST_TIMEOUT_MS, value, 'requestTimeout'); }
+    get peerWeight() { return this.readInt32(option_mapping_1.SocketOption.ROUTER_WEIGHT, 'peerWeight'); }
+    set peerWeight(value) { this.writeInt32(option_mapping_1.SocketOption.ROUTER_WEIGHT, value, 'peerWeight'); }
+}
+exports.RouterSocketOptions = RouterSocketOptions;
+class StreamSocketOptions extends CommonSocketOptions {
+    /** @internal */
+    constructor(token, socket) { super(token, socket); }
+    /** @internal */
+    static create(socket) {
+        return new StreamSocketOptions(exports.OPTION_CREATE_TOKEN, socket);
+    }
+    get notify() { return this.readBool(option_mapping_1.SocketOption.STREAM_NOTIFY, 'notify'); }
+    set notify(value) { this.writeBool(option_mapping_1.SocketOption.STREAM_NOTIFY, value); }
+    get recvMode() {
+        return this.readInt32(option_mapping_1.SocketOption.STREAM_RECV_MODE, 'recvMode');
+    }
+    set recvMode(value) {
+        if (value !== socket_constants_1.StreamRecvMode.Raw && value !== socket_constants_1.StreamRecvMode.Packet) {
+            throw new RangeError('recvMode must be StreamRecvMode.Raw or StreamRecvMode.Packet');
+        }
+        this.writeInt32(option_mapping_1.SocketOption.STREAM_RECV_MODE, value, 'recvMode');
+    }
+}
+exports.StreamSocketOptions = StreamSocketOptions;
+class PubSocketOptions extends CommonSocketOptions {
+    _welcomeMessage = Buffer.alloc(0);
+    /** @internal */
+    constructor(token, socket) { super(token, socket); }
+    /** @internal */
+    static create(socket) {
+        return new PubSocketOptions(exports.OPTION_CREATE_TOKEN, socket);
+    }
+    get verbose() { return this.readBool(option_mapping_1.SocketOption.XPUB_VERBOSE, 'verbose'); }
+    set verbose(value) {
+        this.writeBool(option_mapping_1.SocketOption.XPUB_VERBOSE, value);
+        this.writeBool(option_mapping_1.SocketOption.XPUB_VERBOSER, false);
+    }
+    get verboser() { return this.readBool(option_mapping_1.SocketOption.XPUB_VERBOSER, 'verboser'); }
+    set verboser(value) {
+        this.writeBool(option_mapping_1.SocketOption.XPUB_VERBOSE, value);
+        this.writeBool(option_mapping_1.SocketOption.XPUB_VERBOSER, value);
+    }
+    get noDrop() { return this.readBool(option_mapping_1.SocketOption.XPUB_NODROP, 'noDrop'); }
+    set noDrop(value) {
+        this.writeBool(option_mapping_1.SocketOption.XPUB_NODROP, value);
+    }
+    get manual() { return this.readBool(option_mapping_1.SocketOption.XPUB_MANUAL, 'manual'); }
+    set manual(value) {
+        this.writeBool(option_mapping_1.SocketOption.XPUB_MANUAL, value);
+    }
+    get manualLastValue() { return this.readBool(option_mapping_1.SocketOption.XPUB_MANUAL_LAST_VALUE, 'manualLastValue'); }
+    set manualLastValue(value) {
+        this.writeBool(option_mapping_1.SocketOption.XPUB_MANUAL, value);
+        this.writeBool(option_mapping_1.SocketOption.XPUB_MANUAL_LAST_VALUE, value);
+    }
+    get topicsCount() { return this.readInt32(option_mapping_1.SocketOption.XPUB_TOPICS_COUNT, 'topicsCount'); }
+    welcomeMessage() { return contracts_1.Message.from(this._welcomeMessage); }
+    setWelcomeMessage(message) {
+        const payload = (0, message_conversion_1.normalizeMessageLikePayload)(message);
+        if (Array.isArray(payload))
+            throw new TypeError('welcome payload must contain one frame');
+        const data = Buffer.isBuffer(payload) ? payload : payload.data;
+        this._socket.setSockOptRaw(option_mapping_1.SocketOption.XPUB_WELCOME_MSG, data);
+        this._welcomeMessage = Buffer.from(data);
+    }
+    approveSubscribe(routingId) {
+        this._socket.setSockOptRaw(option_mapping_1.SocketOption.XPUB_APPROVE_SUBSCRIBE, (0, routing_id_1.normalizeRoutingId)(routingId));
+    }
+    rejectSubscribe(routingId) {
+        this._socket.setSockOptRaw(option_mapping_1.SocketOption.XPUB_REJECT_SUBSCRIBE, (0, routing_id_1.normalizeRoutingId)(routingId));
+    }
+}
+exports.PubSocketOptions = PubSocketOptions;
+class SubSocketOptions extends CommonSocketOptions {
+    /** @internal */
+    constructor(token, socket) { super(token, socket); }
+    /** @internal */
+    static create(socket) {
+        return new SubSocketOptions(exports.OPTION_CREATE_TOKEN, socket);
+    }
+    get topicsCount() { return this.readInt32(option_mapping_1.SocketOption.SUB_TOPICS_COUNT, 'topicsCount'); }
+}
+exports.SubSocketOptions = SubSocketOptions;

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

@@ -0,0 +1,3 @@
+import { SubmitError, SubmitResult } from '../../contracts/errors/errors';
+export declare function submitErrorFromResult(result: SubmitResult, message: string): SubmitError;
+export declare function submitErrorFromNativeResult(result: number, nativeErrno: number, message: string): SubmitError;

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

@@ -0,0 +1,13 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitErrorFromResult = submitErrorFromResult;
+exports.submitErrorFromNativeResult = submitErrorFromNativeResult;
+const errors_1 = require("../../contracts/errors/errors");
+const error_state_1 = require("../errors/error_state");
+function submitErrorFromResult(result, message) {
+    return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.SubmitError(result, 0), message);
+}
+function submitErrorFromNativeResult(result, nativeErrno, message) {
+    return (0, error_state_1.withRuntimeErrorMessage)(new errors_1.SubmitError(result, nativeErrno), message);
+}

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

@@ -0,0 +1,15 @@
+import { Received, RoutingId, StreamPacket, type SendOperation } from '../../contracts';
+import { RecvFlags } from '../../contracts/sockets/socket_constants';
+import type { RuntimeContext as Context } from '../core/context';
+import { SocketBase } from './socket_base';
+import { StreamSocketOptions } from './socket_options';
+export declare class StreamSocket extends SocketBase {
+    readonly options: StreamSocketOptions;
+    constructor(ctx: Context);
+    send(routingId: RoutingId): SendOperation;
+    recv(result: Received, flags?: RecvFlags): boolean;
+    recvPacket(result: StreamPacket, flags?: RecvFlags): boolean;
+    setRoutingId(routingId: RoutingId): void;
+    getRoutingId(): RoutingId;
+    disconnectRid(routingId: RoutingId): void;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamSocket = void 0;
+const contracts_1 = require("../../contracts");
+const stream_packet_1 = require("../../contracts/messaging/stream_packet");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+const message_conversion_1 = require("../buffers/message_conversion");
+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_base_1 = require("./socket_base");
+const socket_operations_1 = require("./socket_operations");
+const socket_options_1 = require("./socket_options");
+const native = (0, native_1.requireNative)();
+class StreamSocket extends socket_base_1.SocketBase {
+    options;
+    constructor(ctx) {
+        super(ctx, socket_constants_1.SocketType.STREAM);
+        this.options = socket_options_1.StreamSocketOptions.create(this);
+    }
+    send(routingId) {
+        const target = Buffer.from((0, routing_id_1.normalizeRoutingId)(routingId));
+        return new socket_operations_1.RuntimeSendOperation((parts) => (0, completion_owner_1.completionOwnerOf)(this).submitSend(parts, target), (parts) => (0, completion_owner_1.completionOwnerOf)(this).sendSync(parts, target));
+    }
+    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;
+        const routingId = (0, message_materializer_1.nativeReceivedRoutingId)(raw);
+        const sendSync = (parts) => {
+            if (!routingId)
+                throw new Error('missing routed send target');
+            (0, completion_owner_1.completionOwnerOf)(this).sendSync(parts, routingId);
+        };
+        const sendManaged = (parts) => {
+            if (!routingId)
+                return Promise.reject(new Error('missing routed send target'));
+            return (0, completion_owner_1.completionOwnerOf)(this).submitSend(parts, routingId);
+        };
+        (0, message_materializer_1.materializeReceivedInto)(result, raw, sendSync, sendManaged);
+        return true;
+    }
+    recvPacket(result, flags = socket_constants_1.RecvFlags.None) {
+        if (!(result instanceof contracts_1.StreamPacket)) {
+            throw new TypeError('result must be a StreamPacket');
+        }
+        const state = (0, stream_packet_1.streamPacketState)(result);
+        if (state._receiving)
+            throw new Error('StreamPacket is already in use by recvPacket');
+        result.close();
+        state._receiving = true;
+        try {
+            const raw = native.socketStreamRecvPacket((0, native_handle_1.getNativeHandle)(this), flags | 0);
+            if (raw == null)
+                return false;
+            state._routingId = contracts_1.RoutingId.from(raw.routingId);
+            state._header = (0, message_conversion_1.messageFromNativeBuffer)(raw.header);
+            state._body = (0, message_conversion_1.messageFromNativeBuffer)(raw.body);
+            return true;
+        }
+        catch (error) {
+            result.close();
+            throw (0, native_errors_1.recvNativeError)(error, flags, 'stream packet recv failed');
+        }
+        finally {
+            state._receiving = false;
+        }
+    }
+    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))));
+    }
+    disconnectRid(routingId) {
+        const normalized = (0, routing_id_1.normalizeRoutingId)(routingId);
+        (0, native_errors_1.configCall)('stream disconnect by routing id failed', () => native.socketDisconnectRid((0, native_handle_1.getNativeHandle)(this), normalized));
+    }
+}
+exports.StreamSocket = StreamSocket;

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

@@ -0,0 +1,7 @@
+import { SubSocketOptions } from './socket_options';
+import { SubscriberSocket } from './socket_operations';
+import type { RuntimeContext as Context } from '../core/context';
+export declare class SubSocket extends SubscriberSocket {
+    readonly options: SubSocketOptions;
+    constructor(ctx: Context);
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubSocket = void 0;
+const socket_options_1 = require("./socket_options");
+const socket_operations_1 = require("./socket_operations");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+class SubSocket extends socket_operations_1.SubscriberSocket {
+    options;
+    constructor(ctx) { super(ctx, socket_constants_1.SocketType.SUB); this.options = socket_options_1.SubSocketOptions.create(this); }
+}
+exports.SubSocket = SubSocket;

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

@@ -0,0 +1,10 @@
+import { PubSocketOptions } from './socket_options';
+import { PublisherSocket } from './socket_operations';
+import type { RuntimeContext as Context } from '../core/context';
+import { SubscriptionEvent } from '../../contracts';
+import { RecvFlags } from '../../contracts/sockets/socket_constants';
+export declare class XPubSocket extends PublisherSocket {
+    readonly options: PubSocketOptions;
+    constructor(ctx: Context);
+    receiveSubscriptionEvent(result: SubscriptionEvent, flags?: RecvFlags): boolean;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XPubSocket = void 0;
+const socket_options_1 = require("./socket_options");
+const socket_operations_1 = require("./socket_operations");
+const native_errors_1 = require("../errors/native_errors");
+const native_handle_1 = require("../handles/native_handle");
+const native_1 = require("../native/native");
+const contracts_1 = require("../../contracts");
+const routing_id_conversion_1 = require("../core/routing_id_conversion");
+const subscription_event_state_1 = require("../messaging/subscription_event_state");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+class XPubSocket extends socket_operations_1.PublisherSocket {
+    options;
+    constructor(ctx) { super(ctx, socket_constants_1.SocketType.XPUB); this.options = socket_options_1.PubSocketOptions.create(this); }
+    receiveSubscriptionEvent(resultOrFlags = socket_constants_1.RecvFlags.None, maybeFlags = socket_constants_1.RecvFlags.None) {
+        const hasResult = resultOrFlags instanceof contracts_1.SubscriptionEvent;
+        const flags = hasResult ? maybeFlags : resultOrFlags;
+        let raw;
+        try {
+            raw = ((flags | 0) & (socket_constants_1.RecvFlags.DontWait | 0))
+                ? (0, native_1.requireNative)().socketTrySubscriptionEvent((0, native_handle_1.getNativeHandle)(this))
+                : (0, native_1.requireNative)().socketSubscriptionEvent((0, native_handle_1.getNativeHandle)(this), flags | 0);
+        }
+        catch (error) {
+            throw (0, native_errors_1.recvNativeError)(error, flags, 'subscription event recv failed');
+        }
+        if (!raw) {
+            return hasResult ? false : null;
+        }
+        if (hasResult) {
+            (0, subscription_event_state_1.replaceSubscriptionEvent)(resultOrFlags, raw.topic, raw.subscribed, (0, routing_id_conversion_1.wrapRoutingId)(raw.routingId ?? null));
+            return true;
+        }
+        return (0, subscription_event_state_1.createSubscriptionEvent)(raw.topic, raw.subscribed, (0, routing_id_conversion_1.wrapRoutingId)(raw.routingId ?? null));
+    }
+}
+exports.XPubSocket = XPubSocket;

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

@@ -0,0 +1,7 @@
+import { SubSocketOptions } from './socket_options';
+import { SubscriberSocket } from './socket_operations';
+import type { RuntimeContext as Context } from '../core/context';
+export declare class XSubSocket extends SubscriberSocket {
+    readonly options: SubSocketOptions;
+    constructor(ctx: Context);
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XSubSocket = void 0;
+const socket_options_1 = require("./socket_options");
+const socket_operations_1 = require("./socket_operations");
+const socket_constants_1 = require("../../contracts/sockets/socket_constants");
+class XSubSocket extends socket_operations_1.SubscriberSocket {
+    options;
+    constructor(ctx) { super(ctx, socket_constants_1.SocketType.XSUB); this.options = socket_options_1.SubSocketOptions.create(this); }
+}
+exports.XSubSocket = XSubSocket;

package/native/src/addon.cc

@@ -0,0 +1,11 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
+#include "addon_exports.h"
+
+static napi_value init (napi_env env, napi_value exports)
+{
+    define_core_exports (env, exports);
+    return exports;
+}
+
+NAPI_MODULE (NODE_GYP_MODULE_NAME, init)

package/native/src/addon_common_api.h

@@ -0,0 +1,57 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
+#pragma once
+
+#include <node_api.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <string>
+#include <vector>
+
+#include "zlink.h"
+
+napi_value throw_last_error (napi_env env, const char *prefix);
+napi_value throw_submit_error (napi_env env, const char *prefix, int result);
+std::string get_string (napi_env env, napi_value val);
+const char *get_c_string_arg (
+  napi_env env, napi_value val, char *stack_buf, size_t stack_buf_size, std::string *heap_buf);
+bool build_msg_vector (napi_env env, napi_value arr, std::vector<zlink_msg_t> *out);
+bool build_msg_vector_or_single (napi_env env, napi_value value, std::vector<zlink_msg_t> *out);
+bool init_msg_from_value (napi_env env,
+                          napi_value value,
+                          zlink_msg_t *msg,
+                          bool *contains_native_frame = NULL);
+void close_msg_vector (std::vector<zlink_msg_t> &parts);
+
+// Generic napi object-property setters shared across the addon translation
+// units (message snapshots, discovery summaries, ...). Defined here so each
+// caller pulls in one copy instead of redefining them.
+inline void set_uint32_property (napi_env env, napi_value obj, const char *name, uint32_t value)
+{
+    napi_value out;
+    napi_create_uint32 (env, value, &out);
+    napi_set_named_property (env, obj, name, out);
+}
+
+inline void set_int64_property (napi_env env, napi_value obj, const char *name, int64_t value)
+{
+    napi_value out;
+    napi_create_int64 (env, value, &out);
+    napi_set_named_property (env, obj, name, out);
+}
+
+inline void set_uint64_bigint_property (napi_env env, napi_value obj, const char *name,
+                                        uint64_t value)
+{
+    napi_value out;
+    napi_create_bigint_uint64 (env, value, &out);
+    napi_set_named_property (env, obj, name, out);
+}
+
+inline void set_string_property (napi_env env, napi_value obj, const char *name, const char *value)
+{
+    napi_value out;
+    napi_create_string_utf8 (env, value ? value : "", NAPI_AUTO_LENGTH, &out);
+    napi_set_named_property (env, obj, name, out);
+}