@zlink-systems/framework 0.26.0 → 0.27.0

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 {};

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

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkSpotNativeActorJoinAdmission = void 0;
-const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
-const runtime_message_1 = require("../backend/runtime-message");
-const payload_codec_1 = require("../messaging/payload-codec");
-const spot_remote_codec_1 = require("./spot-remote-codec");
-class ZLinkSpotNativeActorJoinAdmission {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async admit(request, rejectClosing = false) {
-        const actorId = request.info.targetActor.actorId;
-        let accepted = false;
-        let acceptedActor;
-        let reply;
-        const decoded = this.decodeNativeActorJoinRequest(request.message);
-        try {
-            if (decoded !== undefined) {
-                throw new Error('Remote actor join requires the two-phase routed transfer protocol.');
-            }
-            const actor = this.options.resolveActor(actorId);
-            if (!rejectClosing && actor !== undefined) {
-                const target = this.options.getTarget();
-                const joinRequest = request.message;
-                const joinPayload = (0, payload_codec_1.wrapFrameworkPayloadMessage)(joinRequest, this.options.messageSerializers);
-                const response = await this.options.serial.execute(async () => this.options.defaultAccept || target.onActorJoin === undefined
-                    ? { accepted: this.options.defaultAccept }
-                    : target.onActorJoin(actorId, joinPayload));
-                accepted = response.accepted;
-                reply =
-                    response.reply === undefined
-                        ? undefined
-                        : (0, payload_codec_1.encodeFrameworkPayloadMessage)(response.reply, this.options.messageSerializers);
-                if (accepted) {
-                    acceptedActor = actor;
-                }
-            }
-        }
-        catch (error) {
-            this.reportHandlerException(actorId, error);
-            accepted = false;
-            reply?.close();
-            reply = undefined;
-        }
-        const operation = this.options.nativeSpot.replyActorJoin(request, accepted ? 0 : 1);
-        let submitted = false;
-        try {
-            if (reply !== undefined) {
-                operation.message(reply);
-            }
-            operation.submit();
-            submitted = true;
-        }
-        finally {
-            if (!submitted) {
-                reply?.close();
-            }
-            decoded?.request.close();
-            decoded?.actorCreateRequest?.close();
-        }
-        if (acceptedActor !== undefined) {
-            try {
-                // The native reply commits the actor's return to the Entry Spot. Publish
-                // the immutable membership callback only after that commit so observers
-                // never see an accepted membership before Core does.
-                await this.options.commitAcceptedActor?.(acceptedActor);
-            }
-            catch (error) {
-                this.reportHandlerException(actorId, error);
-            }
-        }
-    }
-    decodeNativeActorJoinRequest(message) {
-        try {
-            const payload = JSON.parse(message.data().toString());
-            if (payload.packetName !== spot_remote_codec_1.REMOTE_ACTOR_JOIN_PACKET ||
-                typeof payload.actorType !== 'string' ||
-                typeof payload.request !== 'string') {
-                return undefined;
-            }
-            return {
-                actorType: payload.actorType,
-                actorCreateRequest: typeof payload.actorCreateRequest === 'string'
-                    ? runtime_message_1.ZLinkBufferMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
-                    : undefined,
-                request: runtime_message_1.ZLinkBufferMessage.from(Buffer.from(payload.request, 'base64'))
-            };
-        }
-        catch {
-            return undefined;
-        }
-    }
-    reportHandlerException(actorId, error) {
-        this.options.dispatchErrors?.report({
-            surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotActor,
-            messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend,
-            reason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException,
-            action: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop,
-            actorId,
-            error
-        });
-    }
-}
-exports.ZLinkSpotNativeActorJoinAdmission = ZLinkSpotNativeActorJoinAdmission;

package/src/runtime/actors/post-commit-actor-location.ts

@@ -1,121 +0,0 @@
-import type { RoutingId } from '../../contracts';
-import { ZLinkStateLane } from '../execution/state-lane';
-import type { ZLinkLocationLifecycle } from '../locations';
-import { ZLinkActorRetryDelay } from './actor-retry-delay';
-
-export interface ZLinkPostCommitActorLocationOptions {
-  readonly lifecycle: ZLinkLocationLifecycle;
-  readonly reportError?: (error: unknown) => void;
-  readonly signal?: AbortSignal;
-}
-
-interface ActorOperationQueue {
-  readonly operations: Array<(() => Promise<void>) | undefined>;
-  head: number;
-  count: number;
-}
-
-export class ZLinkPostCommitActorLocation {
-  private readonly lane = new ZLinkStateLane();
-  private readonly queues = new Map<string, ActorOperationQueue>();
-  private readonly tasks = new Map<string, Promise<void>>();
-
-  constructor(private readonly options: ZLinkPostCommitActorLocationOptions) {}
-
-  joinedEventually(
-    actorType: string,
-    actorId: string,
-    meshName: string,
-    spotId: RoutingId,
-    spotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): void {
-    this.enqueue(actorId, () =>
-      this.options.lifecycle.notifyActorJoinedSpot(
-        actorType,
-        actorId,
-        meshName,
-        spotId,
-        spotGeneration,
-        membershipEpoch,
-        ownerNodeGeneration
-      )
-    );
-  }
-
-  leftEventually(
-    actorType: string,
-    actorId: string,
-    entrySpotId: RoutingId,
-    entrySpotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): void {
-    this.enqueue(actorId, () =>
-      this.options.lifecycle.notifyActorLeftSpot(
-        actorType,
-        actorId,
-        entrySpotId,
-        entrySpotGeneration,
-        membershipEpoch,
-        ownerNodeGeneration
-      )
-    );
-  }
-
-  private enqueue(actorId: string, operation: () => Promise<void>): void {
-    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!: Promise<void>;
-    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);
-  }
-
-  private async run(actorId: string): Promise<void> {
-    const retryDelay = new 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;
-        }
-      }
-    }
-  }
-
-  private completeCore(queue: ActorOperationQueue): void {
-    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;
-    }
-  }
-}