@zlink-systems/framework 0.10.0

package/dist/runtime/backend/mesh-record-dispatcher.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkMeshRecordDispatcher = void 0;
+const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
+const execution_1 = require("../execution");
+/**
+ * Routes one pulled Core record to the framework component that owns its
+ * lifecycle. The pump retains the record until the returned promise settles.
+ */
+class ZLinkMeshRecordDispatcher {
+    ports;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    dispatch(owner, record) {
+        switch (record.kind) {
+            case service_runtime_contracts_1.ReceiveKind.NodeSend:
+            case service_runtime_contracts_1.ReceiveKind.NodeRequest:
+            case service_runtime_contracts_1.ReceiveKind.ChannelSend:
+            case service_runtime_contracts_1.ReceiveKind.ChannelRequest:
+                this.requireOwner(owner, service_runtime_contracts_1.ReadyOwnerKind.Node, record);
+                return this.ports.node(record);
+            case service_runtime_contracts_1.ReceiveKind.SpotSend:
+            case service_runtime_contracts_1.ReceiveKind.SpotRequest:
+            case service_runtime_contracts_1.ReceiveKind.SpotMulticast:
+            case service_runtime_contracts_1.ReceiveKind.SpotControl:
+                this.requireOwner(owner, service_runtime_contracts_1.ReadyOwnerKind.Spot, record);
+                return this.ports.spot(owner, record);
+            case service_runtime_contracts_1.ReceiveKind.ActorSend:
+            case service_runtime_contracts_1.ReceiveKind.ActorRequest:
+            case service_runtime_contracts_1.ReceiveKind.ActorBinding:
+                this.requireOwner(owner, service_runtime_contracts_1.ReadyOwnerKind.Actor, record);
+                return this.ports.actor(owner, record);
+            case service_runtime_contracts_1.ReceiveKind.Completion:
+                (0, execution_1.requireZLinkInfrastructureExecutionArea)();
+                return this.ports.completion(record);
+            case service_runtime_contracts_1.ReceiveKind.SendReady:
+                (0, execution_1.requireZLinkInfrastructureExecutionArea)();
+                return this.ports.sendReady(record);
+            case service_runtime_contracts_1.ReceiveKind.TransferControl:
+                (0, execution_1.requireZLinkInfrastructureExecutionArea)();
+                return this.ports.transferControl(record);
+            default:
+                throw new Error(`Unsupported MeshNode receive kind '${record.kind}'.`);
+        }
+    }
+    requireOwner(owner, expected, record) {
+        if (owner.ownerKind !== expected) {
+            throw new Error(`MeshNode receive kind '${record.kind}' requires owner kind '${expected}', got '${owner.ownerKind}'.`);
+        }
+    }
+}
+exports.ZLinkMeshRecordDispatcher = ZLinkMeshRecordDispatcher;

package/dist/runtime/backend/node/index.d.ts

@@ -0,0 +1,4 @@
+export * from './node-backend-adapter-factory';
+export * from './node-mesh-backend-adapter';
+export * from './node-raw-mesh-backend';
+export { getNodeBindingInfo } from '../node-backend-adapter';

package/dist/runtime/backend/node/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeBindingInfo = void 0;
+__exportStar(require("./node-backend-adapter-factory"), exports);
+__exportStar(require("./node-mesh-backend-adapter"), exports);
+__exportStar(require("./node-raw-mesh-backend"), exports);
+var node_backend_adapter_1 = require("../node-backend-adapter");
+Object.defineProperty(exports, "getNodeBindingInfo", { enumerable: true, get: function () { return node_backend_adapter_1.getNodeBindingInfo; } });

package/dist/runtime/backend/node/node-backend-adapter-factory.d.ts

@@ -0,0 +1,12 @@
+import type { Received, TopicMessage } from '@zlink-systems/zlink';
+import type { ZLinkBackendAdapterFactory, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
+import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
+export { isDisconnectRouteNotFoundError } from './node-socket-backend-adapter';
+export declare class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
+    createReceived(): Received;
+    createTopicMessage(): TopicMessage;
+    createChannelAdapter(): ZLinkChannelBackendAdapter;
+    createMeshAdapter(): ZLinkNodeMeshBackendAdapter;
+    createStreamAdapter(): ZLinkStreamBackendAdapter;
+    createMonitoringAdapter(): ZLinkMonitoringBackendAdapter;
+}

