@zlink-systems/framework 0.27.0 → 0.28.0

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-node-route-transport.ts

@@ -16,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);

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);
     }

package/src/runtime/channels/spot-route-dispatch-strategy.ts

@@ -32,8 +32,6 @@ export interface ZLinkLocalSpotRouteDispatcher {
     message: unknown,
     context: {
       readonly channelName: string;
-      readonly admissionTimeoutMs?: number;
-      readonly signal?: AbortSignal;
       readonly metadata?: ReadonlyMap<string, string>;
     }
   ): Promise<void>;
@@ -101,14 +99,12 @@ export class ZLinkSpotRouteDispatchStrategy {
     spotRouteTarget: ZLinkSpotRouteTarget,
     packetName: string | undefined,
     message: unknown,
-    signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>,
-    timeoutMs?: number
+    metadata?: ReadonlyMap<string, string>
   ): Promise<void> {
     // Call-scoped flow (spec 27 §4): the envelope flow pair lives only for
     // the duration of this outbound call, never in the caller's context.
     return runWithOutboundFlow(this.options.flowCreationEnabled?.() ?? true, () =>
-      this.routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs)
+      this.routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata)
     );
   }
 
@@ -116,11 +112,8 @@ export class ZLinkSpotRouteDispatchStrategy {
     spotRouteTarget: ZLinkSpotRouteTarget,
     packetName: string | undefined,
     message: unknown,
-    signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>,
-    timeoutMs?: number
+    metadata?: ReadonlyMap<string, string>
   ): Promise<void> {
-    throwIfAborted(signal);
     const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
     if (localSpotRouteNode !== undefined) {
       await this.localTransport.send(
@@ -128,9 +121,7 @@ export class ZLinkSpotRouteDispatchStrategy {
         spotRouteTarget.spotId,
         packetName,
         message,
-        signal,
-        metadata,
-        timeoutMs
+        metadata
       );
       return;
     }
@@ -148,22 +139,22 @@ export class ZLinkSpotRouteDispatchStrategy {
     ) as readonly Message[];
     if (
       this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId) &&
-      (await this.spotNodeTransport.send(spotRouteTarget, parts, signal))
+      (await this.spotNodeTransport.send(spotRouteTarget, parts))
     ) {
       return;
     }
     if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-      await this.bridgeTransport.send(spotRouteTarget, parts, signal);
+      await this.bridgeTransport.send(spotRouteTarget, parts);
       return;
     }
     if (this.targets.hasBoundRouteRouter(spotRouteTarget.routerChannelId)) {
-      await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT, signal);
+      await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
       return;
     }
-    if (await this.spotNodeTransport.send(spotRouteTarget, parts, signal)) {
+    if (await this.spotNodeTransport.send(spotRouteTarget, parts)) {
       return;
     }
-    await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT, signal);
+    await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
   }
 
   routeRequestToSpot<TReply>(
@@ -291,19 +282,9 @@ export class ZLinkSpotRouteDispatchStrategy {
     spotRouteTarget: ZLinkSpotRouteTarget,
     packetName: string | undefined,
     message: unknown,
-    signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>,
-    timeoutMs?: number
+    metadata?: ReadonlyMap<string, string>
   ): Promise<void> {
-    await this.sourceSpotRouter.send(
-      sourceSpot,
-      spotRouteTarget,
-      packetName,
-      message,
-      signal,
-      metadata,
-      timeoutMs
-    );
+    await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
   }
 
   routeRequestRawFromSpotToSpot(

package/src/runtime/foundation/raw-service-mesh-runtime.ts

@@ -10,7 +10,8 @@ import type {
   ZLinkRawReceivedRecord,
   ZLinkRawRouterPort
 } from '../backend/raw-binding-port';
-import { RequestResult, SubmitResult } from '../backend/runtime-values';
+import { submitToRequestResult } from '../messaging/submission-result';
+import { RequestResult, SubmitResult, isZLinkBackendResultError } from '../backend/runtime-values';
 import { enumWireRejectReason } from '../protocol/service_wire_codec.generated';
 import { OperationRegistry, type PendingOperation } from './operation-registry';
 import { ServiceLivenessRegistry, type ServiceLivenessTick } from './service-liveness-registry';
@@ -830,17 +831,14 @@ export class RawServiceMeshRuntime {
             peer.connectionId,
             record.probeId
           );
-          const sent =
-            ack !== undefined &&
-            (await this.send(received.sourceRid, [
-              livenessCodec.encodeLivenessRecord({
-                command: M6aServiceWireCommand.livenessAck,
-                probeId: record.probeId
-              })
-            ]));
-          if (!sent) {
-            return 'protocolError';
-          }
+          if (ack === undefined) return 'protocolError';
+          const sent = await this.send(received.sourceRid, [
+            livenessCodec.encodeLivenessRecord({
+              command: M6aServiceWireCommand.livenessAck,
+              probeId: record.probeId
+            })
+          ]);
+          if (!sent) return 'dropped';
         } else {
           this.liveness.acknowledge(received.sourceRid, peer.connectionId, record.probeId, nowMs);
         }
@@ -1263,8 +1261,13 @@ export class RawServiceMeshRuntime {
     try {
       await this.requireStarted().send(targetNodeRoutingId, parts);
       return true;
-    } catch {
-      return false;
+    } catch (error) {
+      if (isZLinkBackendResultError(error) && error.operation === 'submit') {
+        const terminal = submitToRequestResult(error.result, error.phase);
+        if (terminal === RequestResult.NotConnected || terminal === RequestResult.NotFound)
+          return false;
+      }
+      throw error;
     }
   }
 }

