@zlink-systems/framework 0.26.0 → 0.28.0

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

@@ -63,11 +63,14 @@ class ZLinkChannelRuntimeManager {
         };
     }
     fanoutTopology(channelName) {
-        return { descriptors: this.sockets.fanoutActiveTargets(channelName) };
+        return {
+            descriptors: this.lifecycle.fanoutTopologyTargets(channelName) ??
+                this.sockets.fanoutActiveTargets(channelName)
+        };
     }
     observeClientServerTopology(channelName, changed) {
         const monitor = this.sockets.clientServerMonitoringSource(channelName);
-        monitor.onEvent(changed);
+        monitor.onChange(changed);
         return () => {
             void monitor.dispose();
         };
@@ -135,8 +138,8 @@ class ZLinkChannelRuntimeManager {
     canDispatchLocalMeshRoute(meshName) {
         return this.lifecycle.canDispatchLocalMeshRoute(meshName);
     }
-    send(channelName, packetName, message, signal, metadata) {
-        return this.outbound.send(channelName, packetName, message, signal, metadata);
+    send(channelName, packetName, message, metadata) {
+        return this.outbound.send(channelName, packetName, message, metadata);
     }
     async request(channelName, packetName, request, timeoutMs, signal, metadata) {
         return this.outbound.request(channelName, packetName, request, timeoutMs, signal, metadata);
@@ -147,14 +150,14 @@ class ZLinkChannelRuntimeManager {
     publish(channelName, topic, packetName, event, signal, metadata) {
         return this.outbound.publish(channelName, topic, packetName, event, signal, metadata);
     }
-    routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata) {
-        return this.outbound.routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata);
+    routeSubmit(routerChannelId, targetNodeRid, packetName, message, metadata) {
+        return this.outbound.routeSubmit(routerChannelId, targetNodeRid, packetName, message, metadata);
     }
     async routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
         return this.outbound.routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata);
     }
-    async routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendToSpot(spotRouteTarget, packetName, message, metadata) {
+        return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, metadata);
     }
     async routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
         return this.spotRoutes.routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata);
@@ -162,8 +165,8 @@ class ZLinkChannelRuntimeManager {
     async routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
         return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
     }
-    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        return this.spotRoutes.routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
+        return this.spotRoutes.routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
     async routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
         return this.spotRoutes.routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal);