package/dist/runtime/backend/node/node-backend-adapter-factory.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkNodeBackendAdapterFactory = exports.isDisconnectRouteNotFoundError = void 0;
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
+const node_monitor_backend_adapter_1 = require("./node-monitor-backend-adapter");
+const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
+const node_mesh_backend_adapter_1 = require("./node-mesh-backend-adapter");
+var node_socket_backend_adapter_2 = require("./node-socket-backend-adapter");
+Object.defineProperty(exports, "isDisconnectRouteNotFoundError", { enumerable: true, get: function () { return node_socket_backend_adapter_2.isDisconnectRouteNotFoundError; } });
+class ZLinkNodeBackendAdapterFactory {
+    createReceived() {
+        return new node_backend_adapter_support_1.zlink.Received();
+    }
+    createTopicMessage() {
+        return new node_backend_adapter_support_1.zlink.TopicMessage();
+    }
+    createChannelAdapter() {
+        return new ZLinkNodeChannelBackendAdapter();
+    }
+    createMeshAdapter() {
+        return new node_mesh_backend_adapter_1.ZLinkNodeMeshBackendAdapter();
+    }
+    createStreamAdapter() {
+        return new ZLinkNodeStreamBackendAdapter();
+    }
+    createMonitoringAdapter() {
+        return new ZLinkNodeMonitoringBackendAdapter();
+    }
+}
+exports.ZLinkNodeBackendAdapterFactory = ZLinkNodeBackendAdapterFactory;
+class ZLinkNodeChannelBackendAdapter {
+    createContext() {
+        return new ZLinkNodeBackendContext(node_backend_adapter_support_1.zlink.createContext());
+    }
+    createTopicMessage() {
+        return new node_backend_adapter_support_1.zlink.TopicMessage();
+    }
+    createDealerSocket(context) {
+        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createDealerSocket(asNodeContext(context)));
+    }
+    createRouterSocket(context) {
+        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createRouterSocket(asNodeContext(context)));
+    }
+    createPublisherSocket(context) {
+        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createPubSocket(asNodeContext(context)));
+    }
+    createSubscriberSocket(context) {
+        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createSubSocket(asNodeContext(context)));
+    }
+    createReadablePoller(socket) {
+        return createNodeReadablePoller(socket);
+    }
+}
+class ZLinkNodeStreamBackendAdapter {
+    createStreamSocket(context) {
+        const socket = node_backend_adapter_support_1.zlink.createStreamSocket(asNodeContext(context));
+        socket.options.recvMode = node_backend_adapter_support_1.zlink.StreamRecvMode.Packet;
+        return (0, node_socket_backend_adapter_1.wrapSocket)(socket);
+    }
+    createStreamPacket() {
+        return new node_backend_adapter_support_1.zlink.StreamPacket();
+    }
+    createReadablePoller(socket) {
+        return createNodeReadablePoller(socket);
+    }
+}
+class ZLinkNodeMonitoringBackendAdapter {
+    openSocketMonitor(socket) {
+        const nativeSocket = socket.nativeInstance;
+        return (0, node_monitor_backend_adapter_1.wrapMonitorSocket)(nativeSocket.monitorOpen());
+    }
+}
+class ZLinkNodeBackendContext {
+    nativeInstance;
+    constructor(nativeInstance) {
+        this.nativeInstance = nativeInstance;
+    }
+    shutdown() {
+        this.nativeInstance.shutdown();
+    }
+    configureCoreHwm(options) {
+        if (options === undefined)
+            return;
+        if (options.profile !== undefined)
+            this.nativeInstance.options.coreHwmProfile = options.profile;
+        if (options.memoryLimitBytes !== undefined)
+            this.nativeInstance.options.coreHwmMemoryLimitBytes = options.memoryLimitBytes;
+        if (options.budgetBytes !== undefined)
+            this.nativeInstance.options.coreHwmBudgetBytes = options.budgetBytes;
+    }
+    getCoreHwmBudgetSnapshot() {
+        return this.nativeInstance.getCoreHwmBudgetSnapshot();
+    }
+    resetCoreHwmBudgetMetrics() {
+        this.nativeInstance.resetCoreHwmBudgetMetrics();
+    }
+    async dispose() {
+        // Terminal cleanup shuts the context down before terminating it, the same
+        // sequence the .NET reference binding runs inside `Context.Dispose()`
+        // (`zlink_ctx_shutdown` then `zlink_ctx_term`). Without the shutdown signal
+        // termination can block forever waiting on the reaper even after every
+        // socket this runtime owns has been closed.
+        try {
+            this.nativeInstance.shutdown();
+        }
+        catch (error) {
+            if (!(0, node_backend_adapter_support_1.isContextTerminatedError)(error)) {
+                throw error;
+            }
+        }
+        await (0, node_backend_adapter_support_1.closeWithBusyRetry)(this.nativeInstance);
+    }
+    close() {
+        this.nativeInstance.close();
+    }
+}
+function asNodeContext(context) {
+    return context.nativeInstance;
+}
+function createNodeReadablePoller(socket) {
+    const poller = node_backend_adapter_support_1.zlink.createPoller();
+    const events = node_backend_adapter_support_1.zlink.createPollEvents(1);
+    try {
+        poller.add(socket.nativeInstance, [node_backend_adapter_support_1.zlink.PollEventFlag.PollIn], 0);
+    }
+    catch (error) {
+        events.close();
+        poller.close();
+        throw error;
+    }
+    let disposed = false;
+    return {
+        wait(timeoutMs) {
+            try {
+                return poller.wait(events, timeoutMs) > 0
+                    && events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn);
+            }
+            catch (error) {
+                if ((0, node_backend_adapter_support_1.isPollerInterruptedError)(error))
+                    return false;
+                throw error;
+            }
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            try {
+                poller.remove(socket.nativeInstance);
+            }
+            finally {
+                try {
+                    events.close();
+                }
+                finally {
+                    poller.close();
+                }
+            }
+        }
+    };
+}

