@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/spots/spot-activation-registry.ts

@@ -1,15 +1,22 @@
+import {
+  type RoutingId,
+  type Type,
+  type ZLinkSpot,
+  type ZLinkSpotInfo,
+  ZLinkSpotCloseReason,
+  ZLinkSpotCreateState
+} from '../../contracts';
+
+import { createAbortError } from '../abort';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
 } from '../framework-errors-internal';
-import type { RoutingId, Type, ZLinkSpot, ZLinkSpotInfo } from '../../contracts';
-import type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
-import { ZLinkSpotCreateState, ZLinkSpotCloseReason } from '../../contracts';
 import type { ZLinkSpotActivation } from './spot-activation-state';
-import { ZLinkSpotCloseOccupiedError } from './spot-activation-state';
-import { ZLinkConfigurationException } from '../configuration';
-import { createAbortError } from '../abort';
 import { ZLinkSpotLifecycleMetrics } from './spot-lifecycle-metrics';
+import type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
+const DEFAULT_ACTIVE_ACTIVATION_BATCH_SIZE = 64;
+
 export { ZLinkSpotActivation } from './spot-activation-state';
 
 interface PendingSpotActivation {
@@ -55,40 +62,21 @@ export class ZLinkSpotActivationRegistry {
 
   resolve(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
     const key = spotActivationKey(meshName, spotId);
-    return this.closing.has(key) || this.failedClose.has(key) || this.staged.has(key)
-      ? undefined
-      : this.activations.get(key);
+    return this.staged.has(key) ? undefined : this.activations.get(key);
   }
 
   resolveUnique(spotId: RoutingId): ZLinkSpotActivation | undefined {
     const matches = [...this.activations.values()].filter(
       (activation) =>
         String(activation.spotId) === String(spotId) &&
-        !this.staged.has(spotActivationKey(activation.meshName, activation.spotId)) &&
-        !this.closing.has(spotActivationKey(activation.meshName, activation.spotId)) &&
-        !this.failedClose.has(spotActivationKey(activation.meshName, activation.spotId))
+        !this.staged.has(spotActivationKey(activation.meshName, activation.spotId))
     );
     return matches.length === 1 ? matches[0] : undefined;
   }
 
   has(meshName: string, spotId: RoutingId): boolean {
     const key = spotActivationKey(meshName, spotId);
-    return (
-      !this.staged.has(key) &&
-      !this.closing.has(key) &&
-      !this.failedClose.has(key) &&
-      this.activations.has(key)
-    );
-  }
-
-  canClose(meshName: string, spotId: RoutingId): boolean {
-    const key = spotActivationKey(meshName, spotId);
-    return (
-      !this.staged.has(key) &&
-      !this.closing.has(key) &&
-      !this.failedClose.has(key) &&
-      this.activations.get(key)?.canClose() === true
-    );
+    return !this.staged.has(key) && this.activations.has(key);
   }
 
   list(meshName: string): readonly ZLinkSpotInfo[] {
@@ -96,7 +84,7 @@ export class ZLinkSpotActivationRegistry {
       .filter((activation) => {
         if (activation.meshName !== meshName) return false;
         const key = spotActivationKey(activation.meshName, activation.spotId);
-        return !this.staged.has(key) && !this.closing.has(key) && !this.failedClose.has(key);
+        return !this.staged.has(key);
       })
       .map((activation) => String(activation.spotId))
       .sort((left, right) => left.localeCompare(right))
@@ -107,11 +95,25 @@ export class ZLinkSpotActivationRegistry {
     return [...this.activations.values()];
   }
 
+  activationForClose(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
+    return this.activations.get(spotActivationKey(meshName, spotId));
+  }
+
+  finishClose(meshName: string, spotId: RoutingId): void {
+    const key = spotActivationKey(meshName, spotId);
+    if (this.activations.delete(key)) this.lifecycleMetrics.closed('user');
+    this.staged.delete(key);
+    this.failedClose.delete(key);
+    this.resolveEmptyWaiters();
+  }
+
   hasActiveActivations(): boolean {
     return this.activations.size > 0;
   }
 
-  nextActiveActivationBatch(limit = 64): readonly ZLinkSpotActivation[] {
+  nextActiveActivationBatch(
+    limit: number = DEFAULT_ACTIVE_ACTIVATION_BATCH_SIZE
+  ): readonly ZLinkSpotActivation[] {
     if (!Number.isInteger(limit) || limit <= 0)
       throw new RangeError('Activation scan limit must be positive.');
     if (this.activations.size === 0) {
@@ -215,30 +217,14 @@ export class ZLinkSpotActivationRegistry {
     }
     const operation = {} as ZLinkSpotCloseOperation;
     let completed = false;
-    let occupiedAfterQuiescence = false;
     const ready = Promise.resolve()
       .then(() => close(activation))
       .then(() => {
         completed = true;
       })
-      .catch((error: unknown) => {
-        // The seal's post-quiescence recheck (spot-activation.ts
-        // closeAfterSeal) found a new join and released the seal instead of
-        // closing. The activation is already back to normal operation, so
-        // this is a "did not close" outcome, not a close failure.
-        if (error instanceof ZLinkSpotCloseOccupiedError) {
-          occupiedAfterQuiescence = true;
-          return;
-        }
-        throw error;
-      })
       .finally(() => {
         if (this.closing.get(key) === operation) {
           this.closing.delete(key);
-          if (occupiedAfterQuiescence) {
-            this.resolveEmptyWaiters();
-            return;
-          }
           if (completed || resourcesReleased(activation)) {
             this.activations.delete(key);
             this.staged.delete(key);
@@ -250,7 +236,7 @@ export class ZLinkSpotActivationRegistry {
           this.resolveEmptyWaiters();
         }
       })
-      .then(() => !occupiedAfterQuiescence);
+      .then(() => true);
     Object.assign(operation, { activation, ready, started: true });
     this.closing.set(key, operation);
     return operation;
@@ -263,34 +249,19 @@ export class ZLinkSpotActivationRegistry {
     create: () => Promise<ZLinkLocalSpotCreateResult>
   ): ZLinkSpotActivationOperation {
     const key = spotActivationKey(meshName, spotId);
-    const closing = this.closing.get(key);
-    if (closing !== undefined) {
-      return {
-        owner: false,
-        ready: closing.ready
-          .catch(() => undefined)
-          .then(() => this.getOrBegin(meshName, spotType, spotId, create).ready)
-      };
-    }
-    if (this.failedClose.has(key)) {
-      return {
-        owner: false,
-        ready: Promise.reject(
-          new ZLinkConfigurationException(`Spot '${spotId}' cleanup has not completed.`)
-        )
-      };
-    }
     const existing = this.activations.get(key);
     if (existing !== undefined) {
-      if (existing.spotType !== spotType) {
-        throw createInternalFrameworkException(
-          ZLinkFrameworkInternalErrorKind.SpotTypeMismatch,
-          `Spot '${spotId}' already exists with a different spot type.`
-        );
-      }
       return {
         owner: false,
-        ready: Promise.resolve({ spotId, state: ZLinkSpotCreateState.Existing })
+        ready: existing.serial.execute(() => {
+          if (existing.spotType !== spotType) {
+            throw createInternalFrameworkException(
+              ZLinkFrameworkInternalErrorKind.SpotTypeMismatch,
+              `Spot '${spotId}' already exists with a different spot type.`
+            );
+          }
+          return { spotId, state: ZLinkSpotCreateState.Existing };
+        })
       };
     }
 

package/src/runtime/spots/spot-activation-state.ts

@@ -25,6 +25,7 @@ import type { ZLinkTimerRelocationState } from './spot-timer';
 export type ZLinkSpotActivationDomain =
   | {
       readonly kind: 'user';
+      readonly objectGeneration?: bigint;
       readonly executionMode: ZLinkUserSpotExecutionMode;
       readonly relocationCoordinationMode: ZLinkSpotRelocationCoordinationMode;
     }
@@ -56,19 +57,6 @@ export interface ZLinkSpotRelocationCapture {
   readonly timers: readonly ZLinkTimerRelocationState[];
 }
 
-/**
- * Internal signal that a close seal reached quiescence but the activation
- * became occupied again while it waited (an actor join queued ahead of the
- * close finished after the eager pre-seal occupancy check). This is not a
- * close failure: the seal is released, the Spot stays open, and the caller
- * reports `close(...)` as `false` instead of throwing.
- */
-export class ZLinkSpotCloseOccupiedError extends Error {
-  constructor(spotId: RoutingId) {
-    super(`Spot '${String(spotId)}' became occupied while its close seal reached quiescence.`);
-  }
-}
-
 export class ZLinkSpotActivation {
   readonly meshName: string;
   readonly spotId: RoutingId;
@@ -126,7 +114,7 @@ export class ZLinkSpotActivation {
   }
 
   get objectGeneration(): bigint | undefined {
-    return this.domain.kind === 'instance' ? this.domain.objectGeneration : undefined;
+    return this.domain.objectGeneration;
   }
 
   get executionMode(): ZLinkUserSpotExecutionMode {
@@ -274,8 +262,8 @@ export class ZLinkSpotActivation {
     return this.serialExecutor.admitActorDurablePrefix(actorId, records);
   }
 
-  sealExecution(): ZLinkExecutionBarrierSeal {
-    return this.executionBarrier.seal();
+  sealExecution(kind: ZLinkExecutionBarrierSeal['kind'] = 'relocation'): ZLinkExecutionBarrierSeal {
+    return this.executionBarrier.seal(kind);
   }
 
   waitForExecutionQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void> {