@zlink-systems/framework 0.27.0 → 0.28.0

package/dist/runtime/channels/spot-route-dispatch-strategy.js

@@ -41,35 +41,34 @@ class ZLinkSpotRouteDispatchStrategy {
     canRoutePacketChannel(routerChannelId) {
         return this.targets.canRoutePacketChannel(routerChannelId);
     }
-    routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
+    routeSendToSpot(spotRouteTarget, packetName, message, metadata) {
         // 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 (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs));
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata));
     }
-    async routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        (0, abort_1.throwIfAborted)(signal);
+    async routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata) {
         const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
         if (localSpotRouteNode !== undefined) {
-            await this.localTransport.send(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, message, signal, metadata, timeoutMs);
+            await this.localTransport.send(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, message, metadata);
             return;
         }
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, spotRouteTarget.routerChannelId, packetName, message, undefined, undefined, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.options.codecs), undefined, this.options.flowCreationEnabled?.() ?? true, metadata);
         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(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
         return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata));
@@ -102,8 +101,8 @@ class ZLinkSpotRouteDispatchStrategy {
     routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
         return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
     }
-    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
+        await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
     routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
         return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal);

package/dist/runtime/foundation/raw-service-mesh-runtime.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RawServiceMeshRuntime = exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS = void 0;
 const node_os_1 = require("node:os");
 const application_ingress_record_owner_1 = require("../application-jobs/application-ingress-record-owner");
+const submission_result_1 = require("../messaging/submission-result");
 const runtime_values_1 = require("../backend/runtime-values");
 const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const operation_registry_1 = require("./operation-registry");
@@ -564,16 +565,16 @@ class RawServiceMeshRuntime {
                 const record = livenessCodec.decodeLivenessRecord(received.parts[0]);
                 if (record.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe) {
                     const ack = this.liveness.acknowledgeProbe(received.sourceRid, peer.connectionId, record.probeId);
-                    const sent = ack !== undefined &&
-                        (await this.send(received.sourceRid, [
-                            livenessCodec.encodeLivenessRecord({
-                                command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
-                                probeId: record.probeId
-                            })
-                        ]));
-                    if (!sent) {
+                    if (ack === undefined)
                         return 'protocolError';
-                    }
+                    const sent = await this.send(received.sourceRid, [
+                        livenessCodec.encodeLivenessRecord({
+                            command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
+                            probeId: record.probeId
+                        })
+                    ]);
+                    if (!sent)
+                        return 'dropped';
                 }
                 else {
                     this.liveness.acknowledge(received.sourceRid, peer.connectionId, record.probeId, nowMs);
@@ -962,8 +963,13 @@ class RawServiceMeshRuntime {
             await this.requireStarted().send(targetNodeRoutingId, parts);
             return true;
         }
-        catch {
-            return false;
+        catch (error) {
+            if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
+                const terminal = (0, submission_result_1.submitToRequestResult)(error.result, error.phase);
+                if (terminal === runtime_values_1.RequestResult.NotConnected || terminal === runtime_values_1.RequestResult.NotFound)
+                    return false;
+            }
+            throw error;
         }
     }
 }

package/dist/runtime/host/actor-packet-relay.d.ts

@@ -43,7 +43,7 @@ export declare class ZLinkActorPacketRelay {
         readonly deferredResponse?: boolean;
         readonly actorPacketTarget?: unknown;
     }>;
-    relayActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message, signal?: AbortSignal): Promise<boolean>;
+    relayActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message): Promise<boolean>;
     confirmRemoteSessionBinding(actor: ActorRef, sessionNodeRid: RoutingId, sessionRid: RoutingId, signal?: AbortSignal, options?: ZLinkSessionBindingConfirmationOptions): Promise<void>;
     /**
      * Session–Actor binding §5·§6 (.NET ZLinkSessionActorCoordinator rule): a
@@ -51,7 +51,7 @@ export declare class ZLinkActorPacketRelay {
      * same install a remote command 38 uses, so relocation seals and carries it.
      */
     private installSameNodeSessionBinding;