package/dist/runtime/backend/node/node-backend-adapter-support.d.ts

@@ -0,0 +1,52 @@
+export type ZLinkBindingModule = typeof import('@zlink-systems/zlink');
+export declare const zlink: ZLinkBindingModule;
+export type ZLinkBindingOperation = {
+    [key: string]: (...args: unknown[]) => unknown;
+};
+export interface ZLinkBindingAsyncSendOperation {
+    message(message: unknown): ZLinkBindingAsyncSendSubmitOperation;
+}
+export interface ZLinkBindingPublishOperation {
+    message(message: unknown): ZLinkBindingPublishSubmitOperation;
+}
+export interface ZLinkBindingReplyOperation {
+    message(message: unknown): ZLinkBindingReplySubmitOperation;
+}
+interface ZLinkBindingPublishSubmitOperation {
+    message(message: unknown): ZLinkBindingPublishSubmitOperation;
+    submit(): void;
+}
+interface ZLinkBindingReplySubmitOperation {
+    message(message: unknown): ZLinkBindingReplySubmitOperation;
+    submit(): void;
+}
+interface ZLinkBindingAsyncSendSubmitOperation {
+    message(message: unknown): ZLinkBindingAsyncSendSubmitOperation;
+    submit(): Promise<void>;
+    submit_sync(): void;
+}
+export interface ZLinkBindingRequestOperation {
+    message(message: unknown): ZLinkBindingRequestSubmitOperation;
+}
+interface ZLinkBindingRequestSubmitOperation {
+    message(message: unknown): ZLinkBindingRequestSubmitOperation;
+    timeout(timeoutMs: number): ZLinkBindingRequestSubmitOperation;
+    submit(): Promise<readonly unknown[]>;
+}
+export declare function isBindingNotFound(error: unknown): boolean;
+export declare function isRouteRecvRetryable(error: unknown): boolean;
+export declare function isPollerInterruptedError(error: unknown): boolean;
+export declare function submitBindingPublish(operation: ZLinkBindingPublishOperation, payload: unknown): void;
+export declare function submitBindingReply(operation: ZLinkBindingReplyOperation, payload: unknown): void;
+export declare function submitBindingAsyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): Promise<void>;
+export declare function submitBindingSyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): void;
+export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined): Promise<readonly unknown[]>;
+export declare function closeWithBusyRetry(target: {
+    close(): void;
+}): Promise<void>;
+export declare function isContextTerminatedError(error: unknown): boolean;
+export declare function disableSocketLinger(target: unknown): void;
+export declare function toNativeRoutingId(routingId: unknown): unknown;
+export declare function translateBindingResultError(error: unknown): unknown;
+export declare function toNativeActorRef(actor: unknown): unknown;
+export {};

