@zlink-systems/framework 0.26.0 → 0.27.0

package/src/runtime/host/spot-address-transport.ts

@@ -1,24 +1,10 @@
+import { ZLinkFrameworkException, ZLinkSpotKind, type RoutingId } from '../../contracts';
 import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException,
-  internalFrameworkErrorKind,
-  internalFrameworkErrorKindFromWireReply,
-  isCanonicalWireReplyTerminal
-} from '../framework-errors-internal';
-import {
-  RequestResult,
-  SubmitResult,
-  type ZLinkBackendMessageLike as MessageLike
-} from '../backend/runtime-values';
-import { ZLinkFrameworkException, type RoutingId } from '../../contracts';
-import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
-import { ZLinkSpotKind } from '../../contracts';
-import {
-  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
   ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
   ZLinkDispatchErrorSurface,
-  ZLinkDispatchMessageKind
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { awaitWithAbort } from '../abort';
 import type { ZLinkBackendMeshNode } from '../backend/contracts';
@@ -27,16 +13,32 @@ import {
   type ZLinkMeshCompletionTable
 } from '../backend/mesh-completion-table';
 import {
+  RequestResult,
+  type ZLinkBackendMessageLike as MessageLike
+} from '../backend/runtime-values';
+import type { ZLinkDispatchErrorReporter } from '../channels';
+import {
+  ZLinkChannelMessageKind,
   decodeChannelReply,
   encodeChannelEnvelopeParts,
   encodeChannelEnvelopePartsAtDeadline,
-  type ZLinkChannelEnvelopeCodecRegistry,
-  ZLinkChannelMessageKind
+  type ZLinkChannelEnvelopeCodecRegistry
 } from '../channels/channel-envelope';
-import type { ZLinkDispatchErrorReporter } from '../channels';
 import { flowIfEnabled } from '../diagnostics';
 import { runWithOutboundFlow } from '../diagnostics/flow-context';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException,
+  internalFrameworkErrorKind,
+  internalFrameworkErrorKindFromWireReply,
+  isCanonicalWireReplyTerminal
+} from '../framework-errors-internal';
 import { resolveFrameworkPacketName } from '../messaging/packet-name';
