@zlink-systems/framework 0.29.1 → 0.30.1

package/dist/runtime/spots/spot-outbound.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkSpotOutbound = void 0;
 exports.sendToSpotHandle = sendToSpotHandle;
 exports.requestToSpotHandle = requestToSpotHandle;
+const request_result_1 = require("../messaging/request-result");
 const contracts_1 = require("../../contracts");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const configuration_1 = require("../configuration");
@@ -115,14 +116,13 @@ function createAddressedSpotSendCall(serial, transport, spotId, message, sourceS
 }
 function createAddressedSpotRequestCall(serial, transport, spotId, request, sourceSpotProvider) {
     const options = newAddressCallOptions();
-    const begin = (waitPolicy, signal) => {
-        markSubmitted(options);
-        rejectSameSpotAsyncRequest(serial, spotId, waitPolicy);
+    const begin = (signal, onAdmitted) => {
         return startRequestOnSerial(serial, () => ({
             pending: transport.requestToSpotAddress(spotId, request, {
                 ...freezeAddressCallOptions(options, sourceSpotProvider?.()),
                 timeoutMs: options.timeoutMs,
-                signal
+                signal,
+                onAdmitted
             })
         }));
     };
@@ -153,12 +153,15 @@ function createAddressedSpotRequestCall(serial, transport, spotId, request, sour
             return this;
         },
         submit(signal) {
-            const pending = begin('async', signal);
-            return serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending);
+            markSubmitted(options);
+            rejectSameSpotAsyncRequest(serial, spotId, 'async');
+            return (0, request_result_1.createZLinkRequest)((onAdmitted) => begin(signal, onAdmitted), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
         },
         yield(signal) {
             const turn = (0, execution_1.requireZLinkYieldTurn)();
-            const pending = begin('yield', signal);
+            markSubmitted(options);
+            rejectSameSpotAsyncRequest(serial, spotId, 'yield');
+            const pending = begin(signal);
             return turn.yieldPromise(pending);
         }
     };
@@ -250,7 +253,12 @@ function wrapPublishCall(serial, inner) {
     };
 }
 function wrapRequestCall(serial, inner) {
-    const begin = (signal) => startRequestOnSerial(serial, () => ({ pending: inner.submit(signal) }));
+    const begin = (signal, onAdmitted) => startRequestOnSerial(serial, () => {
+        const pending = inner.submit(signal);
+        if (onAdmitted !== undefined)
+            void pending.admitted.then(onAdmitted, () => undefined);
+        return { pending };
+    });
     return {
         metadata(key, value) {
             if (typeof key === 'string')
@@ -264,8 +272,7 @@ function wrapRequestCall(serial, inner) {
             return this;
         },
         submit(signal) {
-            const pending = begin(signal);
-            return serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending);
+            return (0, request_result_1.createZLinkRequest)((onAdmitted) => begin(signal, onAdmitted), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
         },
         yield(signal) {
             const turn = (0, execution_1.requireZLinkYieldTurn)();
@@ -320,15 +327,15 @@ function wrapRoutedSpotSendCall(serial, transport, spot, message, spotRouterChan
 function wrapRoutedSpotRequestCall(serial, transport, spot, request, spotRouterChannelIdForMesh, sourceSpotProvider) {
     let selectedTimeoutMs;
     const metadata = new Map();
-    const begin = (waitPolicy, signal) => {
+    const begin = (signal, onAdmitted) => {
         // A request to the current Spot would wait behind the handler that owns
         // the same Spot claim. Reject it before resolving a route or submitting
         // transport work; one-way self-send remains a valid FIFO admission.
-        rejectSameSpotAsyncRequest(serial, spot.spotId, waitPolicy);
         return startRequestOnSerial(serial, () => ({
             pending: requestToSpotHandle(transport, spot, request, {
                 timeoutMs: selectedTimeoutMs,
                 signal,
+                onAdmitted,
                 metadata,
                 spotRouterChannelIdForMesh,
                 sourceSpot: sourceSpotProvider?.()
@@ -352,12 +359,13 @@ function wrapRoutedSpotRequestCall(serial, transport, spot, request, spotRouterC
             return this;
         },
         submit(signal) {
-            const pending = begin('async', signal);
-            return serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending);
+            rejectSameSpotAsyncRequest(serial, spot.spotId, 'async');
+            return (0, request_result_1.createZLinkRequest)((onAdmitted) => begin(signal, onAdmitted), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
         },
         yield(signal) {
             const turn = (0, execution_1.requireZLinkYieldTurn)();
-            const pending = begin('yield', signal);
+            rejectSameSpotAsyncRequest(serial, spot.spotId, 'yield');
+            const pending = begin(signal);
             return turn.yieldPromise(pending);
         }
     };
@@ -395,6 +403,7 @@ async function requestToSpotHandle(transport, spot, request, options = {}) {
             packetName,
             timeoutMs: options.timeoutMs,
             signal: options.signal,
+            onAdmitted: options.onAdmitted,
             metadata: options.metadata
         };
         if (options.sourceSpot !== undefined && transport.requestFromSpotToSpot !== undefined) {

package/dist/runtime/spots/spot-routed-spot-packet-dispatch.d.ts

@@ -23,6 +23,7 @@ interface ZLinkRoutedSpotPacketDispatchOptions {
 }
 interface ZLinkRoutedSpotPacketContext {
     readonly channelName: string;
+    readonly onAdmitted?: () => void;
     readonly contentType?: string;
     readonly workOptions?: ZLinkSerialWorkOptions;
     readonly admissionTimeoutMs?: number;

package/dist/runtime/spots/spot-routed-spot-packet-dispatch.js

@@ -151,7 +151,7 @@ class ZLinkRoutedSpotPacketDispatch {
                 if (activation.serial.isCurrentTurn) {
                     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Spot '${spotId}' cannot await a request to its current serial turn.`);
                 }
-                await activation.serial.execute(runHandler, context.workOptions, instanceIntent ? runHandler : undefined);
+                await activation.serial.execute(runHandler, { ...context.workOptions, onAdmitted: context.onAdmitted }, instanceIntent ? runHandler : undefined);
             }
         }
         catch (error) {

package/dist/runtime/spots/spot-routing-internal.d.ts

@@ -1,6 +1,7 @@
 import type { RoutingId } from '../../contracts/Common';
 import type { ZLinkFrameworkRuntimeState, ZLinkSpotKind } from '../../contracts';
 export interface ZLinkSpotRouteResolver {
+    resolve(spotId: RoutingId, signal: AbortSignal | undefined, instanceIntent: true): Promise<ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute>;
     resolve(spotId: RoutingId, signal?: AbortSignal): Promise<ZLinkSpotRouteTarget>;
     invalidate?(spotId: RoutingId): void;
 }
@@ -26,3 +27,8 @@ export interface ZLinkSpotRouteTarget {
     /** Current state of the owning MeshNode, when the route was resolved from Location Store. */
     readonly targetNodeState?: ZLinkFrameworkRuntimeState;
 }
+export interface ZLinkInstanceReactivationRoute extends Pick<ZLinkSpotRouteTarget, 'spotId' | 'spotKind' | 'stableType'> {
+    readonly kind: 'coldActivation';
+    readonly meshName: string;
+    readonly stableType: string;
+}

package/dist/runtime/spots/spot-runtime-ports.d.ts

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId, ZLinkSpot } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
@@ -7,6 +8,7 @@ import type { ZLinkActorResponseOptions } from './spot-actor-packet-dispatch';
 import type { ZLinkRemoteActorJoinActor, ZLinkRoutedActorTransferProvider } from './spot-remote-codec';
 import type { ZLinkBackendSpotNode } from '../backend/contracts';
 export interface ZLinkEntryActorRuntime {
+    releaseMembers?(meshName: string): Promise<void>;
     resolveActor(actorId: string): ZLinkActor | undefined;
     commitActorTransaction(actor: ZLinkActor, onJoined: () => Promise<void>): Promise<void>;
     destroyActor(node: ZLinkBackendSpotNode, entryNodeRid: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
@@ -44,5 +46,5 @@ export interface ZLinkSpotBoundSessionRuntime {
     sendActorError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, fallbackBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, actorRef?: ActorRef, signal?: AbortSignal): Promise<void>;
 }
 export interface ZLinkSpotActorHandoffRuntime {
-    capture(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch): Promise<unknown> | undefined;
+    capture(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch): Promise<unknown> | undefined;
 }

package/dist/runtime/spots/spot-subscription-dispatch.js

@@ -31,9 +31,6 @@ class ZLinkSpotSubscriptionDispatch {
             }
             const key = subscriptionKey(registration.channelName, registration.topic);
             const existing = this.handlers.get(key) ?? [];
-            if (existing.some((entry) => entry.handlerType === registration.handlerType)) {
-                continue;
-            }
             existing.push(registration);
             this.handlers.set(key, existing);
             this.options.nativeSpot.setSubscription(registration.channelName, registration.topic);

package/dist/runtime/spots/spot-timer.js

@@ -50,6 +50,7 @@ class ZLinkSpotTimerRegistry {
     async add(name, periodMs, options, handlerType, serial, spot, providerResolver, signal, reportFailure) {
         (0, TimerRegistrationValidator_1.validateTimerRegistration)(name, periodMs, options);
         (0, abort_1.throwIfAborted)(signal);
+        (0, handler_instance_scope_1.prepareHandlerInstance)(providerResolver, handlerType);
         const handler = await (0, handler_instance_scope_1.resolveLifecycleHandler)(spot, handlerType, providerResolver);
         const prepared = await this.lane.run(() => this.prepareAddCore(name));
         if (prepared.previous !== undefined)

package/dist/runtime/streams/stream-session-runtime.d.ts

@@ -134,7 +134,7 @@ export declare class ZLinkStreamSessionNodeRuntime {
     private readonly receiveAbortController;
     private receiveLoop;
     private monitorLoop;
-    private readonly receiveWake;
+    private receiveWake;
     private receiveWorkSinceYield;
     constructor(options: ZLinkStreamSessionNodeRuntimeOptions & ZLinkStreamLivenessOptions);
     start(): void;

package/dist/runtime/streams/stream-session-runtime.js

@@ -33,27 +33,6 @@ const systemLivenessClock = {
     setTimer: (callback, delayMs) => setTimeout(callback, Math.min(delayMs, MAX_TIMER_DELAY_MS)),
     clearTimer: (timer) => clearTimeout(timer)
 };
-class ZLinkStreamReceiveWake {
-    pending;
-    resolvePending;
-    finish = () => {
-        const resolve = this.resolvePending;
-        this.pending = undefined;
-        this.resolvePending = undefined;
-        resolve?.();
-    };
-    wait() {
-        if (this.pending !== undefined)
-            return this.pending;
-        this.pending = new Promise((resolve) => {
-            this.resolvePending = resolve;
-        });
-        return this.pending;
-    }
-    wake() {
-        this.finish();
-    }
-}
 class ZLinkStreamSessionRuntime {
     options;
     removeSession;
@@ -650,7 +629,7 @@ class ZLinkStreamSessionNodeRuntime {
     receiveAbortController = new AbortController();
     receiveLoop;
     monitorLoop;
-    receiveWake = new ZLinkStreamReceiveWake();
+    receiveWake;
     receiveWorkSinceYield = 0;
     constructor(options) {
         this.options = options;
@@ -759,7 +738,7 @@ class ZLinkStreamSessionNodeRuntime {
             let packet;
             let packetTransferred = false;
             try {
-                permit = await this.options.applicationJobQueue.acquire(signal);
+                permit = await this.options.applicationJobQueue.acquire(signal, 'remote');
                 if (this.isReceiveStopped(signal)) {
                     permit.releaseAfterInternalProcessing();
                     break;
@@ -1113,13 +1092,20 @@ class ZLinkStreamSessionNodeRuntime {
         });
     }
     async waitReceiveLoopWake(signal) {
-        await Promise.race([
-            this.options.readablePoller.waitForReadable(signal),
-            this.receiveWake.wait()
-        ]);
+        const wake = new AbortController();
+        this.receiveWake = wake;
+        try {
+            // Readiness, internal wake and shutdown share one cancellable wait;
+            // no losing Promise retains reactions across receive cycles.
+            await this.options.readablePoller.waitForReadable(AbortSignal.any([signal, wake.signal]));
+        }
+        finally {
+            wake.abort();
+            this.receiveWake = undefined;
+        }
     }
     wakeReceiveLoop() {
-        this.receiveWake.wake();
+        this.receiveWake?.abort();
     }
     getOrCreateSession(routingId) {
         const sessionId = (0, managed_stream_1.streamSessionIdFromRoutingId)(routingId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.29.1",
+  "version": "0.30.1",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.29.1",
-    "@zlink-systems/zlink": "1.17.0"
+    "@zlink-systems/stream-wire": "0.30.1",
+    "@zlink-systems/zlink": "1.19.0"
   }
 }

package/src/contracts/Actors/ZLinkActorClient.ts

@@ -1,4 +1,5 @@
 import type { ActorId } from '../Common';
+import type { ZLinkRequest } from '../Handlers/Attributes';
 
 export interface ZLinkActorClient {
   sendToActor(actorId: ActorId, message: unknown): ZLinkActorSendCall;
@@ -13,6 +14,6 @@ export interface ZLinkActorSendCall {
 export interface ZLinkActorRequestCall {
   metadata(key: string, value: string): this;
   timeout(timeoutMs: number): this;
-  submit<TReply>(signal?: AbortSignal): Promise<TReply>;
+  submit<TReply>(signal?: AbortSignal): ZLinkRequest<TReply>;
   yield<TReply>(signal?: AbortSignal): Promise<TReply>;
 }

package/src/contracts/Channels/Calls.ts

@@ -1,4 +1,5 @@
 import type { ZLinkMessageMetadata } from '../Common';
+import type { ZLinkRequest } from '../Handlers/Attributes';
 
 export interface ZLinkSendCall {
   metadata(key: string, value: string): this;
@@ -10,7 +11,7 @@ export interface ZLinkRequestCall {
   metadata(key: string, value: string): this;
   metadata(metadata: ZLinkMessageMetadata): this;
   timeout(timeoutMs: number): this;
-  submit<TReply>(signal?: AbortSignal): Promise<TReply>;
+  submit<TReply>(signal?: AbortSignal): ZLinkRequest<TReply>;
 }
 
 export interface ZLinkChannelRequestCall extends ZLinkRequestCall {

package/src/contracts/Common/ZLinkMessageMetadata.ts

@@ -11,7 +11,7 @@ export interface ZLinkMessageMetadataPolicy {
 class ImmutableZLinkMessageMetadata implements ZLinkMessageMetadata {
   readonly values: ReadonlyMap<string, string>;
 
-  constructor(values: ReadonlyMap<string, string> | Readonly<Record<string, string>> = new Map()) {
+  constructor(values: Iterable<readonly [string, string]> = []) {
     this.values = Object.freeze(new ImmutableMetadataMap(values));
   }
 
@@ -23,12 +23,8 @@ class ImmutableZLinkMessageMetadata implements ZLinkMessageMetadata {
 class ImmutableMetadataMap implements ReadonlyMap<string, string> {
   readonly #values: Map<string, string>;
 
-  constructor(values: ReadonlyMap<string, string> | Readonly<Record<string, string>>) {
-    this.#values = new Map(
-      typeof (values as ReadonlyMap<string, string>)[Symbol.iterator] === 'function'
-        ? (values as ReadonlyMap<string, string>)
-        : Object.entries(values)
-    );
+  constructor(values: Iterable<readonly [string, string]>) {
+    this.#values = new Map(values);
   }
 
   get size(): number {
@@ -74,5 +70,14 @@ export const ZLinkMessageMetadataEmpty: ZLinkMessageMetadata = Object.freeze(
 export function zlinkMessageMetadata(
   values: ReadonlyMap<string, string> | Readonly<Record<string, string>>
 ): ZLinkMessageMetadata {
-  return Object.freeze(new ImmutableZLinkMessageMetadata(values));
+  const entries =
+    typeof (values as ReadonlyMap<string, string>)[Symbol.iterator] === 'function'
+      ? (values as ReadonlyMap<string, string>)
+      : Object.entries(values);
+  const size = Array.isArray(entries)
+    ? entries.length
+    : (entries as ReadonlyMap<string, string>).size;
+  return size === 0
+    ? ZLinkMessageMetadataEmpty
+    : Object.freeze(new ImmutableZLinkMessageMetadata(entries));
 }

package/src/contracts/Configuration/Builders.ts

@@ -7,7 +7,6 @@ import type { ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions } from '.
 import type { ZLinkLocationOptions, ZLinkLocationStore, ZLinkRelocationStore } from '../Locations';
 import type { RoutingId, Type } from '../Common';
 import type { ZLinkWorkerOptions } from './RegistrationTypes';
-import type { ZLinkSpotPublisherConfig } from './Configs';
 import type {
   ZLinkActorFactoryBuilder,
   ZLinkInstanceSpotFactoryBuilder,
@@ -120,7 +119,6 @@ export interface ZLinkMeshNodeBuilder {
   setActivationConcurrency(limit: number): this;
   setInstanceSpotIdleTimeout(timeoutMs: number): this;
   configureRouterSocket(): ZLinkMeshNodeSocketConfig;
-  configureSpotPublisher(): ZLinkSpotPublisherConfig;
   peerConnections(): ZLinkMeshPeerConnections;
   setDefaultRequestTimeout(timeoutMs: number): this;
   objects(): ZLinkMeshObjectRoleBuilder;
@@ -180,6 +178,7 @@ export interface ZLinkFanoutChannelBuilder {
   routingId(routingId: string): this;
   setRoutingIdPrefix(prefix: string): this;
   setNoDrop(noDrop?: boolean): this;
+  setSendTimeout(timeoutMs: number): this;
   enableSubscriber(): this;
   subscribe(topic: string): this;
   connect(endpoint: string): this;

package/src/contracts/Configuration/Configs.ts

@@ -19,9 +19,3 @@ export interface ZLinkOutboundRouteConfig {
   targetNodeRid: RoutingId;
   endpoint: string;
 }
-
-export interface ZLinkSpotPublisherConfig {
-  sendHighWaterMark: number;
-  sendTimeoutMs?: number;
-  lingerMs?: number;
-}

package/src/contracts/Configuration/RegistrationBuilders.ts

@@ -27,7 +27,6 @@ import type {
   ZLinkSession,
   ZLinkSessionFactory,
   ZLinkSpot,
-  ZLinkSpotPublisherConfig,
   ZLinkStreamCompressionBuilder,
   ZLinkStreamCompressionCodec,
   ZLinkStreamNodeBuilder,
@@ -53,6 +52,7 @@ import type { ZLinkEndpointConnections } from './Connections';
 import { requireMessageFlowLogMode, requireTraceSampleRate } from './DiagnosticsValidation';
 import { normalizeEndpoint } from './EndpointNotation';
 import { requirePublicFanoutTopic } from './FanoutTopic';
+import { requireValidSendTimeoutMs } from './SendTimeoutValidation';
 import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from './InternalDefaults';
 import {
   type ZLinkActorFactoryBuilder,
@@ -519,6 +519,12 @@ class DefaultFanoutChannelBuilder implements ZLinkFanoutChannelBuilder {
     return this;
   }
 
+  setSendTimeout(timeoutMs: number): this {
+    requireValidSendTimeoutMs(`Fanout channel '${this.name}' send timeout`, timeoutMs);
+    this.channel.sendTimeoutMs = timeoutMs;
+    return this;
+  }
+
   enableSubscriber(endpoint?: string): this {
     this.selectSubscriberMode(endpoint === undefined ? 'automatic' : 'manual');
     this.channel.subscriber ??= { manualConnections: [] };
@@ -984,11 +990,6 @@ class DefaultMeshNodeBuilder implements ZLinkMeshNodeBuilder {
     return this.node.router as ZLinkMeshNodeSocketConfig;
   }
 
-  configureSpotPublisher(): ZLinkSpotPublisherConfig {
-    this.node.publisherConfig ??= {};
-    return this.node.publisherConfig as ZLinkSpotPublisherConfig;
-  }
-
   peerConnections(): ZLinkMeshPeerConnections {
     this.node.router ??= {};
     return new DefaultMeshPeerConnections(this.node.router);
@@ -1576,6 +1577,7 @@ interface MutableChannelOptions {
   routingId?: string;
   routingIdPrefix?: string;
   noDrop?: boolean;
+  sendTimeoutMs?: number;
   publisher?: MutablePublisherCapabilityOptions;
   publishHandlers?: ZLinkChannelPublishHandlerRegistration[];
   subscriptions?: string[];
@@ -1607,7 +1609,6 @@ interface MutableClientCapabilityOptions {
 }
 
 interface MutablePublisherCapabilityOptions {
-  sendTimeoutMs?: number;
   bind?: string;
   bindHost?: string;
   advertiseHost?: string;
@@ -1668,11 +1669,6 @@ interface MutableSpotNodeOptions {
   routeSendHandlers?: Array<{ packetName: string; handlerType: Type }>;
   routeRequestHandlers?: Array<{ packetName: string; handlerType: Type }>;
   requestTimeoutMs?: number;
-  publisherConfig?: {
-    sendHighWaterMark?: number;
-    sendTimeoutMs?: number;
-    lingerMs?: number;
-  };
 }
 
 interface MutableObjectFactoryRegistration<T, TImplementation = T, TOptions = unknown> {

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -166,6 +166,7 @@ export interface ZLinkChannelOptions {
   readonly routingId?: string;
   readonly routingIdPrefix?: string;
   readonly noDrop?: boolean;
+  readonly sendTimeoutMs?: number;
   readonly requestTimeoutMs?: number;
   readonly client?: ZLinkClientCapabilityOptions;
   readonly publisher?: ZLinkPublisherCapabilityOptions;
@@ -196,7 +197,6 @@ export interface ZLinkClientCapabilityOptions {
 }
 
 export interface ZLinkPublisherCapabilityOptions {
-  readonly sendTimeoutMs?: number;
   readonly bind?: string;
   readonly bindHost?: string;
   readonly advertiseHost?: string;
@@ -297,11 +297,6 @@ export interface ZLinkSpotNodeOptions {
   readonly routeSendHandlers?: readonly ZLinkRouteMeshSendHandlerRegistration[];
   readonly routeRequestHandlers?: readonly ZLinkRouteMeshRequestHandlerRegistration[];
   readonly requestTimeoutMs?: number;
-  readonly publisherConfig?: {
-    readonly sendHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
-    readonly lingerMs?: number;
-  };
   readonly entrySpotTimerHandlers?: readonly ZLinkEntrySpotTimerHandlerRegistration[];
   readonly entrySpotPacketHandlers?: readonly ZLinkEntrySpotPacketHandlerRegistration[];
   readonly entrySpotSubscriptionHandlers?: readonly ZLinkEntrySpotSubscriptionHandlerRegistration[];

package/src/contracts/Configuration/RegistrationValidators.ts

@@ -217,9 +217,12 @@ function validateChannelCapabilities(
     if (channel.noDrop !== undefined && typeof channel.noDrop !== 'boolean') {
       throw new ZLinkConfigurationException(`Channel '${channelName}' NoDrop must be a boolean.`);
     }
-    if (channel.noDrop !== undefined && channel.publisher === undefined) {
+    if (
+      (channel.noDrop !== undefined || channel.sendTimeoutMs !== undefined) &&
+      channel.publisher === undefined
+    ) {
       throw new ZLinkConfigurationException(
-        `Channel '${channelName}' NoDrop requires a publisher role.`
+        `Channel '${channelName}': NoDrop and send timeout require the publisher role.`
       );
     }
     if (channel.server !== undefined) {
@@ -235,11 +238,11 @@ function validateChannelCapabilities(
       requirePeerWeight(`channel '${channelName}' server weight`, channel.server.weight);
       requireSocketOptions(`channel '${channelName}' server`, channel.server);
     }
+    requireValidSendTimeoutMs(
+      `channel '${channelName}' publisher sendTimeoutMs`,
+      channel.sendTimeoutMs
+    );
     if (channel.publisher !== undefined) {
-      requireValidSendTimeoutMs(
-        `channel '${channelName}' publisher sendTimeoutMs`,
-        channel.publisher.sendTimeoutMs
-      );
       requireEndpoint(`channel '${channelName}' publisher`, channel.publisher.bind);
       validateListenerNetworkIdentity(
         `channel '${channelName}' publisher`,
@@ -345,10 +348,6 @@ function validateSpotNodes(registration: ZLinkFrameworkRegistration): void {
       `SpotNode '${spotNodeName}' instanceSpotIdleTimeoutMs`,
       spotNode.instanceSpotIdleTimeoutMs
     );
-    requireValidSendTimeoutMs(
-      `SpotNode '${spotNodeName}' publisher sendTimeoutMs`,
-      spotNode.publisherConfig?.sendTimeoutMs
-    );
     validateSpotNodeFactories(spotNodeName, spotNode);
     validateSpotNodeTimers(spotNode);
     if (

package/src/contracts/Configuration/index.ts

@@ -20,12 +20,7 @@ export type {
   ZLinkStreamSocketConfig,
   ZLinkStreamNodeBuilder
 } from './Builders';
-export type {
-  ZLinkOutboundRouteConfig,
-  ZLinkRouteConfig,
-  ZLinkSocketConfig,
-  ZLinkSpotPublisherConfig
-} from './Configs';
+export type { ZLinkOutboundRouteConfig, ZLinkRouteConfig, ZLinkSocketConfig } from './Configs';
 export * from './Connections';
 export * from './ObjectRoles';
 export type {

package/src/contracts/Handlers/Attributes.ts

@@ -4,23 +4,25 @@ import {
   type ZLinkPacketJsonContract
 } from './JsonContract';
 
-export const ZLINK_DECORATOR_METADATA = Symbol.for('@zlink-systems/framework:decorator');
-
-export interface ZLinkDecoratorMetadata {
-  readonly kind: string;
-  readonly packetName?: string;
-  readonly groupName?: string;
-  readonly methodName?: string;
-  readonly meshName?: string;
-  readonly channelName?: string;
-  readonly topic?: string;
-  readonly jsonContract?: ZLinkPacketJsonContract;
-}
+import {
+  ZLINK_DECORATOR_METADATA,
+  readZLinkDecoratorMetadata,
+  type ZLinkDecoratorMetadata
+} from '@zlink-systems/stream-wire/internal/json';
+export {
+  ZLINK_DECORATOR_METADATA,
+  readZLinkDecoratorMetadata
+} from '@zlink-systems/stream-wire/internal/json';
+export type { ZLinkDecoratorMetadata } from '@zlink-systems/stream-wire/internal/json';
 
 export function ZLinkHandlerGroup(groupName: string): ClassDecorator {
   return classDecorator({ kind: 'handlerGroup', groupName });
 }
 
+export interface ZLinkRequest<TReply> extends Promise<TReply> {
+  readonly admitted: Promise<void>;
+}
+
 export function ZLinkRequest(packetName?: string): MethodDecorator {
   return methodDecorator({ kind: 'request', packetName });
 }
@@ -106,12 +108,3 @@ function appendMetadata(target: object, metadata: ZLinkDecoratorMetadata): void
     writable: false
   });
 }
-
-export function readZLinkDecoratorMetadata(target: object): readonly ZLinkDecoratorMetadata[] {
-  if (!Object.prototype.hasOwnProperty.call(target, ZLINK_DECORATOR_METADATA)) {
-    return [];
-  }
-  return (target as Record<symbol, unknown>)[
-    ZLINK_DECORATOR_METADATA
-  ] as readonly ZLinkDecoratorMetadata[];
-}