@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,9 @@
+import type { ZLinkBackendObject } from '../contracts';
+export declare function wrapSocket<T extends {
+    close(): void;
+}>(nativeInstance: T): T & ZLinkBackendObject;
+export declare function disconnectStreamPeer(socket: {
+    disconnectRid(routingId: unknown): void;
+}, routingId: unknown): void;
+export declare function isDisconnectRouteNotFoundError(error: unknown): boolean;
+export declare function isEndpointCloseIgnorableError(error: unknown): boolean;

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

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapSocket = wrapSocket;
+exports.disconnectStreamPeer = disconnectStreamPeer;
+exports.isDisconnectRouteNotFoundError = isDisconnectRouteNotFoundError;
+exports.isEndpointCloseIgnorableError = isEndpointCloseIgnorableError;
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
+function wrapSocket(nativeInstance) {
+    const boundEndpoints = new Set();
+    const connectedEndpoints = new Set();
+    const peerRoutingIds = new Set();
+    const socket = nativeInstance;
+    const hasRequest = typeof nativeInstance.request === 'function';
+    const hasRoutedPeer = hasRequest
+        && typeof nativeInstance.reply === 'function';
+    const hasStream = typeof nativeInstance.recvPacket === 'function';
+    const adapter = {
+        nativeInstance,
+        async dispose() {
+            (0, node_backend_adapter_support_1.disableSocketLinger)(nativeInstance);
+            closeSocketRoutes(nativeInstance, peerRoutingIds);
+            closeSocketEndpoints(nativeInstance, boundEndpoints, connectedEndpoints);
+            await (0, node_backend_adapter_support_1.closeWithBusyRetry)(nativeInstance);
+        },
+        close() {
+            nativeInstance.close();
+        },
+        bind(endpoint) {
+            nativeInstance.bind(endpoint);
+            boundEndpoints.add(endpoint);
+        },
+        unbind(endpoint) {
+            nativeInstance.unbind(endpoint);
+            boundEndpoints.delete(endpoint);
+        },
+        connect(endpoint) {
+            nativeInstance.connect(endpoint);
+            connectedEndpoints.add(endpoint);
+        },
+        disconnect(endpoint) {
+            nativeInstance.disconnect(endpoint);
+            connectedEndpoints.delete(endpoint);
+        },
+        setChannelName(channelName) {
+            const setChannelName = nativeInstance.setChannelName;
+            setChannelName?.call(nativeInstance, channelName);
+        },
+        setReceiveFlowState(state) {
+            nativeInstance
+                .setReceiveFlowState(state);
+        },
+        setProbe(enabled) {
+            requireSocketOptions(socket).probe = enabled;
+        },
+        setTlsServer(cert, key, requireClientCert) {
+            nativeInstance.setTlsServer(cert, key, requireClientCert);
+        },
+        setSubscription(topic) {
+            nativeInstance.setSubscription(topic);
+        },
+        unsetSubscription(topic) {
+            nativeInstance.unsetSubscription(topic);
+        },
+        subscribe(result, flags) {
+            return Boolean(nativeInstance.subscribe(result, flags));
+        },
+        get lastEndpoint() {
+            return socket.options?.lastEndpoint;
+        },
+        setRoutingId(routingId) {
+            nativeInstance.setRoutingId((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
+        },
+        get peerWeight() {
+            return socket.options?.peerWeight ?? 100;
+        },
+        set peerWeight(value) {
+            requireSocketOptions(socket).peerWeight = value;
+        },
+        get sendHighWaterMark() {
+            return Number(socket.options?.sendHwm ?? 0n);
+        },
+        set sendHighWaterMark(value) {
+            requireSocketOptions(socket).sendHwm = value;
+        },
+        get receiveHighWaterMark() {
+            return Number(socket.options?.recvHwm ?? 0n);
+        },
+        set receiveHighWaterMark(value) {
+            requireSocketOptions(socket).recvHwm = value;
+        },
+        get sendTimeoutMs() {
+            return socket.options?.sendTimeout ?? 0;
+        },
+        set sendTimeoutMs(value) {
+            requireSocketOptions(socket).sendTimeout = value;
+        },
+        get maxMessageSize() {
+            return Number(socket.options?.maxMsgSize ?? 0n);
+        },
+        set maxMessageSize(value) {
+            requireSocketOptions(socket).maxMsgSize = BigInt(value);
+        },
+        send(...args) {
+            if (hasStream) {
+                const [routingId, payload] = args;
+                peerRoutingIds.add(routingId);
+                const operation = nativeInstance.send((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
+                (0, node_backend_adapter_support_1.submitBindingSyncSend)(operation, payload);
+                return true;
+            }
+            if (hasRoutedPeer) {
+                const [routingId, payload] = args;
+                peerRoutingIds.add(routingId);
+                return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(nativeInstance
+                    .send((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload);
+            }
+            const [payload, flags] = args;
+            if (hasRequest) {
+                return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(nativeInstance.send(), payload);
+            }
+            const operation = nativeInstance.send();
+            if ((flags ?? node_backend_adapter_support_1.zlink.SendFlags.None) === node_backend_adapter_support_1.zlink.SendFlags.DontWait) {
+                (0, node_backend_adapter_support_1.submitBindingSyncSend)(operation, payload);
+                return true;
+            }
+            return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(operation, payload);
+        },
+        submit(routingId, payload, _timeoutMs) {
+            if (!hasStream)
+                throw new TypeError('Async stream send requires a STREAM socket.');
+            peerRoutingIds.add(routingId);
+            return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(nativeInstance
+                .send((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload);
+        },
+        request(...args) {
+            if (hasRoutedPeer) {
+                const [routingId, payload, timeoutMs] = args;
+                peerRoutingIds.add(routingId);
+                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance
+                    .request((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload, timeoutMs);
+            }
+            if (hasRequest) {
+                const [payload, timeoutMs] = args;
+                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.request(), payload, timeoutMs);
+            }
+            throw new TypeError('Backend request requires a DEALER or ROUTER socket.');
+        },
+        reply(...args) {
+            const [routingId, replyToken, payload] = args;
+            peerRoutingIds.add(routingId);
+            const operation = nativeInstance.reply((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId), replyToken);
+            return args.length < 3 ? operation : (0, node_backend_adapter_support_1.submitBindingReply)(operation, payload);
+        },
+        recv(flags) {
+            const received = new node_backend_adapter_support_1.zlink.Received();
+            let ok = false;
+            try {
+                ok = nativeInstance.recv(received, flags);
+            }
+            catch (error) {
+                received.close();
+                if ((0, node_backend_adapter_support_1.isRouteRecvRetryable)(error)) {
+                    return undefined;
+                }
+                throw error;
+            }
+            if (!ok) {
+                received.close();
+                return undefined;
+            }
+            return received;
+        },
+        recvPacket(packet, flags) {
+            if (!hasStream)
+                throw new TypeError('Packet receive requires a STREAM socket.');
+            try {
+                return nativeInstance.recvPacket(packet, flags);
+            }
+            catch (error) {
+                if ((0, node_backend_adapter_support_1.isRouteRecvRetryable)(error))
+                    return false;
+                throw error;
+            }
+        },
+        publish(...args) {
+            if (args.length >= 2) {
+                const [topic, payload] = args;
+                (0, node_backend_adapter_support_1.submitBindingPublish)(nativeInstance.publish(topic), payload);
+                return;
+            }
+            throw new TypeError('Backend publish requires a topic and payload.');
+        },
+        async sendToSpot(targetRid, targetSpot, payload, _flags) {
+            const operation = nativeInstance.sendToSpot((0, node_backend_adapter_support_1.toNativeRoutingId)(targetRid), (0, node_backend_adapter_support_1.toNativeRoutingId)(targetSpot));
+            await (0, node_backend_adapter_support_1.submitBindingAsyncSend)(operation, payload);
+        },
+        requestToSpot(targetRid, targetSpot, payload, timeoutMs) {
+            return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.requestToSpot((0, node_backend_adapter_support_1.toNativeRoutingId)(targetRid), (0, node_backend_adapter_support_1.toNativeRoutingId)(targetSpot)), payload, timeoutMs);
+        },
+        disconnectPeer(routingId) {
+            disconnectStreamPeer(nativeInstance, routingId);
+        },
+        async bindActor(_sessionRid, _actor, _timeoutMs, _signal) {
+            throw new Error('Session Actor dispatch requires enableActorDispatch() and a Framework MeshNode service route.');
+        },
+        async unbindActor(_sessionRid, _actorId, _timeoutMs, _signal) {
+            throw new Error('Session Actor dispatch requires enableActorDispatch() and a Framework MeshNode service route.');
+        },
+        sendBoundActor(_sessionRid, _actorId, _parts, _flags) {
+            return false;
+        }
+    };
+    return adapter;
+}
+function disconnectStreamPeer(socket, routingId) {
+    try {
+        socket.disconnectRid((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
+    }
+    catch (error) {
+        // An absent RID has already completed the physical close. The existing
+        // session lifecycle still owns local cleanup and unbind.
+        if (!(0, node_backend_adapter_support_1.isBindingNotFound)(error))
+            throw error;
+    }
+}
+function requireSocketOptions(socket) {
+    if (socket.options === undefined) {
+        throw new TypeError('Binding socket does not expose options.');
+    }
+    return socket.options;
+}
+function closeSocketRoutes(target, peerRoutingIds) {
+    if (peerRoutingIds.size === 0 || !hasDisconnectRid(target)) {
+        return;
+    }
+    for (const routingId of peerRoutingIds) {
+        try {
+            target.disconnectRid((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
+        }
+        catch (error) {
+            if (!isDisconnectRouteNotFoundError(error)) {
+                throw error;
+            }
+        }
+        peerRoutingIds.delete(routingId);
+    }
+}
+function isDisconnectRouteNotFoundError(error) {
+    return (0, node_backend_adapter_support_1.isBindingNotFound)(error) || (0, node_backend_adapter_support_1.isContextTerminatedError)(error) || (error instanceof Error && 'code' in error &&
+        (error.code === node_backend_adapter_support_1.zlink.ConnectResult.NotFound ||
+            error.code === node_backend_adapter_support_1.zlink.ConnectResult.Busy ||
+            (error.code === node_backend_adapter_support_1.zlink.ConnectResult.InternalError &&
+                /current state/i.test(error.message))));
+}
+function hasDisconnectRid(target) {
+    return target !== null && typeof target === 'object' && 'disconnectRid' in target &&
+        typeof target.disconnectRid === 'function';
+}
+function closeSocketEndpoints(target, boundEndpoints, connectedEndpoints) {
+    for (const endpoint of connectedEndpoints) {
+        try {
+            target.disconnect(endpoint);
+        }
+        catch (error) {
+            if (!isEndpointCloseIgnorableError(error)) {
+                throw error;
+            }
+        }
+        connectedEndpoints.delete(endpoint);
+    }
+    for (const endpoint of boundEndpoints) {
+        try {
+            target.unbind(endpoint);
+        }
+        catch (error) {
+            if (!isEndpointCloseIgnorableError(error)) {
+                throw error;
+            }
+        }
+        boundEndpoints.delete(endpoint);
+    }
+}
+function isEndpointCloseIgnorableError(error) {
+    return (0, node_backend_adapter_support_1.isContextTerminatedError)(error) || (error instanceof Error && 'code' in error &&
+        (error.code === 604 || error.code === node_backend_adapter_support_1.zlink.ConnectResult.NotFound));
+}

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

@@ -0,0 +1,9 @@
+type ZLinkBindingModule = {
+    version(): [number, number, number];
+};
+export declare function loadBinding(): ZLinkBindingModule;
+export interface ZLinkNodeBindingInfo {
+    readonly version: readonly [number, number, number];
+}
+export declare function getNodeBindingInfo(): ZLinkNodeBindingInfo;
+export {};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBinding = loadBinding;
+exports.getNodeBindingInfo = getNodeBindingInfo;
+const node_module_1 = require("node:module");
+const requireBinding = (0, node_module_1.createRequire)(__filename);
+function loadBinding() {
+    return requireBinding('@zlink-systems/zlink');
+}
+function getNodeBindingInfo() {
+    return { version: loadBinding().version() };
+}

package/dist/runtime/backend/raw-binding-port.d.ts

@@ -0,0 +1,58 @@
+export interface ZLinkRawReceivedRecord {
+    readonly sourceRid: string;
+    readonly sourceRoute: Uint8Array;
+    readonly requestSeq?: bigint;
+    readonly reply?: (parts: readonly Uint8Array[]) => void;
+    readonly parts: readonly Buffer[];
+    /** Releases the ordinary Framework-owned receive record exactly once. */
+    close(): void;
+}
+export interface ZLinkRawMonitorRecord {
+    readonly event: number;
+    /** Lossless native monitor value (Core exposes the full unsigned 64-bit field). */
+    readonly value: bigint;
+    readonly routingId?: string;
+    readonly localAddress: string;
+    readonly remoteAddress: string;
+    readonly connectionId?: bigint;
+    readonly transportLane?: number;
+    readonly flags?: number;
+}
+export interface ZLinkRawSocketPort {
+    bind(endpoint: string): void;
+    unbind(endpoint: string): void;
+    connect(endpoint: string): void;
+    disconnect(endpoint: string): void;
+    setReceiveFlowState(state: 'running' | 'paused'): void;
+    monitor(): ZLinkRawMonitorPort;
+    close(): void;
+}
+export interface ZLinkRawMonitorPort {
+    drain(handler: (event: ZLinkRawMonitorRecord) => void): number;
+    statusReady(): boolean;
+    close(): void;
+}
+export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
+    disconnectRid?(routingId: string): void;
+    localEndpoint(): string;
+    setRoutingId(routingId: string): void;
+    connectToRoutingId(routingId: string, endpoint: string): void;
+    send(targetRid: string, parts: readonly Uint8Array[]): Promise<void>;
+    request(targetRid: string, parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
+    receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
+}
+export interface ZLinkRawDealerPort extends ZLinkRawSocketPort {
+    setRoutingId(routingId: string): void;
+    send(parts: readonly Uint8Array[]): Promise<void>;
+    request(parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
+    receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
+}
+export interface ZLinkRawHostPort {
+    createRouter(): ZLinkRawRouterPort;
+    createDealer(): ZLinkRawDealerPort;
+    shutdown(): void;
+    close(): void;
+}
+export interface ZLinkRawBindingPort {
+    createHost(): ZLinkRawHostPort;
+}

package/dist/runtime/backend/raw-binding-port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/backend/runtime-message.d.ts

@@ -0,0 +1,14 @@
+import type { Message } from '../../contracts/Common/Message';
+export declare class ZLinkBufferMessage implements Message {
+    private readonly bytes;
+    private constructor();
+    static from(value: Message | Buffer | Uint8Array | string): ZLinkBufferMessage;
+    static fromOwned(bytes: Buffer): ZLinkBufferMessage;
+    data(): Buffer;
+    toBytes(): Uint8Array;
+    copy(): Message;
+    size(): number;
+    isEmpty(): boolean;
+    getString(encoding?: BufferEncoding): string;
+    close(): void;
+}

package/dist/runtime/backend/runtime-message.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkBufferMessage = void 0;
+class ZLinkBufferMessage {
+    bytes;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    static from(value) {
+        if (typeof value === 'string')
+            return new ZLinkBufferMessage(Buffer.from(value));
+        if (isMessage(value))
+            return new ZLinkBufferMessage(Buffer.from(value.data()));
+        return new ZLinkBufferMessage(Buffer.from(value));
+    }
+    static fromOwned(bytes) {
+        return new ZLinkBufferMessage(bytes);
+    }
+    data() {
+        return this.bytes;
+    }
+    toBytes() {
+        return Buffer.from(this.bytes);
+    }
+    copy() {
+        return ZLinkBufferMessage.from(this.bytes);
+    }
+    size() {
+        return this.bytes.byteLength;
+    }
+    isEmpty() {
+        return this.bytes.byteLength === 0;
+    }
+    getString(encoding = 'utf8') {
+        return this.bytes.toString(encoding);
+    }
+    close() { }
+}
+exports.ZLinkBufferMessage = ZLinkBufferMessage;
+function isMessage(value) {
+    return typeof value === 'object'
+        && value !== null
+        && typeof value.data === 'function';
+}

package/dist/runtime/backend/runtime-values.d.ts

@@ -0,0 +1,78 @@
+import type { Message } from '../../contracts/Common/Message';
+export declare const RequestResult: Readonly<{
+    readonly Ok: 0;
+    readonly TimedOut: 101;
+    readonly NotFound: 102;
+    readonly Terminated: 103;
+    readonly ProtocolError: 104;
+    readonly InternalError: 105;
+    readonly Rejected: 106;
+    readonly Conflict: 107;
+    readonly Busy: 108;
+    readonly NotConnected: 109;
+    readonly InvalidArgument: 110;
+    readonly InvalidState: 111;
+    readonly NotSupported: 112;
+    readonly Backpressured: 113;
+}>;
+export type RequestResult = typeof RequestResult[keyof typeof RequestResult];
+export declare const SubmitResult: Readonly<{
+    readonly Ok: 0;
+    readonly Backpressured: 1;
+    readonly NotConnected: 2;
+    readonly NotFound: 3;
+    readonly Terminated: 4;
+    readonly InvalidHandle: 5;
+    readonly InvalidArgument: 6;
+    readonly NotSupported: 7;
+    readonly InvalidState: 8;
+    readonly ThreadViolation: 9;
+    readonly OutOfMemory: 10;
+    readonly SeqExhausted: 11;
+    readonly InternalError: 12;
+    readonly NotAdmitted: 13;
+}>;
+export type SubmitResult = typeof SubmitResult[keyof typeof SubmitResult];
+export type ZLinkBackendSendFlags = number;
+export type ZLinkBackendRecvFlags = number;
+export declare const ZLINK_BACKEND_SEND_NONE: ZLinkBackendSendFlags;
+export declare const ZLINK_BACKEND_RECV_DONT_WAIT: ZLinkBackendRecvFlags;
+export declare class ZLinkBackendResultError extends Error {
+    readonly operation: 'request' | 'submit';
+    readonly result: number;
+    readonly nativeErrno?: number | undefined;
+    constructor(operation: 'request' | 'submit', result: number, nativeErrno?: number | undefined, options?: ErrorOptions);
+}
+export declare function isZLinkBackendResultError(error: unknown): error is ZLinkBackendResultError;
+export declare function isBackendNotConnectedError(error: unknown): boolean;
+export type ZLinkBackendMessageLike = Message | Buffer | Uint8Array | string;
+export interface ZLinkBackendSendSubmitBuilder {
+    message(message: ZLinkBackendMessageLike): ZLinkBackendSendSubmitBuilder;
+    submit(): Promise<void>;
+}
+export interface ZLinkBackendSendBuilder {
+    message(message: ZLinkBackendMessageLike): ZLinkBackendSendSubmitBuilder;
+}
+export interface ZLinkBackendReplySubmitBuilder {
+    message(message: ZLinkBackendMessageLike): ZLinkBackendReplySubmitBuilder;
+    submit(): void;
+}
+export interface ZLinkBackendReplyBuilder {
+    message(message: ZLinkBackendMessageLike): ZLinkBackendReplySubmitBuilder;
+}
+export interface ZLinkBackendReceived {
+    readonly parts: readonly Message[];
+    readonly routingId: unknown | null;
+    readonly spotId?: unknown;
+    readonly replyToken: unknown | null;
+    send?(): ZLinkBackendSendBuilder;
+    reply(): ZLinkBackendReplyBuilder;
+    close(): void;
+}
+export interface ZLinkBackendTopicMessage {
+    readonly parts: readonly Message[];
+    readonly routingId: unknown | null;
+    readonly topic: string;
+    close(): void;
+}
+export type ZLinkBackendMonitorEventType = number;

package/dist/runtime/backend/runtime-values.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkBackendResultError = exports.ZLINK_BACKEND_RECV_DONT_WAIT = exports.ZLINK_BACKEND_SEND_NONE = exports.SubmitResult = exports.RequestResult = void 0;
+exports.isZLinkBackendResultError = isZLinkBackendResultError;
+exports.isBackendNotConnectedError = isBackendNotConnectedError;
+exports.RequestResult = Object.freeze({
+    Ok: 0,
+    TimedOut: 101,
+    NotFound: 102,
+    Terminated: 103,
+    ProtocolError: 104,
+    InternalError: 105,
+    Rejected: 106,
+    Conflict: 107,
+    Busy: 108,
+    NotConnected: 109,
+    InvalidArgument: 110,
+    InvalidState: 111,
+    NotSupported: 112,
+    Backpressured: 113
+});
+exports.SubmitResult = Object.freeze({
+    Ok: 0,
+    Backpressured: 1,
+    NotConnected: 2,
+    NotFound: 3,
+    Terminated: 4,
+    InvalidHandle: 5,
+    InvalidArgument: 6,
+    NotSupported: 7,
+    InvalidState: 8,
+    ThreadViolation: 9,
+    OutOfMemory: 10,
+    SeqExhausted: 11,
+    InternalError: 12,
+    NotAdmitted: 13
+});
+exports.ZLINK_BACKEND_SEND_NONE = 0;
+exports.ZLINK_BACKEND_RECV_DONT_WAIT = 1;
+class ZLinkBackendResultError extends Error {
+    operation;
+    result;
+    nativeErrno;
+    constructor(operation, result, nativeErrno, options) {
+        super(`Backend ${operation} failed with result ${result}.`, options);
+        this.operation = operation;
+        this.result = result;
+        this.nativeErrno = nativeErrno;
+        this.name = 'ZLinkBackendResultError';
+    }
+}
+exports.ZLinkBackendResultError = ZLinkBackendResultError;
+function isZLinkBackendResultError(error) {
+    return error instanceof ZLinkBackendResultError;
+}
+function isBackendNotConnectedError(error) {
+    if (isZLinkBackendResultError(error)) {
+        return error.result === exports.SubmitResult.NotConnected
+            || error.result === exports.RequestResult.NotConnected;
+    }
+    if (typeof error !== 'object' || error === null || !('result' in error)) {
+        return false;
+    }
+    const result = error.result;
+    return result === exports.SubmitResult.NotConnected || result === exports.RequestResult.NotConnected;
+}

package/dist/runtime/channels/channel-autoconnect.d.ts

@@ -0,0 +1,14 @@
+import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
+import type { ZLinkDomainLocationStore as ZLinkLocationStore } from '../locations/domain-store-contract';
+import type { ZLinkLocationEventSink, ZLinkLocationRuntimeStores } from '../locations';
+import { ZLinkLocationRuntime, ZLinkOwnerLeaseTracker, ZLinkStoreLocationResolvers } from '../locations';
+export interface ZLinkChannelLocationAutoConnectContext {
+    readonly runtime: ZLinkLocationRuntime;
+    readonly stores: ZLinkLocationRuntimeStores;
+    readonly options: ZLinkLocationOptionOverrides;
+    readonly leaseTracker: ZLinkOwnerLeaseTracker;
+    readonly resolver: ZLinkStoreLocationResolvers;
+    readonly events?: ZLinkLocationEventSink;
+    readonly changeStampStore?: Pick<ZLinkLocationStore, 'getMeshNodeChangeStamp'>;
+}
+export declare function createChannelLocationAutoConnectContext(runtime: ZLinkLocationRuntime, stores: ZLinkLocationRuntimeStores, options: ZLinkLocationOptionOverrides, events?: ZLinkLocationEventSink): ZLinkChannelLocationAutoConnectContext;

package/dist/runtime/channels/channel-autoconnect.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelLocationAutoConnectContext = createChannelLocationAutoConnectContext;
+const locations_1 = require("../locations");
+function createChannelLocationAutoConnectContext(runtime, stores, options, events) {
+    const leaseTracker = new locations_1.ZLinkOwnerLeaseTracker({
+        store: stores.ownerLeaseStore,
+        options
+    });
+    return {
+        runtime,
+        stores,
+        options,
+        leaseTracker,
+        resolver: new locations_1.ZLinkStoreLocationResolvers({
+            stores,
+            leaseTracker,
+            events
+        }),
+        events,
+        changeStampStore: stores.locationStore
+    };
+}

package/dist/runtime/channels/channel-clients.d.ts

@@ -0,0 +1,50 @@
+import type { ZLinkChannelClient, ZLinkChannelRequestCall, ZLinkFanoutClient, ZLinkFanoutPublishCall, ZLinkPublishCall, ZLinkRequestCall, ZLinkRouteClient, ZLinkSendCall, ZLinkSpotPublisherClient } from '../../contracts';
+import type { SpotHandle } from '../spots/spot-handle';
+import { type ZLinkFrameworkRegistration } from '../configuration';
+import type { ZLinkChannelClientTransportSource, ZLinkRouteClientTransport, ZLinkSpotPublisherClientTransport } from './channel-transports';
+export declare class DefaultZLinkChannelClient implements ZLinkChannelClient {
+    private readonly registration;
+    private readonly transport?;
+    constructor(registration: ZLinkFrameworkRegistration, transport?: ZLinkChannelClientTransportSource | undefined);
+    sendToChannel(channelName: string, message: unknown): ZLinkSendCall;
+    requestToChannel(channelName: string, request: unknown): ZLinkChannelRequestCall;
+    private defaultRequestTimeout;
+    private requireChannel;
+    private requireTransport;
+}
+export declare class DefaultZLinkFanoutClient implements ZLinkFanoutClient {
+    private readonly registration;
+    private readonly transport?;
+    constructor(registration: ZLinkFrameworkRegistration, transport?: ZLinkChannelClientTransportSource | undefined);
+    publish(channelName: string, event: unknown): ZLinkFanoutPublishCall;
+    publish(channelName: string, topic: string, event: unknown): ZLinkFanoutPublishCall;
+    getListenerStatus(channelName: string): import('../../contracts').ZLinkFanoutListenerStatus;
+    private requirePublisherChannel;
+    private requireTransport;
+}
+export declare class DefaultZLinkRouteClient implements ZLinkRouteClient {
+    private readonly registration;
+    private readonly transport?;
+    private readonly spotRouterChannelIdForMesh;
+    constructor(registration: ZLinkFrameworkRegistration, transport?: ZLinkRouteClientTransport | undefined, spotRouterChannelIdForMesh?: (meshName: string) => string);
+    sendToNode(meshName: string, targetNodeRid: string, message: unknown): ZLinkSendCall;
+    requestToNode(meshName: string, targetNodeRid: string, request: unknown): ZLinkRequestCall;
+    sendToChannel(channelName: string, message: unknown): ZLinkSendCall;
+    requestToChannel(channelName: string, request: unknown): ZLinkChannelRequestCall;
+    sendToSpot(spot: SpotHandle, message: unknown): ZLinkSendCall;
+    requestToSpot(spot: SpotHandle, request: unknown): ZLinkRequestCall;
+    private defaultRequestTimeout;
+    private requireMesh;
+    private resolveMeshChannel;
+    private defaultRequestTimeoutForChannel;
+    private requireTransport;
+    private requireSpotTransport;
+}
+export declare class DefaultZLinkSpotPublisherClient implements ZLinkSpotPublisherClient {
+    private readonly registration;
+    private readonly transport?;
+    constructor(registration: ZLinkFrameworkRegistration, transport?: ZLinkSpotPublisherClientTransport | undefined);
+    publish(meshName: string, channelName: string, topic: string, event: unknown): ZLinkPublishCall;
+    private requireMeshChannel;
+    private requireTransport;
+}