package/src/runtime/host/actor-packet-relay.ts

@@ -464,13 +464,12 @@ export class ZLinkActorPacketRelay {
   async relayActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
-    if (await this.relayRemoteActorPacket(actor, frameHeader, payload, signal)) {
+    if (await this.relayRemoteActorPacket(actor, frameHeader, payload)) {
       return true;
     }
-    return this.relayLocalActorPacket(actor, frameHeader, payload, signal);
+    return this.relayLocalActorPacket(actor, frameHeader, payload);
   }
 
   async confirmRemoteSessionBinding(
@@ -581,8 +580,7 @@ export class ZLinkActorPacketRelay {
   async relayRemoteActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
     const streamRuntime = this.options.streamBindingRuntime();
     const responseTarget = await streamRuntime.captureBoundSessionResponseTarget(actor);
@@ -671,8 +669,7 @@ export class ZLinkActorPacketRelay {
         remoteAddress.routerChannelId,
         String(remoteAddress.targetNodeRid),
         ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        request,
-        signal
+        request
       );
       if (result.status !== ZLinkSubmitStatus.Submitted) {
         throw new Error(`Actor '${actor.actorId}' remote node relay was not admitted.`);
@@ -681,8 +678,7 @@ export class ZLinkActorPacketRelay {
     }
     if (frameHeader.kind === ZLinkStreamMessageKind.Send || frameHeader.requestSeq === undefined) {
       await this.options.routeTransport.sendToSpot(remoteAddress, request, {
-        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        signal
+        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
       });
       return true;
     }
@@ -702,8 +698,7 @@ export class ZLinkActorPacketRelay {
           throw new Error(`Remote actor packet relay reply was empty for '${actor.actorId}'.`);
         }
         return JSON.parse(parts[0].getString('utf8')) as typeof reply;
-      },
-      signal
+      }
     );
     const actorPacketTarget = this.targets.decodeFromWire(reply.actorPacketTarget);
     const currentStoredRoute = await streamRuntime.sessionRouteFence(actor.actorId);
@@ -863,10 +858,8 @@ export class ZLinkActorPacketRelay {
   private async relayLocalActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
-    void signal;
     const state = this.options.actorManager()?.getState(actor.actorId);
     const spotId = state?.spotId as RoutingId | undefined;
     const hasActiveSpot =

package/src/runtime/host/index.ts

@@ -221,8 +221,6 @@ const HOST_SHUTDOWN_POLL_INTERVAL_MS = 100;
 const HANDOFF_ACCEPTANCE_POLL_INTERVAL_MS = 10;
 const DEFAULT_HOST_CONTROL_TIMEOUT_MS = 30_000;
 
-const LEGACY_MESH_SEND_TIMEOUT_MS = 1000;
-
 export interface ZLinkFrameworkRuntimeLifecycle {
   readonly isStarted: boolean;
   readonly locationRuntimeQuery?: ZLinkLocationRuntimeQuery;
@@ -367,25 +365,6 @@ export class ZLinkFrameworkRuntimeHost
     );
     this.meshRouters = new MeshRouterResolver(options.registration);
     this.spotRouterChannelIdForMesh = this.meshRouters.spotRouterChannelIdByMesh();
-    const sendTimeoutMsForSpotMesh = (meshName: string): number =>
-      options.registration.spotNodes.get(meshName)?.router?.sendTimeoutMs ??
-      LEGACY_MESH_SEND_TIMEOUT_MS;
-    const sendTimeoutMsForSpotRouteChannel = (routeChannelId: string): number => {
-      const routeChannel = options.registration.routeChannelOptions.get(routeChannelId);
-      if (routeChannel !== undefined) {
-        return routeChannel.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS;
-      }
-      return sendTimeoutMsForSpotMesh(routeChannelId);
-    };
-    const defaultSpotSendTimeoutMs = Math.max(
-      LEGACY_MESH_SEND_TIMEOUT_MS,
-      ...[...options.registration.spotNodes.values()].map(
-        (node) => node.router?.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS
-      ),
-      ...[...options.registration.routeChannelOptions.values()].map(
-        (route) => route.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS
-      )
-    );
     this.routeTransport = new ZLinkRuntimeRouteTransport(
       () => this.channelRuntime,
       (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId),
@@ -410,9 +389,6 @@ export class ZLinkFrameworkRuntimeHost
       completions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
       codecs: { serializers: options.registration.messageSerializers },
       defaultRequestTimeoutMs: options.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
-      defaultSendTimeoutMs: defaultSpotSendTimeoutMs,
-      sendTimeoutMsForMesh: sendTimeoutMsForSpotMesh,
-      sendTimeoutMsForRouteChannel: sendTimeoutMsForSpotRouteChannel,
       dispatchErrors: this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink)
     });
     this.locationOwner = new ZLinkLocationRuntimeOwner({
@@ -463,8 +439,8 @@ export class ZLinkFrameworkRuntimeHost
               options
             );
       },
