@zlink-systems/framework 0.27.0 → 0.29.0

package/src/runtime/host/actor-packet-relay.ts

@@ -464,13 +464,12 @@ export class ZLinkActorPacketRelay {
   async relayActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
-    if (await this.relayRemoteActorPacket(actor, frameHeader, payload, signal)) {
+    if (await this.relayRemoteActorPacket(actor, frameHeader, payload)) {
       return true;
     }
-    return this.relayLocalActorPacket(actor, frameHeader, payload, signal);
+    return this.relayLocalActorPacket(actor, frameHeader, payload);
   }
 
   async confirmRemoteSessionBinding(
@@ -581,8 +580,7 @@ export class ZLinkActorPacketRelay {
   async relayRemoteActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
     const streamRuntime = this.options.streamBindingRuntime();
     const responseTarget = await streamRuntime.captureBoundSessionResponseTarget(actor);
@@ -671,8 +669,7 @@ export class ZLinkActorPacketRelay {
         remoteAddress.routerChannelId,
         String(remoteAddress.targetNodeRid),
         ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        request,
-        signal
+        request
       );
       if (result.status !== ZLinkSubmitStatus.Submitted) {
         throw new Error(`Actor '${actor.actorId}' remote node relay was not admitted.`);
@@ -681,8 +678,7 @@ export class ZLinkActorPacketRelay {
     }
     if (frameHeader.kind === ZLinkStreamMessageKind.Send || frameHeader.requestSeq === undefined) {
       await this.options.routeTransport.sendToSpot(remoteAddress, request, {
-        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        signal
+        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
       });
       return true;
     }
@@ -702,8 +698,7 @@ export class ZLinkActorPacketRelay {
           throw new Error(`Remote actor packet relay reply was empty for '${actor.actorId}'.`);
         }
         return JSON.parse(parts[0].getString('utf8')) as typeof reply;
-      },
-      signal
+      }
     );
     const actorPacketTarget = this.targets.decodeFromWire(reply.actorPacketTarget);
     const currentStoredRoute = await streamRuntime.sessionRouteFence(actor.actorId);
@@ -863,10 +858,8 @@ export class ZLinkActorPacketRelay {
   private async relayLocalActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
-    void signal;
     const state = this.options.actorManager()?.getState(actor.actorId);
     const spotId = state?.spotId as RoutingId | undefined;
     const hasActiveSpot =

package/src/runtime/host/index.ts

@@ -221,8 +221,6 @@ const HOST_SHUTDOWN_POLL_INTERVAL_MS = 100;
 const HANDOFF_ACCEPTANCE_POLL_INTERVAL_MS = 10;
 const DEFAULT_HOST_CONTROL_TIMEOUT_MS = 30_000;
 
-const LEGACY_MESH_SEND_TIMEOUT_MS = 1000;
-
 export interface ZLinkFrameworkRuntimeLifecycle {
   readonly isStarted: boolean;
   readonly locationRuntimeQuery?: ZLinkLocationRuntimeQuery;
@@ -367,25 +365,6 @@ export class ZLinkFrameworkRuntimeHost
     );
     this.meshRouters = new MeshRouterResolver(options.registration);
     this.spotRouterChannelIdForMesh = this.meshRouters.spotRouterChannelIdByMesh();
-    const sendTimeoutMsForSpotMesh = (meshName: string): number =>
-      options.registration.spotNodes.get(meshName)?.router?.sendTimeoutMs ??
-      LEGACY_MESH_SEND_TIMEOUT_MS;
-    const sendTimeoutMsForSpotRouteChannel = (routeChannelId: string): number => {
-      const routeChannel = options.registration.routeChannelOptions.get(routeChannelId);
-      if (routeChannel !== undefined) {
-        return routeChannel.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS;
-      }
-      return sendTimeoutMsForSpotMesh(routeChannelId);
-    };
-    const defaultSpotSendTimeoutMs = Math.max(
-      LEGACY_MESH_SEND_TIMEOUT_MS,
-      ...[...options.registration.spotNodes.values()].map(
-        (node) => node.router?.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS
-      ),
-      ...[...options.registration.routeChannelOptions.values()].map(
-        (route) => route.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS
-      )
-    );
     this.routeTransport = new ZLinkRuntimeRouteTransport(
       () => this.channelRuntime,
       (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId),
@@ -410,9 +389,6 @@ export class ZLinkFrameworkRuntimeHost
       completions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
       codecs: { serializers: options.registration.messageSerializers },
       defaultRequestTimeoutMs: options.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
-      defaultSendTimeoutMs: defaultSpotSendTimeoutMs,
-      sendTimeoutMsForMesh: sendTimeoutMsForSpotMesh,
-      sendTimeoutMsForRouteChannel: sendTimeoutMsForSpotRouteChannel,
       dispatchErrors: this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink)
     });
     this.locationOwner = new ZLinkLocationRuntimeOwner({
@@ -463,8 +439,8 @@ export class ZLinkFrameworkRuntimeHost
               options
             );
       },
