@zlink-systems/framework 0.27.0 → 0.29.0

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

@@ -1,3 +1,4 @@
+import { ServiceRelocationAuthorityPayloadCodec } from '../foundation/service-relocation-runtime';
 import { UINT64_MAX } from '@zlink-systems/stream-wire';
 import { createHash, randomUUID } from 'node:crypto';
 import { zlinkRuntimeDefaultLocationOptions } from '../../contracts/Locations/Options';
@@ -17,6 +18,8 @@ import {
   type ZLinkStoreScanCursor,
   type ZLinkStoreVersion,
   type ZLinkStoreWriteRequest,
+  ZLinkFrameworkException,
+  ZLinkFrameworkErrorKind,
   ZLinkFrameworkRuntimeState,
   ZLinkObjectRole
 } from '../../contracts';
@@ -204,7 +207,30 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     private readonly nowProvider: () => Date = () => new Date()
   ) {
     super(nowProvider);
-    this.provider = provider;
+    // Classify only failures of the opaque SPI, before interpreting its records.
+    this.provider = {
+      async read(key, signal) {
+        try {
+          return await provider.read(key, signal);
+        } catch (error) {
+          throw locationStoreProviderFailure(error, signal);
+        }
+      },
+      async write(request, signal) {
+        try {
+          return await provider.write(request, signal);
+        } catch (error) {
+          throw locationStoreProviderFailure(error, signal);
+        }
+      },
+      async scan(request, signal) {
+        try {
+          return await provider.scan(request, signal);
+        } catch (error) {
+          throw locationStoreProviderFailure(error, signal);
+        }
+      }
+    };
     this.aggregateInventory = new ZLinkAggregateInventoryStore(this.provider);
   }
 
@@ -1099,6 +1125,77 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     }
   }
 
+  override async releaseEndedReservation(
+    key: ZLinkAuthorityKey,
+    expectedStoreVersion: string,
+    signal?: AbortSignal
+  ): Promise<boolean> {
+    const rowKey = authorityKey(key.value);
+    const current = await this.provider.read(rowKey, signal);
+    if (current.kind === 'missing' || current.value.version.value !== expectedStoreVersion)
+      return false;
+    const record = decodeAuthorityRecord(current.value.bytes);
+    const snapshot = record.snapshot;
+    if (
+      snapshot.allocation.state !== 'reserved' ||
+      snapshot.pendingCreation === undefined ||
+      record.aggregate !== undefined ||
+      hasRelocationAuthority(snapshot.payload)
+    )
+      return false;
+    const leaseKey = ownerKey(snapshot.ownerId);
+    const descriptorKey = meshKey(
+      snapshot.allocation.descriptor.meshName,
+      snapshot.allocation.descriptor.rid
+    );
+    const capacityRowKey = capacityKey(
+      snapshot.allocation.descriptor.meshName,
+      String(snapshot.allocation.descriptor.rid)
+    );
+    const [lease, descriptor, capacity] = await Promise.all([
+      this.provider.read(leaseKey, signal),
+      this.provider.read(descriptorKey, signal),
+      this.provider.read(capacityRowKey, signal)
+    ]);
+    if (lease.kind === 'found' && lease.value.expiresAt === undefined)
+      throw new Error('Location Store owner lease record is invalid.');
+    if (
+      sameLiveOwner(lease, snapshot) &&
+      descriptor.kind === 'found' &&
+      reviveMeshDescriptor(
+        decodeCanonicalDescriptorRecord<ZLinkMeshNodeDescriptor>(descriptor.value.bytes).descriptor
+      ).lifecycleGeneration === snapshot.allocation.descriptorLifecycleGeneration
+    )
+      return false;
+    const mutations: ZLinkStoreWriteRequest['mutations'][number][] = [
+      { kind: 'delete', key: rowKey }
+    ];
+    if (capacity.kind === 'found') {
+      const stored = decodeJson<CapacityRecord>(capacity.value.bytes);
+      mutations.push({
+        kind: 'put',
+        key: capacityRowKey,
+        bytes: encodeJson({
+          active: stored.active,
+          pending: subtractCapacity(stored.pending, snapshot.allocation.capacity)
+        } satisfies CapacityRecord)
+      });
+    }
+    const result = await this.provider.write(
+      {
+        conditions: [
+          { kind: 'version', key: rowKey, expected: current.value.version },
+          conditionFor(leaseKey, lease),
+          conditionFor(descriptorKey, descriptor),
+          conditionFor(capacityRowKey, capacity)
+        ],
+        mutations
+      },
+      signal
+    );
+    return result.kind === 'applied';
+  }
+
   override async reserve(
     request: ZLinkObjectReserveRequest,
     signal?: AbortSignal,
@@ -1130,62 +1227,13 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
           return { kind: 'alreadyExists', current: snapshot };
         }
         if (
-          record.aggregate !== undefined ||
-          isCanonicalAuthorityPayload(record.snapshot.payload)
-        ) {
-          // A relocation record carries its own recovery protocol. Reserve
-          // may reclaim only an unfinished plain creation.
-          return { kind: 'conflict', current: snapshot };
-        }
-        // The row is Reserved by another owner. An unfinished creation
-        // whose owner lease ended is cancellable, so reclaim it and retry
-        // instead of blocking the key forever.
-        const staleOwnerKey = ownerKey(snapshot.ownerId);
-        const staleCapacityKey = capacityKey(
-          snapshot.allocation.descriptor.meshName,
-          String(snapshot.allocation.descriptor.rid)
-        );
-        const [staleOwnerRead, staleCapacityRead] = await Promise.all([
-          this.provider.read(staleOwnerKey, signal),
-          this.provider.read(staleCapacityKey, signal)
-        ]);
-        if (staleOwnerRead.kind === 'found' && staleOwnerRead.value.expiresAt === undefined) {
-          // A lease is always written with a positive TTL, so a missing
-          // expiry is a corrupt record. Reclaiming deletes authority state,
-          // so refuse rather than read the absence as expiry.
-          throw new Error('Location Store owner lease record is invalid.');
-        }
-        if (sameLiveOwner(staleOwnerRead, record.snapshot)) {
+          !(await this.releaseEndedReservation(
+            encodedAuthorityKey,
+            current.value.version.value,
+            signal
+          ))
+        )
           return { kind: 'conflict', current: snapshot };
