@zlink-systems/framework 0.26.0 → 0.28.0

package/src/runtime/streams/session-context.ts

@@ -1,11 +1,10 @@
-import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import type {
   ActorRef,
   RoutingId,
   Type,
-  ZLinkMessage,
   ZLinkActor,
   ZLinkBoundSession,
+  ZLinkMessage,
   ZLinkSessionActor,
   ZLinkSessionActors,
   ZLinkSessionClient,
@@ -17,18 +16,27 @@ import type {
   ZLinkSessionSendCall,
   ZLinkStream
 } from '../../contracts';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
-import { requireOneWayCompletion } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import { readZLinkDecoratorMetadata } from '../../contracts/Handlers/Attributes';
 import { throwIfAborted } from '../abort';
+import { releaseApplicationJobPermitBeforeHandler } from '../application-jobs/application-job-queue-scope';
 import { ZLinkConfigurationException } from '../configuration';
+import {
+  guardStateLaneCompletion,
+  isStructuralGuardEnabled,
+  trackDiagnosticCompletion
+} from '../execution/state-lane';
+import type { ServiceActorRef } from '../foundation/service-stateful-registry';
+import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
+import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
+import { type ZLinkSubmitResult, requireOneWayCompletion } from '../messaging/submission-result';
+
 import {
   messageToBytes,
-  type ZLinkStreamFrameHeader,
   ZLinkStreamHeaderFlags,
   ZLinkStreamMessageKind,
+  type ZLinkStreamFrameHeader,
   type ZLinkStreamReplyMessageKind
 } from './protocol';
 import {
@@ -36,15 +44,12 @@ import {
   DefaultZLinkSessionReplyCall,
   DefaultZLinkSessionSendCall
 } from './session-calls';
-import { ZLinkSessionRequestTracker, type ZLinkPendingSessionRequest } from './session-requests';
 import { ZLinkSessionLocalActorBindings } from './session-local-actors';
-import type { ServiceActorRef } from '../foundation/service-stateful-registry';
-import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
-import { releaseApplicationJobPermitBeforeHandler } from '../application-jobs/application-job-queue-scope';
+import { ZLinkSessionRequestTracker, type ZLinkPendingSessionRequest } from './session-requests';
 
 export interface ZLinkSessionContextStream extends ZLinkStream {
   writeRaw(payload: Message, flags?: number): boolean;
-  submitRaw(payload: Message, signal?: AbortSignal, timeoutMs?: number): Promise<ZLinkSubmitResult>;
+  submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
   enqueueActorBound?(actorSlot: number, actorId: string): Promise<void>;
   enqueueActorUnbound?(actorSlot: number): Promise<void>;
 }
@@ -83,7 +88,6 @@ interface ZLinkSessionContextRuntime {
   relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     dispatchHeader?: ZLinkStreamFrameHeader
   ): Promise<ZLinkSubmitResult>;
   notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void>;
@@ -533,30 +537,22 @@ export class DefaultZLinkSessionActor implements ZLinkSessionActor {
     this.currentRef = ref;
   }
 
-  async relay(payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
-  async relay(
-    dispatch: ZLinkSessionDispatchContext,
-    payload: ZLinkMessage,
-    signal?: AbortSignal
-  ): Promise<void>;
+  async relay(payload: ZLinkMessage): Promise<void>;
+  async relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage): Promise<void>;
   async relay(
     dispatchOrPayload: ZLinkSessionDispatchContext | ZLinkMessage,
-    payloadOrSignal?: ZLinkMessage | AbortSignal,
-    signal?: AbortSignal
+    selectedPayload?: ZLinkMessage
   ): Promise<void> {
     const dispatch = isSessionDispatchContext(dispatchOrPayload) ? dispatchOrPayload : undefined;
     let payload: ZLinkMessage;
-    let relaySignal: AbortSignal | undefined;
     let header: ZLinkStreamFrameHeader | undefined;
     if (dispatch === undefined) {
       payload = dispatchOrPayload as ZLinkMessage;
-      relaySignal = payloadOrSignal as AbortSignal | undefined;
     } else {
-      payload = payloadOrSignal as ZLinkMessage;
-      relaySignal = signal;
+      payload = selectedPayload as ZLinkMessage;
       header = sessionDispatchHeader(dispatch);
     }
-    const result = await this.runtime.relay(this, payload, relaySignal, header);
+    const result = await this.runtime.relay(this, payload, header);
     requireOneWayCompletion(
       result,
       'Session Actor relay',
@@ -652,3 +648,42 @@ function sameRetiredSession(
     left.retiredBindingGeneration === right.retiredBindingGeneration
   );
 }
+
+if (isStructuralGuardEnabled()) {
+  const controlsGetter = Object.getOwnPropertyDescriptor(
+    DefaultZLinkSessionContext.prototype,
+    'actorSlotControls'
+  )?.get;
+  if (controlsGetter !== undefined) {
+    Object.defineProperty(DefaultZLinkSessionContext.prototype, 'actorSlotControls', {
+      configurable: true,
+      get(this: DefaultZLinkSessionContext) {
+        const controls = controlsGetter.call(this) as
+          | {
+              enqueueBound(actorSlot: number, actorId: string): Promise<void>;
+              enqueueUnbound(actorSlot: number): Promise<void>;
+            }
+          | undefined;
+        if (controls === undefined) return undefined;
+        return {
+          enqueueBound: (actorSlot: number, actorId: string) =>
+            guardStateLaneCompletion(
+              trackDiagnosticCompletion(
+                controls.enqueueBound(actorSlot, actorId),
+                `binding transport bound ${actorId}`
+              ),
+              'binding transport completion'
+            ),
+          enqueueUnbound: (actorSlot: number) =>
+            guardStateLaneCompletion(
+              trackDiagnosticCompletion(
+                controls.enqueueUnbound(actorSlot),
+                `binding transport unbound ${actorSlot}`
+              ),
+              'binding transport completion'
+            )
+        };
+      }
+    });
+  }
+}

package/src/runtime/streams/session-requests.ts

@@ -1,3 +1,4 @@
+import { UINT64_MAX } from '@zlink-systems/stream-wire';
 import type { Message } from '../../contracts/Common/Message';
 import { copyMessage } from './stream-message-utils';
 
@@ -102,7 +103,7 @@ export class ZLinkSessionRequestTracker {
 
   private next(): bigint {
     do {
-      this.nextRequestSeq = (this.nextRequestSeq + 1n) & 0xffffffffffffffffn;
+      this.nextRequestSeq = (this.nextRequestSeq + 1n) & UINT64_MAX;
     } while (this.nextRequestSeq === 0n);
     return this.nextRequestSeq;
   }

package/src/runtime/streams/stream-binding-runtime-ports.ts

@@ -3,6 +3,7 @@ import type { ZLinkBackendActorSessionNode } from '../backend';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import type { DefaultZLinkSessionActor } from './session-context';
 import type { ZLinkBoundSessionResponseTarget } from './bound-session-response-target';
+import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
 
 export interface ZLinkStreamActorLookupPort {
   find(actorId: string): Promise<DefaultZLinkSessionActor | undefined>;
@@ -74,8 +75,28 @@ export interface ZLinkBoundSessionResponsePort {
   ): Promise<boolean>;
 }
 
+/**
+ * Session–Actor binding §5: the Session owner's registry snapshot travels with
+ * the bind confirmation so a same-node Actor owner installs the same identity a
+ * remote command 38 would carry.
+ */
+export interface ZLinkSessionBindingConfirmationOptions {
+  readonly waitForAcknowledgement?: boolean;
+  readonly binding?: ServiceStreamSessionBinding;
+}
+
+/** The exact Session binding identity a relocation validated (§8.1). */
+export interface ZLinkSessionBindingIdentity {
+  readonly sessionRid: string;
+  readonly bindingGeneration: bigint;
+}
+
 export interface ZLinkRemoteBoundSessionPort extends ZLinkStreamActorLifecyclePort {
-  disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
+  closeSessionBinding(
+    actorId: string,
+    expected: ZLinkSessionBindingIdentity,
+    signal?: AbortSignal
+  ): Promise<void>;
   sendLocalBoundSession(
     actorId: string,
     message: unknown,

package/src/runtime/streams/stream-frame-factory.ts

@@ -1,4 +1,5 @@
 import type { ZLinkStreamCompressionCodec, ZLinkStreamCompressionOptions } from '../../contracts';
+import { defaultMaxDecompressedPayloadSize } from '@zlink-systems/stream-wire';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkBufferMessage as ZLinkBindingMessage } from '../backend/runtime-message';
 import { currentOrCreateFlow } from '../diagnostics/flow-context';
@@ -18,8 +19,6 @@ import {
   type ZLinkStreamReplyMessageKind
 } from './protocol';
 
-const DEFAULT_MAX_DECOMPRESSED_STREAM_PAYLOAD_SIZE = 64 * 1024;
-
 export interface ZLinkStreamFramePayloadCodec {
   encode(
     payload: unknown,
@@ -245,7 +244,7 @@ function compressStreamPayload(
 export function decompressStreamPayload(
   payload: Uint8Array,
   codec: ZLinkStreamCompressionCodec | undefined,
-  maxDecompressedSize = DEFAULT_MAX_DECOMPRESSED_STREAM_PAYLOAD_SIZE
+  maxDecompressedSize = defaultMaxDecompressedPayloadSize
 ): Uint8Array {
   if (codec === undefined) {
     throw new Error('Compression codec is not configured.');

package/src/runtime/streams/stream-session-runtime.ts

@@ -1,61 +1,66 @@
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException
-} from '../framework-errors-internal';
-import type { ZLinkMessageSerializer, RoutingId, ZLinkSession } from '../../contracts';
+import type { RoutingId, ZLinkMessageSerializer, ZLinkSession } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import { ZLinkSocketNativeEventType } from '../diagnostics/internal-event-contracts';
+import { DEFAULT_SESSION_REPLACEMENT_CALLBACK_TIMEOUT_MS } from '../../contracts/Configuration/Registration';
 import {
-  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
   ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
   ZLinkDispatchErrorSurface,
-  ZLinkDispatchMessageKind
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import type { Message } from '../../contracts/Common/Message';
 import { throwIfAborted } from '../abort';
-import { ZLinkDispatchErrorReporter, ZLinkRouteDisconnectedError } from '../channels';
-import { boundSessionErrorPayload } from './bound-session-response-target';
-import { flowIfEnabled } from '../diagnostics';
-import type { ZLinkRuntimeMetrics } from '../diagnostics';
-import { wrapFrameworkPayloadMessage } from '../messaging/payload-codec';
+import { type ZLinkApplicationWorkClaim, shouldCompactBackingArray } from '../admission';
+
+import {
+  releaseApplicationJobPermitBeforeHandler,
+  runWithApplicationJobPermit
+} from '../application-jobs/application-job-queue-scope';
+import type {
+  ApplicationJobPermitPort,
+  ApplicationJobQueuePort
+} from '../application-jobs/contracts';
 import type {
+  ZLinkBackendReadablePoller,
   ZLinkBackendSocketMonitor,
   ZLinkBackendSocketMonitorEvent,
-  ZLinkBackendReadablePoller,
   ZLinkBackendStreamPacket,
   ZLinkBackendStreamSocket
 } from '../backend/contracts';
 import type { ZLinkMeshCompletionTable } from '../backend/mesh-completion-table';
+import { ZLinkDispatchErrorReporter, ZLinkRouteDisconnectedError } from '../channels';
+import { type ZLinkRuntimeMetrics, flowIfEnabled } from '../diagnostics';
+
+import { createInboundFlow, runWithFlow } from '../diagnostics/flow-context';
+import { ZLinkSocketNativeEventType } from '../diagnostics/internal-event-contracts';
+import { METRIC_NAMES } from '../diagnostics/runtime-metrics';
 import type { StreamSessionService } from '../foundation/service-runtime-contracts';
+import type { ServiceActorRef } from '../foundation/service-stateful-registry';
+import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
+import {
+  createInternalFrameworkException,
+  ZLinkFrameworkInternalErrorKind
+} from '../framework-errors-internal';
+import { wrapFrameworkPayloadMessage } from '../messaging/payload-codec';
+import { boundSessionErrorPayload } from './bound-session-response-target';
+import {
+  streamSessionIdFromRoutingId,
+  ZLinkManagedStream,
+  type ZLinkNativeSessionRoute
+} from './managed-stream';
 import {
   decodeStreamHeader,
   messageToBytes,
   streamCodecContentType,
-  type ZLinkStreamFrameHeader,
   ZLINK_STREAM_HEARTBEAT_PING,
   ZLINK_STREAM_HEARTBEAT_PONG,
   ZLinkStreamCloseReasonCode,
-  ZLinkStreamMessageKind
+  ZLinkStreamMessageKind,
+  type ZLinkStreamFrameHeader
 } from './protocol';
-import { createInboundFlow, runWithFlow } from '../diagnostics/flow-context';
-import {
-  streamSessionIdFromRoutingId,
-  ZLinkManagedStream,
-  type ZLinkNativeSessionRoute
-} from './managed-stream';
 import { createSessionDispatchContext, DefaultZLinkSessionContext } from './session-context';
 import { ZLinkSessionSerialExecutor } from './session-serial-executor';
-import type { ZLinkApplicationWorkClaim } from '../admission';
 import { ownedMessage } from './stream-message-utils';
-import type { ServiceActorRef } from '../foundation/service-stateful-registry';
-import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
-import type {
-  ApplicationJobPermitPort,
-  ApplicationJobQueuePort
-} from '../application-jobs/contracts';
-import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
-import { releaseApplicationJobPermitBeforeHandler } from '../application-jobs/application-job-queue-scope';
 
 const ZLINK_SEND_DONT_WAIT = 1;
 const ZLINK_RECV_DONT_WAIT = 1;
@@ -63,7 +68,6 @@ const ZLINK_STREAM_HEARTBEAT_INTERVAL_MS = 1_000;
 const ZLINK_STREAM_HEARTBEAT_TIMEOUT_MS = 5_000;
 const ZLINK_STREAM_APPLICATION_IDLE_TIMEOUT_MS = 30_000;
 const ZLINK_STREAM_RECEIVE_FRAME_BATCH_LIMIT = 64;
-const ZLINK_STREAM_ACTOR_BINDING_REPLACEMENT_CALLBACK_TIMEOUT_MS = 30_000;
 const ZLINK_STREAM_ACTOR_BINDING_REPLACEMENT_CLOSE_DELAY_MS = 100;
 const ZLINK_STREAM_MONITOR_IDLE_MIN_DELAY_MS = 1;
 const ZLINK_STREAM_MONITOR_IDLE_MAX_DELAY_MS = 20;
@@ -162,7 +166,7 @@ export class ZLinkStreamSessionRuntime {
   private metricsClosed = false;
   private readonly livenessClock: ZLinkStreamLivenessClock;
   private lastApplicationActivityAt = 0;
-  private awaitingPongSince: number | undefined;
+  private lastInboundFrameAt = 0;
   private livenessTimer: unknown;
 
   constructor(
@@ -243,6 +247,7 @@ export class ZLinkStreamSessionRuntime {
     terminalOwner?: ZLinkRetainedStreamOwner,
     applicationJobPermit?: ApplicationJobPermitPort
   ): void {
+    this.lastInboundFrameAt = Math.max(this.lastInboundFrameAt, this.livenessClock.now());
     let terminalReleased = false;
     const releaseTerminal = (): void => {
       if (terminalReleased) return;
@@ -389,7 +394,7 @@ export class ZLinkStreamSessionRuntime {
         }
         forcedClose = true;
         void this.close().catch((error) => this.options.onError?.(error));
-      }, this.options.replacementCallbackTimeoutMs ?? ZLINK_STREAM_ACTOR_BINDING_REPLACEMENT_CALLBACK_TIMEOUT_MS);
+      }, this.options.replacementCallbackTimeoutMs ?? DEFAULT_SESSION_REPLACEMENT_CALLBACK_TIMEOUT_MS);
 
       const callback = session.onActorBindingReplaced;
       if (callback === undefined) {
@@ -453,10 +458,12 @@ export class ZLinkStreamSessionRuntime {
       return;
     }
     this.connected = true;
-    this.lastApplicationActivityAt = this.livenessClock.now();
+    const connectedAt = this.livenessClock.now();
+    this.lastApplicationActivityAt = connectedAt;
+    this.lastInboundFrameAt = Math.max(this.lastInboundFrameAt, connectedAt);
     this.scheduleLivenessCheck();
-    this.options.metrics?.change('zlink.stream.connections.active', 1, { transport: 'tcp' });
-    this.options.metrics?.count('zlink.stream.connections.opened', 1, { transport: 'tcp' });
+    this.options.metrics?.change(METRIC_NAMES.StreamConnectionsActive, 1, { transport: 'tcp' });
+    this.options.metrics?.count(METRIC_NAMES.StreamConnectionsOpened, 1, { transport: 'tcp' });
     const session = await this.requireSession();
     await session.onConnected?.(this.context);
   }
@@ -650,7 +657,6 @@ export class ZLinkStreamSessionRuntime {
       return;
     }
     if (header.name === ZLINK_STREAM_HEARTBEAT_PONG) {
-      this.awaitingPongSince = undefined;
       return;
     }
     if (header.name === ZLINK_STREAM_HEARTBEAT_PING) {
@@ -691,10 +697,7 @@ export class ZLinkStreamSessionRuntime {
       );
       return;
     }
-    if (
-      this.awaitingPongSince !== undefined &&
-      now - this.awaitingPongSince >= ZLINK_STREAM_HEARTBEAT_TIMEOUT_MS
-    ) {
+    if (now - this.lastInboundFrameAt >= ZLINK_STREAM_HEARTBEAT_TIMEOUT_MS) {
       await this.closeForLiveness(
         ZLinkStreamCloseReasonCode.HeartbeatTimeout,
         'heartbeat_timeout',
@@ -703,7 +706,6 @@ export class ZLinkStreamSessionRuntime {
       return;
     }
     await this.stream.writeControl(ZLINK_STREAM_HEARTBEAT_PING);
-    this.awaitingPongSince ??= now;
     this.scheduleLivenessCheck();
   }
 
@@ -829,8 +831,8 @@ export class ZLinkStreamSessionRuntime {
   private async cleanup(): Promise<void> {
     if (this.connected && !this.metricsClosed) {
       this.metricsClosed = true;
-      this.options.metrics?.change('zlink.stream.connections.active', -1, { transport: 'tcp' });
-      this.options.metrics?.count('zlink.stream.connections.closed', 1, {
+      this.options.metrics?.change(METRIC_NAMES.StreamConnectionsActive, -1, { transport: 'tcp' });
+      this.options.metrics?.count(METRIC_NAMES.StreamConnectionsClosed, 1, {
         transport: 'tcp',
         close_reason: normalizeStreamCloseReason(this.closeReason)
       });
@@ -956,7 +958,6 @@ export class ZLinkStreamSessionNodeRuntime {
   private readonly unaddressedMonitorSessions: Array<string | undefined> = [];
   private unaddressedMonitorSessionHead = 0;
   private unaddressedMonitorSessionCount = 0;
-  private readonly disconnectedEndpoints = new Set<string>();
   private pendingEndpointlessDisconnect:
     | {
         readonly session: ZLinkStreamSessionRuntime;
@@ -1238,18 +1239,12 @@ export class ZLinkStreamSessionNodeRuntime {
     }
     switch (event.nativeEvent) {
       case ZLinkSocketNativeEventType.ConnectionReady:
+        if (!event.readyEdge) return;
         this.activityVersion += 1;
-        {
-          const endpointKey = streamMonitorEndpointKey(event.localAddr, event.remoteAddr);
-          if (this.disconnectedEndpoints.delete(endpointKey)) {
-            return;
-          }
-        }
         if (event.routingId === undefined) {
           const endpointKey = streamMonitorEndpointKey(event.localAddr, event.remoteAddr);
           const unaddressed = this.firstUnaddressedSession();
           if (unaddressed !== undefined) {
-            this.disconnectedEndpoints.delete(endpointKey);
             unaddressed.enqueueConnected(event.localAddr, event.remoteAddr);
             this.enqueueUnaddressedMonitorSession(unaddressed.stream.sessionId);
             return;
@@ -1272,7 +1267,6 @@ export class ZLinkStreamSessionNodeRuntime {
       case ZLinkSocketNativeEventType.Disconnected:
         {
           const endpointKey = streamMonitorEndpointKey(event.localAddr, event.remoteAddr);
-          this.disconnectedEndpoints.add(endpointKey);
           this.removePendingConnectionMetadata(endpointKey);
           const session = this.resolveMonitorSession(event);
           const error = new Error(`Stream disconnected: ${event.nativeEvent}/${event.value}`);
@@ -1350,8 +1344,10 @@ export class ZLinkStreamSessionNodeRuntime {
       this.pendingConnectionMetadata.length = 0;
       this.pendingConnectionMetadataHead = 0;
     } else if (
-      this.pendingConnectionMetadataHead >= 1024 &&
-      this.pendingConnectionMetadataHead * 2 >= this.pendingConnectionMetadata.length
+      shouldCompactBackingArray(
+        this.pendingConnectionMetadataHead,
+        this.pendingConnectionMetadata.length
+      )
     ) {
       this.pendingConnectionMetadata.splice(0, this.pendingConnectionMetadataHead);
       this.pendingConnectionMetadataHead = 0;
@@ -1379,8 +1375,10 @@ export class ZLinkStreamSessionNodeRuntime {
       this.unaddressedMonitorSessions.length = 0;
       this.unaddressedMonitorSessionHead = 0;
     } else if (
-      this.unaddressedMonitorSessionHead >= 1024 &&
-      this.unaddressedMonitorSessionHead * 2 >= this.unaddressedMonitorSessions.length
+      shouldCompactBackingArray(
+        this.unaddressedMonitorSessionHead,
+        this.unaddressedMonitorSessions.length
+      )
     ) {
       this.unaddressedMonitorSessions.splice(0, this.unaddressedMonitorSessionHead);
       this.unaddressedMonitorSessionHead = 0;

package/src/runtime/workers/index.ts

@@ -1,23 +1,24 @@
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException
-} from '../framework-errors-internal';
 import { Worker } from 'node:worker_threads';
-import type { ZLinkWorkerCall } from '../../contracts';
-import { ZLinkFrameworkException } from '../../contracts';
-import type { ZLinkWorkerOptions } from '../configuration';
-import { ZLinkConfigurationException } from '../configuration';
+import { type ZLinkWorkerCall, ZLinkFrameworkException } from '../../contracts';
+
 import {
-  defaultWorkerMaxThreads,
   DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-  DEFAULT_WORKER_MIN_THREADS
+  DEFAULT_WORKER_MIN_THREADS,
+  defaultWorkerMaxThreads
 } from '../../contracts/Configuration/InternalDefaults';
 import { createAbortError } from '../abort';
+import { shouldCompactBackingArray } from '../admission';
+import { type ZLinkWorkerOptions, ZLinkConfigurationException } from '../configuration';
+
 import {
   captureZLinkSpotSerialTurn,
   requireZLinkYieldTurn,
   type ZLinkSpotSerialTurn
 } from '../execution';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 
 export type ZLinkCpuWorkerWork<T> = (signal: AbortSignal) => T;
 export type ZLinkIoWorkerWork<T> = (signal: AbortSignal) => Promise<T>;
@@ -332,7 +333,7 @@ class ZLinkCpuWorkerPool {
     if (this.queueCount === 0) {
       this.queue.length = 0;
       this.queueHead = 0;
-    } else if (this.queueHead >= 1024 && this.queueHead * 2 >= this.queue.length) {
+    } else if (shouldCompactBackingArray(this.queueHead, this.queue.length)) {
       this.queue.splice(0, this.queueHead);
       this.queueHead = 0;
     }
@@ -351,7 +352,7 @@ class ZLinkCpuWorkerPool {
         while (this.queueHead < this.queue.length && this.queue[this.queueHead] === undefined) {
           this.queueHead += 1;
         }
-        if (this.queueHead >= 1024 && this.queueHead * 2 >= this.queue.length) {
+        if (shouldCompactBackingArray(this.queueHead, this.queue.length)) {
           this.queue.splice(0, this.queueHead);
           this.queueHead = 0;
         }

package/dist/runtime/actors/post-commit-actor-location.d.ts

@@ -1,19 +0,0 @@
-import type { RoutingId } from '../../contracts';
-import type { ZLinkLocationLifecycle } from '../locations';
-export interface ZLinkPostCommitActorLocationOptions {
-    readonly lifecycle: ZLinkLocationLifecycle;
-    readonly reportError?: (error: unknown) => void;
-    readonly signal?: AbortSignal;
-}
-export declare class ZLinkPostCommitActorLocation {
-    private readonly options;
-    private readonly lane;
-    private readonly queues;
-    private readonly tasks;
-    constructor(options: ZLinkPostCommitActorLocationOptions);
-    joinedEventually(actorType: string, actorId: string, meshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): void;
-    leftEventually(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): void;
-    private enqueue;
-    private run;
-    private completeCore;
-}

package/dist/runtime/actors/post-commit-actor-location.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkPostCommitActorLocation = void 0;
-const state_lane_1 = require("../execution/state-lane");
-const actor_retry_delay_1 = require("./actor-retry-delay");
-class ZLinkPostCommitActorLocation {
-    options;
-    lane = new state_lane_1.ZLinkStateLane();
-    queues = new Map();
-    tasks = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    joinedEventually(actorType, actorId, meshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        this.enqueue(actorId, () => this.options.lifecycle.notifyActorJoinedSpot(actorType, actorId, meshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration));
-    }
-    leftEventually(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        this.enqueue(actorId, () => this.options.lifecycle.notifyActorLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration));
-    }
-    enqueue(actorId, operation) {
-        const queue = this.queues.get(actorId) ?? { operations: [], head: 0, count: 0 };
-        queue.operations.push(operation);
-        queue.count += 1;
-        this.queues.set(actorId, queue);
-        if (this.tasks.has(actorId)) {
-            return;
-        }
-        let task;
-        task = this.run(actorId).finally(async () => await this.lane.run(() => {
-            if (this.tasks.get(actorId) === task) {
-                this.tasks.delete(actorId);
-            }
-        }));
-        this.tasks.set(actorId, task);
-    }
-    async run(actorId) {
-        const retryDelay = new actor_retry_delay_1.ZLinkActorRetryDelay();
-        while (this.options.signal?.aborted !== true) {
-            const queue = this.queues.get(actorId);
-            const operation = queue?.operations[queue.head];
-            if (queue === undefined || operation === undefined) {
-                this.queues.delete(actorId);
-                return;
-            }
-            try {
-                await operation();
-                await this.lane.run(() => this.completeCore(queue));
-                retryDelay.reset();
-            }
-            catch (error) {
-                this.options.reportError?.(error);
-                if (!(await retryDelay.wait(this.options.signal))) {
-                    return;
-                }
-            }
-        }
-    }
-    completeCore(queue) {
-        queue.operations[queue.head] = undefined;
-        queue.head += 1;
-        queue.count -= 1;
-        if (queue.count === 0) {
-            queue.operations.length = 0;
-            queue.head = 0;
-        }
-        else if (queue.head >= 1024 && queue.head * 2 >= queue.operations.length) {
-            queue.operations.splice(0, queue.head);
-            queue.head = 0;
-        }
-    }
-}
-exports.ZLinkPostCommitActorLocation = ZLinkPostCommitActorLocation;

package/dist/runtime/spots/spot-native-actor-join-admission.d.ts

@@ -1,26 +0,0 @@
-import type { ZLinkActor, ZLinkMessage, ZLinkMessageSerializer, ZLinkSpotActorJoinResult } from '../../contracts';
-import type { ZLinkBackendActorJoinRequest, ZLinkBackendSpot } from '../backend/contracts';
-import type { ZLinkDispatchErrorReporter } from '../channels';
-import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-interface ZLinkNativeActorJoinAdmissionTarget {
-    onActorJoin?(actorId: string, request: ZLinkMessage): Promise<ZLinkSpotActorJoinResult>;
-    onJoinedActor?(actor: ZLinkActor): Promise<void>;
-}
-interface ZLinkSpotNativeActorJoinAdmissionOptions {
-    readonly nativeSpot: ZLinkBackendSpot;
-    readonly serial: ZLinkSpotSerialTurnExecutor;
-    readonly resolveActor: (actorId: string) => ZLinkActor | undefined;
-    readonly getTarget: () => ZLinkNativeActorJoinAdmissionTarget;
-    readonly defaultAccept: boolean;
-    readonly commitAcceptedActor?: (actor: ZLinkActor) => Promise<void>;
-    readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
-    readonly dispatchErrors?: ZLinkDispatchErrorReporter;
-}
-export declare class ZLinkSpotNativeActorJoinAdmission {
-    private readonly options;
-    constructor(options: ZLinkSpotNativeActorJoinAdmissionOptions);
-    admit(request: ZLinkBackendActorJoinRequest, rejectClosing?: boolean): Promise<void>;
-    private decodeNativeActorJoinRequest;
-    private reportHandlerException;
-}
-export {};