-      relay: (actor, header, payload, signal) =>
-        this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload, signal),
+      relay: (actor, header, payload) =>
+        this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload),
       notifyDisconnected: (actor, signal) =>
         this.boundSessionRelay.actorPackets.notifyBoundActorDisconnected(actor, signal)
     });

package/src/runtime/host/instance-activation-authority.ts

@@ -16,7 +16,7 @@ import type {
   ZLinkAuthorityStore,
   ZLinkObjectCreationStore
 } from '../locations/internal-store-contracts';
-import { ZLinkFrameworkException } from '../../contracts';
+import { ZLinkFrameworkErrorKind, ZLinkFrameworkException } from '../../contracts';
 import {
   decodeServiceInstanceAuthorityPayload,
   decodeServiceReadySpotAuthority,
@@ -46,7 +46,6 @@ import {
 
 const CREATION_REQUEST_RETENTION_MS = 24 * 60 * 60 * 1_000;
 const MAX_CREATION_REQUEST_BYTES = 1024 * 1024;
-const ACTIVATION_JOIN_POLL_INTERVAL_MS = 10;
 
 interface PendingReservation {
   readonly reservationId: string;
@@ -115,87 +114,81 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
     }
     let reserved: Awaited<ReturnType<ZLinkObjectCreationStore['reserve']>>;
     try {
-      for (;;) {
-        reserved = await this.options.store.reserve(
-          {
-            key: { kind: 'instance_spot', globalId: target.targetSpotId },
-            intent: {
-              stableType: target.stableType,
-              requestContentReference: stored.reference.value,
-              requestSha256: requestHash,
-              requestEncodedSize: BigInt(requestBytes.byteLength)
-            },
-            target: {
-              meshName: this.options.meshName,
-              nodeRid: target.targetNodeRid,
-              nodeLifecycleGeneration: target.targetNodeGeneration,
-              owner
-            },
-            creatingPayload: encodeServiceInstanceAuthorityPayload({
-              state: 'coldActivating',
+      reserved = await this.options.store.reserve(
+        {
+          key: { kind: 'instance_spot', globalId: target.targetSpotId },
+          intent: {
+            stableType: target.stableType,
+            requestContentReference: stored.reference.value,
+            requestSha256: requestHash,
+            requestEncodedSize: BigInt(requestBytes.byteLength)
+          },
+          target: {
+            meshName: this.options.meshName,
+            nodeRid: target.targetNodeRid,
+            nodeLifecycleGeneration: target.targetNodeGeneration,
+            owner
+          },
+          creatingPayload: encodeServiceInstanceAuthorityPayload({
+            state: 'coldActivating',
+            stableType: target.stableType,
+            spotId: target.targetSpotId,
+            ownerId: owner.ownerId,
+            ownerLeaseGeneration: owner.leaseGeneration,
+            ownerMeshName: this.options.meshName,
+            ownerNodeRid: target.targetNodeRid,
+            ownerNodeGeneration: target.targetNodeGeneration
+          }),
+          capacity: {
+            actors: 0,
+            spots: 1,
+            spotType: {
+              objectKind: 'instance_spot',
               stableType: target.stableType,
-              spotId: target.targetSpotId,
-              ownerId: owner.ownerId,
-              ownerLeaseGeneration: owner.leaseGeneration,
-              ownerMeshName: this.options.meshName,
-              ownerNodeRid: target.targetNodeRid,
-              ownerNodeGeneration: target.targetNodeGeneration
-            }),
-            capacity: {
-              actors: 0,
-              spots: 1,
-              spotType: {
-                objectKind: 'instance_spot',
-                stableType: target.stableType,
-                count: 1
-              }
+              count: 1
             }
-          },
-          undefined,
-          activation.deadlineUnixMs
-        );
-        if (reserved.kind !== 'alreadyExists') break;
-        this.options.metrics?.recordInstanceSpotClaimConflict(
-          this.options.meshName,
-          target.stableType,
-          'already_exists'
-        );
-        await this.deleteOrphan(stored.reference);
-        return readyExisting(reserved.current, target);
-      }
+          }
+        },
+        undefined,
+        activation.deadlineUnixMs
+      );
     } catch (error) {
       await this.deleteOrphan(stored.reference);
       throw error;
     }
-    if (
-      reserved.kind === 'conflict' &&
-      reserved.current.kind === 'snapshot' &&
-      reserved.current.allocation.objectKind === 'instance_spot' &&
-      reserved.current.allocation.stableType === target.stableType &&
-      reserved.current.allocation.state === 'reserved'
-    ) {
-      this.options.metrics?.recordInstanceSpotClaimConflict(
-        this.options.meshName,
-        target.stableType,
-        'activation_in_progress'
-      );
-      await this.deleteOrphan(stored.reference);
-      return await this.awaitConcurrentActivation(target, activation.deadlineUnixMs);
-    }
     if (reserved.kind !== 'reserved') {
+      const conflictReason =
+        reserved.kind === 'alreadyExists'
+          ? 'already_exists'
+          : reserved.kind === 'conflict' &&
+              reserved.current.kind === 'snapshot' &&
+              reserved.current.allocation.objectKind === 'instance_spot' &&
+              reserved.current.allocation.stableType === target.stableType &&
+              reserved.current.allocation.state === 'reserved'
+            ? 'activation_in_progress'
+            : reserved.kind;
       this.options.metrics?.recordInstanceSpotClaimConflict(
         this.options.meshName,
         target.stableType,
-        reserved.kind
+        conflictReason
       );
       await this.deleteOrphan(stored.reference);
+      if (reserved.kind === 'typeMismatch') {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.SpotTypeMismatch,
+          `Instance activation reservation failed: ${reserved.kind}.`
+        );
+      }
       if (reserved.kind === 'placementCapacityExhausted') {
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted,
           `Instance Spot placement capacity is exhausted for '${String(target.targetSpotId)}'.`
         );
       }
-      throw new Error(`Instance activation reservation failed: ${reserved.kind}.`);
+      throw new ZLinkFrameworkException(
+        ZLinkFrameworkErrorKind.Unavailable,
+        `Instance activation reservation failed: ${reserved.kind}.`
+      );
     }
     const reservation: ServiceInstanceActivationReservation = {
       attempt: reserved.creating.objectGeneration,
@@ -455,34 +448,6 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
     }
   }
 
