@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/streams/session-actor-coordinator.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS } from './bound-actor-relay-sender';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
@@ -13,6 +14,7 @@ import {
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 import { ZLinkManagedStream } from './managed-stream';
 import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
+import type { ZLinkSessionBindingConfirmationOptions } from './stream-binding-runtime-ports';
 
 export interface ZLinkSessionActorCoordinatorOptions {
   readonly actorBindTimeoutMs?: number;
@@ -31,7 +33,7 @@ export interface ZLinkSessionActorCoordinatorOptions {
     actor: ActorRef,
     sessionRid: ActorRef['nodeRid'],
     signal?: AbortSignal,
-    options?: { readonly waitForAcknowledgement?: boolean }
+    options?: ZLinkSessionBindingConfirmationOptions
   ) => Promise<void>;
   readonly errorSink?: () =>
     | {
@@ -181,7 +183,13 @@ export class ZLinkSessionActorCoordinator {
         boundActorRef,
         this.actorBindingRoutingId(context),
         undefined,
-        { waitForAcknowledgement }
+        {
+          waitForAcknowledgement,
+          binding:
+            context.stream instanceof ZLinkManagedStream
+              ? context.stream.actorBinding(actorRef.actorId)
+              : undefined
+        }
       );
       const reportFailure = (error: unknown) => {
         // A fire-and-forget route update retains the already-current binding;
@@ -204,7 +212,7 @@ export class ZLinkSessionActorCoordinator {
             if (context.stream instanceof ZLinkManagedStream) {
               await context.stream.unbindActor(
                 actorRef.actorId,
-                this.options.actorBindTimeoutMs ?? 2000
+                this.options.actorBindTimeoutMs ?? DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS
               );
             }
           } catch (cleanupError) {
@@ -354,7 +362,11 @@ export class ZLinkSessionActorCoordinator {
             true
           );
         }
-        route.actor.updateRef(normalizedActorRef);
+        // A location refresh never changes the route's Session binding
+        // generation; the native bind owns it.
+        route.actor.updateRef(
+          withBindingGeneration(normalizedActorRef, bindingGenerationOf(route.actor.ref), undefined)
+        );
         if (authorityFence !== undefined) {
           await this.routes.updateAuthorityFence(normalizedActorRef.actorId, authorityFence);
         }
@@ -463,7 +475,7 @@ export class ZLinkSessionActorCoordinator {
     try {
       await context.stream.bindActor(
         actorRef,
-        this.options.actorBindTimeoutMs ?? 2000,
+        this.options.actorBindTimeoutMs ?? DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS,
         signal,
         context.actorBindingReplacedHandler,
         authorityFence

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

@@ -1,14 +1,15 @@
-import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import type {
   ZLinkBoundSessionSendCall,
   ZLinkSessionReplyCall,
   ZLinkSessionSendCall
 } from '../../contracts';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
-import { requireOneWayCompletion } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
+import { ZLINK_MAX_SEND_TIMEOUT_MS } from '../../contracts/Configuration/SendTimeoutValidation';
 import { throwIfAborted } from '../abort';
 import { ZLinkConfigurationException } from '../configuration';
+import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
+import { type ZLinkSubmitResult, requireOneWayCompletion } from '../messaging/submission-result';
+
 import {
   ensureSingleSubmit,
   resolvePacketName,
@@ -135,9 +136,9 @@ export class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
   }
 
   timeout(timeoutMs: number): this {
-    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647) {
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > ZLINK_MAX_SEND_TIMEOUT_MS) {
       throw new ZLinkConfigurationException(
-        'STREAM session send timeout must be an integer from 1 through 2147483647 milliseconds.'
+        `STREAM session send timeout must be an integer from 1 through ${ZLINK_MAX_SEND_TIMEOUT_MS} milliseconds.`
       );
     }
     this.selectedTimeoutMs = timeoutMs;

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,11 +44,8 @@ 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;
@@ -652,3 +657,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/session-serial-executor.ts

@@ -55,8 +55,8 @@ export class ZLinkSessionSerialExecutor {
     }
     const boundWork = bindApplicationJobPermit(work);
     return hasApplicationJobPermit()
-      ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'lifecycle' })
-      : this.scheduler.submit(boundWork, { lane: 'lifecycle' });
+      ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'application' })
+      : this.scheduler.submit(boundWork, { lane: 'application' });
   }
 
   private submit(

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/deferred-join-accepted-journal.d.ts

@@ -1,47 +0,0 @@
-import type { ActorRef, ZLinkActor, ZLinkActorJoinOperationId, ZLinkBlobReference, ZLinkMessageSerializer, ZLinkRelocationStore } from '../../contracts';
-import type { ZLinkAuthoritySnapshot } from '../locations/internal-location-contracts';
-import type { ZLinkAuthorityStore } from '../locations/internal-store-contracts';
-export type ZLinkDeferredJoinDeliveryCursor = 'prepared' | 'committed' | 'delivered';
-export interface ZLinkDeferredJoinAcceptedRoot {
-    readonly authority: ZLinkAuthoritySnapshot;
-    readonly reference: ZLinkBlobReference;
-    readonly checksumCrc32c: number;
-    readonly operationId: ZLinkActorJoinOperationId;
-    readonly actor: ActorRef;
-    readonly rawReply: Buffer;
-    readonly replyContentType?: string;
-    readonly cursor: ZLinkDeferredJoinDeliveryCursor;
-}
-export interface ZLinkDeferredJoinRootIdentity {
-    readonly authorityKey: string;
-    readonly objectKind: 'actor' | 'user_spot' | 'instance_spot';
-    readonly objectGeneration: bigint;
-    readonly aggregateId: string;
-    readonly aggregateGeneration: bigint;
-}
-/** Identifies whether an authority slot points at a deferred Join journal root. */
-export declare function isDeferredJoinAcceptedRootPublication(relocation: ZLinkRelocationStore, reference: string, checksumCrc32c: number, expected: ZLinkDeferredJoinRootIdentity, signal?: AbortSignal): Promise<boolean>;
-/**
- * Keeps a cross-node Accepted Join completion under the Actor authority.
- * Every cursor transition writes and verifies a new immutable root before the
- * authority CAS. A failed callback leaves the committed root available for the
- * next target Actor mailbox retry.
- */
-export declare class ZLinkDeferredJoinAcceptedJournal {
-    private readonly authority;
-    private readonly relocation;
-    private readonly messageSerializers?;
-    constructor(authority: ZLinkAuthorityStore, relocation: ZLinkRelocationStore, messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer> | undefined);
-    prepare(actorId: string, operationId: ZLinkActorJoinOperationId, actor: ActorRef, rawReply: Uint8Array, replyContentType?: string, signal?: AbortSignal, canonicalInventoryDigest?: string): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    recover(actorId: string, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot | undefined>;
-    markCommitted(root: ZLinkDeferredJoinAcceptedRoot, actor?: ActorRef, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    markDelivered(root: ZLinkDeferredJoinAcceptedRoot, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    discardPrepared(root: ZLinkDeferredJoinAcceptedRoot, signal?: AbortSignal): Promise<void>;
-    deliver(root: ZLinkDeferredJoinAcceptedRoot, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    private releaseDelivered;
-    private moveCursor;
-    private readPublished;
-    private storeRoot;
-    private storeCanonicalRoot;
-    private deleteBestEffort;
-}