+import {
+  ZLinkSubmitStatus,
+  classifySubmitResult,
+  type ZLinkSubmitResult
+} from '../messaging/submission-result';
 import type {
   ZLinkSpotAddressCallOptions,
   ZLinkSpotAddressTransport,
@@ -84,11 +86,6 @@ type MissingTargetSelection =
   | { readonly kind: 'capacity' }
   | { readonly kind: 'unavailable' };
 
-// 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<ZLinkFrameworkException>();
-
 /** Owns global Spot authority lookup and Missing Instance placement. */
 export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport {
   constructor(private readonly options: ZLinkHostSpotAddressTransportOptions) {}
@@ -123,6 +120,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
         try {
           const result = await awaitWithAbort(
             this.options.routed.sendToSpot(existing, message, {
+              instanceSpot: call.instanceSpot,
               timeoutMs: deadline.requireRemaining(),
               signal: deadline.signal,
               metadata: call.metadata
@@ -226,7 +224,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
       const encoded = this.encode(ZLinkChannelMessageKind.Command, selected.meshName, message);
       const sourceSpotId =
         call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
-      const mapped = mapSubmitResult(
+      const mapped = classifySubmitResult(
         await awaitWithAbort(
           selected.node.sendToMissingInstanceSpot(
             selected.target,
@@ -236,7 +234,8 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
             call.metadata
           ),
           deadline.signal
-        )
+        ),
+        'Instance Spot submission'
       );
       this.traceInstanceAddress(
         submitResultFlowOutcome(mapped.status),
@@ -280,57 +279,41 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     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) {
       if (
@@ -372,6 +355,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     );
     const reply = await awaitWithAbort(
       this.options.routed.requestToSpot<TReply>(existing, request, {
+        instanceSpot: call.instanceSpot,
         timeoutMs: deadline.requireRemaining(),
         signal: deadline.signal,
         metadata: call.metadata
@@ -446,28 +430,17 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     const table = this.options.completions(selected.meshName);
     if (table === undefined)
       throw new Error(`MeshNode '${selected.meshName}' completion table is not started.`);
-    let completionPromise: ReturnType<ZLinkMeshCompletionTable['submit']>;
-    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 ZLinkFrameworkException &&
-        internalFrameworkErrorKind(error) === 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(
       ZLinkMessageFlowOutcome.Sent,
       ZLinkDispatchMessageKind.Request,
@@ -580,35 +553,6 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     }
   }
 
-  private async recoverStaleInstanceRoute(
-    spotId: RoutingId,
-    call: ZLinkSpotAddressCallOptions,
-    deadline: ZLinkSpotAddressDeadline,
-    error: unknown,
-    staleRoute: ZLinkSpotRouteTarget
-  ): Promise<
-    | { readonly kind: 'route'; readonly route: ZLinkSpotRouteTarget }
-    | { readonly kind: 'cold' }
-    | { readonly kind: 'fail' }
-  > {
-    if (
-      !call.instanceSpot ||
-      !(error instanceof 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);
-    }
-  }
-
   private selectMissingTarget(
     spotId: RoutingId,
     call: ZLinkSpotAddressCallOptions
@@ -771,25 +715,6 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
   }
 }
 
-function isInstanceRouteStaleError(error: unknown): error is ZLinkFrameworkException {
-  if (!(error instanceof ZLinkFrameworkException)) return false;
-  const kind = 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 === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound) return true;
-  return false;
-}
-
-function isMissingInstanceRetryError(error: unknown): error is ZLinkFrameworkException {
-  return (
-    error instanceof ZLinkFrameworkException && PRE_ADMISSION_MISSING_INSTANCE_ERRORS.has(error)
-  );
-}
-
 function missingInstanceRequestFailure(
   result: number,
   nativeErrno: number
@@ -819,27 +744,6 @@ function missingInstanceRequestFailure(
   );
 }
 
-function mapSubmitResult(result: number): ZLinkSubmitResult {
-  switch (result) {
-    case SubmitResult.Ok:
-      return { status: ZLinkSubmitStatus.Submitted };
-    case SubmitResult.Backpressured:
-    case SubmitResult.NotAdmitted:
-      return { status: ZLinkSubmitStatus.Backpressured };
-    case SubmitResult.NotFound:
-      return { status: ZLinkSubmitStatus.TargetNotFound };
-    case SubmitResult.NotConnected:
-      return { status: ZLinkSubmitStatus.RouteNotConnected };
-    case SubmitResult.Terminated:
-      return { status: ZLinkSubmitStatus.Shutdown };
-    default:
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.RequestFailed,
-        `Instance Spot submission failed with result ${result}.`
-      );
-  }
-}
-
 function missingInstancePlacementCapacity(
   spotId: RoutingId,
   stableType: string | undefined
@@ -877,39 +781,13 @@ function isSpotRouteRefreshError(error: unknown): error is ZLinkFrameworkExcepti
   );
 }
 
-function sameSpotRouteSnapshot(left: ZLinkSpotRouteTarget, right: ZLinkSpotRouteTarget): boolean {
+function isOwnerFenceRefusal(error: unknown): boolean {
   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
+    error instanceof ZLinkFrameworkException &&
+    internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotMoving
   );
 }
 
-function waitForSpotRouteRefresh(delayMs: number, signal: AbortSignal): Promise<void> {
-  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 submitResultReason(status: ZLinkSubmitStatus): ZLinkDispatchErrorReason {
   switch (status) {
     case ZLinkSubmitStatus.Backpressured:

package/src/runtime/host/spot-node-runtime-options-factory.ts

@@ -51,7 +51,8 @@ export interface ZLinkSpotNodeRuntimeOptionsFactoryOptions {
 export class ZLinkSpotNodeRuntimeOptionsFactory {
   constructor(private readonly options: ZLinkSpotNodeRuntimeOptionsFactoryOptions) {}
 
-  create(): ZLinkSpotNodeRuntimeManagerOptions {
+  create(): Omit<ZLinkSpotNodeRuntimeManagerOptions, 'errorSink'> {
+    const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
     return {
       registration: this.options.registration,
       primaryMeshName: this.options.meshRouters.primaryMeshName(),
@@ -59,7 +60,9 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
       context: this.options.context,
       channelClient: new DefaultZLinkChannelClient(
         this.options.registration,
-        this.options.channelTransport
+        this.options.channelTransport,
+        this.options.routeTransport,
+        spotRouterChannelIdForMesh
       ),
       fanoutClient: new DefaultZLinkFanoutClient(
         this.options.registration,
@@ -70,7 +73,7 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
         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/src/runtime/host/spot-runtime-options-factory.ts

@@ -51,18 +51,24 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
     meshName: string,
     spotId: string,
     onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly beginInstanceClosingAuthority: (
     meshName: string,
     spotId: string,
     onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly beginUserClosingAuthority: (
     meshName: string,
     spotId: string,
     objectGeneration: bigint,
     onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly createLocationSpotRouteResolver: () => ZLinkSpotRouteResolver | undefined;
   readonly boundSessionRelay: ZLinkBoundSessionRelay;
   readonly actorHandoff: ZLinkActorHandoffCoordinator;
@@ -71,13 +77,14 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
   readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
   readonly metrics: import('../diagnostics').ZLinkRuntimeMetrics;
   readonly admission: ZLinkRuntimeAdmissionGate;
-  readonly statefulExecutionAllowed: () => boolean;
+  readonly statefulExecution: NonNullable<ZLinkSpotManagerOptions['statefulExecution']>;
 }
 
 export class ZLinkSpotRuntimeOptionsFactory {
   constructor(private readonly options: ZLinkSpotRuntimeOptionsFactoryOptions) {}
 
   create(actorTransferRuntime: ZLinkActorTransferRuntime): Partial<ZLinkSpotManagerOptions> {
+    const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
     return {
       nodeRid: undefined,
       nodeRidProvider: (meshName) => this.meshNodeRoutingId(meshName),
@@ -128,9 +135,20 @@ export class ZLinkSpotRuntimeOptionsFactory {
         }
         await runtime.dispatchEntryActorJoin(meshName, actor, handoffBacklog);
       },
+      executeEntryActor: (meshName, actorId, operation) => {
+        const runtime = this.options.spotNodeRuntime();
+        if (runtime === undefined) {
+          throw new ZLinkConfigurationException(
+            'Entry Spot Actor completion requires the MeshNode runtime.'
+          );
+        }
+        return runtime.executeEntryActor(meshName, actorId, operation);
+      },
       channelClient: new DefaultZLinkChannelClient(
         this.options.registration,
-        this.options.channelTransport
+        this.options.channelTransport,
+        this.options.routeTransport,
+        spotRouterChannelIdForMesh
       ),
       fanoutClient: new DefaultZLinkFanoutClient(
         this.options.registration,
@@ -142,15 +160,7 @@ export class ZLinkSpotRuntimeOptionsFactory {
       ),
       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,
@@ -159,8 +169,54 @@ export class ZLinkSpotRuntimeOptionsFactory {
         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,
@@ -274,17 +330,12 @@ export class ZLinkSpotRuntimeOptionsFactory {
           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/src/runtime/host/user-spot-creation-coordinator.ts

@@ -1,10 +1,29 @@
+import { createHash } from 'node:crypto';
+import {
+  type RoutingId,
+  type SpotRef,
+  type ZLinkSpotCreateResult,
+  ZLinkFrameworkException,
+  ZLinkSpotCreateState
+} from '../../contracts';
+
+import {
+  decodeServiceClosingSpotAuthority,
+  decodeServiceReadySpotAuthority,
+  encodeServiceUserSpotAuthorityPayload
+} from '../foundation/service-authority-payload-codec';
+import type { ServiceUserSpotOperationResult } from '../foundation/service-stateful-runtime';
+import type {
+  ServiceDirectSpotRouteFence,
+  ServiceUserSpotCloseRecord,
+  ServiceUserSpotCreateRecord
+} from '../foundation/service-stateful-wire-codec';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException,
   wireReplyFailureException
 } from '../framework-errors-internal';
-import { createHash } from 'node:crypto';
-import type { RoutingId, SpotRef, ZLinkSpotCreateResult } from '../../contracts';
+import { encodeAuthorityKey } from '../locations/authority-key-codec';
 import type {
   ZLinkAuthoritySnapshot,
   ZLinkLocationOwnerToken,
@@ -14,20 +33,9 @@ import type {
   ZLinkAuthorityStore,
   ZLinkObjectCreationStore
 } from '../locations/internal-store-contracts';
-import { ZLinkFrameworkException, ZLinkSpotCreateState } from '../../contracts';
-import {
-  decodeServiceReadySpotAuthority,
-  decodeServiceClosingSpotAuthority,
-  encodeServiceUserSpotAuthorityPayload
-} from '../foundation/service-authority-payload-codec';
-import { encodeAuthorityKey } from '../locations/authority-key-codec';
 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';
+const DEFAULT_USER_SPOT_CLEANUP_TIMEOUT_MS = 1_000;
+const DEFAULT_USER_SPOT_POLL_INTERVAL_MS = 10;
 
 export interface ZLinkUserSpotCreationCoordinatorOptions {
   readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
@@ -109,9 +117,10 @@ export class ZLinkUserSpotCreationCoordinator {
     ) => Promise<ZLinkLocalSpotCreateResult>,
     discard?: (signal?: AbortSignal) => Promise<void>
   ): Promise<ZLinkUserSpotCreationResult> {
-    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 = createHash('sha256').update(request.requestPayload).digest();
@@ -187,7 +196,8 @@ export class ZLinkUserSpotCreationCoordinator {
               }
             }
           },
-          signal
+          signal,
+          BigInt(deadlineUnixMs)
         );
       } catch (error) {
         deadline.close();
@@ -530,7 +540,8 @@ export class ZLinkUserSpotCreationCoordinator {
               }
             }
           },
-          signal
+          signal,
+          record.deadlineUnixMs
         );
         await discard?.(signal);
         return {
@@ -565,7 +576,8 @@ export class ZLinkUserSpotCreationCoordinator {
               ownerNodeGeneration: current.allocation.descriptorLifecycleGeneration
             })
           },
-          signal
+          signal,
+          record.deadlineUnixMs
         );
       } catch (error) {
         throw createInternalFrameworkException(
@@ -596,7 +608,9 @@ export 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(
@@ -760,7 +774,7 @@ export 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);
     }
   }