@zlink-systems/framework 0.26.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,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<{

package/dist/runtime/host/user-spot-creation-coordinator.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkUserSpotCreationCoordinator = void 0;
 exports.encodeLocationCreationContent = encodeLocationCreationContent;
 exports.decodeLocationCreationContent = decodeLocationCreationContent;
-const framework_errors_internal_1 = require("../framework-errors-internal");
 const node_crypto_1 = require("node:crypto");
 const contracts_1 = require("../../contracts");
 const service_authority_payload_codec_1 = require("../foundation/service-authority-payload-codec");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
+const DEFAULT_USER_SPOT_CLEANUP_TIMEOUT_MS = 1_000;
+const DEFAULT_USER_SPOT_POLL_INTERVAL_MS = 10;
 /**
  * Makes generic Location Store reservation the only visibility barrier for a
  * User Spot. Only the reservation winner invokes application lifecycle code.
@@ -20,9 +22,10 @@ class ZLinkUserSpotCreationCoordinator {
         this.options = options;
     }
     async getOrCreate(request, materialize, discard) {
-        const deadline = createDeadline(request.timeoutMs, request.signal);
-        const deadlineMs = performance.now() + request.timeoutMs;
         const deadlineUnixMs = Date.now() + request.timeoutMs;
+        const remainingMs = Math.max(0, deadlineUnixMs - Date.now());
+        const deadline = createDeadline(remainingMs, request.signal);
+        const deadlineMs = performance.now() + remainingMs;
         const signal = deadline.signal;
         signal.throwIfAborted();
         const sha256 = (0, node_crypto_1.createHash)('sha256').update(request.requestPayload).digest();
@@ -85,7 +88,7 @@ class ZLinkUserSpotCreationCoordinator {
                             count: 1
                         }
                     }
-                }, signal);
+                }, signal, BigInt(deadlineUnixMs));
             }
             catch (error) {
                 deadline.close();
@@ -323,7 +326,7 @@ class ZLinkUserSpotCreationCoordinator {
                             leaseGeneration: current.ownerLeaseGeneration
                         }
                     }
-                }, signal);
+                }, signal, record.deadlineUnixMs);
                 await discard?.(signal);
                 return {
                     result: { spot, state: local.state, reply: local.reply },
@@ -355,7 +358,7 @@ class ZLinkUserSpotCreationCoordinator {
                         ownerNodeRid: String(current.allocation.descriptor.rid),
                         ownerNodeGeneration: current.allocation.descriptorLifecycleGeneration
                     })
-                }, signal);
+                }, signal, record.deadlineUnixMs);
             }
             catch (error) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, 'User Spot Ready commit Store operation failed.', false, error);
@@ -376,7 +379,7 @@ class ZLinkUserSpotCreationCoordinator {
         }
         catch (error) {
             local?.publication?.abort();
-            const cleanupDeadline = createDeadline(this.options.cleanupTimeoutMs ?? 1_000);
+            const cleanupDeadline = createDeadline(this.options.cleanupTimeoutMs ?? DEFAULT_USER_SPOT_CLEANUP_TIMEOUT_MS);
             const cleanupSignal = cleanupDeadline.signal;
             const cleanup = await Promise.allSettled([
                 waitForAbort(this.options.store.abort({
@@ -474,7 +477,7 @@ class ZLinkUserSpotCreationCoordinator {
             if (current.kind === 'snapshot' && current.allocation.state === 'active') {
                 return spotRef(current, request);
             }
-            await wait(this.options.pollIntervalMs ?? 10, signal);
+            await wait(this.options.pollIntervalMs ?? DEFAULT_USER_SPOT_POLL_INTERVAL_MS, signal);
         }
     }
     async remoteCreate(request, snapshot, targetNodeRid, targetNodeGeneration, deadlineUnixMs, deadlineMs) {

package/dist/runtime/locations/aggregate-inventory-store.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkAggregateInventoryStore = void 0;
 const node_crypto_1 = require("node:crypto");
+const actor_join_recovery_codec_1 = require("../foundation/actor-join-recovery-codec");
 const in_memory_provider_location_store_1 = require("./in-memory-provider-location-store");
-const PREFIX = 'zlink:v11:aggregate-inventory:';
+const INVENTORY_PAGE_KIND = 'aggregate-inventory-page-v1';
+const INVENTORY_ROOT_KIND = 'aggregate-inventory-root-v1';
+const PREFIX = `${in_memory_provider_location_store_1.PROVIDER_STORAGE_NAMESPACE_PREFIX}aggregate-inventory:`;
 const MAX_PAGE_ENTRIES = 1_024;
 const MAX_PAGE_BYTES = 1_024 * 1_024;
 const MAX_TREE_LEVELS = 32;
@@ -135,8 +138,8 @@ function buildTree(request) {
     if (request.participants.length < 1) {
         throw new RangeError('Aggregate inventory requires at least one participant.');
     }
-    if (request.inventoryDigest.byteLength !== 32) {
-        throw new TypeError('Aggregate inventory digest must contain 32 bytes.');
+    if (request.inventoryDigest.byteLength !== actor_join_recovery_codec_1.SHA256_DIGEST_BYTES) {
+        throw new TypeError(`Aggregate inventory digest must contain ${actor_join_recovery_codec_1.SHA256_DIGEST_BYTES} bytes.`);
     }
     const entries = request.participants.map((participant, index) => ({
         index,
@@ -162,7 +165,7 @@ function buildTree(request) {
             MAX_PAGE_BYTES) {
         level++;
         if (level >= MAX_TREE_LEVELS) {
-            throw new RangeError('Aggregate inventory tree exceeds 32 levels.');
+            throw new RangeError(`Aggregate inventory tree exceeds ${MAX_TREE_LEVELS} levels.`);
         }
         references = packIndexPages(level, references, pages);
     }
@@ -180,7 +183,7 @@ function packLeafPages(entries, pages) {
         let bytes;
         do {
             page = {
-                kind: 'aggregate-inventory-page-v1',
+                kind: INVENTORY_PAGE_KIND,
                 level: 0,
                 index: references.length,
                 startIndex: offset,
@@ -211,7 +214,7 @@ function packIndexPages(level, children, pages) {
         do {
             const selected = children.slice(offset, offset + count);
             page = {
-                kind: 'aggregate-inventory-page-v1',
+                kind: INVENTORY_PAGE_KIND,
                 level,
                 index: references.length,
                 startIndex: selected[0].startIndex,
@@ -240,7 +243,7 @@ function rootCandidate(totalCount, topLevel, topPages, pages, digest, declaredDi
             pageCountsByLevel[page.level]++;
     }
     return {
-        kind: 'aggregate-inventory-root-v1',
+        kind: INVENTORY_ROOT_KIND,
         totalCount,
         digest,
         declaredDigest,
@@ -325,7 +328,7 @@ function decodeRoot(bytes) {
     if (value === null ||
         typeof value !== 'object' ||
         !('kind' in value) ||
-        value.kind !== 'aggregate-inventory-root-v1') {
+        value.kind !== INVENTORY_ROOT_KIND) {
         throw new Error('Invalid inventory root.');
     }
     return value;
@@ -335,7 +338,7 @@ function decodePage(bytes) {
     if (value === null ||
         typeof value !== 'object' ||
         !('kind' in value) ||
-        value.kind !== 'aggregate-inventory-page-v1' ||
+        value.kind !== INVENTORY_PAGE_KIND ||
         !('entries' in value) ||
         !Array.isArray(value.entries) ||
         !('children' in value) ||
@@ -379,7 +382,7 @@ function isSha256(value) {
 }
 function sameHash(expected, actual) {
     return (isSha256(expected) &&
-        actual.byteLength === 32 &&
+        actual.byteLength === actor_join_recovery_codec_1.SHA256_DIGEST_BYTES &&
         (0, node_crypto_1.timingSafeEqual)(Buffer.from(expected, 'hex'), Buffer.from(actual)));
 }
 function dataLost(fence, reason) {

package/dist/runtime/locations/authority-key-codec.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeAuthorityKey = encodeAuthorityKey;
 exports.decodeAuthorityKey = decodeAuthorityKey;
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 function encodeAuthorityKey(kind, globalId) {
     const bytes = Buffer.from(globalId);
-    if (bytes.byteLength < 1 || bytes.byteLength > 255) {
-        throw new RangeError('Authority identity must contain 1..255 UTF-8 bytes.');
+    if (bytes.byteLength < 1 || bytes.byteLength > CoreTypes_1.ZLINK_MAX_IDENTITY_TEXT_BYTES) {
+        throw new RangeError(`Authority identity must contain 1..${CoreTypes_1.ZLINK_MAX_IDENTITY_TEXT_BYTES} UTF-8 bytes.`);
     }
     const discriminator = kind === 'actor' ? 'a' : 's';
     return {
@@ -20,7 +21,7 @@ function decodeAuthorityKey(key) {
     if (match === null)
         throw new TypeError('Authority key is not canonical.');
     const declaredLength = Number(match[2]);
-    if (declaredLength > 255)
+    if (declaredLength > CoreTypes_1.ZLINK_MAX_IDENTITY_TEXT_BYTES)
         throw new TypeError('Authority key identity exceeds the byte limit.');
     const encoded = match[3];
     const bytes = [];