@zlink-systems/zlink 0.17.3

package/dist/zlink/contracts/messaging/received.js

@@ -0,0 +1,130 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Received = exports.ReplyToken = void 0;
+exports.createReplyToken = createReplyToken;
+exports.replyTokenOwnerMatches = replyTokenOwnerMatches;
+exports.replyTokenNativeValue = replyTokenNativeValue;
+const errors_1 = require("../errors/errors");
+const message_parts_envelope_1 = require("./message_parts_envelope");
+const replyTokenOwnerIds = new WeakMap();
+let nextReplyTokenOwnerId = 1;
+let makeReplyToken;
+let tokenOwnerMatches;
+let tokenNativeValue;
+/** Opaque capability required to reply to one ROUTER request. */
+class ReplyToken {
+    #owner;
+    #value;
+    constructor(secret, owner, value) {
+        if (secret !== replyTokenSecret || value === 0n) {
+            throw new TypeError('ReplyToken values are created by ROUTER request receive');
+        }
+        this.#owner = owner;
+        this.#value = value;
+        Object.freeze(this);
+    }
+    static {
+        makeReplyToken = (owner, value) => new ReplyToken(replyTokenSecret, owner, value);
+        // Keep the capability in its private fields only. Package-private
+        // readers use the same brand check instead of duplicating every token
+        // in a WeakMap with a second owner/value record.
+        tokenOwnerMatches = (token, owner) => typeof token === 'object' && token !== null
+            && #owner in token && token.#owner === owner;
+        tokenNativeValue = (token) => {
+            if (typeof token !== 'object' || token === null || !(#value in token)) {
+                throw new TypeError('invalid ReplyToken');
+            }
+            return token.#value;
+        };
+    }
+    equals(other) {
+        return other instanceof ReplyToken
+            && this.#owner === other.#owner
+            && this.#value === other.#value;
+    }
+    hashCode() {
+        let ownerId = replyTokenOwnerIds.get(this.#owner);
+        if (ownerId === undefined) {
+            ownerId = nextReplyTokenOwnerId++;
+            replyTokenOwnerIds.set(this.#owner, ownerId);
+        }
+        const valueHash = Number((this.#value ^ (this.#value >> 32n)) & 0xffffffffn);
+        return (Math.imul(ownerId, 0x9e3779b1) ^ valueHash) | 0;
+    }
+    toString() { return 'ReplyToken'; }
+}
+exports.ReplyToken = ReplyToken;
+const replyTokenSecret = Symbol('ReplyToken');
+/** @internal Package-private receive factory; not exported from the package root. */
+function createReplyToken(owner, value) {
+    return makeReplyToken(owner, value);
+}
+/** @internal */
+function replyTokenOwnerMatches(token, owner) {
+    return tokenOwnerMatches(token, owner);
+}
+/** @internal */
+function replyTokenNativeValue(token) {
+    return tokenNativeValue(token);
+}
+function invalidReplyContextError() {
+    const error = new errors_1.SubmitError(errors_1.SubmitResult.InvalidState, 0);
+    error.message = 'reply is only valid for request-reply receive contexts';
+    return error;
+}
+function invalidSendContextError() {
+    const error = new errors_1.SubmitError(errors_1.SubmitResult.InvalidState, 0);
+    error.message = 'send is only valid for received routed message contexts';
+    return error;
+}
+/**
+ * A received message envelope: its routing metadata and message parts, plus an
+ * optional reply/send context.
+ *
+ * Owns its parts until closed. Reuse one instance across `recv` calls to avoid
+ * a per-receive allocation.
+ */
+class Received extends message_parts_envelope_1.MessagePartsEnvelope {
+    /** The source routing id, or null when the receive path provides none. */
+    routingId;
+    /** Opaque reply capability, present only for a ROUTER REQUEST receive. */
+    replyToken;
+    _replyContext;
+    _sendContext;
+    /** Create an empty reusable envelope for use with `recv`. */
+    constructor(...args) {
+        if (args.length > 0) {
+            throw new TypeError('Received reusable envelopes are created without constructor arguments');
+        }
+        super();
+        this.routingId = null;
+        this.replyToken = null;
+        this._replyContext = null;
+        this._sendContext = null;
+    }
+    /**
+     * Begin a reply to this request: add parts on the returned builder, then
+     * submit. Parts are consumed on a successful submit. Throws when the envelope
+     * is not replyable (has no reply token).
+     */
+    reply() {
+        if (!this.replyToken || !this._replyContext) {
+            throw invalidReplyContextError();
+        }
+        return this._replyContext.beginReply();
+    }
+    /**
+     * Begin a send addressed to this envelope's source route: add parts, then
+     * submit. Message ownership transfers on immediate admission or after the
+     * managed send takes its first back-pressure snapshot, before the Promise may
+     * resolve. Throws when the envelope carries no send context.
+     */
+    send() {
+        if (!this._sendContext) {
+            throw invalidSendContextError();
+        }
+        return this._sendContext.beginSend();
+    }
+}
+exports.Received = Received;

package/dist/zlink/contracts/messaging/stream_packet.d.ts

@@ -0,0 +1,14 @@
+import type { RoutingId } from '../core';
+import type { Message } from './message';
+/** Reusable output storage for one STREAM packet. */
+export declare class StreamPacket {
+    private _receiving;
+    private _routingId;
+    private _header;
+    private _body;
+    get isEmpty(): boolean;
+    get routingId(): RoutingId | null;
+    get header(): Message | null;
+    get body(): Message | null;
+    close(): void;
+}

package/dist/zlink/contracts/messaging/stream_packet.js

@@ -0,0 +1,33 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamPacket = void 0;
+exports.streamPacketState = streamPacketState;
+/** Reusable output storage for one STREAM packet. */
+class StreamPacket {
+    _receiving = false;
+    _routingId = null;
+    _header = null;
+    _body = null;
+    get isEmpty() {
+        return !this._receiving
+            && this._routingId === null
+            && this._header === null
+            && this._body === null;
+    }
+    get routingId() { return this._routingId; }
+    get header() { return this._header; }
+    get body() { return this._body; }
+    close() {
+        this._header?.close();
+        this._body?.close();
+        this._routingId = null;
+        this._header = null;
+        this._body = null;
+    }
+}
+exports.StreamPacket = StreamPacket;
+/** @internal */
+function streamPacketState(packet) {
+    return packet;
+}

package/dist/zlink/contracts/messaging/subscription_event.d.ts

@@ -0,0 +1,12 @@
+import { RoutingId } from '../core/routing_id';
+/** A subscriber's subscribe or unsubscribe as observed by an XPUB socket. */
+export declare class SubscriptionEvent {
+    /** The subscriber's routing id, or null when not known. */
+    routingId: RoutingId | null;
+    /** The topic that was subscribed or unsubscribed. */
+    topic: string;
+    /** True for a subscribe, false for an unsubscribe. */
+    subscribed: boolean;
+    /** Create an empty reusable event for use with `receiveSubscriptionEvent`. */
+    constructor();
+}

package/dist/zlink/contracts/messaging/subscription_event.js

@@ -0,0 +1,20 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionEvent = void 0;
+/** A subscriber's subscribe or unsubscribe as observed by an XPUB socket. */
+class SubscriptionEvent {
+    /** The subscriber's routing id, or null when not known. */
+    routingId;
+    /** The topic that was subscribed or unsubscribed. */
+    topic;
+    /** True for a subscribe, false for an unsubscribe. */
+    subscribed;
+    /** Create an empty reusable event for use with `receiveSubscriptionEvent`. */
+    constructor() {
+        this.routingId = null;
+        this.topic = '';
+        this.subscribed = false;
+    }
+}
+exports.SubscriptionEvent = SubscriptionEvent;

package/dist/zlink/contracts/messaging/topic_message.d.ts

@@ -0,0 +1,14 @@
+import { RoutingId } from '../core/routing_id';
+import { MessagePartsEnvelope } from './message_parts_envelope';
+/**
+ * A received publish: its topic and message parts. Owns its parts until closed.
+ */
+export declare class TopicMessage extends MessagePartsEnvelope {
+    /** The source routing id, or null when the receive path provides none. */
+    routingId: RoutingId | null;
+    /** The topic the message was published under. */
+    topic: string;
+    /** Create an empty reusable envelope for use with `subscribe`. */
+    constructor();
+    close(): void;
+}

package/dist/zlink/contracts/messaging/topic_message.js

@@ -0,0 +1,36 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicMessage = void 0;
+const message_parts_envelope_1 = require("./message_parts_envelope");
+/**
+ * A received publish: its topic and message parts. Owns its parts until closed.
+ */
+class TopicMessage extends message_parts_envelope_1.MessagePartsEnvelope {
+    /** The source routing id, or null when the receive path provides none. */
+    routingId;
+    /** The topic the message was published under. */
+    topic;
+    /** @internal Single-part receive candidate, never exposed through parts. */
+    _reusableSinglePart;
+    /** @internal Frozen single-part views paired with reusable wrappers. */
+    _reusableSinglePartSlots;
+    /** Create an empty reusable envelope for use with `subscribe`. */
+    constructor() {
+        super();
+        this.routingId = null;
+        this.topic = '';
+        this._reusableSinglePart = null;
+        this._reusableSinglePartSlots = [];
+    }
+    close() {
+        const candidate = this._reusableSinglePart;
+        super.close();
+        this._reusableSinglePart = null;
+        this._reusableSinglePartSlots = [];
+        if (candidate && !this.parts.includes(candidate)) {
+            candidate.close();
+        }
+    }
+}
+exports.TopicMessage = TopicMessage;

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

@@ -0,0 +1,29 @@
+import type { RoutingId } from '../core';
+import type { Received, RequestOperation, SendOperation } from '../messaging';
+import type { RecvFlags } from './socket_constants';
+import type { DealerSocketOptions } from './socket_options';
+import type { ConnectableSocket } from './socket';
+/**
+ * DEALER socket: load-balances sends across its connected peers and can issue
+ * routed requests.
+ */
+export interface DealerSocket extends ConnectableSocket {
+    /** The DEALER-specific typed options facade. */
+    readonly options: DealerSocketOptions;
+    /** Begin a managed send; `submit()` resolves after Core accepts the record. */
+    send(): SendOperation;
+    /** Receive a message into `result`; false for non-blocking no-data. */
+    recv(result: Received, flags?: RecvFlags): boolean;
+    /**
+     * Set the routing id that identifies this DEALER to its peers. Apply before
+     * connecting so peers observe it from the first message.
+     */
+    setRoutingId(routingId: RoutingId): void;
+    /** Return the routing id that identifies this DEALER to its peers. */
+    getRoutingId(): RoutingId;
+    /**
+     * Begin a request: add parts on the returned builder, then submit and await a
+     * reply. Parts are consumed on a successful submit.
+     */
+    request(): RequestOperation;
+}

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

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

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

@@ -0,0 +1,10 @@
+export { SocketType, SOCKET_MONITOR_EVENT_ALL, SendFlags, RecvFlags, CompletionKind, RidDuplicatePolicy, SubmitRetryMode, StreamRecvMode, PollEventFlag, ReceiveFlowState, } from './socket_constants';
+export type { MonitorEventMask, SocketTypeValue, SendFlags as SendFlagsValue, RecvFlags as RecvFlagsValue, CompletionKind as CompletionKindValue, RidDuplicatePolicy as RidDuplicatePolicyValue, SubmitRetryMode as SubmitRetryModeValue, PollEventFlagValue, ReceiveFlowState as ReceiveFlowStateValue, } from './socket_constants';
+export type { BaseSocket, ConnectableSocket, Socket, } from './socket';
+export type { CommonSocketOptions, DealerSocketOptions, PubSocketOptions, RouterSocketOptions, StreamSocketOptions, SubSocketOptions, } from './socket_options';
+export type * from '../messaging/operations';
+export type { PairSocket } from './pair_socket';
+export type { DealerSocket } from './dealer_socket';
+export type { RouterSocket } from './router_socket';
+export type { PubSocket, SubSocket, XPubSocket, XSubSocket, } from './pubsub_sockets';
+export type { StreamSocket } from './stream_socket';

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

@@ -0,0 +1,15 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiveFlowState = exports.PollEventFlag = exports.StreamRecvMode = exports.SubmitRetryMode = exports.RidDuplicatePolicy = exports.CompletionKind = exports.RecvFlags = exports.SendFlags = exports.SOCKET_MONITOR_EVENT_ALL = exports.SocketType = void 0;
+var socket_constants_1 = require("./socket_constants");
+Object.defineProperty(exports, "SocketType", { enumerable: true, get: function () { return socket_constants_1.SocketType; } });
+Object.defineProperty(exports, "SOCKET_MONITOR_EVENT_ALL", { enumerable: true, get: function () { return socket_constants_1.SOCKET_MONITOR_EVENT_ALL; } });
+Object.defineProperty(exports, "SendFlags", { enumerable: true, get: function () { return socket_constants_1.SendFlags; } });
+Object.defineProperty(exports, "RecvFlags", { enumerable: true, get: function () { return socket_constants_1.RecvFlags; } });
+Object.defineProperty(exports, "CompletionKind", { enumerable: true, get: function () { return socket_constants_1.CompletionKind; } });
+Object.defineProperty(exports, "RidDuplicatePolicy", { enumerable: true, get: function () { return socket_constants_1.RidDuplicatePolicy; } });
+Object.defineProperty(exports, "SubmitRetryMode", { enumerable: true, get: function () { return socket_constants_1.SubmitRetryMode; } });
+Object.defineProperty(exports, "StreamRecvMode", { enumerable: true, get: function () { return socket_constants_1.StreamRecvMode; } });
+Object.defineProperty(exports, "PollEventFlag", { enumerable: true, get: function () { return socket_constants_1.PollEventFlag; } });
+Object.defineProperty(exports, "ReceiveFlowState", { enumerable: true, get: function () { return socket_constants_1.ReceiveFlowState; } });

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

@@ -0,0 +1,20 @@
+import type { Received } from '../messaging';
+import type { SendOperation } from '../messaging';
+import type { RecvFlags } from './socket_constants';
+import type { CommonSocketOptions } from './socket_options';
+import type { ConnectableSocket } from './socket';
+/** PAIR socket: an exclusive one-to-one peering with no routing. */
+export interface PairSocket extends ConnectableSocket {
+    /** The typed options facade common to all socket types. */
+    readonly options: CommonSocketOptions;
+    /**
+     * Begin a multipart send: add parts on the returned builder, then submit.
+     * Parts are consumed on a successful submit.
+     */
+    send(): SendOperation;
+    /**
+     * Receive a message into `result`; return true on success, or false when
+     * `RecvFlags.DontWait` is set and no message is available.
+     */
+    recv(result: Received, flags?: RecvFlags): boolean;
+}

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

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

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

@@ -0,0 +1,40 @@
+import type { SubscriptionEvent, TopicMessage } from '../messaging';
+import type { PublishOperation } from '../messaging';
+import type { SubscriptionEntry } from '../messaging';
+import type { RecvFlags } from './socket_constants';
+import type { PubSocketOptions, SubSocketOptions } from './socket_options';
+import type { ConnectableSocket } from './socket';
+/** PUB socket: topic-filtered publish that drops messages with no matching subscriber. */
+export interface PubSocket extends ConnectableSocket {
+    /** The PUB-specific typed options facade. */
+    readonly options: PubSocketOptions;
+    /** Begin synchronous lossy publishing under `topic`; submit is void-or-throw. */
+    publish(topic: string): PublishOperation;
+}
+/** XPUB socket: like PUB, but also surfaces subscriber subscription and unsubscription events. */
+export interface XPubSocket extends PubSocket {
+    /**
+     * Receive the next subscriber (un)subscription event into `result`; false
+     * when `RecvFlags.DontWait` is set and none is available.
+     */
+    receiveSubscriptionEvent(result: SubscriptionEvent, flags?: RecvFlags): boolean;
+}
+/** SUB socket: a receive-only subscriber filtered by its subscriptions. */
+export interface SubSocket extends ConnectableSocket {
+    /** The SUB-specific typed options facade. */
+    readonly options: SubSocketOptions;
+    /** Add a subscription for `filter` (an exact topic or pattern); subscriptions accumulate. */
+    setSubscription(filter: string): void;
+    /** Remove a subscription previously added for `filter`. */
+    unsetSubscription(filter: string): void;
+    /** Return the active subscription at `index`, or null when out of range. */
+    subscriptionAt(index: number): SubscriptionEntry | null;
+    /**
+     * Receive the next matching topic message into `result`; false when
+     * `RecvFlags.DontWait` is set and none is available.
+     */
+    subscribe(result: TopicMessage, flags?: RecvFlags): boolean;
+}
+/** XSUB socket: a subscriber whose subscriptions are carried as messages. */
+export interface XSubSocket extends SubSocket {
+}

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

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

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

@@ -0,0 +1,32 @@
+import type { RoutingId } from '../core';
+import type { Received, ReplyToken } from '../messaging';
+import type { ReplyOperation, RequestOperation, SendOperation } from '../messaging';
+import type { RecvFlags } from './socket_constants';
+import type { RouterSocketOptions } from './socket_options';
+import type { ConnectableSocket } from './socket';
+/**
+ * ROUTER socket: routes messages to peers addressed by routing id, the server
+ * side of asynchronous request/reply.
+ */
+export interface RouterSocket extends ConnectableSocket {
+    /** The ROUTER-specific typed options facade. */
+    readonly options: RouterSocketOptions;
+    /** Begin a send addressed to `routingId`; parts are consumed on a successful submit. */
+    send(routingId: RoutingId): SendOperation;
+    /**
+     * Receive a routed message into `result`; false when `RecvFlags.DontWait` is
+     * set and no message is available.
+     */
+    recv(result: Received, flags?: RecvFlags): boolean;
+    /**
+     * Set the routing id that identifies this ROUTER to its peers. Apply before
+     * connecting so peers observe it from the first message.
+     */
+    setRoutingId(routingId: RoutingId): void;
+    /** Return the routing id that identifies this ROUTER to its peers. */
+    getRoutingId(): RoutingId;
+    /** Begin a request to peer `peerRid`; parts are consumed on submit and a reply is awaited. */
+    request(peerRid: RoutingId): RequestOperation;
+    /** Begin a reply using the opaque token returned by this ROUTER's request receive. */
+    reply(peerRid: RoutingId, token: ReplyToken): ReplyOperation;
+}

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

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

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

@@ -0,0 +1,58 @@
+import type { MonitorEventType, MonitorSocket } from '../eventing';
+import type { RoutingId } from '../core';
+import type { ReceiveFlowState } from './socket_constants';
+import type { DealerSocket } from './dealer_socket';
+import type { PairSocket } from './pair_socket';
+import type { PubSocket, SubSocket, XPubSocket, XSubSocket } from './pubsub_sockets';
+import type { RouterSocket } from './router_socket';
+import type { StreamSocket } from './stream_socket';
+/** Base contract shared by every socket type: lifetime, binding, TLS, and monitoring. */
+export interface Socket {
+    /**
+     * Bind to a local transport address (for example `tcp://*:5555`) to accept
+     * connections there.
+     */
+    bind(endpoint: string): void;
+    /** Stop accepting connections at `endpoint`, a previously bound address. */
+    unbind(endpoint: string): void;
+    /** Close the socket and release its native resources. */
+    close(): void;
+    /**
+     * Open a monitor reporting the selected lifecycle `events`. The caller owns
+     * the returned monitor and must close it.
+     */
+    monitorOpen(events?: readonly MonitorEventType[], monitorHwmBytes?: bigint): MonitorSocket;
+    /**
+     * Configure this socket as a TLS server. Apply before binding. `cert`/`key`
+     * are PEM paths; `requireClientCert` requires mutual TLS.
+     */
+    setTlsServer(cert: string, key: string, requireClientCert?: boolean): void;
+    /**
+     * Configure this socket as a TLS client. Apply before connecting. `ca` is the
+     * CA bundle path, `hostname` the expected server hostname, and `trustSystem`
+     * also trusts the system CA store.
+     */
+    setTlsClient(ca: string, hostname: string, trustSystem?: boolean): void;
+    /**
+     * Set this socket's local receive-flow state. Only DEALER and ROUTER
+     * sockets support this; PAIR, the PUB/SUB family, and STREAM report
+     * `ConfigResult.NotSupported`. Setting the same state again succeeds
+     * (idempotent). This does not expose flow frames or any PAUSE-bypass send
+     * path; observe flow transitions only through the existing monitor and
+     * snapshot surfaces.
+     */
+    setReceiveFlowState(state: ReceiveFlowState): void;
+}
+/** A socket that can also initiate outbound connections, not just bind. */
+export interface ConnectableSocket extends Socket {
+    /**
+     * Connect to a remote transport address. Connection is asynchronous; this
+     * returns before the peer is reachable.
+     */
+    connect(endpoint: string): void;
+    /** Disconnect the connection previously established to `endpoint`. */
+    disconnect(endpoint: string): void;
+    /** Disconnect the peer identified by `routingId` rather than by address. */
+    disconnectRid(routingId: RoutingId): void;
+}
+export type BaseSocket = PairSocket | PubSocket | SubSocket | DealerSocket | RouterSocket | XPubSocket | XSubSocket | StreamSocket;

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

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

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

@@ -0,0 +1,88 @@
+/** A socket's messaging pattern (PAIR, PUB, DEALER, ROUTER, STREAM, and so on). */
+export declare const SocketType: Readonly<{
+    readonly ANY: 0;
+    readonly PAIR: 4097;
+    readonly PUB: 4098;
+    readonly SUB: 4099;
+    readonly DEALER: 4100;
+    readonly ROUTER: 4101;
+    readonly XPUB: 4102;
+    readonly XSUB: 4103;
+    readonly STREAM: 4104;
+    readonly Any: 0;
+    readonly Pair: 4097;
+    readonly Pub: 4098;
+    readonly Sub: 4099;
+    readonly Dealer: 4100;
+    readonly Router: 4101;
+    readonly XPub: 4102;
+    readonly XSub: 4103;
+    readonly Stream: 4104;
+}>;
+export type SocketTypeValue = typeof SocketType[keyof typeof SocketType];
+/** A bitmask selecting which socket monitor events to subscribe to. */
+export type MonitorEventMask = number;
+/** Subscribe to every socket monitor event. */
+export declare const SOCKET_MONITOR_EVENT_ALL = 524287;
+/**
+ * A socket's local receive-flow state, applied to DEALER/ROUTER sockets via
+ * `setReceiveFlowState`. Values match `zlink_receive_flow_state_t`. Setting
+ * `PAUSED` synthesizes a remote-PAUSE condition for affected Application
+ * pipes; control uses the Application connection for count-1 peers and the
+ * Completion connection for count-2 ROUTER-ROUTER peers. Setting the same
+ * state again is a no-op success.
+ */
+export declare const ReceiveFlowState: Readonly<{
+    readonly RUNNING: 0;
+    readonly PAUSED: 1;
+}>;
+export type ReceiveFlowState = typeof ReceiveFlowState[keyof typeof ReceiveFlowState];
+/** Flags that modify send behavior; `DontWait` reports back-pressure instead of blocking. */
+export declare const SendFlags: Readonly<{
+    readonly None: 0;
+    readonly DontWait: 1;
+}>;
+export type SendFlags = typeof SendFlags[keyof typeof SendFlags];
+/** Flags that modify receive behavior; `DontWait` returns instead of blocking when no message is available. */
+export declare const RecvFlags: Readonly<{
+    readonly None: 0;
+    readonly DontWait: 1;
+}>;
+export type RecvFlags = typeof RecvFlags[keyof typeof RecvFlags];
+/** Kinds carried by socket-local Core completion records. */
+export declare const CompletionKind: Readonly<{
+    readonly Send: 1;
+    readonly Request: 2;
+    readonly Writable: 3;
+}>;
+export type CompletionKind = typeof CompletionKind[keyof typeof CompletionKind];
+/** How a socket reacts to a peer that reuses an existing routing id. */
+export declare const RidDuplicatePolicy: Readonly<{
+    readonly Reject: 0;
+    readonly Handover: 1;
+}>;
+export type RidDuplicatePolicy = typeof RidDuplicatePolicy[keyof typeof RidDuplicatePolicy];
+export type RidDuplicatePolicyValue = RidDuplicatePolicy;
+/** Whether a failed submit is retried (`Off` or `LocalFailure`). */
+export declare const SubmitRetryMode: Readonly<{
+    readonly Off: 0;
+    readonly LocalFailure: 1;
+}>;
+export type SubmitRetryMode = typeof SubmitRetryMode[keyof typeof SubmitRetryMode];
+export type SubmitRetryModeValue = SubmitRetryMode;
+/** STREAM receive representation. Unspecified cannot be assigned by callers. */
+export declare const StreamRecvMode: Readonly<{
+    readonly Unspecified: 0;
+    readonly Raw: 1;
+    readonly Packet: 2;
+}>;
+export type StreamRecvMode = typeof StreamRecvMode[keyof typeof StreamRecvMode];
+/** Readiness conditions a poll source can be watched for or report (readable, writable, error). */
+export declare const PollEventFlag: Readonly<{
+    readonly PollIn: 1;
+    readonly PollOut: 2;
+    readonly PollErr: 4;
+    readonly PollPri: 8;
+    readonly PollCompletion: 32;
+}>;
+export type PollEventFlagValue = typeof PollEventFlag[keyof typeof PollEventFlag];

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

@@ -0,0 +1,67 @@
+"use strict";
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollEventFlag = exports.StreamRecvMode = exports.SubmitRetryMode = exports.RidDuplicatePolicy = exports.CompletionKind = exports.RecvFlags = exports.SendFlags = exports.ReceiveFlowState = exports.SOCKET_MONITOR_EVENT_ALL = exports.SocketType = void 0;
+/** A socket's messaging pattern (PAIR, PUB, DEALER, ROUTER, STREAM, and so on). */
+exports.SocketType = Object.freeze({
+    ANY: 0,
+    PAIR: 0x1001, PUB: 0x1002, SUB: 0x1003, DEALER: 0x1004,
+    ROUTER: 0x1005, XPUB: 0x1006, XSUB: 0x1007, STREAM: 0x1008,
+    Any: 0,
+    Pair: 0x1001,
+    Pub: 0x1002,
+    Sub: 0x1003,
+    Dealer: 0x1004,
+    Router: 0x1005,
+    XPub: 0x1006,
+    XSub: 0x1007,
+    Stream: 0x1008
+});
+/** Subscribe to every socket monitor event. */
+exports.SOCKET_MONITOR_EVENT_ALL = 0x7FFFF;
+/**
+ * A socket's local receive-flow state, applied to DEALER/ROUTER sockets via
+ * `setReceiveFlowState`. Values match `zlink_receive_flow_state_t`. Setting
+ * `PAUSED` synthesizes a remote-PAUSE condition for affected Application
+ * pipes; control uses the Application connection for count-1 peers and the
+ * Completion connection for count-2 ROUTER-ROUTER peers. Setting the same
+ * state again is a no-op success.
+ */
+exports.ReceiveFlowState = Object.freeze({
+    RUNNING: 0,
+    PAUSED: 1
+});
+/** Flags that modify send behavior; `DontWait` reports back-pressure instead of blocking. */
+exports.SendFlags = Object.freeze({ None: 0, DontWait: 0x0001 });
+/** Flags that modify receive behavior; `DontWait` returns instead of blocking when no message is available. */
+exports.RecvFlags = Object.freeze({ None: 0, DontWait: 0x0001 });
+/** Kinds carried by socket-local Core completion records. */
+exports.CompletionKind = Object.freeze({
+    Send: 1,
+    Request: 2,
+    Writable: 3
+});
+/** How a socket reacts to a peer that reuses an existing routing id. */
+exports.RidDuplicatePolicy = Object.freeze({
+    Reject: 0,
+    Handover: 1
+});
+/** Whether a failed submit is retried (`Off` or `LocalFailure`). */
+exports.SubmitRetryMode = Object.freeze({
+    Off: 0,
+    LocalFailure: 1
+});
+/** STREAM receive representation. Unspecified cannot be assigned by callers. */
+exports.StreamRecvMode = Object.freeze({
+    Unspecified: 0,
+    Raw: 1,
+    Packet: 2
+});
+/** Readiness conditions a poll source can be watched for or report (readable, writable, error). */
+exports.PollEventFlag = Object.freeze({
+    PollIn: 1,
+    PollOut: 2,
+    PollErr: 4,
+    PollPri: 8,
+    PollCompletion: 32
+});