-    relayRemoteActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message, signal?: AbortSignal): Promise<boolean>;
+    relayRemoteActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message): Promise<boolean>;
     notifyRemoteActorDisconnected(actorId: string, remoteTarget: ZLinkRemoteBoundSessionTarget | ZLinkRemoteActorPacketTarget, signal?: AbortSignal, bindingActorRef?: ActorRef): Promise<void>;
     private requireCurrentRemoteBinding;
     private requestRemoteTarget;

package/dist/runtime/host/actor-packet-relay.js

@@ -273,11 +273,11 @@ class ZLinkActorPacketRelay {
             }
         }
     }
-    async relayActorPacket(actor, frameHeader, payload, signal) {
-        if (await this.relayRemoteActorPacket(actor, frameHeader, payload, signal)) {
+    async relayActorPacket(actor, frameHeader, payload) {
+        if (await this.relayRemoteActorPacket(actor, frameHeader, payload)) {
             return true;
         }
-        return this.relayLocalActorPacket(actor, frameHeader, payload, signal);
+        return this.relayLocalActorPacket(actor, frameHeader, payload);
     }
     async confirmRemoteSessionBinding(actor, sessionNodeRid, sessionRid, signal, options) {
         const target = this.targets.targetForActorRef(actor);
@@ -349,7 +349,7 @@ class ZLinkActorPacketRelay {
             bindingGeneration: binding.bindingGeneration
         });
     }
-    async relayRemoteActorPacket(actor, frameHeader, payload, signal) {
+    async relayRemoteActorPacket(actor, frameHeader, payload) {
         const streamRuntime = this.options.streamBindingRuntime();
         const responseTarget = await streamRuntime.captureBoundSessionResponseTarget(actor);
         const localNode = this.options.spotNodeRuntime()?.primaryMeshNode;
@@ -419,7 +419,7 @@ class ZLinkActorPacketRelay {
         if ((frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Send || frameHeader.requestSeq === undefined) &&
             remoteAddress.spotKind === contracts_1.ZLinkSpotKind.Entry &&
             this.options.routeTransport.submit !== undefined) {
-            const result = await this.options.routeTransport.submit(remoteAddress.routerChannelId, String(remoteAddress.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, request, signal);
+            const result = await this.options.routeTransport.submit(remoteAddress.routerChannelId, String(remoteAddress.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, request);
             if (result.status !== submission_result_1.ZLinkSubmitStatus.Submitted) {
                 throw new Error(`Actor '${actor.actorId}' remote node relay was not admitted.`);
             }
@@ -427,8 +427,7 @@ class ZLinkActorPacketRelay {
         }
         if (frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Send || frameHeader.requestSeq === undefined) {
             await this.options.routeTransport.sendToSpot(remoteAddress, request, {
-                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-                signal
+                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
             });
             return true;
         }
@@ -438,7 +437,7 @@ class ZLinkActorPacketRelay {
                 throw new Error(`Remote actor packet relay reply was empty for '${actor.actorId}'.`);
             }
             return JSON.parse(parts[0].getString('utf8'));
-        }, signal);
+        });
         const actorPacketTarget = this.targets.decodeFromWire(reply.actorPacketTarget);
         const currentStoredRoute = await streamRuntime.sessionRouteFence(actor.actorId);
         const currentAggregateRoute = aggregateOwner === undefined ? undefined : await aggregateOwner.committedRoute(actor.actorId);
@@ -526,8 +525,7 @@ class ZLinkActorPacketRelay {
         }
         return (0, actor_routed_json_request_1.requestRoutedJsonReply)(this.options.routeTransport, withDefaultSpotKind(target), request, { timeoutMs: this.options.requestTimeoutMs, signal }, unavailableMessage, decodeReply);
     }
-    async relayLocalActorPacket(actor, frameHeader, payload, signal) {
-        void signal;
+    async relayLocalActorPacket(actor, frameHeader, payload) {
         const state = this.options.actorManager()?.getState(actor.actorId);
         const spotId = state?.spotId;
         const hasActiveSpot = spotId !== undefined && this.options.spotManager()?.hasActiveSpot(spotId) === true;

package/dist/runtime/host/index.js

@@ -70,7 +70,6 @@ const user_spot_creation_coordinator_1 = require("./user-spot-creation-coordinat
 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;
 class ZLinkFrameworkRuntimeHost {
     options;
     backendAdapterFactory;
@@ -168,16 +167,6 @@ class ZLinkFrameworkRuntimeHost {
         this.fanoutRuntime = new topology_runtime_projections_1.ZLinkFanoutRuntimeProjection(() => this.channelRuntime, () => this.runtimeState);
         this.meshRouters = new mesh_router_resolver_1.MeshRouterResolver(options.registration);
         this.spotRouterChannelIdForMesh = this.meshRouters.spotRouterChannelIdByMesh();
-        const sendTimeoutMsForSpotMesh = (meshName) => options.registration.spotNodes.get(meshName)?.router?.sendTimeoutMs ??
-            LEGACY_MESH_SEND_TIMEOUT_MS;
-        const sendTimeoutMsForSpotRouteChannel = (routeChannelId) => {
-            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 channels_1.ZLinkRuntimeRouteTransport(() => this.channelRuntime, (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId), () => this.spotNodeRuntime, { serializers: options.registration.messageSerializers }, (meshName, targetNodeRid) => this.meshRouters.classifyManualNodeTarget(meshName, targetNodeRid), (meshName, sourceNodeRid, parts) => this.submitLocalMeshRoute(meshName, sourceNodeRid, parts), this.metrics, () => this.flowCreationEnabled(), () => this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow);
         this.spotAddressTransport = new spot_address_transport_1.ZLinkHostSpotAddressTransport({
             resolver: () => this.createLocationSpotRouteResolver(),
@@ -190,9 +179,6 @@ class ZLinkFrameworkRuntimeHost {
             completions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
             codecs: { serializers: options.registration.messageSerializers },
             defaultRequestTimeoutMs: options.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS,
-            defaultSendTimeoutMs: defaultSpotSendTimeoutMs,
-            sendTimeoutMsForMesh: sendTimeoutMsForSpotMesh,
-            sendTimeoutMsForRouteChannel: sendTimeoutMsForSpotRouteChannel,
             dispatchErrors: this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink)
         });
         this.locationOwner = new location_runtime_owner_1.ZLinkLocationRuntimeOwner({
@@ -233,7 +219,7 @@ class ZLinkFrameworkRuntimeHost {
                     ? Promise.resolve()
                     : this.boundSessionRelay.actorPackets.confirmRemoteSessionBinding(actor, sessionNode.status().routingId, sessionRid, signal, 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)
         });
         this.actorHandoff = new actors_1.ZLinkActorHandoffCoordinator({

package/dist/runtime/host/remote-bound-session-relay.js

@@ -420,7 +420,7 @@ class ZLinkRemoteBoundSessionRelay {
         const actorRef = currentActorRef(state, fallbackActorRef);
         const remoteTarget = fallbackBoundSessionTarget ?? state?.remoteBoundSessionTarget;
         if (remoteTarget !== undefined) {
-            await this.sendRemoteBoundSessionResponse(remoteTarget, actor.context.actorId, packetName, requestSeq, response, replyOptions, signal);
+            await this.sendRemoteBoundSessionResponse(remoteTarget, actor.context.actorId, packetName, requestSeq, response, replyOptions);
             return;
         }
         if (actorRef === undefined) {
@@ -444,7 +444,7 @@ class ZLinkRemoteBoundSessionRelay {
         const actorRef = currentActorRef(state, fallbackActorRef) ?? this.options.destroyedActorRefs.get(actorId);
         const remoteTarget = fallbackBoundSessionTarget ?? state?.remoteBoundSessionTarget;
         if (remoteTarget !== undefined) {
-            await this.sendRemoteBoundSessionError(remoteTarget, actorId, packetName, requestSeq, error, metadata, signal);
+            await this.sendRemoteBoundSessionError(remoteTarget, actorId, packetName, requestSeq, error, metadata);
             return;
         }
         if (actorRef === undefined) {
@@ -458,7 +458,7 @@ class ZLinkRemoteBoundSessionRelay {
             .streamBindingRuntime()
             .sendNativeBoundSessionError(actorSessionNode, actorRef, packetName, requestSeq, error, metadata, signal);
     }
-    async sendRemoteBoundSessionResponse(target, actorId, packetName, requestSeq, message, replyOptions, signal) {
+    async sendRemoteBoundSessionResponse(target, actorId, packetName, requestSeq, message, replyOptions) {
         const actorPacketTarget = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.options.actorPacketTargetForState(actorId));
         await this.sendRemoteBoundSessionControl(target, (0, bound_session_wire_1.encodeRemoteBoundSessionResponsePayload)({
             actorId,
@@ -468,9 +468,9 @@ class ZLinkRemoteBoundSessionRelay {
             metadata: replyOptions.metadata,
             compressPayload: replyOptions.compressPayload,
             actorPacketTarget
-        }), signal);
+        }));
     }
-    async sendRemoteBoundSessionError(target, actorId, packetName, requestSeq, error, metadata, signal) {
+    async sendRemoteBoundSessionError(target, actorId, packetName, requestSeq, error, metadata) {
         await this.sendRemoteBoundSessionControl(target, (0, bound_session_wire_1.encodeRemoteBoundSessionErrorPayload)({
             actorId,
             boundPacketName: packetName,
@@ -478,9 +478,9 @@ class ZLinkRemoteBoundSessionRelay {
             error,
             metadata,
             actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.options.actorPacketTargetForState(actorId))
-        }), signal);
+        }));
     }
-    async sendRemoteBoundSessionControl(target, payload, signal) {
+    async sendRemoteBoundSessionControl(target, payload) {
         const packetName = payload.packetName;
         if (typeof packetName !== 'string') {
             throw new Error('Remote bound session control payload does not declare a packet name.');
@@ -489,7 +489,7 @@ class ZLinkRemoteBoundSessionRelay {
         if (submit === undefined) {
             throw new Error('Remote bound session node-direct transport is not available.');
         }
-        const result = await submit.call(this.options.routeTransport, target.routerChannelId, String(target.targetNodeRid), packetName, payload, signal);
+        const result = await submit.call(this.options.routeTransport, target.routerChannelId, String(target.targetNodeRid), packetName, payload);
         if (result.status !== submission_result_1.ZLinkSubmitStatus.Submitted) {
             throw new Error(`Remote bound session control '${packetName}' was not admitted` +
                 ` on '${target.routerChannelId}' for '${String(target.targetNodeRid)}'` +

package/dist/runtime/host/spot-address-transport.d.ts

@@ -15,12 +15,6 @@ export interface ZLinkHostSpotAddressTransportOptions {
     readonly completions: (meshName: string) => ZLinkMeshCompletionTable | undefined;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
     readonly defaultRequestTimeoutMs: number;
-    /** Internal one-way deadline policy; public calls do not expose this option. */
-    readonly defaultSendTimeoutMs?: number;
-    /** Resolves the send timeout for a configured Spot Mesh. */
-    readonly sendTimeoutMsForMesh?: (meshName: string) => number;
-    /** Resolves the send timeout for a resolved Spot route channel. */
-    readonly sendTimeoutMsForRouteChannel?: (routeChannelId: string) => number;
     readonly dispatchErrors?: ZLinkDispatchErrorReporter;
 }
 export declare function hasObjectClientCapability(role: 'none' | 'client' | 'server' | undefined): boolean;
@@ -28,7 +22,7 @@ export declare function hasObjectClientCapability(role: 'none' | 'client' | 'ser
 export declare class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport {
     private readonly options;
     constructor(options: ZLinkHostSpotAddressTransportOptions);
-    sendToSpotAddress(spotId: RoutingId, message: unknown, call: ZLinkSpotAddressCallOptions): Promise<ZLinkSubmitResult>;
+    sendToSpotAddress(spotId: RoutingId, message: unknown, call: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>): Promise<ZLinkSubmitResult>;
     private sendToSpotAddressScoped;
     requestToSpotAddress<TReply = unknown>(spotId: RoutingId, request: unknown, call: ZLinkSpotAddressCallOptions): Promise<TReply>;
     private requestToSpotAddressScoped;
@@ -38,8 +32,6 @@ export declare class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTr
     private traceInstanceAddress;
     private resolveExisting;
     private selectMissingTarget;
-    private sendTimeoutMsForMesh;
-    private sendTimeoutMsForRouteChannel;
     private validateExisting;
     private encode;
     private encodeAtDeadline;

package/dist/runtime/host/spot-address-transport.js

@@ -29,79 +29,60 @@ class ZLinkHostSpotAddressTransport {
         return (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => this.sendToSpotAddressScoped(spotId, message, call));
     }
     async sendToSpotAddressScoped(spotId, message, call) {
-        const timeoutMs = initialSendTimeoutMs(this.options, call);
-        const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
-        try {
-            const existing = await this.resolveExisting(spotId, deadline.signal);
-            deadline.requireRemaining();
-            if (existing !== undefined) {
-                this.validateExisting(existing, call);
-                deadline.setOwnerTimeout(this.sendTimeoutMsForRouteChannel(existing.routerChannelId));
-                try {
-                    const result = await (0, abort_1.awaitWithAbort)(this.options.routed.sendToSpot(existing, message, {
-                        instanceSpot: call.instanceSpot,
-                        timeoutMs: deadline.requireRemaining(),
-                        signal: deadline.signal,
-                        metadata: call.metadata
-                    }), deadline.signal);
-                    if (result.status === submission_result_1.ZLinkSubmitStatus.Submitted) {
-                        this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
-                    }
-                    else {
-                        this.traceInstanceAddress(submitResultFlowOutcome(result.status), ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, existing.routerChannelId, existing.stableType, existing.targetNodeRid, submitResultReason(result.status));
-                    }
-                    if (result.status === submission_result_1.ZLinkSubmitStatus.TargetNotFound ||
-                        result.status === submission_result_1.ZLinkSubmitStatus.RouteNotConnected) {
-                        this.options.resolver()?.invalidate?.(spotId);
-                    }
-                    return result;
+        const activationDeadlineUnixMs = BigInt(Math.round(Date.now() + this.options.defaultRequestTimeoutMs));
+        const existing = await this.resolveExisting(spotId);
+        if (existing !== undefined) {
+            this.validateExisting(existing, call);
+            try {
+                const result = await this.options.routed.sendToSpot(existing, message, {
+                    instanceSpot: call.instanceSpot,
+                    metadata: call.metadata
+                });
+                if (result.status === submission_result_1.ZLinkSubmitStatus.Submitted) {
+                    this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
                 }
-                catch (error) {
-                    if (isSpotRouteRefreshError(error)) {
-                        this.options.resolver()?.invalidate?.(spotId);
-                    }
-                    const reason = addressedInstanceErrorReason(error);
-                    this.traceInstanceAddress(reason === ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.Backpressure
-                        ? ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured
-                        : ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, existing.routerChannelId, existing.stableType, existing.targetNodeRid, reason);
-                    throw error;
+                else {
+                    this.traceInstanceAddress(submitResultFlowOutcome(result.status), ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, existing.routerChannelId, existing.stableType, existing.targetNodeRid, submitResultReason(result.status));
                 }
+                if (result.status === submission_result_1.ZLinkSubmitStatus.TargetNotFound ||
+                    result.status === submission_result_1.ZLinkSubmitStatus.RouteNotConnected) {
+                    this.options.resolver()?.invalidate?.(spotId);
+                }
+                return result;
             }
-            if (!call.instanceSpot) {
-                return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
-            }
-            const selected = this.selectMissingTarget(spotId, call);
-            if (selected.kind === 'unsupported') {
-                this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget);
-                return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
-            }
-            if (selected.kind === 'capacity') {
-                const error = missingInstancePlacementCapacity(spotId, call.instanceSpotType);
-                this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.Backpressure);
+            catch (error) {
+                if (isSpotRouteRefreshError(error)) {
+                    this.options.resolver()?.invalidate?.(spotId);
+                }
+                const reason = addressedInstanceErrorReason(error);
+                this.traceInstanceAddress(reason === ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.Backpressure
+                    ? ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured
+                    : ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, existing.routerChannelId, existing.stableType, existing.targetNodeRid, reason);
                 throw error;
             }
-            if (selected.kind === 'unavailable') {
-                this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget);
-                return { status: submission_result_1.ZLinkSubmitStatus.RouteNotConnected };
-            }
-            deadline.setOwnerTimeout(this.sendTimeoutMsForMesh(selected.meshName));
-            const encoded = this.encode(3 /* ZLinkChannelMessageKind.Command */, selected.meshName, message);
-            const sourceSpotId = call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
-            const mapped = (0, submission_result_1.classifySubmitResult)(await (0, abort_1.awaitWithAbort)(selected.node.sendToMissingInstanceSpot(selected.target, encoded, BigInt(deadline.deadlineUnixMs), sourceSpotId, call.metadata), deadline.signal), 'Instance Spot submission');
-            this.traceInstanceAddress(submitResultFlowOutcome(mapped.status), ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, selected.meshName, selected.target.stableType, selected.target.targetNodeRid, mapped.status === submission_result_1.ZLinkSubmitStatus.Submitted
-                ? undefined
-                : submitResultReason(mapped.status));
-            return mapped;
         }
-        catch (error) {
-            if (deadline.expired()) {
-                return { status: submission_result_1.ZLinkSubmitStatus.TimedOut };
-            }
+        if (!call.instanceSpot) {
+            return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
+        }
+        const selected = this.selectMissingTarget(spotId, call);
+        if (selected.kind === 'unsupported') {
+            this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget);
+            return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
+        }
+        if (selected.kind === 'capacity') {
+            const error = missingInstancePlacementCapacity(spotId, call.instanceSpotType);
+            this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.Backpressure);
             throw error;
         }
-        finally {
-            deadline.close();
+        if (selected.kind === 'unavailable') {
+            this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget);
+            return { status: submission_result_1.ZLinkSubmitStatus.RouteNotConnected };
         }
+        const encoded = this.encode(3 /* ZLinkChannelMessageKind.Command */, selected.meshName, message);
+        const sourceSpotId = call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
+        const mapped = (0, submission_result_1.classifySubmitResult)(await selected.node.sendToMissingInstanceSpot(selected.target, encoded, activationDeadlineUnixMs, sourceSpotId, call.metadata), 'Instance Spot submission');
+        this.traceInstanceAddress(submitResultFlowOutcome(mapped.status), ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, selected.meshName, selected.target.stableType, selected.target.targetNodeRid, mapped.status === submission_result_1.ZLinkSubmitStatus.Submitted ? undefined : submitResultReason(mapped.status));
+        return mapped;
     }
     requestToSpotAddress(spotId, request, call) {
         return (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => this.requestToSpotAddressScoped(spotId, request, call));
@@ -315,16 +296,6 @@ class ZLinkHostSpotAddressTransport {
             return { kind: 'unsupported' };
         return { kind: 'unavailable' };
     }
-    sendTimeoutMsForMesh(meshName) {
-        return (this.options.sendTimeoutMsForMesh?.(meshName) ??
-            this.options.defaultSendTimeoutMs ??
-            this.options.defaultRequestTimeoutMs);
-    }
-    sendTimeoutMsForRouteChannel(routeChannelId) {
-        return (this.options.sendTimeoutMsForRouteChannel?.(routeChannelId) ??
-            this.options.defaultSendTimeoutMs ??
-            this.options.defaultRequestTimeoutMs);
-    }
     validateExisting(target, call) {
         if (!call.instanceSpot)
             return;
@@ -436,17 +407,10 @@ function addressedInstanceErrorReason(error) {
     }
     return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException;
 }
-function initialSendTimeoutMs(options, call) {
-    return call.initialMeshName === undefined
-        ? (options.defaultSendTimeoutMs ?? options.defaultRequestTimeoutMs)
-        : (options.sendTimeoutMsForMesh?.(call.initialMeshName) ??
-            options.defaultSendTimeoutMs ??
-            options.defaultRequestTimeoutMs);
-}
 function createSpotAddressDeadline(timeoutMs, parent) {
     const startedAtMs = performance.now();
     const startedAtUnixMs = Date.now();
-    let deadlineMs = startedAtMs + Math.max(0, timeoutMs);
+    const deadlineMs = startedAtMs + Math.max(0, timeoutMs);
     const controller = new AbortController();
     let expired = false;
     let timeout;
@@ -475,10 +439,6 @@ function createSpotAddressDeadline(timeoutMs, parent) {
             return Math.round(startedAtUnixMs + (deadlineMs - startedAtMs));
         },
         signal: controller.signal,
-        setOwnerTimeout(ownerTimeoutMs) {
-            deadlineMs = startedAtMs + Math.max(0, ownerTimeoutMs);
-            arm();
-        },
         requireRemaining() {
             const remainingMs = deadlineMs - performance.now();
             if (remainingMs <= 0) {

package/dist/runtime/locations/location-store-repository.js

@@ -859,7 +859,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 this.provider.read(leaseKey, signal)
             ]);
             const descriptor = liveTargetDescriptor(descriptorRead, leaseRead, request.target);
-            if (descriptor === undefined) {
+            if (descriptor === undefined || descriptor.state !== contracts_1.ZLinkFrameworkRuntimeState.Serving) {
                 return { kind: 'conflict', current: { kind: 'missing', storeNow: current.storeNow } };
             }
             const [capacityRead, objectGenerationRead, authorityOwnerGenerationRead] = await Promise.all([
@@ -1042,9 +1042,11 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 !sameCreationTarget(record.snapshot, request.target)) {
                 return { kind: 'stale' };
             }
+            const descriptorKey = meshKey(request.target.meshName, request.target.nodeRid);
             const leaseKey = ownerKey(request.target.owner.ownerId);
             const capacityRowKey = capacityKey(request.target.meshName, String(request.target.nodeRid));
-            const [leaseRead, capacityRead] = await Promise.all([
+            const [descriptorRead, leaseRead, capacityRead] = await Promise.all([
+                this.provider.read(descriptorKey, signal),
                 this.provider.read(leaseKey, signal),
                 this.provider.read(capacityRowKey, signal)
             ]);
@@ -1054,7 +1056,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 // rather than read the absence as expiry.
                 throw new Error('Location Store owner lease record is invalid.');
             }
-            if (!sameLiveOwner(leaseRead, record.snapshot))
+            if (liveTargetDescriptor(descriptorRead, leaseRead, request.target) === undefined)
                 return { kind: 'stale' };
             const capacity = capacityRead.kind === 'missing'
                 ? emptyCapacityRecord()
@@ -1062,6 +1064,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             const result = await this.provider.write({
                 conditions: [
                     { kind: 'version', key: rowKey, expected: current.value.version },
+                    versionCondition(descriptorKey, descriptorRead),
                     leaseValueCondition(leaseKey, {
                         ownerId: record.snapshot.ownerId,
                         leaseGeneration: record.snapshot.ownerLeaseGeneration
@@ -2843,7 +2846,6 @@ function liveTargetDescriptor(descriptorRead, leaseRead, target) {
         descriptor.ownerId === target.owner.ownerId &&
         descriptor.leaseGeneration === target.owner.leaseGeneration &&
         descriptor.objectRole === contracts_1.ZLinkObjectRole.Server &&
-        descriptor.state === contracts_1.ZLinkFrameworkRuntimeState.Serving &&
         lease.ownerId === target.owner.ownerId &&
         BigInt(lease.leaseGeneration) === target.owner.leaseGeneration &&
         leaseRead.value.expiresAt !== undefined &&

package/dist/runtime/messaging/request-deadline.d.ts

@@ -0,0 +1,3 @@
+export declare function remainingRequestTimeout(operation: string, deadlineMs: number | undefined): number | undefined;
+/** Bounds caller waiting across outbound admission and reply; late completions stay observed. */
+export declare function waitRequestReply<T>(reply: Promise<T>, operation: string, deadlineMs: number | undefined, signal?: AbortSignal, endWait?: () => void, discardLateReply?: (reply: T) => void): Promise<T>;

package/dist/runtime/messaging/request-deadline.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remainingRequestTimeout = remainingRequestTimeout;
+exports.waitRequestReply = waitRequestReply;
+const abort_1 = require("../abort");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+function remainingRequestTimeout(operation, deadlineMs) {
+    if (deadlineMs === undefined)
+        return undefined;
+    const remaining = deadlineMs - performance.now();
+    if (remaining <= 0) {
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `${operation} exceeded its deadline.`);
+    }
+    return Math.max(1, Math.ceil(remaining));
+}
+/** Bounds caller waiting across outbound admission and reply; late completions stay observed. */
+async function waitRequestReply(reply, operation, deadlineMs, signal, endWait, discardLateReply) {
+    let timer;
+    let waiting = reply;
+    if (deadlineMs !== undefined) {
+        const timeout = new Promise((_resolve, reject) => {
+            const remaining = remainingRequestTimeout(operation, deadlineMs);
+            timer = setTimeout(() => reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `${operation} exceeded its deadline.`)), remaining);
+        });
+        waiting = Promise.race([reply, timeout]);
+    }
+    try {
+        return await (0, abort_1.awaitWithAbort)(waiting, signal);
+    }
+    catch (error) {
+        endWait?.();
+        if (discardLateReply !== undefined)
+            void reply.then(discardLateReply, () => undefined);
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/runtime/messaging/submission-result.d.ts

@@ -10,9 +10,10 @@ export declare enum ZLinkSubmitStatus {
 export interface ZLinkSubmitResult {
     readonly status: ZLinkSubmitStatus;
 }
-/** Projects the Core submit result once; phase only determines capacity refusal meaning. */
+/** Projects immediate refusal and pending admission failure from their Core phase. */
 export declare function submitToRequestResult(result: number, phase: 'submit' | 'completion'): number;
 export declare function classifySubmitResult(result: number, operation: string, phase?: 'submit' | 'completion'): ZLinkSubmitResult;
 export declare function requireOneWayCompletion(result: ZLinkSubmitResult, operation: string, notFoundKind?: ZLinkFrameworkInternalErrorKind): void;
 export declare function requirePublishCompletion(result: ZLinkSubmitResult, operation: string): void;
+export declare function requireClassicFanoutCompletion(result: ZLinkSubmitResult, operation: string): void;
 export declare function throwAlreadySubmitted(operation: string): never;