-      relay: (actor, header, payload, signal) =>
-        this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload, signal),
+      relay: (actor, header, payload) =>
+        this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload),
       notifyDisconnected: (actor, signal) =>
         this.boundSessionRelay.actorPackets.notifyBoundActorDisconnected(actor, signal)
     });

package/src/runtime/host/remote-bound-session-relay.ts

@@ -642,8 +642,7 @@ export class ZLinkRemoteBoundSessionRelay {
         packetName,
         requestSeq,
         response,
-        replyOptions,
-        signal
+        replyOptions
       );
       return;
     }
@@ -698,8 +697,7 @@ export class ZLinkRemoteBoundSessionRelay {
         packetName,
         requestSeq,
         error,
-        metadata,
-        signal
+        metadata
       );
       return;
     }
@@ -731,8 +729,7 @@ export class ZLinkRemoteBoundSessionRelay {
     packetName: string,
     requestSeq: bigint,
     message: unknown,
-    replyOptions: ZLinkActorResponseOptions,
-    signal?: AbortSignal
+    replyOptions: ZLinkActorResponseOptions
   ): Promise<void> {
     const actorPacketTarget = encodeRemoteActorPacketTarget(
       this.options.actorPacketTargetForState(actorId)
@@ -747,8 +744,7 @@ export class ZLinkRemoteBoundSessionRelay {
         metadata: replyOptions.metadata,
         compressPayload: replyOptions.compressPayload,
         actorPacketTarget
-      }),
-      signal
+      })
     );
   }
 
@@ -758,8 +754,7 @@ export class ZLinkRemoteBoundSessionRelay {
     packetName: string,
     requestSeq: bigint,
     error: unknown,
-    metadata: ReadonlyMap<string, string>,
-    signal?: AbortSignal
+    metadata: ReadonlyMap<string, string>
   ): Promise<void> {
     await this.sendRemoteBoundSessionControl(
       target,
@@ -772,15 +767,13 @@ export class ZLinkRemoteBoundSessionRelay {
         actorPacketTarget: encodeRemoteActorPacketTarget(
           this.options.actorPacketTargetForState(actorId)
         )
-      }),
-      signal
+      })
     );
   }
 
   private async sendRemoteBoundSessionControl(
     target: ZLinkRemoteBoundSessionTarget,
-    payload: Record<string, unknown>,
-    signal?: AbortSignal
+    payload: Record<string, unknown>
   ): Promise<void> {
     const packetName = payload.packetName;
     if (typeof packetName !== 'string') {
@@ -796,8 +789,7 @@ export class ZLinkRemoteBoundSessionRelay {
       target.routerChannelId,
       String(target.targetNodeRid),
       packetName,
-      payload,
-      signal
+      payload
     );
     if (result.status !== ZLinkSubmitStatus.Submitted) {
       throw new Error(