@zlink-systems/framework 0.26.0 → 0.28.0

package/src/runtime/channels/client-server-service-wire.ts

@@ -1,16 +1,40 @@
-import type { ZLinkClientServerServerDescriptor } from '../../contracts/Locations';
-import { ZLinkFrameworkRuntimeState } from '../../contracts/Locations';
+import { UINT32_MAX } from '@zlink-systems/stream-wire';
+import { normalizeEndpoint } from '../../contracts/Configuration/EndpointNotation';
+import { isValidPublicWeight } from '../../contracts/Configuration/RegistrationBuilderPolicy';
+import {
+  type ZLinkClientServerServerDescriptor,
+  ZLinkFrameworkRuntimeState
+} from '../../contracts/Locations';
+
 import {
   decodeCanonicalServiceWireText,
   decodeServiceWireRoutingId,
   encodeCanonicalServiceWireText,
   encodeServiceWireRoutingId
 } from '../foundation/service-wire-binary-primitives';
-import { normalizeEndpoint } from '../../contracts/Configuration/EndpointNotation';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR
+} from '../foundation/service-wire-constants.generated';
+export const DEFAULT_CLIENT_SERVER_MESSAGE_LIMIT = 0x7fff_ffff;
+export function normalizeClientServerMessageLimit(value: number): number {
+  return Number.isSafeInteger(value) && value > 0
+    ? Math.min(value, UINT32_MAX)
+    : DEFAULT_CLIENT_SERVER_MESSAGE_LIMIT;
+}
+
+const CLIENT_SERVER_PREFIX_BYTES = 5;
+const CLIENT_SERVER_ROLE_BODY_MAX_BYTES = 0xffff;
+const CLIENT_SERVER_TEXT_MAX_BYTES = 4096;
+
+export enum ClientServerRejectReason {
+  ProtocolVersionUnsupported = 1,
+  AdmissionMismatch = 3
+}
 
-const MAGIC_0 = 0x5a;
-const MAGIC_1 = 0x4d;
-const WIRE_MAJOR = 1;
+const MAGIC_0 = SERVICE_WIRE_MAGIC[0];
+const MAGIC_1 = SERVICE_WIRE_MAGIC[1];
+const WIRE_MAJOR = SERVICE_WIRE_MAJOR;
 const TOPOLOGY_CLIENT_SERVER = 2;
 const ROLE_CLIENT = 1;
 const ROLE_SERVER = 2;
@@ -22,7 +46,7 @@ const COMMAND_UPDATE = 4;
 const COMMAND_LIVENESS_PROBE = 5;
 const COMMAND_LIVENESS_ACK = 6;
 const MAX_DESCRIPTOR_BYTES = 1024 * 1024;