package/dist/runtime/backend/node/node-backend-adapter-support.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zlink = void 0;
+exports.isBindingNotFound = isBindingNotFound;
+exports.isRouteRecvRetryable = isRouteRecvRetryable;
+exports.isPollerInterruptedError = isPollerInterruptedError;
+exports.submitBindingPublish = submitBindingPublish;
+exports.submitBindingReply = submitBindingReply;
+exports.submitBindingAsyncSend = submitBindingAsyncSend;
+exports.submitBindingSyncSend = submitBindingSyncSend;
+exports.submitBindingRequest = submitBindingRequest;
+exports.closeWithBusyRetry = closeWithBusyRetry;
+exports.isContextTerminatedError = isContextTerminatedError;
+exports.disableSocketLinger = disableSocketLinger;
+exports.toNativeRoutingId = toNativeRoutingId;
+exports.translateBindingResultError = translateBindingResultError;
+exports.toNativeActorRef = toNativeActorRef;
+const node_backend_adapter_1 = require("../node-backend-adapter");
+const runtime_values_1 = require("../runtime-values");
+exports.zlink = (0, node_backend_adapter_1.loadBinding)();
+function isBindingNotFound(error) {
+    return error instanceof exports.zlink.ConfigError && error.result === exports.zlink.ConfigResult.NotFound;
+}
+function isNonBlockingRecvEmpty(error) {
+    return error instanceof exports.zlink.RecvError && error.result === exports.zlink.RecvResult.NoData;
+}
+function isRouteRecvRetryable(error) {
+    return isNonBlockingRecvEmpty(error) ||
+        (error instanceof exports.zlink.RecvError &&
+            (error.result === exports.zlink.RecvResult.InternalError || error.result === exports.zlink.RecvResult.InvalidHandle) &&
+            isNativeBadAddress(error));
+}
+function isPollerInterruptedError(error) {
+    return error instanceof exports.zlink.RecvError && error.nativeErrno === 4;
+}
+function isNativeBadAddress(error) {
+    return error.nativeErrno === 14 || /Bad address/i.test(String(error.message ?? ''));
+}
+function submitBindingPublish(operation, payload) {
+    try {
+        let current;
+        const parts = Array.isArray(payload) ? payload : [payload];
+        for (const part of parts.length === 0 ? [Buffer.alloc(0)] : parts) {
+            const nativePart = toNativeMessageLike(part);
+            current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+        }
+        current.submit();
+    }
+    catch (error) {
+        throw translateBindingResultError(error);
+    }
+}
+function submitBindingReply(operation, payload) {
+    try {
+        let current;
+        const parts = Array.isArray(payload) ? payload : [payload];
+        for (const part of parts.length === 0 ? [Buffer.alloc(0)] : parts) {
+            const nativePart = toNativeMessageLike(part);
+            current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+        }
+        current.submit();
+    }
+    catch (error) {
+        throw translateBindingResultError(error);
+    }
+}
+async function submitBindingAsyncSend(operation, payload) {
+    try {
+        let current;
+        const parts = Array.isArray(payload) ? payload : [payload];
+        for (const part of parts) {
+            const nativePart = toNativeMessageLike(part);
+            current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+        }
+        current ??= operation.message(Buffer.alloc(0));
+        await current.submit();
+    }
+    catch (error) {
+        throw translateBindingResultError(error);
+    }
+}
+function submitBindingSyncSend(operation, payload) {
+    try {
+        let current;
+        const parts = Array.isArray(payload) ? payload : [payload];
+        for (const part of parts) {
+            const nativePart = toNativeMessageLike(part);
+            current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+        }
+        current ??= operation.message(Buffer.alloc(0));
+        current.submit_sync();
+    }
+    catch (error) {
+        throw translateBindingResultError(error);
+    }
+}
+async function submitBindingRequest(operation, payload, timeoutMs) {
+    try {
+        let current;
+        if (Array.isArray(payload)) {
+            for (const part of payload) {
+                const nativePart = toNativeMessageLike(part);
+                current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+            }
+        }
+        else {
+            current = operation.message(toNativeMessageLike(payload));
+        }
+        current ??= operation.message(Buffer.alloc(0));
+        if (timeoutMs !== undefined) {
+            current = current.timeout(timeoutMs);
+        }
+        return await current.submit();
+    }
+    catch (error) {
+        throw translateBindingResultError(error);
+    }
+}
+async function closeWithBusyRetry(target) {
+    let lastError;
+    for (let attempt = 0; attempt < 8; attempt++) {
+        try {
+            target.close();
+            return;
+        }
+        catch (error) {
+            if (isSuccessfulOrAlreadyShutdownCloseError(error)) {
+                return;
+            }
+            if (!isBusyCloseError(error)) {
+                throw error;
+            }
+            lastError = error;
+            await new Promise(resolve => setImmediate(resolve));
+        }
+    }
+    throw lastError;
+}
+function isBusyCloseError(error) {
+    return error instanceof Error && 'code' in error && [401, 404].includes(error.code);
+}
+function isSuccessfulOrAlreadyShutdownCloseError(error) {
+    return isContextTerminatedError(error) || (error instanceof Error && 'code' in error && [0, 402, 403].includes(error.code));
+}
+function isContextTerminatedError(error) {
+    return error instanceof Error && /context was terminated/i.test(error.message);
+}
+function disableSocketLinger(target) {
+    if (target !== null &&
+        typeof target === 'object' &&
+        'options' in target &&
+        typeof target.options === 'object' &&
+        target.options !== null &&
+        'linger' in target.options) {
+        try {
+            target.options.linger = 0;
+        }
+        catch (error) {
+            if (!isContextTerminatedError(error)) {
+                throw error;
+            }
+        }
+    }
+}
+function toNativeRoutingId(routingId) {
+    if (typeof routingId === 'string')
+        return exports.zlink.RoutingId.from(routingId);
+    const toHex = routingId?.toHex;
+    return typeof toHex === 'function'
+        ? exports.zlink.RoutingId.fromHex(toHex.call(routingId))
+        : routingId;
+}
+function toNativeMessageLike(message) {
+    if (message instanceof exports.zlink.Message || Buffer.isBuffer(message)
+        || message instanceof Uint8Array || typeof message === 'string') {
+        return message;
+    }
+    const data = message?.data;
+    if (typeof data === 'function') {
+        const bytes = data.call(message);
+        if (bytes instanceof Uint8Array)
+            return Buffer.from(bytes);
+    }
+    return message;
+}
+function translateBindingResultError(error) {
+    if (error instanceof exports.zlink.SubmitError) {
+        return new runtime_values_1.ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
+    }
+    if (error instanceof exports.zlink.RequestError) {
+        return new runtime_values_1.ZLinkBackendResultError('request', error.result, error.nativeErrno, { cause: error });
+    }
+    return error;
+}
+function toNativeActorRef(actor) {
+    if (typeof actor !== 'object' || actor === null || !('nodeRid' in actor)) {
+        return actor;
+    }
+    return {
+        ...actor,
+        nodeRid: toNativeRoutingId(actor.nodeRid)
+    };
+}