-        }
-        const staleCapacity =
-          staleCapacityRead.kind === 'missing'
-            ? emptyCapacityRecord()
-            : decodeJson<CapacityRecord>(staleCapacityRead.value.bytes);
-        await this.provider.write(
-          {
-            conditions: [
-              { kind: 'version', key: rowKey, expected: current.value.version },
-              versionCondition(staleOwnerKey, staleOwnerRead),
-              conditionFor(staleCapacityKey, staleCapacityRead)
-            ],
-            mutations: [
-              { kind: 'delete', key: rowKey },
-              {
-                kind: 'put',
-                key: staleCapacityKey,
-                bytes: encodeJson({
-                  active: staleCapacity.active,
-                  pending: subtractCapacity(
-                    staleCapacity.pending,
-                    record.snapshot.allocation.capacity
-                  )
-                } satisfies CapacityRecord)
-              }
-            ]
-          },
-          signal
-        );
         continue;
       }
       const [descriptorRead, leaseRead] = await Promise.all([
@@ -1193,7 +1241,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 +1442,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 +1456,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 +1466,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 +3956,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 &&
@@ -4034,15 +4085,10 @@ function sameCreationTarget(
   );
 }
 
-const CANONICAL_AUTHORITY_MAGIC = Buffer.from('ZLAU');
+const relocationAuthorityCodec = new ServiceRelocationAuthorityPayloadCodec();
 
-function isCanonicalAuthorityPayload(payload: Uint8Array): boolean {
-  return (
-    payload.byteLength >= CANONICAL_AUTHORITY_MAGIC.byteLength &&
-    Buffer.from(payload.buffer, payload.byteOffset, CANONICAL_AUTHORITY_MAGIC.byteLength).equals(
-      CANONICAL_AUTHORITY_MAGIC
-    )
-  );
+function hasRelocationAuthority(payload: Uint8Array): boolean {
+  return relocationAuthorityCodec.read(payload) !== undefined;
 }
 
 function sameLiveOwner(lease: ZLinkStoreReadResult, snapshot: StoredAuthoritySnapshot): boolean {
@@ -4438,3 +4484,19 @@ function throwIfOperationExpired(signal?: AbortSignal, deadlineUnixMs?: bigint):
     throw new DOMException('Operation deadline exceeded.', 'TimeoutError');
   }
 }
+
+// Store SPI §6: preserve caller failures and classify provider failures once.
+function locationStoreProviderFailure(error: unknown, signal?: AbortSignal): unknown {
+  if (
+    error instanceof ZLinkFrameworkException ||
+    error instanceof TypeError ||
+    error instanceof RangeError ||
+    signal?.aborted === true
+  )
+    return error;
+  return new ZLinkFrameworkException(
+    ZLinkFrameworkErrorKind.Unavailable,
+    'Location Store provider is unavailable.',
+    error
+  );
+}

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/protocol/service_wire_pilot_codec.generated.ts

@@ -1,4 +1,4 @@
-// <auto-generated> DO NOT EDIT. schema-sha256: 77748ba8f585cb70ad337fa3203b5f9b9aa7a89e7f95f7fdc20159c30987be0f
+// <auto-generated> DO NOT EDIT. schema-sha256: 818fcd2f767793be8b5f626e5ac688807e671e546af2b11786e6fbaa02010ba5
 export interface ServiceWireRouteFence { readonly id: string; readonly generation: bigint; readonly targetNodeRid: Uint8Array; readonly targetNodeGeneration: bigint; readonly expectedAuthorityOwnerGeneration: bigint; readonly expectedOwnerLeaseGeneration: bigint; }
 	export interface ApplicationPayloadEnvelopeV1 { readonly packetName: string; readonly contentType: string; readonly payload: Uint8Array; }
 	export interface ActorJoin28 { readonly correlation: bigint; readonly actor: ServiceWireRouteFence; readonly entry: boolean; readonly targetSpot: ServiceWireRouteFence; readonly payload?: ApplicationPayloadEnvelopeV1; }

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>(

package/src/runtime/spots/spot-serial-executor.ts

@@ -134,7 +134,10 @@ export class ZLinkSpotSerialExecutor {
     this.throwIfClosing();
     let executor = this.actorExecutors.get(actorId);
     if (executor === undefined) {
-      executor = new ZLinkActorSerialExecutor(actorId, this.sourceSpotId, this.actorOptions);
+      executor =
+        this.executionMode === ZLinkUserSpotExecutionMode.SpotWide
+          ? this.spotSerial.createActorExecutor(actorId, this.sourceSpotId, this.actorOptions)
+          : new ZLinkActorSerialExecutor(actorId, this.sourceSpotId, this.actorOptions);
       this.actorExecutors.set(actorId, executor);
     }
     return executor;

package/src/runtime/spots/spot-serial-turn-executor.ts

@@ -19,6 +19,7 @@ import {
   type ZLinkSerialWorkRecord
 } from '../execution/serial-execution-queue';
 import type { ZLinkSerialLifecycleContext } from '../execution/serial-execution-queue';
+import { ZLinkActorSerialExecutor } from '../actors/actor-mailbox';
 
 export type ZLinkSpotApplicationTurnContext = ZLinkExecutionBarrierClaim & {
   readonly replay?: (failure?: unknown) => Promise<unknown> | unknown;
@@ -53,6 +54,15 @@ export class ZLinkSpotSerialTurnExecutor {
     return this.depth > 0;
   }
 
+  /** Creates a passive Actor mailbox consumed by this Spot's scheduler. */
+  createActorExecutor(
+    actorId: string,
+    sourceSpotId: unknown,
+    options?: ZLinkSerialSchedulerOptions
+  ): ZLinkActorSerialExecutor {
+    return new ZLinkActorSerialExecutor(actorId, sourceSpotId, options, this.scheduler);
+  }
+
   get isCurrentTurn(): boolean {
     return this.depth > 0 && isCurrentZLinkSpotSerialTurn(this);
   }