@zlink-systems/framework 0.27.0 → 0.29.0

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/instance-activation-authority.d.ts

@@ -27,6 +27,5 @@ export declare class ZLinkInstanceActivationAuthority implements ServiceAsyncIns
     abort(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation): Promise<void>;
     private requireOwner;
     private deleteOrphan;
-    private awaitConcurrentActivation;
     private requirePending;
 }

package/dist/runtime/host/instance-activation-authority.js

@@ -11,7 +11,6 @@ const relocation_blob_1 = require("../locations/relocation-blob");
 const service_instance_activation_recovery_codec_1 = require("../foundation/service-instance-activation-recovery-codec");
 const CREATION_REQUEST_RETENTION_MS = 24 * 60 * 60 * 1_000;
 const MAX_CREATION_REQUEST_BYTES = 1024 * 1024;
-const ACTIVATION_JOIN_POLL_INTERVAL_MS = 10;
 class ZLinkInstanceActivationAuthority {
     options;
     pending = new Map();
@@ -48,68 +47,64 @@ class ZLinkInstanceActivationAuthority {
         }
         let reserved;
         try {
-            for (;;) {
-                reserved = await this.options.store.reserve({
-                    key: { kind: 'instance_spot', globalId: target.targetSpotId },
-                    intent: {
-                        stableType: target.stableType,
-                        requestContentReference: stored.reference.value,
-                        requestSha256: requestHash,
-                        requestEncodedSize: BigInt(requestBytes.byteLength)
-                    },
-                    target: {
-                        meshName: this.options.meshName,
-                        nodeRid: target.targetNodeRid,
-                        nodeLifecycleGeneration: target.targetNodeGeneration,
-                        owner
-                    },
-                    creatingPayload: (0, service_authority_payload_codec_1.encodeServiceInstanceAuthorityPayload)({
-                        state: 'coldActivating',
+            reserved = await this.options.store.reserve({
+                key: { kind: 'instance_spot', globalId: target.targetSpotId },
+                intent: {
+                    stableType: target.stableType,
+                    requestContentReference: stored.reference.value,
+                    requestSha256: requestHash,
+                    requestEncodedSize: BigInt(requestBytes.byteLength)
+                },
+                target: {
+                    meshName: this.options.meshName,
+                    nodeRid: target.targetNodeRid,
+                    nodeLifecycleGeneration: target.targetNodeGeneration,
+                    owner
+                },
+                creatingPayload: (0, service_authority_payload_codec_1.encodeServiceInstanceAuthorityPayload)({
+                    state: 'coldActivating',
+                    stableType: target.stableType,
+                    spotId: target.targetSpotId,
+                    ownerId: owner.ownerId,
+                    ownerLeaseGeneration: owner.leaseGeneration,
+                    ownerMeshName: this.options.meshName,
+                    ownerNodeRid: target.targetNodeRid,
+                    ownerNodeGeneration: target.targetNodeGeneration
+                }),
+                capacity: {
+                    actors: 0,
+                    spots: 1,
+                    spotType: {
+                        objectKind: 'instance_spot',
                         stableType: target.stableType,
-                        spotId: target.targetSpotId,
-                        ownerId: owner.ownerId,
-                        ownerLeaseGeneration: owner.leaseGeneration,
-                        ownerMeshName: this.options.meshName,
-                        ownerNodeRid: target.targetNodeRid,
-                        ownerNodeGeneration: target.targetNodeGeneration
-                    }),
-                    capacity: {
-                        actors: 0,
-                        spots: 1,
-                        spotType: {
-                            objectKind: 'instance_spot',
-                            stableType: target.stableType,
-                            count: 1
-                        }
+                        count: 1
                     }
-                }, undefined, activation.deadlineUnixMs);
-                if (reserved.kind !== 'alreadyExists')
-                    break;
-                this.options.metrics?.recordInstanceSpotClaimConflict(this.options.meshName, target.stableType, 'already_exists');
-                await this.deleteOrphan(stored.reference);
-                return readyExisting(reserved.current, target);
-            }
+                }
+            }, undefined, activation.deadlineUnixMs);
         }
         catch (error) {
             await this.deleteOrphan(stored.reference);
             throw error;
         }
-        if (reserved.kind === 'conflict' &&
-            reserved.current.kind === 'snapshot' &&
-            reserved.current.allocation.objectKind === 'instance_spot' &&
-            reserved.current.allocation.stableType === target.stableType &&
-            reserved.current.allocation.state === 'reserved') {
-            this.options.metrics?.recordInstanceSpotClaimConflict(this.options.meshName, target.stableType, 'activation_in_progress');
-            await this.deleteOrphan(stored.reference);
-            return await this.awaitConcurrentActivation(target, activation.deadlineUnixMs);
-        }
         if (reserved.kind !== 'reserved') {
-            this.options.metrics?.recordInstanceSpotClaimConflict(this.options.meshName, target.stableType, reserved.kind);
+            const conflictReason = reserved.kind === 'alreadyExists'
+                ? 'already_exists'
+                : reserved.kind === 'conflict' &&
+                    reserved.current.kind === 'snapshot' &&
+                    reserved.current.allocation.objectKind === 'instance_spot' &&
+                    reserved.current.allocation.stableType === target.stableType &&
+                    reserved.current.allocation.state === 'reserved'
+                    ? 'activation_in_progress'
+                    : reserved.kind;
+            this.options.metrics?.recordInstanceSpotClaimConflict(this.options.meshName, target.stableType, conflictReason);
             await this.deleteOrphan(stored.reference);
+            if (reserved.kind === 'typeMismatch') {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `Instance activation reservation failed: ${reserved.kind}.`);
+            }
             if (reserved.kind === 'placementCapacityExhausted') {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted, `Instance Spot placement capacity is exhausted for '${String(target.targetSpotId)}'.`);
             }
-            throw new Error(`Instance activation reservation failed: ${reserved.kind}.`);
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, `Instance activation reservation failed: ${reserved.kind}.`);
         }
         const reservation = {
             attempt: reserved.creating.objectGeneration,
@@ -334,27 +329,6 @@ class ZLinkInstanceActivationAuthority {
             // best-effort deletion fails.
         }
     }
