@zlink-systems/framework 0.25.0 → 0.27.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 {
@@ -37,7 +37,6 @@ export declare class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTr
     private reportInstanceRequestError;
     private traceInstanceAddress;
     private resolveExisting;
-    private recoverStaleInstanceRoute;
     private selectMissingTarget;
     private sendTimeoutMsForMesh;
     private sendTimeoutMsForRouteChannel;

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;
@@ -44,6 +39,7 @@ class ZLinkHostSpotAddressTransport {
                 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
@@ -91,7 +87,7 @@ class ZLinkHostSpotAddressTransport {
             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));
+            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));
@@ -114,44 +110,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 +154,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 +186,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 +249,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 &&
@@ -370,7 +328,7 @@ class ZLinkHostSpotAddressTransport {
     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 +341,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 +363,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 +382,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) {

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,12 +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) => Promise<{
-        restoreReady(): Promise<void>;
-    } | undefined>;
-    readonly beginInstanceClosingAuthority: (meshName: string, spotId: string) => Promise<{
-        restoreReady(): 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;
@@ -36,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,65 @@ 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) => this.options.beginInstanceIdleClosingAuthority(meshName, String(spotId)),
-            beginInstanceClosingAuthority: (meshName, spotId) => this.options.beginInstanceClosingAuthority(meshName, String(spotId)),
+            beginInstanceIdleClosingAuthority: (meshName, spotId, onCommitted) => this.options.beginInstanceIdleClosingAuthority(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()
                 ?.meshNode(meshName)
@@ -85,12 +126,6 @@ class ZLinkSpotRuntimeOptionsFactory {
                     }
                 };
             },
-            createReceived: () => {
-                const runtime = this.options.spotNodeRuntime();
-                if (runtime === undefined)
-                    throw new Error('Spot backend runtime is not initialized.');
-                return runtime.createReceived();
-            },
             createTopicMessage: () => {
                 const runtime = this.options.spotNodeRuntime();
                 if (runtime === undefined)
@@ -142,16 +177,13 @@ 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/stateful-authority-route-runtime.js

@@ -78,7 +78,7 @@ class ZLinkStatefulAuthorityRouteRuntime {
                 const expectedSpotRoute = previousRoute?.spotRoute ?? null;
                 const expectedInstanceRoute = previousRoute?.kind === 'instance_spot' ? previousRoute.instanceRoute : null;
                 sink.rememberSpotRoute(route.spotRoute, expectedSpotRoute);
-                if (route.kind === 'instance_spot') {
+                if (route.kind === 'instance_spot' && !route.closing) {
                     const status = sink.status();
                     if ((0, routing_id_1.routingIdsEqual)(status.routingId, route.instanceRoute.targetNodeRid) &&
                         status.lifecycleGeneration === route.instanceRoute.targetNodeGeneration) {
@@ -346,7 +346,9 @@ function pendingInstanceActivation(snapshot) {
 }
 function authorityRoute(snapshot) {
     const allocation = snapshot.allocation;
-    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(snapshot.payload));
+    const payload = (0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(snapshot.payload);
+    const ready = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(payload);
+    const decoded = ready ?? (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(payload);
     if (allocation.state !== 'active' ||
         allocation.objectKind === 'actor' ||
         allocation.descriptor.meshName.length === 0 ||
@@ -372,6 +374,7 @@ function authorityRoute(snapshot) {
     };
     return {
         kind: allocation.objectKind,
+        closing: ready === undefined,
         stableType: allocation.stableType,
         meshName: allocation.descriptor.meshName,
         spotRoute,
@@ -397,6 +400,7 @@ function sameAppliedRoute(left, right) {
     if (right === undefined)
         return false;
     return (left.kind === right.kind &&
+        left.closing === right.closing &&
         left.stableType === right.stableType &&
         left.meshName === right.meshName &&
         left.instanceRoute.targetNodeRid === right.instanceRoute.targetNodeRid &&

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<{
@@ -53,15 +53,23 @@ export declare class ZLinkUserSpotCreationCoordinator {
         readonly nodeRid: RoutingId;
         readonly isLocal: boolean;
     }, authority: ZLinkAuthoritySnapshot, signal: AbortSignal) => Promise<ZLinkLocalSpotCreateResult>, discard?: (signal?: AbortSignal) => Promise<void>): Promise<ZLinkUserSpotCreationResult>;
-    close(spot: SpotRef, closeOwner: (current: SpotRef, snapshot: ZLinkAuthoritySnapshot) => Promise<boolean>, signal?: AbortSignal, ownerPresent?: (current: SpotRef) => boolean, ownerCanClose?: (current: SpotRef) => boolean): Promise<boolean>;
+    close(spot: SpotRef, closeOwner: (current: SpotRef, beginAuthority: (onCommitted: () => void) => Promise<{
+        release(): Promise<void>;
+    }>) => Promise<boolean>, signal?: AbortSignal): Promise<boolean>;
+    /** Commits Closing for the owner's own incarnation when its context requests Close. */
+    beginOwnerClose(spot: SpotRef, onCommitted: () => void): Promise<{
+        release(): Promise<void>;
+    } | undefined>;
     resolveCloseTarget(spot: SpotRef, signal?: AbortSignal): Promise<ZLinkUserSpotCloseTarget | undefined>;
     handleRemoteCreate(record: ServiceUserSpotCreateRecord, materialize: (requestPayload: Uint8Array, authority: ZLinkAuthoritySnapshot, signal: AbortSignal) => Promise<ZLinkLocalSpotCreateResult>, discard?: (signal?: AbortSignal) => Promise<void>, signal?: AbortSignal): Promise<ZLinkUserSpotCreationResult>;
     private handleLocalCreate;
     private materializeRemoteCreate;
-    handleRemoteClose(record: ServiceUserSpotCloseRecord, closeOwner: (spot: SpotRef, signal?: AbortSignal) => Promise<boolean>, signal?: AbortSignal): Promise<boolean>;
+    handleRemoteClose(record: ServiceUserSpotCloseRecord, closeOwner: (spot: SpotRef, beginAuthority: (onCommitted: () => void) => Promise<{
+        release(): Promise<void>;
+    }>, signal?: AbortSignal) => Promise<boolean>, signal?: AbortSignal, canResume?: (spot: SpotRef) => boolean): Promise<boolean>;
+    private commitCloseAuthority;
     forgetReadyRoute(spotId: RoutingId, snapshot: ZLinkAuthoritySnapshot): void;
     private beginClosing;
-    private restoreReady;
     private awaitReady;
     private remoteCreate;
 }