package/dist/runtime/channels/channel-socket-options.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkChannelRuntimeOptions = void 0;
+const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
 const configuration_1 = require("../configuration");
 const SendTimeoutValidation_1 = require("../../contracts/Configuration/SendTimeoutValidation");
 class ZLinkLiveSocketConfig {
@@ -40,13 +41,6 @@ class ZLinkLiveSocketConfig {
         (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)('receiveTimeoutMs', value);
         this.socket.receiveTimeoutMs = value;
     }
-    get sendTimeoutMs() {
-        return this.socket.sendTimeoutMs;
-    }
-    set sendTimeoutMs(value) {
-        validateSendTimeout(value);
-        this.socket.sendTimeoutMs = value;
-    }
 }
 class ZLinkServerRuntimeOptions {
     serverSocket;
@@ -112,8 +106,8 @@ function requireChannelName(channelName) {
     }
 }
 function validatePublicWeight(value) {
-    if (!Number.isInteger(value) || value < 0 || value > 10_000) {
-        throw new configuration_1.ZLinkConfigurationException('Weight must be an integer in 0..10000.');
+    if (!(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(value)) {
+        throw new configuration_1.ZLinkConfigurationException(`Weight must be an integer in 0..${RegistrationBuilderPolicy_1.ZLINK_MAX_PUBLIC_WEIGHT}.`);
     }
 }
 function validateHighWaterMark(value, label) {
@@ -121,6 +115,3 @@ function validateHighWaterMark(value, label) {
         throw new configuration_1.ZLinkConfigurationException(`${label} must be a non-negative integer.`);
     }
 }
-function validateSendTimeout(value) {
-    (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)('sendTimeoutMs', value);
-}

package/dist/runtime/channels/channel-socket-registry.d.ts

@@ -1,11 +1,11 @@
-import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { type ZLinkClientServerServerDescriptor, type ZLinkFanoutPublisherDescriptor } from '../../contracts';
-import { type ZLinkFrameworkRegistration } from '../configuration';
-import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
 import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
+import { type ZLinkFrameworkRegistration } from '../configuration';
+import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
-import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
 import type { ApplicationJobQueue } from '../host/application-job-queue';
+import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
 export interface ZLinkClientServerServerSocketIdentity {
     readonly serverRid: string;
     readonly lifecycleGeneration: bigint;
@@ -41,7 +41,8 @@ export declare class ZLinkChannelSocketRegistry {
     private readonly routeMeshPublicWeights;
     private readonly clientServerAdmittedClients;
     private readonly clientServerServerPeers;
-    private readonly ownedMonitors;
+    private readonly disposal;
+    private readonly ownedResources;
     private readonly fanoutConnections;
     private readonly fanoutPublisherNextBeacon;
     private clientServerLivenessTimer?;
@@ -52,6 +53,7 @@ export declare class ZLinkChannelSocketRegistry {
     private readonly listenerRecords;
     constructor(registration: ZLinkFrameworkRegistration, adapter: ZLinkChannelBackendAdapter, context: ZLinkBackendContext, monitoringAdapter?: ZLinkMonitoringBackendAdapter | undefined, oneWayFailureSink?: ((error: unknown) => void) | undefined, applicationJobQueue?: ApplicationJobQueue | undefined, listenerRecords?: ZLinkListenerRecords);
     dispose(): Promise<void>;
+    private disposeCore;
     clientDealer(channelName: string): ZLinkBackendDealerSocket;
     channelRouter(channelName: string): ZLinkBackendRouterSocket;
     clientServerServerIdentity(channelName: string): ZLinkClientServerServerSocketIdentity;
@@ -68,36 +70,19 @@ export declare class ZLinkChannelSocketRegistry {
     selectClientServerDealer(channelName: string): ZLinkBackendDealerSocket | undefined;
     clientDealerForOutbound(channelName: string): ZLinkBackendDealerSocket | undefined;
     selectedClientServerRid(channelName: string, dealer: ZLinkBackendDealerSocket): string | undefined;
-    /**
-     * Resolves a ClientServer send target, waiting when the ready candidate set is still empty, as
-     * `framework/doc/framework/common/spec/server/02-channel-transport/02-channel-messaging.ko.md` §3.2 requires: the call waits
-     * at call time for a bounded period and then fails with no-target. The bound is the shorter of
-     * the call's remaining deadline and five seconds, mirroring the .NET reference
-     * `ZLinkClientServerClientRuntime.WaitForReadyAsync`. The wait lives here because this registry
-     * owns ClientServer connections, admission and weighted selection. Sends have no per-call
-     * timeout, so they use the Channel's request timeout.
-     *
-     * The wait only observes admission that is already in flight: it never opens or reconnects a
-     * connection, so it cannot trigger the admission it waits for, and Framework startup keeps not
-     * waiting for local ClientServer admission. It applies whenever nothing is selectable, including
-     * candidate sets excluded by weight 0 or drain, because `selectClientServerDealer` filters the
-     * same way the reference `SelectReady()` does.
-     *
-     * Every attempt yields to the event loop between polls. ClientServer admission completes on the
-     * monitor drains that the backend poll timer pumps, so a synchronous wait would starve the
-     * admission it is waiting for and burn the whole bound before failing anyway. That is this
-     * execution model's form of the hazard the JVM mirror avoids by not holding the admission
-     * monitor across its sleep.
-     */
-    awaitClientDealerForOutbound(channelName: string, signal?: AbortSignal, deadlineAtMs?: number): Promise<ZLinkBackendDealerSocket | undefined>;
+    /** Observes discovery changes until a server is ready or the runtime closes. */
+    awaitClientDealerForOutbound(channelName: string, signal?: AbortSignal): Promise<ZLinkBackendDealerSocket | undefined>;
     startManualClientServerConnections(): void;
     startLocalClientServerConnections(): void;
-    clientServerMonitoringSource(channelName: string): ZLinkBackendSocketMonitor;
+    clientServerMonitoringSource(channelName: string): ZLinkBackendSocketMonitor & {
+        onChange(handler: () => void): void;
+    };
     clientServerActiveTargets(channelName: string): readonly Pick<ClientServerDiscoveryDescriptor, 'serverRoutingId' | 'weight' | 'state'>[];
     fanoutActiveTargets(channelName: string): readonly import("../foundation/service-discovery-registry").FanoutPublisherDescriptor[];
     admitFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, connectionId: string): boolean;
     removeFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, connectionId: string): boolean;
     setClientServerServerDescriptor(descriptor: ZLinkClientServerServerDescriptor | undefined, channelName: string): void;
+    private notifyClientServerTopology;
     tryHandleClientServerControl(channelName: string, received: {
         readonly parts: readonly Message[];
         readonly replyToken: unknown | null;
@@ -127,7 +112,7 @@ export declare class ZLinkChannelSocketRegistry {
         onChange(handler: () => void): void;
         dispose(): Promise<void>;
     };
-    private notifyFanoutTopology;
+    notifyFanoutTopology(channelName: string): void;
     private tickFanoutLiveness;
     private openManualClientServerConnection;
     private openConfiguredClientServerConnection;