-  private async awaitConcurrentActivation(
-    target: ServiceInstanceActivationTarget,
-    deadlineUnixMs: bigint
-  ): Promise<Extract<ServiceInstanceAuthorityRead, { readonly kind: 'ready' }>> {
-    const key = authorityKey(target.targetSpotId);
-    const deadlineMs = performance.now() + Number(deadlineUnixMs - BigInt(Date.now()));
-    while (performance.now() <= deadlineMs) {
-      const current = await this.options.store.readAuthority(key);
-      if (current.kind === 'snapshot') {
-        if (
-          current.allocation.objectKind !== 'instance_spot' ||
-          current.allocation.stableType !== target.stableType
-        ) {
-          throw new Error('Concurrent Instance activation resolved to a different Spot type.');
-        }
-        if (current.allocation.state === 'active') {
-          return readyExisting(current, target);
-        }
-      } else {
-        throw new Error('Concurrent Instance activation ended before the Ready barrier.');
-      }
-      await waitForActivationJoin(deadlineMs);
-    }
-    throw new Error(
-      `Concurrent Instance activation for '${target.targetSpotId}' did not reach Ready before deadline.`
-    );
-  }
-
   private requirePending(reservation: ServiceInstanceActivationReservation): PendingReservation {
     const pending = this.pending.get(reservation.token);
     if (pending === undefined || pending.creating.objectGeneration !== reservation.attempt) {
@@ -539,38 +504,6 @@ function readyRead(
   return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
 }
 
-function readyExisting(
-  snapshot: ZLinkAuthoritySnapshot,
-  target: ServiceInstanceActivationTarget
-): Extract<ServiceInstanceAuthorityRead, { readonly kind: 'ready' }> {
-  const decoded =
-    decodeServiceReadySpotAuthority(snapshot.payload) ??
-    decodeServiceClosingSpotAuthority(snapshot.payload);
-  if (
-    decoded?.kind !== 'instance_spot' ||
-    decoded.stableType !== target.stableType ||
-    decoded.spotId !== target.targetSpotId ||
-    snapshot.allocation.objectKind !== 'instance_spot' ||
-    snapshot.allocation.state !== 'active' ||
-    decoded.ownerId !== snapshot.ownerId ||
-    decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration ||
-    decoded.ownerMeshName !== snapshot.allocation.descriptor.meshName ||
-    decoded.ownerNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration ||
-    !routingIdsEqual(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid)
-  ) {
-    throw new Error('Existing Instance authority is not a matching Ready allocation.');
-  }
-  return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
-}
-
-async function waitForActivationJoin(deadlineMs: number): Promise<void> {
-  const remaining = deadlineMs - performance.now();
-  if (remaining <= 0) return;
-  await new Promise<void>((resolve) => {
-    setTimeout(resolve, Math.min(ACTIVATION_JOIN_POLL_INTERVAL_MS, remaining));
-  });
-}
-
 function requireCommitIdentity(
   target: ServiceInstanceActivationTarget,
   reservation: ServiceInstanceActivationReservation,

package/src/runtime/host/remote-bound-session-relay.ts

@@ -642,8 +642,7 @@ export class ZLinkRemoteBoundSessionRelay {
         packetName,
         requestSeq,
         response,
-        replyOptions,
-        signal
+        replyOptions
       );
       return;
     }
@@ -698,8 +697,7 @@ export class ZLinkRemoteBoundSessionRelay {
         packetName,
         requestSeq,
         error,
-        metadata,
-        signal
+        metadata
       );
       return;
     }
@@ -731,8 +729,7 @@ export class ZLinkRemoteBoundSessionRelay {
     packetName: string,
     requestSeq: bigint,
     message: unknown,
-    replyOptions: ZLinkActorResponseOptions,
-    signal?: AbortSignal
+    replyOptions: ZLinkActorResponseOptions
   ): Promise<void> {
     const actorPacketTarget = encodeRemoteActorPacketTarget(
       this.options.actorPacketTargetForState(actorId)
@@ -747,8 +744,7 @@ export class ZLinkRemoteBoundSessionRelay {
         metadata: replyOptions.metadata,
         compressPayload: replyOptions.compressPayload,
         actorPacketTarget
-      }),
-      signal
+      })
     );
   }
 