package/dist/runtime/backend/node/node-dealer-channel-client-transport.d.ts

@@ -0,0 +1,13 @@
+import type { DealerSocket, Message, PubSocket } from '@zlink-systems/zlink';
+import { type ZLinkSubmitResult } from '../../messaging/submission-result';
+import type { ZLinkChannelClientTransport } from '../../channels/channel-transports';
+/** Adapter used by direct binding-socket integration and its contract tests. */
+export declare class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTransport {
+    private readonly dealer;
+    private readonly publisher?;
+    constructor(dealer: DealerSocket, publisher?: PubSocket | undefined);
+    send(channelName: string, packetName: string | undefined, message: Message, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    tryPublish(channelName: string, topic: string, packetName: string | undefined, event: Message, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
+    publish(channelName: string, topic: string, packetName: string | undefined, event: Message, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+}

package/dist/runtime/backend/node/node-dealer-channel-client-transport.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkDealerChannelClientTransport = void 0;
+const configuration_1 = require("../../configuration");
+const submission_result_1 = require("../../messaging/submission-result");
+const channel_envelope_1 = require("../../channels/channel-envelope");
+const abort_1 = require("../../abort");
+const channel_multipart_1 = require("../../channels/channel-multipart");
+const flow_context_1 = require("../../diagnostics/flow-context");
+const EMPTY_METADATA = new Map();
+/** Adapter used by direct binding-socket integration and its contract tests. */
+class ZLinkDealerChannelClientTransport {
+    dealer;
+    publisher;
+    constructor(dealer, publisher) {
+        this.dealer = dealer;
+        this.publisher = publisher;
+    }
+    async send(channelName, packetName, message, signal, metadata = EMPTY_METADATA) {
+        (0, abort_1.throwIfAborted)(signal);
+        // Call-scoped flow (spec 27 §4): the envelope flow pair does not outlive
+        // this outbound call.
+        await (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.send(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, undefined, undefined, undefined, true, metadata)).submit());
+        return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
+    }
+    async request(channelName, packetName, request, timeoutMs, signal, metadata = EMPTY_METADATA) {
+        (0, abort_1.throwIfAborted)(signal);
+        const operation = (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.request(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs, undefined, undefined, undefined, true, metadata)));
+        if (timeoutMs !== undefined)
+            operation.timeout(timeoutMs);
+        const reply = await (0, channel_multipart_1.submitRequestOperation)(operation, 'channel request');
+        try {
+            return (0, channel_envelope_1.decodeChannelReply)(reply);
+        }
+        finally {
+            for (const part of reply)
+                part.close();
+        }
+    }
+    tryPublish(channelName, topic, packetName, event, metadata = EMPTY_METADATA) {
+        if (this.publisher === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Channel publisher runtime is not started.');
+        }
+        (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.publisher.publish(topic), (0, channel_envelope_1.encodeChannelEnvelopeParts)(4 /* ZLinkChannelMessageKind.Publish */, channelName, packetName, event, undefined, topic, undefined, undefined, true, metadata)).submit());
+        return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
+    }
+    async publish(channelName, topic, packetName, event, signal, metadata = EMPTY_METADATA) {
+        (0, abort_1.throwIfAborted)(signal);
+        return this.tryPublish(channelName, topic, packetName, event, metadata);
+    }
+}
+exports.ZLinkDealerChannelClientTransport = ZLinkDealerChannelClientTransport;

