@zlink-systems/framework 0.26.0 → 0.28.0

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

@@ -1,9 +1,9 @@
 import { type RoutingId } from '../../contracts';
-import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkBackendMeshNode } from '../backend/contracts';
 import { type ZLinkMeshCompletionTable } from '../backend/mesh-completion-table';
-import { type ZLinkChannelEnvelopeCodecRegistry } from '../channels/channel-envelope';
 import type { ZLinkDispatchErrorReporter } from '../channels';
+import { type ZLinkChannelEnvelopeCodecRegistry } from '../channels/channel-envelope';
+import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkSpotAddressCallOptions, ZLinkSpotAddressTransport, ZLinkSpotRoutedTransport } from '../spots/spot-outbound';
 import type { ZLinkSpotRouteResolver } from '../spots/spot-routing-internal';
 export interface ZLinkHostSpotAddressTransportOptions {
@@ -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;
@@ -37,10 +31,7 @@ export declare class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTr
     private reportInstanceRequestError;
     private traceInstanceAddress;
     private resolveExisting;
-    private recoverStaleInstanceRoute;
     private selectMissingTarget;
-    private sendTimeoutMsForMesh;
-    private sendTimeoutMsForRouteChannel;
     private validateExisting;
     private encode;
     private encodeAtDeadline;

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

@@ -2,25 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkHostSpotAddressTransport = void 0;
 exports.hasObjectClientCapability = hasObjectClientCapability;
-const framework_errors_internal_1 = require("../framework-errors-internal");
-const runtime_values_1 = require("../backend/runtime-values");
 const contracts_1 = require("../../contracts");
-const submission_result_1 = require("../messaging/submission-result");
-const contracts_2 = require("../../contracts");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const abort_1 = require("../abort");
 const mesh_completion_table_1 = require("../backend/mesh-completion-table");
+const runtime_values_1 = require("../backend/runtime-values");
 const channel_envelope_1 = require("../channels/channel-envelope");
 const diagnostics_1 = require("../diagnostics");
 const flow_context_1 = require("../diagnostics/flow-context");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const packet_name_1 = require("../messaging/packet-name");
+const submission_result_1 = require("../messaging/submission-result");
 function hasObjectClientCapability(role) {
     return role === 'client' || role === 'server';
 }
-// Only a synchronous target-admission rejection is safe to retry. A
-// completion with the same public error kind may already represent an
-// admitted application operation, so it must not enter the retry loop.
-const PRE_ADMISSION_MISSING_INSTANCE_ERRORS = new WeakSet();
 /** Owns global Spot authority lookup and Missing Instance placement. */
 class ZLinkHostSpotAddressTransport {
     options;
@@ -34,78 +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, {
-                        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 = mapSubmitResult(await (0, abort_1.awaitWithAbort)(selected.node.sendToMissingInstanceSpot(selected.target, encoded, BigInt(deadline.deadlineUnixMs), sourceSpotId, call.metadata), deadline.signal));
-            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));
@@ -114,44 +91,32 @@ class ZLinkHostSpotAddressTransport {
         const timeoutMs = call.timeoutMs ?? this.options.defaultRequestTimeoutMs;
         const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
         try {
-            for (;;) {
-                const existing = await this.resolveExisting(spotId, deadline.signal);
-                deadline.requireRemaining();
-                if (existing !== undefined) {
-                    this.validateExisting(existing, call);
-                    try {
-                        return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
-                    }
-                    catch (error) {
-                        if (isSpotRouteRefreshError(error)) {
-                            this.options.resolver()?.invalidate?.(spotId);
-                        }
-                        const recovery = await this.recoverStaleInstanceRoute(spotId, call, deadline, error, existing);
-                        if (recovery.kind === 'route') {
-                            // Retry only after the resolver exposes a different route. The
-                            // stale target cannot have admitted the application operation.
-                            continue;
-                        }
-                        if (recovery.kind !== 'cold') {
-                            this.reportInstanceRequestError(spotId, request, error, existing.routerChannelId, existing.targetNodeRid, existing.stableType, addressedInstanceErrorReason(error));
-                            throw error;
-                        }
-                        // The logical authority is no longer Ready, so the Instance
-                        // intent path below may submit the original operation once.
-                    }
+            const existing = await this.resolveExisting(spotId, deadline.signal);
+            deadline.requireRemaining();
+            if (existing === undefined) {
+                return await this.requestToMissingInstance(spotId, request, call, deadline);
+            }
+            this.validateExisting(existing, call);
+            try {
+                return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
+            }
+            catch (error) {
+                if (isSpotRouteRefreshError(error)) {
+                    this.options.resolver()?.invalidate?.(spotId);
                 }
-                try {
+                // Failover policy §4.4: SpotMoving is the owner's Ready owner-fence
+                // refusal, made before admission. With Instance intent, one authority
+                // read under the same deadline decides: Missing means Close released
+                // the incarnation, so the request activates a new one. Any other
+                // answer, and any message the owner admitted, keeps this terminal.
+                if (call.instanceSpot &&
+                    isOwnerFenceRefusal(error) &&
+                    (await this.resolveExisting(spotId, deadline.signal)) === undefined) {
+                    deadline.requireRemaining();
                     return await this.requestToMissingInstance(spotId, request, call, deadline);
                 }
-                catch (error) {
-                    if (!isMissingInstanceRetryError(error))
-                        throw error;
-                    // A placement node can finish cleanup before its stale native result
-                    // reaches this process. Refresh authority and select again under the
-                    // same end-to-end deadline; the old envelope was not admitted.
-                    this.options.resolver()?.invalidate?.(spotId);
-                    await waitForSpotRouteRefresh(Math.min(10, deadline.requireRemaining()), deadline.signal);
-                }
+                this.reportInstanceRequestError(spotId, request, error, existing.routerChannelId, existing.targetNodeRid, existing.stableType, addressedInstanceErrorReason(error));
+                throw error;
             }
         }
         catch (error) {
@@ -170,6 +135,7 @@ class ZLinkHostSpotAddressTransport {
     async requestToExistingSpot(spotId, request, call, existing, deadline) {
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
         const reply = await (0, abort_1.awaitWithAbort)(this.options.routed.requestToSpot(existing, request, {
+            instanceSpot: call.instanceSpot,
             timeoutMs: deadline.requireRemaining(),
             signal: deadline.signal,
             metadata: call.metadata
@@ -201,17 +167,7 @@ class ZLinkHostSpotAddressTransport {
         const table = this.options.completions(selected.meshName);
         if (table === undefined)
             throw new Error(`MeshNode '${selected.meshName}' completion table is not started.`);
-        let completionPromise;
-        try {
-            completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata), deadline.signal);
-        }
-        catch (error) {
-            if (error instanceof contracts_1.ZLinkFrameworkException &&
-                (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound) {
-                PRE_ADMISSION_MISSING_INSTANCE_ERRORS.add(error);
-            }
-            throw error;
-        }
+        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata), deadline.signal);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, selected.meshName, selected.target.stableType, selected.target.targetNodeRid);
         const completion = await (0, abort_1.awaitWithAbort)(completionPromise, deadline.signal);
         try {
@@ -274,23 +230,6 @@ class ZLinkHostSpotAddressTransport {
             throw error;
         }
     }
-    async recoverStaleInstanceRoute(spotId, call, deadline, error, staleRoute) {
-        if (!call.instanceSpot ||
-            !(error instanceof contracts_1.ZLinkFrameworkException) ||
-            !isInstanceRouteStaleError(error)) {
-            return { kind: 'fail' };
-        }
-        for (;;) {
-            deadline.requireRemaining();
-            const current = await this.resolveExisting(spotId, deadline.signal);
-            if (current === undefined)
-                return { kind: 'cold' };
-            if (!sameSpotRouteSnapshot(current, staleRoute)) {
-                return { kind: 'route', route: current };
-            }
-            await waitForSpotRouteRefresh(Math.min(10, deadline.requireRemaining()), deadline.signal);
-        }
-    }
     selectMissingTarget(spotId, call) {
         const configuredMeshes = this.options.meshNames();
         if (call.initialMeshName !== undefined &&
@@ -357,20 +296,10 @@ 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;
-        if (target.spotKind !== contracts_2.ZLinkSpotKind.Instance ||
+        if (target.spotKind !== contracts_1.ZLinkSpotKind.Instance ||
             (call.instanceSpotType !== undefined && target.stableType !== call.instanceSpotType)) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `Spot '${String(target.spotId)}' is not the requested Instance Spot type.`);
         }
@@ -383,23 +312,6 @@ class ZLinkHostSpotAddressTransport {
     }
 }
 exports.ZLinkHostSpotAddressTransport = ZLinkHostSpotAddressTransport;
-function isInstanceRouteStaleError(error) {
-    if (!(error instanceof contracts_1.ZLinkFrameworkException))
-        return false;
-    const kind = (0, framework_errors_internal_1.internalFrameworkErrorKind)(error);
-    // RequestTargetNotFound from an existing route is a pre-admission route
-    // lookup failure. A stale owner result is terminal for this application
-    // operation: the routed request may already have crossed the transport
-    // boundary, so refreshing the route and resubmitting it could execute the
-    // same operation twice. Instance cold activation is selected only when the
-    // authority resolver itself reports that the Ready route is absent.
-    if (kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound)
-        return true;
-    return false;
-}
-function isMissingInstanceRetryError(error) {
-    return (error instanceof contracts_1.ZLinkFrameworkException && PRE_ADMISSION_MISSING_INSTANCE_ERRORS.has(error));
-}
 function missingInstanceRequestFailure(result, nativeErrno) {
     const canonical = (0, framework_errors_internal_1.isCanonicalWireReplyTerminal)(result, nativeErrno);
     const wireKind = canonical
@@ -422,23 +334,6 @@ function missingInstanceRequestFailure(result, nativeErrno) {
                             : (wireKind ?? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed);
     return (0, framework_errors_internal_1.createInternalFrameworkException)(kind, `Instance Spot request failed with result ${result} and errno ${nativeErrno}.`);
 }
-function mapSubmitResult(result) {
-    switch (result) {
-        case runtime_values_1.SubmitResult.Ok:
-            return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
-        case runtime_values_1.SubmitResult.Backpressured:
-        case runtime_values_1.SubmitResult.NotAdmitted:
-            return { status: submission_result_1.ZLinkSubmitStatus.Backpressured };
-        case runtime_values_1.SubmitResult.NotFound:
-            return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
-        case runtime_values_1.SubmitResult.NotConnected:
-            return { status: submission_result_1.ZLinkSubmitStatus.RouteNotConnected };
-        case runtime_values_1.SubmitResult.Terminated:
-            return { status: submission_result_1.ZLinkSubmitStatus.Shutdown };
-        default:
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, `Instance Spot submission failed with result ${result}.`);
-    }
-}
 function missingInstancePlacementCapacity(spotId, stableType) {
     const type = stableType === undefined ? '' : ` of type '${stableType}'`;
     return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted, `No eligible Instance Spot placement target${type} is available for '${String(spotId)}'.`, true);
@@ -458,35 +353,9 @@ function isSpotRouteRefreshError(error) {
         kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale ||
         kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected);
 }
-function sameSpotRouteSnapshot(left, right) {
-    return (String(left.targetNodeRid) === String(right.targetNodeRid) &&
-        String(left.spotId) === String(right.spotId) &&
-        left.routerChannelId === right.routerChannelId &&
-        left.spotKind === right.spotKind &&
-        left.stableType === right.stableType &&
-        left.targetSpotGeneration === right.targetSpotGeneration &&
-        left.targetNodeGeneration === right.targetNodeGeneration &&
-        left.authorityOwnerGeneration === right.authorityOwnerGeneration &&
-        left.targetOwnerId === right.targetOwnerId &&
-        left.ownerLeaseGeneration === right.ownerLeaseGeneration &&
-        left.authorityStoreVersion === right.authorityStoreVersion);
-}
-function waitForSpotRouteRefresh(delayMs, signal) {
-    return new Promise((resolve, reject) => {
-        const finish = () => {
-            signal.removeEventListener('abort', abort);
-            resolve();
-        };
-        const abort = () => {
-            clearTimeout(timer);
-            signal.removeEventListener('abort', abort);
-            reject(signal.reason);
-        };
-        const timer = setTimeout(finish, delayMs);
-        signal.addEventListener('abort', abort, { once: true });
-        if (signal.aborted)
-            abort();
-    });
+function isOwnerFenceRefusal(error) {
+    return (error instanceof contracts_1.ZLinkFrameworkException &&
+        (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving);
 }
 function submitResultReason(status) {
     switch (status) {
@@ -538,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;
@@ -577,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/spot-node-runtime-options-factory.d.ts

@@ -34,5 +34,5 @@ export interface ZLinkSpotNodeRuntimeOptionsFactoryOptions {
 export declare class ZLinkSpotNodeRuntimeOptionsFactory {
     private readonly options;
     constructor(options: ZLinkSpotNodeRuntimeOptionsFactoryOptions);
-    create(): ZLinkSpotNodeRuntimeManagerOptions;
+    create(): Omit<ZLinkSpotNodeRuntimeManagerOptions, 'errorSink'>;
 }

package/dist/runtime/host/spot-node-runtime-options-factory.js

@@ -8,16 +8,17 @@ class ZLinkSpotNodeRuntimeOptionsFactory {
         this.options = options;
     }
     create() {
+        const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
         return {
             registration: this.options.registration,
             primaryMeshName: this.options.meshRouters.primaryMeshName(),
             backendAdapterFactory: this.options.backendAdapterFactory,
             context: this.options.context,
-            channelClient: new channels_1.DefaultZLinkChannelClient(this.options.registration, this.options.channelTransport),
+            channelClient: new channels_1.DefaultZLinkChannelClient(this.options.registration, this.options.channelTransport, this.options.routeTransport, spotRouterChannelIdForMesh),
             fanoutClient: new channels_1.DefaultZLinkFanoutClient(this.options.registration, this.options.channelTransport),
             spotPublisherClient: new channels_1.DefaultZLinkSpotPublisherClient(this.options.registration, this.options.spotPublisherTransport),
             routedTransport: this.options.routeTransport,
-            spotRouterChannelIdForMesh: this.options.meshRouters.spotRouterChannelIdByMesh(),
+            spotRouterChannelIdForMesh,
             providerResolver: this.options.providerResolver,
             dispatchErrors: this.options.dispatchErrors,
             runtimeEventPublisher: this.options.runtimeEventPublisher,

package/dist/runtime/host/spot-runtime-options-factory.d.ts

@@ -22,15 +22,9 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
     readonly actorManager: () => DefaultZLinkActorManager | undefined;
     readonly locationLifecycle: () => ZLinkLocationLifecycle | undefined;
     readonly releaseInstanceAuthority: (meshName: string, spotId: string, objectGeneration: bigint) => Promise<void>;
-    readonly beginInstanceIdleClosingAuthority: (meshName: string, spotId: string, onCommitted: () => void) => Promise<{
-        release(): Promise<void>;
-    } | undefined>;
-    readonly beginInstanceClosingAuthority: (meshName: string, spotId: string, onCommitted: () => void) => Promise<{
-        release(): Promise<void>;
-    } | undefined>;
-    readonly beginUserClosingAuthority: (meshName: string, spotId: string, objectGeneration: bigint, onCommitted: () => void) => Promise<{
-        release(): Promise<void>;
-    } | undefined>;
+    readonly beginInstanceIdleClosingAuthority: (meshName: string, spotId: string, onCommitted: () => void) => Promise<import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined>;
+    readonly beginInstanceClosingAuthority: (meshName: string, spotId: string, onCommitted: () => void) => Promise<import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined>;
+    readonly beginUserClosingAuthority: (meshName: string, spotId: string, objectGeneration: bigint, onCommitted: () => void) => Promise<import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined>;
     readonly createLocationSpotRouteResolver: () => ZLinkSpotRouteResolver | undefined;
     readonly boundSessionRelay: ZLinkBoundSessionRelay;
     readonly actorHandoff: ZLinkActorHandoffCoordinator;
@@ -39,7 +33,7 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
     readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
     readonly metrics: import('../diagnostics').ZLinkRuntimeMetrics;
     readonly admission: ZLinkRuntimeAdmissionGate;
-    readonly statefulExecutionAllowed: () => boolean;
+    readonly statefulExecution: NonNullable<ZLinkSpotManagerOptions['statefulExecution']>;
 }
 export declare class ZLinkSpotRuntimeOptionsFactory {
     private readonly options;

package/dist/runtime/host/spot-runtime-options-factory.js

@@ -11,6 +11,7 @@ class ZLinkSpotRuntimeOptionsFactory {
         this.options = options;
     }
     create(actorTransferRuntime) {
+        const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
         return {
             nodeRid: undefined,
             nodeRidProvider: (meshName) => this.meshNodeRoutingId(meshName),
@@ -38,25 +39,64 @@ class ZLinkSpotRuntimeOptionsFactory {
                 }
                 await runtime.dispatchEntryActorJoin(meshName, actor, handoffBacklog);
             },
-            channelClient: new channels_1.DefaultZLinkChannelClient(this.options.registration, this.options.channelTransport),
+            executeEntryActor: (meshName, actorId, operation) => {
+                const runtime = this.options.spotNodeRuntime();
+                if (runtime === undefined) {
+                    throw new configuration_1.ZLinkConfigurationException('Entry Spot Actor completion requires the MeshNode runtime.');
+                }
+                return runtime.executeEntryActor(meshName, actorId, operation);
+            },
+            channelClient: new channels_1.DefaultZLinkChannelClient(this.options.registration, this.options.channelTransport, this.options.routeTransport, spotRouterChannelIdForMesh),
             fanoutClient: new channels_1.DefaultZLinkFanoutClient(this.options.registration, this.options.channelTransport),
             spotPublisherClient: new channels_1.DefaultZLinkSpotPublisherClient(this.options.registration, this.options.spotPublisherTransport),
             routedTransport: this.options.routeTransport,
             addressTransport: this.options.addressTransport,
-            spotRouterChannelIdForMesh: this.options.meshRouters.spotRouterChannelIdByMesh(),
-            channelMeshNameForChannel: (channelName) => {
-                const matches = [...this.options.registration.spotNodes.entries()]
-                    .filter(([, node]) => Object.prototype.hasOwnProperty.call(node.meshChannels ?? {}, channelName))
-                    .map(([meshName]) => meshName);
-                return matches.length === 1 ? matches[0] : undefined;
-            },
+            spotRouterChannelIdForMesh,
             messageSerializers: this.options.registration.messageSerializers,
             runtimeEventPublisher: this.options.runtimeEventPublisher,
             detachedTaskRunner: this.options.detachedTaskRunner,
             locationLifecycle: this.options.locationLifecycle(),
             releaseInstanceAuthority: (meshName, spotId, objectGeneration) => this.options.releaseInstanceAuthority(meshName, String(spotId), objectGeneration),
             beginInstanceIdleClosingAuthority: (meshName, spotId, onCommitted) => this.options.beginInstanceIdleClosingAuthority(meshName, String(spotId), onCommitted),
-            beginInstanceClosingAuthority: (meshName, spotId, onCommitted) => this.options.beginInstanceClosingAuthority(meshName, String(spotId), onCommitted),
+            beginInstanceClosingAuthority: async (meshName, spotId, onCommitted, objectGeneration) => {
+                const authority = await this.options.beginInstanceClosingAuthority(meshName, String(spotId), onCommitted);
+                if (authority === undefined)
+                    return undefined;
+                // A Close without Reincarnate ends this incarnation. The Instance authority
+                // release also forgets the node's Ready projection, so a request on a cached
+                // Ready route is refused instead of rematerializing the closed generation.
+                const release = () => this.options.releaseInstanceAuthority(meshName, String(spotId), objectGeneration);
+                if (authority.reincarnate === undefined)
+                    return { release };
+                return {
+                    release,
+                    reincarnate: async (initialize) => {
+                        const current = await authority.reincarnate(initialize);
+                        const node = this.options.spotNodeRuntime()?.meshNode(meshName);
+                        const route = {
+                            targetSpotId: String(spotId),
+                            targetNodeRid: String(current.allocation.descriptor.rid),
+                            targetNodeGeneration: current.allocation.descriptorLifecycleGeneration,
+                            objectGeneration: current.objectGeneration,
+                            authorityOwnerGeneration: current.authorityOwnerGeneration,
+                            ownerId: current.ownerId,
+                            leaseGeneration: current.ownerLeaseGeneration,
+                            storeVersion: current.storeVersion.value
+                        };
+                        node?.restoreSpotAuthority?.(String(spotId), 'instance_spot', current.stableType, current.objectGeneration, current.authorityOwnerGeneration);
+                        node?.registerInstanceIntent?.(current.stableType, route);
+                        node?.rememberSpotRoute?.({
+                            spot: { spotId: String(spotId), generation: current.objectGeneration },
+                            targetNodeRid: route.targetNodeRid,
+                            targetNodeGeneration: route.targetNodeGeneration,
+                            authorityOwnerGeneration: route.authorityOwnerGeneration,
+                            ownerLeaseGeneration: route.leaseGeneration,
+                            storeVersion: route.storeVersion
+                        });
+                        return current;
+                    }
+                };
+            },
             beginUserClosingAuthority: (meshName, spotId, objectGeneration, onCommitted) => this.options.beginUserClosingAuthority(meshName, String(spotId), objectGeneration, onCommitted),
             instanceSpotApplicationTargetProvider: (meshName, spotId) => this.options
                 .spotNodeRuntime()
@@ -137,16 +177,12 @@ class ZLinkSpotRuntimeOptionsFactory {
                 return (registration?.options?.relocationCoordinationMode ??
                     contracts_1.ZLinkSpotRelocationCoordinationMode.FrameworkManaged);
             },
-            actorBindingGenerationObserver: (actorId, generation) => this.options
-                .actorManager()
-                ?.getState(actorId)
-                ?.setBoundSessionBindingGeneration(generation),
             actorTransferRuntime,
             boundSessionRuntime: this.options.boundSessionRelay.boundSessions,
             actorHandoffRuntime: this.options.actorHandoff,
             metrics: this.options.metrics,
             admission: this.options.admission,
-            statefulExecutionAllowed: this.options.statefulExecutionAllowed,
+            statefulExecution: this.options.statefulExecution,
             closeErrorSink: this.options.runtimeOrPreStartErrorSink,
             dispatchErrors: this.options.dispatchErrorReporter(this.options.runtimeOrPreStartErrorSink)
         };

package/dist/runtime/host/user-spot-creation-coordinator.d.ts

@@ -1,9 +1,9 @@
-import type { RoutingId, SpotRef, ZLinkSpotCreateResult } from '../../contracts';
+import { type RoutingId, type SpotRef, type ZLinkSpotCreateResult } from '../../contracts';
+import type { ServiceUserSpotOperationResult } from '../foundation/service-stateful-runtime';
+import type { ServiceDirectSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../foundation/service-stateful-wire-codec';
 import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken } from '../locations/internal-location-contracts';
 import type { ZLinkAuthorityStore, ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
 import type { ZLinkLocalSpotCreateResult } from '../spots/spot-manager-internal-contracts';
-import type { ServiceUserSpotOperationResult } from '../foundation/service-stateful-runtime';
-import type { ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord, ServiceDirectSpotRouteFence } from '../foundation/service-stateful-wire-codec';
 export interface ZLinkUserSpotCreationCoordinatorOptions {
     readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
     readonly target: (request: Pick<ZLinkUserSpotCreationRequest, 'meshName' | 'stableType'>, signal?: AbortSignal, excludedNodeRids?: ReadonlySet<string>) => Promise<{