-    async awaitConcurrentActivation(target, deadlineUnixMs) {
-        const key = authorityKey(target.targetSpotId);
-        const deadlineMs = performance.now() + Number(deadlineUnixMs - BigInt(Date.now()));
-        while (performance.now() <= deadlineMs) {
-            const current = await this.options.store.readAuthority(key);
-            if (current.kind === 'snapshot') {
-                if (current.allocation.objectKind !== 'instance_spot' ||
-                    current.allocation.stableType !== target.stableType) {
-                    throw new Error('Concurrent Instance activation resolved to a different Spot type.');
-                }
-                if (current.allocation.state === 'active') {
-                    return readyExisting(current, target);
-                }
-            }
-            else {
-                throw new Error('Concurrent Instance activation ended before the Ready barrier.');
-            }
-            await waitForActivationJoin(deadlineMs);
-        }
-        throw new Error(`Concurrent Instance activation for '${target.targetSpotId}' did not reach Ready before deadline.`);
-    }
     requirePending(reservation) {
         const pending = this.pending.get(reservation.token);
         if (pending === undefined || pending.creating.objectGeneration !== reservation.attempt) {
@@ -402,31 +376,6 @@ function readyRead(snapshot, target) {
     }
     return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
 }
-function readyExisting(snapshot, target) {
-    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload) ??
-        (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(snapshot.payload);
-    if (decoded?.kind !== 'instance_spot' ||
-        decoded.stableType !== target.stableType ||
-        decoded.spotId !== target.targetSpotId ||
-        snapshot.allocation.objectKind !== 'instance_spot' ||
-        snapshot.allocation.state !== 'active' ||
-        decoded.ownerId !== snapshot.ownerId ||
-        decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration ||
-        decoded.ownerMeshName !== snapshot.allocation.descriptor.meshName ||
-        decoded.ownerNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration ||
-        !(0, routing_id_1.routingIdsEqual)(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid)) {
-        throw new Error('Existing Instance authority is not a matching Ready allocation.');
-    }
-    return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
-}
-async function waitForActivationJoin(deadlineMs) {
-    const remaining = deadlineMs - performance.now();
-    if (remaining <= 0)
-        return;
-    await new Promise((resolve) => {
-        setTimeout(resolve, Math.min(ACTIVATION_JOIN_POLL_INTERVAL_MS, remaining));
-    });
-}
 function requireCommitIdentity(target, reservation, creating, spot, meshName) {
     if (creating.allocation.state !== 'reserved' ||
         creating.allocation.objectKind !== 'instance_spot' ||

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));
@@ -273,7 +254,7 @@ class ZLinkHostSpotAddressTransport {
         if (stableType === undefined) {
             if (distinctTypes.length === 0)
                 return { kind: 'unsupported' };
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidConfiguration, 'Instance Spot type is required when multiple types are registered.');
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'Instance Spot type is required when multiple types are registered.');
         }
         if (canInspectPlacementTypes && !distinctTypes.includes(stableType)) {
             return { kind: 'unsupported' };
@@ -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/host/stateful-authority-route-runtime.d.ts

@@ -28,6 +28,7 @@ export declare class ZLinkStatefulAuthorityRouteRuntime {
     reconcile(signal?: AbortSignal, requireComplete?: boolean): Promise<void>;
     private recoverInstanceActivation;
     private recoverPendingInstanceActivation;
+    private clearRecoveryRoot;
     private readRecoveryEnvelope;
     private run;
     private readCompleteSnapshot;

package/dist/runtime/host/stateful-authority-route-runtime.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkStatefulAuthorityRouteRuntime = void 0;
+const authority_key_codec_1 = require("../locations/authority-key-codec");
 const node_crypto_1 = require("node:crypto");
 const relocation_blob_1 = require("../locations/relocation-blob");
 const routing_id_1 = require("../routing-id");
@@ -65,11 +66,19 @@ class ZLinkStatefulAuthorityRouteRuntime {
             const previous = this.appliedByMesh.get(meshName) ?? new Map();
             const status = sink.status();
             for (const pending of snapshot.pending) {
-                if (pending.targetMeshName === meshName &&
-                    (0, routing_id_1.routingIdsEqual)(status.routingId, pending.targetNodeRid) &&
+                if (pending.targetMeshName !== meshName)
+                    continue;
+                if ((0, routing_id_1.routingIdsEqual)(status.routingId, pending.targetNodeRid) &&
                     status.lifecycleGeneration === pending.targetNodeGeneration) {
                     await this.recoverPendingInstanceActivation(sink, pending, signal);
                 }
+                else {
+                    const release = this.options.creationStore?.releaseEndedReservation;
+                    if (release === undefined)
+                        throw new Error('Reservation lifecycle recovery requires a Location repository.');
+                    if (await release.call(this.options.creationStore, (0, authority_key_codec_1.encodeAuthorityKey)('instance_spot', pending.spotId), pending.pending.storeVersion, signal))
+                        await this.clearRecoveryRoot(pending.pending.requestReference, signal);
+                }
             }
             for (const [key, route] of current) {
                 if (route.meshName !== meshName)
@@ -207,19 +216,18 @@ class ZLinkStatefulAuthorityRouteRuntime {
                 }
             }, signal);
             if (aborted.kind === 'aborted' || aborted.kind === 'alreadyAborted') {
-                try {
-                    await this.options.relocationStore?.delete((0, relocation_blob_1.relocationBlobReference)(recovery.pending.requestReference));
-                }
-                catch {
-                    // The authority no longer publishes this root. Retention owns a
-                    // failed best-effort orphan cleanup.
-                }
+                await this.clearRecoveryRoot(recovery.pending.requestReference, signal);
             }
             return;
         }
         if ((await sink.recoverPendingInstanceActivation(envelope, recovery.pending, null)) === false)
             return;
     }
+    async clearRecoveryRoot(reference, signal) {
+        if (this.options.relocationStore === undefined)
+            throw new Error('Instance activation recovery requires a Relocation Store.');
+        await this.options.relocationStore.delete((0, relocation_blob_1.relocationBlobReference)(reference), signal);
+    }
     async readRecoveryEnvelope(recovery, signal) {
         const relocationStore = this.options.relocationStore;
         if (relocationStore === undefined) {