-const MAX_U32 = 0xffff_ffff;
+const MAX_U32 = UINT32_MAX;
 const MAX_GENERATION = 0x7fff_ffff_ffff_ffffn;
 
 export interface ZLinkClientServerHello {
@@ -99,7 +123,10 @@ export function encodeClientServerLivenessAck(probeId: bigint): Buffer {
 
 export function isClientServerControlFrame(frame: Uint8Array): boolean {
   return (
-    frame.byteLength >= 5 && frame[0] === MAGIC_0 && frame[1] === MAGIC_1 && frame[2] === WIRE_MAJOR
+    frame.byteLength >= CLIENT_SERVER_PREFIX_BYTES &&
+    frame[0] === MAGIC_0 &&
+    frame[1] === MAGIC_1 &&
+    frame[2] === WIRE_MAJOR
   );
 }
 
@@ -177,7 +204,8 @@ function encodeServerAdmission(
 }
 
 function encodeAdmission(command: number, role: number, roleBody: Buffer): Buffer {
-  if (roleBody.byteLength > 0xffff) fail('ClientServer role body is oversized.');
+  if (roleBody.byteLength > CLIENT_SERVER_ROLE_BODY_MAX_BYTES)
+    fail('ClientServer role body is oversized.');
   const admission = concat(Buffer.of(role), encodeU16(roleBody.byteLength), roleBody);
   const result = concat(
     prefix(command),
@@ -210,7 +238,7 @@ function decodeServerAdmission(reader: Reader): ZLinkClientServerAdmission {
   const lifecycleGeneration = reader.nonZeroU64('lifecycleGeneration');
   const descriptorRevision = reader.nonZeroU64('descriptorRevision');
   const weight = reader.u32('weight');
-  if (weight > 10_000) fail('ClientServer weight is invalid.');
+  if (!isValidPublicWeight(weight)) fail('ClientServer weight is invalid.');
   return {
     channelName,
     serverRid,
@@ -261,7 +289,7 @@ function encodeText8(value: string, field: string): Buffer {
 }
 
 function encodeText16(value: string, field: string): Buffer {
-  const bytes = encodeCanonicalServiceWireText(value, field, 4096, fail);
+  const bytes = encodeCanonicalServiceWireText(value, field, CLIENT_SERVER_TEXT_MAX_BYTES, fail);
   return concat(encodeU16(bytes.byteLength), bytes);
 }
 
@@ -373,7 +401,7 @@ class Reader {
 
   text16(field: string): string {
     const length = this.u16(`${field}.length`);
-    if (length < 1 || length > 4096) fail(`${field} length is invalid.`);
+    if (length < 1 || length > CLIENT_SERVER_TEXT_MAX_BYTES) fail(`${field} length is invalid.`);
     return decodeText(this.bytes(length, field), field);
   }
 

package/src/runtime/channels/dispatch-error-reporter.ts

@@ -1,19 +1,21 @@
 import {
-  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
   ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
   ZLinkDispatchErrorSurface,
   ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   type ZLinkDispatchFailure
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import type { ZLinkRuntimeMetrics } from '../diagnostics';
 import {
-  ZLinkMessageFlowTracer,
+  type ZLinkRuntimeMetrics,
   DEFAULT_ZLINK_DIAGNOSTICS,
+  ZLinkMessageFlowTracer,
   type ZLinkDiagnosticsContext
 } from '../diagnostics';
-import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
+
 import { dispatchErrorDetails } from '../diagnostics/dispatch-error-details';
+import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
+import { METRIC_NAMES } from '../diagnostics/runtime-metrics';
 
 export type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
 
@@ -49,7 +51,7 @@ export class ZLinkDispatchErrorReporter {
     const normalized = normalizeDispatchFailure(event);
     const dropReason = channelDropReason(normalized);
     if (dropReason !== undefined) {
-      this.metrics?.count('zlink.mesh_node.messages.dropped', 1, {
+      this.metrics?.count(METRIC_NAMES.MeshNodeMessagesDropped, 1, {
         surface: normalized.surface,
         message_kind: normalized.messageKind,
         reason: dropReason

package/src/runtime/channels/fanout-location-runtime.ts

@@ -6,23 +6,28 @@ import {
   type ZLinkFanoutPublisherDescriptor,
   type ZLinkLocationOwnerToken
 } from '../../contracts/Locations';
-import type { ZLinkFanoutLocationStore } from '../locations/internal-store-contracts';
 import {
   zlinkRuntimeDefaultLocationOptions,
   type ZLinkLocationOptionOverrides
 } from '../../contracts/Locations/Options';
-import type { ZLinkFrameworkRegistration } from '../configuration';
-import { ZLinkConfigurationException } from '../configuration';
-import type { ZLinkLocationRuntime, ZLinkLocationRuntimeStores } from '../locations';
+import { ZLINK_PROVIDER_MAX_PAGE_SIZE } from '../../contracts/Locations/Stores';
 import type { ZLinkBackendSubscriberSocket } from '../backend/contracts';
-import { ZLinkChannelSocketRegistry } from './channel-socket-registry';
+import { type ZLinkFrameworkRegistration, ZLinkConfigurationException } from '../configuration';
+
 import { ZLinkStateLane } from '../execution/state-lane';
+import { discoveryAvailabilityForRuntimeState } from '../foundation/runtime-state-projections';
+import { closeResources, finishResourceCleanup } from '../foundation/event-loop-resources';
+import type { ZLinkLocationRuntime, ZLinkLocationRuntimeStores } from '../locations';
+import type { ZLinkFanoutLocationStore } from '../locations/internal-store-contracts';
+import { ZLinkChannelSocketRegistry } from './channel-socket-registry';
 
-interface ActiveFanoutTarget {
+interface FanoutTarget {
   descriptor: ZLinkFanoutPublisherDescriptor;
+  connection?: ActiveFanoutConnection;
+}
+
+interface ActiveFanoutConnection {
   readonly connectionId: string;
-  readonly subscriber: ZLinkBackendSubscriberSocket;
-  reconnectEligible: boolean;
   stopReceiver: () => Promise<void>;
   state: 'connecting' | 'ready';
 }
@@ -39,7 +44,7 @@ export class ZLinkFanoutLocationRuntime {
       readonly lifecycleGeneration: bigint;
     }
   >();
-  private readonly connections = new Map<string, ActiveFanoutTarget>();
+  private readonly targets = new Map<string, FanoutTarget>();
   private controller?: AbortController;
   private timer?: NodeJS.Timeout;
 
@@ -95,18 +100,49 @@ export class ZLinkFanoutLocationRuntime {
       return current;
     });
     if (timer !== undefined) clearTimeout(timer);
-    const connectionIds = await this.lane.run(() => [...this.connections.keys()]);
-    await Promise.allSettled(connectionIds.map((id) => this.closeConnection(id)));
-    await this.removeLocalPublishers(signal);
+    const targets = await this.lane.run(() => [...this.targets]);
+    const targetResults = await Promise.allSettled(
+      targets.map(([id, target]) => this.removeTarget(id, target))
+    );
+    const publisherResults = await Promise.allSettled([this.removeLocalPublishers(signal)]);
+    finishResourceCleanup(
+      [...targetResults, ...publisherResults].flatMap((result) =>
+        result.status === 'rejected' ? [result.reason] : []
+      )
+    );
   }
 
   activeTargets(channelName: string): readonly ZLinkFanoutPublisherDescriptor[] {
-    return [...this.connections.values()]
-      .filter((target) => target.state === 'ready')
+    return [...this.targets.values()]
+      .filter((target) => target.connection?.state === 'ready')
       .map((target) => target.descriptor)
       .filter((descriptor) => descriptor.channelName === channelName);
   }
 
+  topologyTargets(channelName: string) {
+    if (!this.isAutomaticSubscriber(channelName)) return undefined;
+    return [...this.targets.values()]
+      .filter((target) => target.descriptor.channelName === channelName)
+      .map((target) => ({
+        channelName,
+        publisherRoutingId: String(target.descriptor.publisherRid),
+        lifecycleGeneration: target.descriptor.lifecycleGeneration,
+        descriptorRevision: target.descriptor.descriptorRevision,
+        advertisedEndpoint: target.descriptor.endpoint,
+        state:
+          target.descriptor.state === ZLinkFrameworkRuntimeState.Serving
+            ? target.connection?.state === 'ready'
+              ? ('serving' as const)
+              : ('preparing' as const)
+            : discoveryAvailabilityForRuntimeState(target.descriptor.state)
+      }));
+  }
+
+  private isAutomaticSubscriber(channelName: string): boolean {
+    const subscriber = this.registration.channels.get(channelName)?.subscriber;
+    return subscriber !== undefined && (subscriber.manualConnections?.length ?? 0) === 0;
+  }
+
   async reclaimOwnerRows(signal?: AbortSignal): Promise<void> {
     const owner = this.requireOwnerToken();
     const descriptors = await this.lane.run(() => [...this.localDescriptors]);
@@ -215,74 +251,87 @@ export class ZLinkFanoutLocationRuntime {
   }
 
   private async reconcileSubscribers(signal?: AbortSignal): Promise<void> {
-    for (const [channelName, channel] of this.registration.channels) {
-      if (
-        channel.subscriber === undefined ||
-        (channel.subscriber.manualConnections?.length ?? 0) > 0
-      ) {
-        continue;
-      }
+    for (const channelName of this.registration.channels.keys()) {
+      if (!this.isAutomaticSubscriber(channelName)) continue;
+      const previous = this.topologyTargets(channelName)!;
       const rows = await this.listLivePublishers(channelName, signal);
       const desired = new Map(rows.map((row) => [fanoutConnectionId(row), row]));
       for (const [connectionId, descriptor] of desired) {
-        const current = await this.lane.run(() => this.connections.get(connectionId));
+        let current = await this.lane.run(() => this.targets.get(connectionId));
         if (current === undefined) {
-          await this.openConnection(connectionId, descriptor);
-          continue;
-        }
-        if (descriptor.descriptorRevision < current.descriptor.descriptorRevision) {
+          const created = { descriptor };
+          current = created;
+          await this.lane.run(() => this.targets.set(connectionId, created));
+        } else if (descriptor.descriptorRevision < current.descriptor.descriptorRevision) {
           continue;
-        }
-        if (descriptor.descriptorRevision === current.descriptor.descriptorRevision) {
+        } else if (descriptor.descriptorRevision === current.descriptor.descriptorRevision) {
           if (!sameFanoutDescriptor(descriptor, current.descriptor)) {
-            await this.closeConnection(connectionId);
+            await this.removeTarget(connectionId, current);
+            continue;
           }
+        } else if (!sameFanoutImmutableIdentity(descriptor, current.descriptor)) {
+          await this.removeTarget(connectionId, current);
           continue;
+        } else {
+          const target = current;
+          await this.lane.run(() => {
+            if (this.targets.get(connectionId) === target) target.descriptor = descriptor;
+          });
+          if (current.connection?.state === 'ready') {
+            this.sockets.admitFanoutPublisher(current.descriptor, connectionId);
+          }
         }
-        if (!sameFanoutImmutableIdentity(descriptor, current.descriptor)) {
-          await this.closeConnection(connectionId);
-          continue;
-        }
-        await this.lane.run(() => {
-          if (this.connections.get(connectionId) === current) current.descriptor = descriptor;
-        });
-        if (current.state === 'ready') {
-          this.sockets.admitFanoutPublisher(descriptor, connectionId);
-        }
+        await this.reconcileConnection(connectionId, current);
       }
-      const connections = await this.lane.run(() => [...this.connections]);
-      for (const [connectionId, current] of connections) {
+      const targets = await this.lane.run(() => [...this.targets]);
+      for (const [connectionId, current] of targets) {
         if (current.descriptor.channelName === channelName && !desired.has(connectionId)) {
-          await this.closeConnection(connectionId);
+          await this.removeTarget(connectionId, current);
         }
       }
+      const next = this.topologyTargets(channelName)!;
+      if (
+        previous.length !== next.length ||
+        previous.some(
+          (publisher, index) =>
+            publisher.publisherRoutingId !== next[index]!.publisherRoutingId ||
+            publisher.state !== next[index]!.state
+        )
+      ) {
+        this.sockets.notifyFanoutTopology(channelName);
+      }
     }
   }
 
-  private async openConnection(
-    connectionId: string,
-    descriptor: ZLinkFanoutPublisherDescriptor
-  ): Promise<void> {
-    let target: ActiveFanoutTarget | undefined;
+  private async reconcileConnection(connectionId: string, target: FanoutTarget): Promise<void> {
+    if (target.descriptor.state !== ZLinkFrameworkRuntimeState.Serving) {
+      await this.closeConnection(target);
+    } else if (target.connection === undefined) {
+      await this.openConnection(connectionId, target);
+    }
+  }
+
+  private async openConnection(connectionId: string, target: FanoutTarget): Promise<void> {
+    const descriptor = target.descriptor;
+    let connection: ActiveFanoutConnection | undefined;
     const subscriber = this.sockets.openFanoutSubscriberConnection(
       descriptor.channelName,
       connectionId,
       descriptor.endpoint,
       {
         onReady: () => {
-          const current = this.connections.get(connectionId);
-          if (target !== undefined && current === target) {
-            current.state = 'ready';
-            this.sockets.admitFanoutPublisher(descriptor, connectionId);
+          if (connection !== undefined && target.connection === connection) {
+            connection.state = 'ready';
+            this.sockets.admitFanoutPublisher(target.descriptor, connectionId);
           }
         },
         onTerminated: () => {
-          const current = this.connections.get(connectionId);
-          if (target !== undefined && current === target && current.reconnectEligible) {
-            this.sockets.removeFanoutPublisher(descriptor, connectionId);
-            current.state = 'connecting';
+          if (connection !== undefined && target.connection === connection) {
+            this.sockets.removeFanoutPublisher(target.descriptor, connectionId);
+            connection.state = 'connecting';
+            const terminated = connection;
             setImmediate(() => {
-              void this.replaceConnection(current).catch((error) =>
+              void this.replaceConnection(target, terminated).catch((error) =>
                 this.locationRuntime.reportDiscoveryFailure(error)
               );
             });
@@ -290,50 +339,76 @@ export class ZLinkFanoutLocationRuntime {
         }
       }
     );
-    target = {
-      descriptor,
+    connection = {
       connectionId,
-      subscriber,
-      reconnectEligible: true,
       stopReceiver: async () => {},
       state: 'connecting'
     };
-    await this.lane.run(() => this.connections.set(connectionId, target));
-    target.stopReceiver = this.onSubscriberOpened(descriptor.channelName, connectionId, subscriber);
+    const opened = connection;
+    await this.lane.run(() => (target.connection = opened));
+    connection.stopReceiver = this.onSubscriberOpened(
+      descriptor.channelName,
+      connectionId,
+      subscriber
+    );
   }
 
-  private async closeConnection(connectionId: string): Promise<void> {
-    const current = await this.lane.run(() => {
-      const target = this.connections.get(connectionId);
-      if (target !== undefined) {
-        target.reconnectEligible = false;
-        this.connections.delete(connectionId);
-      }
-      return target;
+  private async removeTarget(connectionId: string, target: FanoutTarget): Promise<void> {
+    const detached = await this.lane.run(() => {
+      if (this.targets.get(connectionId) !== target) return undefined;
+      this.targets.delete(connectionId);
+      return this.detachConnection(target);
     });
+    await this.closeDetachedConnection(target.descriptor, detached);
+  }
+
+  private async closeConnection(target: FanoutTarget): Promise<void> {
+    const detached = await this.lane.run(() => this.detachConnection(target));
+    await this.closeDetachedConnection(target.descriptor, detached);
+  }
+
+  private detachConnection(target: FanoutTarget): ActiveFanoutConnection | undefined {
+    const connection = target.connection;
+    target.connection = undefined;
+    return connection;
+  }
+
+  private async closeDetachedConnection(
+    descriptor: ZLinkFanoutPublisherDescriptor,
+    current: ActiveFanoutConnection | undefined
+  ): Promise<void> {
     if (current === undefined) return;
-    this.sockets.removeFanoutPublisher(current.descriptor, connectionId);
-    await current.stopReceiver();
-    await this.sockets.closeFanoutSubscriberConnection(connectionId);
+    this.sockets.removeFanoutPublisher(descriptor, current.connectionId);
+    await closeResources([
+      { close: () => current.stopReceiver() },
+      { close: () => this.sockets.closeFanoutSubscriberConnection(current.connectionId) }
+    ]);
   }
 
-  private async replaceConnection(expected: ActiveFanoutTarget): Promise<void> {
+  private async replaceConnection(
+    target: FanoutTarget,
+    expected: ActiveFanoutConnection
+  ): Promise<void> {
     const prepared = await this.lane.run(() => {
       const controller = this.controller;
       if (
-        this.connections.get(expected.connectionId) !== expected ||
-        !expected.reconnectEligible ||
+        this.targets.get(expected.connectionId) !== target ||
+        target.connection !== expected ||
         controller === undefined
       )
         return undefined;
-      return { controller, descriptor: expected.descriptor };
+      return controller;
     });
     if (prepared === undefined) {
       return;
     }
-    await this.closeConnection(expected.connectionId);
-    if (await this.lane.run(() => this.controller === prepared.controller)) {
-      await this.openConnection(expected.connectionId, prepared.descriptor);
+    await this.closeConnection(target);
+    if (
+      await this.lane.run(
+        () => this.controller === prepared && this.targets.get(expected.connectionId) === target
+      )
+    ) {
+      await this.reconcileConnection(expected.connectionId, target);
     }
   }
 
@@ -346,7 +421,7 @@ export class ZLinkFanoutLocationRuntime {
     do {
       const page = await this.store.listFanoutPublishers(
         channelName,
-        { pageSize: 1000, continuationToken },
+        { pageSize: ZLINK_PROVIDER_MAX_PAGE_SIZE, continuationToken },
         signal
       );
       rows.push(...page.items);
@@ -354,7 +429,6 @@ export class ZLinkFanoutLocationRuntime {
     } while (continuationToken !== undefined);
     const live: ZLinkFanoutPublisherDescriptor[] = [];
     for (const descriptor of rows) {
-      if (descriptor.state !== ZLinkFrameworkRuntimeState.Serving) continue;
       const lease = await this.storeOwnerLease(descriptor.ownerId, signal);
       if (
         lease.kind === 'found' &&
@@ -375,17 +449,24 @@ export class ZLinkFanoutLocationRuntime {
     const owner = this.locationRuntime.currentOwnerToken;
     if (owner === undefined) return;
     const descriptors = await this.lane.run(() => [...this.localDescriptors.values()]);
-    for (const descriptor of descriptors) {
-      await this.store.removeFanoutPublisher(
-        {
-          channelName: descriptor.channelName,
-          publisherRid: descriptor.publisherRid
-        },
-        owner,
-        signal
+    try {
+      await closeResources(
+        descriptors.map((descriptor) => ({
+          close: async () => {
+            await this.store.removeFanoutPublisher(
+              {
+                channelName: descriptor.channelName,
+                publisherRid: descriptor.publisherRid
+              },
+              owner,
+              signal
+            );
+          }
+        }))
       );
+    } finally {
+      await this.lane.run(() => this.localDescriptors.clear());
     }
-    await this.lane.run(() => this.localDescriptors.clear());
   }
 
   private requireOwnerToken(): ZLinkLocationOwnerToken {

package/src/runtime/channels/local-spot-route-transport.ts

@@ -13,9 +13,7 @@ export class ZLinkLocalSpotRouteTransport {
     spotId: RoutingId,
     packetName: string | undefined,
     message: unknown,
-    signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>,
-    timeoutMs?: number
+    metadata?: ReadonlyMap<string, string>
   ): Promise<void> {
     if (this.dispatcher === undefined) {
       throw new ZLinkConfigurationException(
@@ -24,8 +22,6 @@ export class ZLinkLocalSpotRouteTransport {
     }
     await this.dispatcher.send(spotId, packetName, message, {
       channelName: routerChannelId,
-      admissionTimeoutMs: timeoutMs ?? this.defaultRequestTimeoutMs,
-      signal,
       metadata
     });
   }

package/src/runtime/channels/router-socket-spot-route-transport.ts

@@ -15,15 +15,11 @@ export class ZLinkRouterSocketSpotRouteTransport {
   async send(
     target: ZLinkSpotRouteTarget,
     parts: readonly Message[],
-    flags: ZLinkBackendSendFlags,
-    signal?: AbortSignal
+    flags: ZLinkBackendSendFlags
   ): Promise<void> {
     const router = this.sockets.routeRouter(target.routerChannelId);
     try {
-      await awaitWithAbort(
-        router.sendToSpot(target.targetNodeRid, target.spotId, parts, flags),
-        signal
-      );
+      await router.sendToSpot(target.targetNodeRid, target.spotId, parts, flags);
     } finally {
       closeMessages(parts);
     }

package/src/runtime/channels/source-spot-router.ts

@@ -47,11 +47,8 @@ export class ZLinkSourceSpotRouter {
     target: ZLinkSpotRouteTarget,
     packetName: string | undefined,
     message: unknown,
-    signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>,
-    timeoutMs?: number
+    metadata?: ReadonlyMap<string, string>
   ): Promise<void> {
-    throwIfAborted(signal);
     const parts = [
       encodeSpotDirectEnvelope(
         ZLinkChannelMessageKind.Command,
@@ -62,11 +59,7 @@ export class ZLinkSourceSpotRouter {
       )
     ] as readonly Message[];
     try {
-      void timeoutMs;
-      await awaitWithAbort(
-        sourceSpot.sendToSpot(target.targetNodeRid, target.spotId, parts),
-        signal
-      );
+      await sourceSpot.sendToSpot(target.targetNodeRid, target.spotId, parts);
     } finally {
       closeMessages(parts);
     }

package/src/runtime/channels/spot-direct-envelope.ts

@@ -3,7 +3,7 @@ import type { ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-
 import { ZLinkConfigurationException } from '../configuration';
 import { ZLinkChannelMessageKind } from './channel-envelope';
 
-const SPOT_DIRECT_ENVELOPE = 'zlink.framework.spot-direct.v1';
+export const SPOT_DIRECT_ENVELOPE = 'zlink.framework.spot-direct.v1';
 
 export function encodeSpotDirectEnvelope(
   kind: ZLinkChannelMessageKind.Request | ZLinkChannelMessageKind.Command,

package/src/runtime/channels/spot-node-route-transport.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../../contracts/Configuration/Registration';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkFrameworkRegistration } from '../configuration';
 import { awaitWithAbort, throwIfAborted } from '../abort';
@@ -15,18 +16,13 @@ export class ZLinkSpotNodeRouteTransport {
     private readonly targets: ZLinkSpotRouteTargetResolver
   ) {}
 
-  async send(
-    target: ZLinkSpotRouteTarget,
-    parts: readonly Message[],
-    signal?: AbortSignal
-  ): Promise<boolean> {
+  async send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<boolean> {
     const router = this.targets.spotNodeRouter(target.routerChannelId);
     if (router === undefined) {
       return false;
     }
     try {
-      throwIfAborted(signal);
-      await awaitWithAbort(router.sendToSpot(target.targetNodeRid, target.spotId, parts), signal);
+      await router.sendToSpot(target.targetNodeRid, target.spotId, parts);
       return true;
     } finally {
       closeMessages(parts);
@@ -44,7 +40,8 @@ export class ZLinkSpotNodeRouteTransport {
     if (router === undefined) {
       return undefined;
     }
-    const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? 30_000;
+    const effectiveTimeoutMs =
+      timeoutMs ?? this.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     throwIfAborted(signal);
     const operation = router.requestToSpot(
       target.targetNodeRid,
@@ -74,7 +71,8 @@ export class ZLinkSpotNodeRouteTransport {
     if (router === undefined) {
       return undefined;
     }
-    const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? 30_000;
+    const effectiveTimeoutMs =
+      timeoutMs ?? this.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     throwIfAborted(signal);
     const operation = router.requestToSpot(
       target.targetNodeRid,

package/src/runtime/channels/spot-route-bridge-transport.ts

@@ -20,20 +20,13 @@ export class ZLinkSpotRouteBridgeTransport {
     return this.bridges.has(routerChannelId);
   }
 
-  async send(
-    target: ZLinkSpotRouteTarget,
-    parts: readonly Message[],
-    signal?: AbortSignal
-  ): Promise<void> {
+  async send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<void> {
     const bridge = this.requireBridge(target.routerChannelId);
     try {
-      await awaitWithAbort(
-        appendParts(
-          bridge.send(target.routerChannelId, target.targetNodeRid, target.spotId),
-          parts
-        ).submit(),
-        signal
-      );
+      await appendParts(
+        bridge.send(target.routerChannelId, target.targetNodeRid, target.spotId),
+        parts
+      ).submit();
     } finally {
       closeMessages(parts);
     }