@zlink-systems/framework 0.27.0 → 0.28.0

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

@@ -55,12 +55,6 @@ export interface ZLinkHostSpotAddressTransportOptions {
   readonly completions: (meshName: string) => ZLinkMeshCompletionTable | undefined;
   readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
   readonly defaultRequestTimeoutMs: number;
-  /** Internal one-way deadline policy; public calls do not expose this option. */
-  readonly defaultSendTimeoutMs?: number;
-  /** Resolves the send timeout for a configured Spot Mesh. */
-  readonly sendTimeoutMsForMesh?: (meshName: string) => number;
-  /** Resolves the send timeout for a resolved Spot route channel. */
-  readonly sendTimeoutMsForRouteChannel?: (routeChannelId: string) => number;
   readonly dispatchErrors?: ZLinkDispatchErrorReporter;
 }
 
@@ -93,7 +87,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
   sendToSpotAddress(
     spotId: RoutingId,
     message: unknown,
-    call: ZLinkSpotAddressCallOptions
+    call: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>
   ): Promise<ZLinkSubmitResult> {
     // Call-scoped flow (spec 27 §4): the envelope encoders and the
     // traceInstanceAddress points share one ambient flow that does not
@@ -107,157 +101,136 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
   private async sendToSpotAddressScoped(
     spotId: RoutingId,
     message: unknown,
-    call: ZLinkSpotAddressCallOptions
+    call: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>
   ): Promise<ZLinkSubmitResult> {
-    const timeoutMs = initialSendTimeoutMs(this.options, call);
-    const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
-    try {
-      const existing = await this.resolveExisting(spotId, deadline.signal);
-      deadline.requireRemaining();
-      if (existing !== undefined) {
-        this.validateExisting(existing, call);
-        deadline.setOwnerTimeout(this.sendTimeoutMsForRouteChannel(existing.routerChannelId));
-        try {
-          const result = await awaitWithAbort(
-            this.options.routed.sendToSpot(existing, message, {
-              instanceSpot: call.instanceSpot,
-              timeoutMs: deadline.requireRemaining(),
-              signal: deadline.signal,
-              metadata: call.metadata
-            }),
-            deadline.signal
+    const activationDeadlineUnixMs = BigInt(
+      Math.round(Date.now() + this.options.defaultRequestTimeoutMs)
+    );
+    const existing = await this.resolveExisting(spotId);
+    if (existing !== undefined) {
+      this.validateExisting(existing, call);
+      try {
+        const result = await this.options.routed.sendToSpot(existing, message, {
+          instanceSpot: call.instanceSpot,
+          metadata: call.metadata
+        });
+        if (result.status === ZLinkSubmitStatus.Submitted) {
+          this.traceInstanceAddress(
+            ZLinkMessageFlowOutcome.Sent,
+            ZLinkDispatchMessageKind.Send,
+            spotId,
+            message,
+            existing.routerChannelId,
+            existing.stableType,
+            existing.targetNodeRid
           );
-          if (result.status === ZLinkSubmitStatus.Submitted) {
-            this.traceInstanceAddress(
-              ZLinkMessageFlowOutcome.Sent,
-              ZLinkDispatchMessageKind.Send,
-              spotId,
-              message,
-              existing.routerChannelId,
-              existing.stableType,
-              existing.targetNodeRid
-            );
-          } else {
-            this.traceInstanceAddress(
-              submitResultFlowOutcome(result.status),
-              ZLinkDispatchMessageKind.Send,
-              spotId,
-              message,
-              existing.routerChannelId,
-              existing.stableType,
-              existing.targetNodeRid,
-              submitResultReason(result.status)
-            );
-          }
-          if (
-            result.status === ZLinkSubmitStatus.TargetNotFound ||
-            result.status === ZLinkSubmitStatus.RouteNotConnected
-          ) {
-            this.options.resolver()?.invalidate?.(spotId);
-          }
-          return result;
-        } catch (error) {
-          if (isSpotRouteRefreshError(error)) {
-            this.options.resolver()?.invalidate?.(spotId);
-          }
-          const reason = addressedInstanceErrorReason(error);
+        } else {
           this.traceInstanceAddress(
-            reason === ZLinkDispatchErrorReason.Backpressure
-              ? ZLinkMessageFlowOutcome.Backpressured
-              : ZLinkMessageFlowOutcome.Dropped,
+            submitResultFlowOutcome(result.status),
             ZLinkDispatchMessageKind.Send,
             spotId,
             message,
             existing.routerChannelId,
             existing.stableType,
             existing.targetNodeRid,
-            reason
+            submitResultReason(result.status)
           );
-          throw error;
         }
-      }
-      if (!call.instanceSpot) {
-        return { status: ZLinkSubmitStatus.TargetNotFound };
-      }
-      const selected = this.selectMissingTarget(spotId, call);
-      if (selected.kind === 'unsupported') {
-        this.traceInstanceAddress(
-          ZLinkMessageFlowOutcome.Dropped,
-          ZLinkDispatchMessageKind.Send,
-          spotId,
-          message,
-          call.initialMeshName,
-          call.instanceSpotType,
-          undefined,
-          ZLinkDispatchErrorReason.StaleTarget
-        );
-        return { status: ZLinkSubmitStatus.TargetNotFound };
-      }
-      if (selected.kind === 'capacity') {
-        const error = missingInstancePlacementCapacity(spotId, call.instanceSpotType);
+        if (
+          result.status === ZLinkSubmitStatus.TargetNotFound ||
+          result.status === ZLinkSubmitStatus.RouteNotConnected
+        ) {
+          this.options.resolver()?.invalidate?.(spotId);
+        }
+        return result;
+      } catch (error) {
+        if (isSpotRouteRefreshError(error)) {
+          this.options.resolver()?.invalidate?.(spotId);
+        }
+        const reason = addressedInstanceErrorReason(error);
         this.traceInstanceAddress(
-          ZLinkMessageFlowOutcome.Backpressured,
+          reason === ZLinkDispatchErrorReason.Backpressure
+            ? ZLinkMessageFlowOutcome.Backpressured
+            : ZLinkMessageFlowOutcome.Dropped,
           ZLinkDispatchMessageKind.Send,
           spotId,
           message,
-          call.initialMeshName,
-          call.instanceSpotType,
-          undefined,
-          ZLinkDispatchErrorReason.Backpressure
+          existing.routerChannelId,
+          existing.stableType,
+          existing.targetNodeRid,
+          reason
         );
         throw error;
       }
-      if (selected.kind === 'unavailable') {
-        this.traceInstanceAddress(
-          ZLinkMessageFlowOutcome.Dropped,
-          ZLinkDispatchMessageKind.Send,
-          spotId,
-          message,
-          call.initialMeshName,
-          call.instanceSpotType,
-          undefined,
-          ZLinkDispatchErrorReason.StaleTarget
-        );
-        return { status: ZLinkSubmitStatus.RouteNotConnected };
-      }
-      deadline.setOwnerTimeout(this.sendTimeoutMsForMesh(selected.meshName));
-      const encoded = this.encode(ZLinkChannelMessageKind.Command, selected.meshName, message);
-      const sourceSpotId =
-        call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
-      const mapped = classifySubmitResult(
-        await awaitWithAbort(
-          selected.node.sendToMissingInstanceSpot(
-            selected.target,
-            encoded,
-            BigInt(deadline.deadlineUnixMs),
-            sourceSpotId,
-            call.metadata
-          ),
-          deadline.signal
-        ),
-        'Instance Spot submission'
+    }
+    if (!call.instanceSpot) {
+      return { status: ZLinkSubmitStatus.TargetNotFound };
+    }
+    const selected = this.selectMissingTarget(spotId, call);
+    if (selected.kind === 'unsupported') {
+      this.traceInstanceAddress(
+        ZLinkMessageFlowOutcome.Dropped,
+        ZLinkDispatchMessageKind.Send,
+        spotId,
+        message,
+        call.initialMeshName,
+        call.instanceSpotType,
+        undefined,
+        ZLinkDispatchErrorReason.StaleTarget
       );
+      return { status: ZLinkSubmitStatus.TargetNotFound };
+    }
+    if (selected.kind === 'capacity') {
+      const error = missingInstancePlacementCapacity(spotId, call.instanceSpotType);
       this.traceInstanceAddress(
-        submitResultFlowOutcome(mapped.status),
+        ZLinkMessageFlowOutcome.Backpressured,
         ZLinkDispatchMessageKind.Send,
         spotId,
         message,
-        selected.meshName,
-        selected.target.stableType,
-        selected.target.targetNodeRid,
-        mapped.status === ZLinkSubmitStatus.Submitted
-          ? undefined
-          : submitResultReason(mapped.status)
+        call.initialMeshName,
+        call.instanceSpotType,
+        undefined,
+        ZLinkDispatchErrorReason.Backpressure
       );
-      return mapped;
-    } catch (error) {
-      if (deadline.expired()) {
-        return { status: ZLinkSubmitStatus.TimedOut };
-      }
       throw error;
-    } finally {
-      deadline.close();
     }
+    if (selected.kind === 'unavailable') {
+      this.traceInstanceAddress(
+        ZLinkMessageFlowOutcome.Dropped,
+        ZLinkDispatchMessageKind.Send,
+        spotId,
+        message,
+        call.initialMeshName,
+        call.instanceSpotType,
+        undefined,
+        ZLinkDispatchErrorReason.StaleTarget
+      );
+      return { status: ZLinkSubmitStatus.RouteNotConnected };
+    }
+    const encoded = this.encode(ZLinkChannelMessageKind.Command, selected.meshName, message);
+    const sourceSpotId =
+      call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
+    const mapped = classifySubmitResult(
+      await selected.node.sendToMissingInstanceSpot(
+        selected.target,
+        encoded,
+        activationDeadlineUnixMs,
+        sourceSpotId,
+        call.metadata
+      ),
+      'Instance Spot submission'
+    );
+    this.traceInstanceAddress(
+      submitResultFlowOutcome(mapped.status),
+      ZLinkDispatchMessageKind.Send,
+      spotId,
+      message,
+      selected.meshName,
+      selected.target.stableType,
+      selected.target.targetNodeRid,
+      mapped.status === ZLinkSubmitStatus.Submitted ? undefined : submitResultReason(mapped.status)
+    );
+    return mapped;
   }
 
   requestToSpotAddress<TReply = unknown>(
@@ -642,22 +615,6 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     return { kind: 'unavailable' };
   }
 
-  private sendTimeoutMsForMesh(meshName: string): number {
-    return (
-      this.options.sendTimeoutMsForMesh?.(meshName) ??
-      this.options.defaultSendTimeoutMs ??
-      this.options.defaultRequestTimeoutMs
-    );
-  }
-
-  private sendTimeoutMsForRouteChannel(routeChannelId: string): number {
-    return (
-      this.options.sendTimeoutMsForRouteChannel?.(routeChannelId) ??
-      this.options.defaultSendTimeoutMs ??
-      this.options.defaultRequestTimeoutMs
-    );
-  }
-
   private validateExisting(
     target: import('../spots/spot-routing-internal').ZLinkSpotRouteTarget,
     call: ZLinkSpotAddressCallOptions
@@ -845,21 +802,9 @@ function addressedInstanceErrorReason(error: unknown): ZLinkDispatchErrorReason
   return ZLinkDispatchErrorReason.HandlerException;
 }
 
-function initialSendTimeoutMs(
-  options: ZLinkHostSpotAddressTransportOptions,
-  call: ZLinkSpotAddressCallOptions
-): number {
-  return call.initialMeshName === undefined
-    ? (options.defaultSendTimeoutMs ?? options.defaultRequestTimeoutMs)
-    : (options.sendTimeoutMsForMesh?.(call.initialMeshName) ??
-        options.defaultSendTimeoutMs ??
-        options.defaultRequestTimeoutMs);
-}
-
 interface ZLinkSpotAddressDeadline {
   readonly deadlineUnixMs: number;
   readonly signal: AbortSignal;
-  setOwnerTimeout(timeoutMs: number): void;
   requireRemaining(): number;
   expired(): boolean;
   close(): void;
@@ -871,7 +816,7 @@ function createSpotAddressDeadline(
 ): ZLinkSpotAddressDeadline {
   const startedAtMs = performance.now();
   const startedAtUnixMs = Date.now();
-  let deadlineMs = startedAtMs + Math.max(0, timeoutMs);
+  const deadlineMs = startedAtMs + Math.max(0, timeoutMs);
   const controller = new AbortController();
   let expired = false;
   let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -897,10 +842,6 @@ function createSpotAddressDeadline(
       return Math.round(startedAtUnixMs + (deadlineMs - startedAtMs));
     },
     signal: controller.signal,
-    setOwnerTimeout(ownerTimeoutMs: number) {
-      deadlineMs = startedAtMs + Math.max(0, ownerTimeoutMs);
-      arm();
-    },
     requireRemaining() {
       const remainingMs = deadlineMs - performance.now();
       if (remainingMs <= 0) {

package/src/runtime/locations/location-store-repository.ts

@@ -1193,7 +1193,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         this.provider.read(leaseKey, signal)
       ]);
       const descriptor = liveTargetDescriptor(descriptorRead, leaseRead, request.target);
-      if (descriptor === undefined) {
+      if (descriptor === undefined || descriptor.state !== ZLinkFrameworkRuntimeState.Serving) {
         return { kind: 'conflict', current: { kind: 'missing', storeNow: current.storeNow } };
       }
       const [capacityRead, objectGenerationRead, authorityOwnerGenerationRead] = await Promise.all([
@@ -1394,9 +1394,11 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
       ) {
         return { kind: 'stale' };
       }
+      const descriptorKey = meshKey(request.target.meshName, request.target.nodeRid);
       const leaseKey = ownerKey(request.target.owner.ownerId);
       const capacityRowKey = capacityKey(request.target.meshName, String(request.target.nodeRid));
-      const [leaseRead, capacityRead] = await Promise.all([
+      const [descriptorRead, leaseRead, capacityRead] = await Promise.all([
+        this.provider.read(descriptorKey, signal),
         this.provider.read(leaseKey, signal),
         this.provider.read(capacityRowKey, signal)
       ]);
@@ -1406,7 +1408,8 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         // rather than read the absence as expiry.
         throw new Error('Location Store owner lease record is invalid.');
       }
-      if (!sameLiveOwner(leaseRead, record.snapshot)) return { kind: 'stale' };
+      if (liveTargetDescriptor(descriptorRead, leaseRead, request.target) === undefined)
+        return { kind: 'stale' };
       const capacity =
         capacityRead.kind === 'missing'
           ? emptyCapacityRecord()
@@ -1415,6 +1418,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         {
           conditions: [
             { kind: 'version', key: rowKey, expected: current.value.version },
+            versionCondition(descriptorKey, descriptorRead),
             leaseValueCondition(leaseKey, {
               ownerId: record.snapshot.ownerId,
               leaseGeneration: record.snapshot.ownerLeaseGeneration
@@ -3904,7 +3908,6 @@ function liveTargetDescriptor(
     descriptor.ownerId === target.owner.ownerId &&
     descriptor.leaseGeneration === target.owner.leaseGeneration &&
     descriptor.objectRole === ZLinkObjectRole.Server &&
-    descriptor.state === ZLinkFrameworkRuntimeState.Serving &&
     lease.ownerId === target.owner.ownerId &&
     BigInt(lease.leaseGeneration) === target.owner.leaseGeneration &&
     leaseRead.value.expiresAt !== undefined &&

package/src/runtime/messaging/request-deadline.ts

@@ -0,0 +1,58 @@
+import { awaitWithAbort } from '../abort';
+import {
+  createInternalFrameworkException,
+  ZLinkFrameworkInternalErrorKind
+} from '../framework-errors-internal';
+
+export function remainingRequestTimeout(
+  operation: string,
+  deadlineMs: number | undefined
+): number | undefined {
+  if (deadlineMs === undefined) return undefined;
+  const remaining = deadlineMs - performance.now();
+  if (remaining <= 0) {
+    throw createInternalFrameworkException(
+      ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
+      `${operation} exceeded its deadline.`
+    );
+  }
+  return Math.max(1, Math.ceil(remaining));
+}
+
+/** Bounds caller waiting across outbound admission and reply; late completions stay observed. */
+export async function waitRequestReply<T>(
+  reply: Promise<T>,
+  operation: string,
+  deadlineMs: number | undefined,
+  signal?: AbortSignal,
+  endWait?: () => void,
+  discardLateReply?: (reply: T) => void
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let waiting = reply;
+  if (deadlineMs !== undefined) {
+    const timeout = new Promise<never>((_resolve, reject) => {
+      const remaining = remainingRequestTimeout(operation, deadlineMs);
+      timer = setTimeout(
+        () =>
+          reject(
+            createInternalFrameworkException(
+              ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
+              `${operation} exceeded its deadline.`
+            )
+          ),
+        remaining
+      );
+    });
+    waiting = Promise.race([reply, timeout]);
+  }
+  try {
+    return await awaitWithAbort(waiting, signal);
+  } catch (error) {
+    endWait?.();
+    if (discardLateReply !== undefined) void reply.then(discardLateReply, () => undefined);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/runtime/messaging/submission-result.ts

@@ -18,7 +18,7 @@ export interface ZLinkSubmitResult {
   readonly status: ZLinkSubmitStatus;
 }
 
-/** Projects the Core submit result once; phase only determines capacity refusal meaning. */
+/** Projects immediate refusal and pending admission failure from their Core phase. */
 export function submitToRequestResult(result: number, phase: 'submit' | 'completion'): number {
   switch (result) {
     case SubmitResult.Ok:
@@ -28,7 +28,7 @@ export function submitToRequestResult(result: number, phase: 'submit' | 'complet
     case SubmitResult.NotConnected:
       return RequestResult.NotConnected;
     case SubmitResult.NotFound:
-      return RequestResult.NotFound;
+      return phase === 'submit' ? RequestResult.NotFound : RequestResult.NotConnected;
     case SubmitResult.NotAdmitted:
       return RequestResult.Rejected;
     case SubmitResult.InvalidHandle:
@@ -49,7 +49,7 @@ export function submitToRequestResult(result: number, phase: 'submit' | 'complet
 export function classifySubmitResult(
   result: number,
   operation: string,
-  phase: 'submit' | 'completion' = 'completion'
+  phase: 'submit' | 'completion' = 'submit'
 ): ZLinkSubmitResult {
   const terminal = submitToRequestResult(result, phase);
   switch (terminal) {
@@ -80,12 +80,17 @@ export function requireOneWayCompletion(
     case ZLinkSubmitStatus.Submitted:
       return;
     case ZLinkSubmitStatus.TimedOut:
-    case ZLinkSubmitStatus.Backpressured:
       throw createInternalFrameworkException(
         ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
         `${operation} did not obtain admission before its deadline.`,
         true
       );
+    case ZLinkSubmitStatus.Backpressured:
+      throw createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.RouteNotConnected,
+        `${operation} has no admission wait token.`,
+        true
+      );
     case ZLinkSubmitStatus.TargetNotFound:
       throw createInternalFrameworkException(notFoundKind, `${operation} target was not found.`);
     case ZLinkSubmitStatus.RouteNotConnected:
@@ -106,6 +111,15 @@ export function requirePublishCompletion(result: ZLinkSubmitResult, operation: s
   requireOneWayCompletion(result, operation);
 }
 
+export function requireClassicFanoutCompletion(result: ZLinkSubmitResult, operation: string): void {
+  requireOneWayCompletion(
+    result.status === ZLinkSubmitStatus.Backpressured
+      ? { status: ZLinkSubmitStatus.TimedOut }
+      : result,
+    operation
+  );
+}
+
 export function throwAlreadySubmitted(operation: string): never {
   throw createInternalFrameworkException(
     ZLinkFrameworkInternalErrorKind.AlreadySubmitted,

package/src/runtime/spots/spot-outbound.ts

@@ -191,7 +191,7 @@ export interface ZLinkSpotAddressTransport {
   sendToSpotAddress(
     spotId: RoutingId,
     message: unknown,
-    options: ZLinkSpotAddressCallOptions
+    options: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>
   ): Promise<ZLinkSubmitResult>;
   requestToSpotAddress<TReply = unknown>(
     spotId: RoutingId,
@@ -228,14 +228,12 @@ export interface ZLinkSpotRoutedTransport {
 export interface ZLinkSpotRoutedSendOptions {
   readonly instanceSpot?: boolean;
   readonly packetName?: string;
-  /** Internal end-to-end budget remaining for route admission. */
-  readonly timeoutMs?: number;
-  readonly signal?: AbortSignal;
   readonly metadata?: ReadonlyMap<string, string>;
 }
 
 export interface ZLinkSpotRoutedRequestOptions extends ZLinkSpotRoutedSendOptions {
   readonly timeoutMs?: number;
+  readonly signal?: AbortSignal;
 }
 
 interface MutableAddressCallOptions {
@@ -283,13 +281,13 @@ function createAddressedSpotSendCall(
       );
       return this;
     },
-    async submit(signal?: AbortSignal): Promise<void> {
+    async submit(): Promise<void> {
       markSubmitted(options);
       const pending = startRequestOnSerial(serial, () => ({
         pending: transport.sendToSpotAddress(
           spotId,
           message,
-          freezeAddressCallOptions(options, signal, sourceSpotProvider?.())
+          freezeAddressCallOptions(options, sourceSpotProvider?.())
         )
       }));
       const result = await (serial.isCurrentTurn ? pending : deliverOnSerial(serial, pending));
@@ -314,11 +312,11 @@ function createAddressedSpotRequestCall(
     markSubmitted(options);
     rejectSameSpotAsyncRequest(serial, spotId, waitPolicy);
     return startRequestOnSerial<TReply>(serial, () => ({
-      pending: transport.requestToSpotAddress<TReply>(
-        spotId,
-        request,
-        freezeAddressCallOptions(options, signal, sourceSpotProvider?.())
-      )
+      pending: transport.requestToSpotAddress<TReply>(spotId, request, {
+        ...freezeAddressCallOptions(options, sourceSpotProvider?.()),
+        timeoutMs: options.timeoutMs,
+        signal
+      })
     }));
   };
   return {
@@ -422,7 +420,6 @@ function markSubmitted(options: MutableAddressCallOptions): void {
 
 function freezeAddressCallOptions(
   options: MutableAddressCallOptions,
-  signal: AbortSignal | undefined,
   sourceSpot: ZLinkBackendSpot | undefined
 ): ZLinkSpotAddressCallOptions {
   return {
@@ -430,8 +427,6 @@ function freezeAddressCallOptions(
     instanceSpot: options.instanceSpot,
     instanceSpotType: options.instanceSpotType,
     initialMeshName: options.initialMeshName,
-    timeoutMs: options.timeoutMs,
-    signal,
     sourceSpot
   };
 }
@@ -453,8 +448,8 @@ function wrapSendCall(serial: ZLinkSpotSerialTurnExecutor, inner: ZLinkSendCall)
       else inner.metadata(key);
       return this;
     },
-    async submit(signal?: AbortSignal) {
-      const result = await runInternalTransportStart(serial, () => inner.submit(signal));
+    async submit() {
+      const result = await runInternalTransportStart(serial, () => inner.submit());
       return result;
     }
   };
@@ -548,11 +543,10 @@ function wrapRoutedSpotSendCall(
       }
       return this;
     },
-    async submit(signal?: AbortSignal): Promise<void> {
+    async submit(): Promise<void> {
       const pending = startRequestOnSerial(serial, () => ({
         pending: sendToSpotHandle(transport, spot, message, {
           metadata,
-          signal,
           spotRouterChannelIdForMesh,
           sourceSpot: sourceSpotProvider?.()
         })
@@ -645,7 +639,7 @@ export async function sendToSpotHandle(
   transport: ZLinkSpotRoutedTransport,
   spot: SpotHandle,
   message: unknown,
-  options: ZLinkSpotHandleCallOptions = {}
+  options: Omit<ZLinkSpotHandleCallOptions, 'timeoutMs' | 'signal'> = {}
 ): Promise<ZLinkSubmitResult> {
   const packetName = resolveFrameworkPacketName(message, undefined, 'SPOT');
   const sendResolved = async (resolved: ResolvedSpotHandle): Promise<ZLinkSubmitResult> => {
@@ -653,20 +647,16 @@ export async function sendToSpotHandle(
     if (options.sourceSpot !== undefined && transport.sendFromSpotToSpot !== undefined) {
       return transport.sendFromSpotToSpot(options.sourceSpot, target, message, {
         packetName,
-        timeoutMs: options.timeoutMs,
-        signal: options.signal,
         metadata: options.metadata
       });
     }
     return transport.sendToSpot(target, message, {
       packetName,
-      timeoutMs: options.timeoutMs,
-      signal: options.signal,
       metadata: options.metadata
     });
   };
 
-  return sendResolved(await requireSpotRef(spot, options.signal));
+  return sendResolved(await requireSpotRef(spot));
 }
 
 export async function requestToSpotHandle<TReply = unknown>(