package/dist/runtime/backend/node/node-mesh-backend-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { ZLinkBackendContext, ZLinkBackendMeshNode, ZLinkMeshBackendAdapter } from '../contracts';
+export declare class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
+    createMeshNode(context: ZLinkBackendContext, options: {
+        readonly meshName: string;
+        readonly routingId?: string;
+        readonly trustProfile?: string;
+        readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
+        readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
+        readonly peerAdmissionSealed?: () => boolean;
+    }): ZLinkBackendMeshNode;
+}

package/dist/runtime/backend/node/node-mesh-backend-adapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkNodeMeshBackendAdapter = void 0;
+const node_raw_mesh_backend_1 = require("./node-raw-mesh-backend");
+const node_raw_binding_port_1 = require("./node-raw-binding-port");
+class ZLinkNodeMeshBackendAdapter {
+    createMeshNode(context, options) {
+        if (options.trustProfile !== undefined) {
+            throw new Error('M6A raw MeshNode trust profiles require the service admission security runtime.');
+        }
+        const bindingContext = context.nativeInstance;
+        if (!isBindingContext(bindingContext)) {
+            throw new TypeError('Node MeshNode creation requires the Node binding Context owned by the host.');
+        }
+        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed);
+    }
+}
+exports.ZLinkNodeMeshBackendAdapter = ZLinkNodeMeshBackendAdapter;
+function isBindingContext(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.shutdown === 'function'
+        && typeof value.close === 'function';
+}

package/dist/runtime/backend/node/node-monitor-backend-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { MonitorEvent } from '@zlink-systems/zlink';
+import type { ZLinkBackendSocketMonitor } from '../contracts';
+export declare function wrapMonitorSocket(nativeInstance: {
+    close(): void;
+    recv(flags?: number): MonitorEvent | null;
+}): ZLinkBackendSocketMonitor;

package/dist/runtime/backend/node/node-monitor-backend-adapter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapMonitorSocket = wrapMonitorSocket;
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
+function wrapMonitorSocket(nativeInstance) {
+    const handlers = new Set();
+    return {
+        nativeInstance,
+        async dispose() {
+            handlers.clear();
+            nativeInstance.close();
+        },
+        drain() {
+            let count = 0;
+            for (;;) {
+                const event = nativeInstance.recv(node_backend_adapter_support_1.zlink.RecvFlags.DontWait);
+                if (event === null)
+                    return count;
+                const value = toBackendMonitorEvent(event);
+                for (const registered of handlers)
+                    registered(value);
+                count += 1;
+            }
+        },
+        onEvent(handler) {
+            handlers.add(handler);
+        }
+    };
+}
+function toBackendMonitorEvent(event) {
+    return {
+        nativeEvent: event.event,
+        routingId: event.routingId ?? undefined,
+        localAddr: event.localAddr,
+        remoteAddr: event.remoteAddr,
+        value: event.value
+    };
+}