@@ -758,8 +754,7 @@ export class ZLinkRemoteBoundSessionRelay {
     packetName: string,
     requestSeq: bigint,
     error: unknown,
-    metadata: ReadonlyMap<string, string>,
-    signal?: AbortSignal
+    metadata: ReadonlyMap<string, string>
   ): Promise<void> {
     await this.sendRemoteBoundSessionControl(
       target,
@@ -772,15 +767,13 @@ export class ZLinkRemoteBoundSessionRelay {
         actorPacketTarget: encodeRemoteActorPacketTarget(
           this.options.actorPacketTargetForState(actorId)
         )
-      }),
-      signal
+      })
     );
   }
 
   private async sendRemoteBoundSessionControl(
     target: ZLinkRemoteBoundSessionTarget,
-    payload: Record<string, unknown>,
-    signal?: AbortSignal
+    payload: Record<string, unknown>
   ): Promise<void> {
     const packetName = payload.packetName;
     if (typeof packetName !== 'string') {
@@ -796,8 +789,7 @@ export class ZLinkRemoteBoundSessionRelay {
       target.routerChannelId,
       String(target.targetNodeRid),
       packetName,
-      payload,
-      signal
+      payload
     );
     if (result.status !== ZLinkSubmitStatus.Submitted) {
       throw new Error(