@zlink-systems/framework 0.24.0 → 0.26.0

package/src/runtime/actors/actor-context.ts

@@ -212,7 +212,7 @@ class DefaultZLinkActorJoinSpotCall implements ZLinkActorJoinSpotCall {
       discarded = true;
       this.state.endDeferredJoin();
       try {
-        await this.coordinator.abortDeferredJoin?.(this.actor, this.state, operationId);
+        await this.coordinator.abortDeferredJoin?.(this.actor, this.state);
       } finally {
         deadline.close();
         requestMessage.close();
@@ -228,7 +228,7 @@ class DefaultZLinkActorJoinSpotCall implements ZLinkActorJoinSpotCall {
             // The provisional ingress fence is installed only after the
             // handler terminal. Target admission starts before reply encoding,
             // while completion and finalization remain in execute().
-            this.coordinator.beginDeferredJoin?.(this.actor, this.state, operationId);
+            this.coordinator.beginDeferredJoin?.(this.actor, this.state);
             pendingJoin = this.coordinator.joinSpot(
               this.actor,
               this.state,
@@ -268,7 +268,7 @@ class DefaultZLinkActorJoinSpotCall implements ZLinkActorJoinSpotCall {
           } catch (error) {
             this.state.endDeferredJoin();
             await this.coordinator
-              .abortDeferredJoin?.(this.actor, this.state, operationId)
+              .abortDeferredJoin?.(this.actor, this.state)
               .catch(() => undefined);
             await notifyJoinFailure(this.actor, operationId, error, this.coordinator);
             return;
@@ -350,7 +350,7 @@ class DefaultZLinkActorJoinEntrySpotCall implements ZLinkActorJoinEntrySpotCall
       discarded = true;
       this.state.endDeferredJoin();
       try {
-        await this.coordinator.abortDeferredJoin?.(this.actor, this.state, operationId);
+        await this.coordinator.abortDeferredJoin?.(this.actor, this.state);
       } finally {
         deadline.close();
         requestMessage.close();
@@ -363,7 +363,7 @@ class DefaultZLinkActorJoinEntrySpotCall implements ZLinkActorJoinEntrySpotCall
           prepared = true;
           this.state.endDeferredJoin();
           try {
-            this.coordinator.beginDeferredJoin?.(this.actor, this.state, operationId);
+            this.coordinator.beginDeferredJoin?.(this.actor, this.state);
             pendingJoin = this.coordinator.joinEntrySpot(
               this.actor,
               this.state,
@@ -403,7 +403,7 @@ class DefaultZLinkActorJoinEntrySpotCall implements ZLinkActorJoinEntrySpotCall
           } catch (error) {
             this.state.endDeferredJoin();
             await this.coordinator
-              .abortDeferredJoin?.(this.actor, this.state, operationId)
+              .abortDeferredJoin?.(this.actor, this.state)
               .catch(() => undefined);
             await notifyJoinFailure(this.actor, operationId, error, this.coordinator);
             return;

package/src/runtime/actors/actor-handoff.ts

@@ -185,7 +185,12 @@ interface ActiveHandoff {
   readonly sourceEvidence: ReplySourceEvidence;
   readonly sourceOwner: ZLinkActorMessageFollowOwnerFence;
   phase: 'provisional' | 'releasing' | 'relocating';
-  readonly operationId?: string;
+  /**
+   * True for the handoff a deferred Join started. The handoff is keyed by
+   * its Actor; the public Join OperationId is a completion idempotency ID and
+   * never identifies the handoff (Spot Actor membership section 4).
+   */
+  readonly deferredJoin: boolean;
   replay?: ZLinkActorHandoffDispatch;
   connectionBoundSealed: boolean;
   readonly pending: PendingPacket[];
@@ -300,22 +305,17 @@ export class ZLinkActorHandoffCoordinator {
   }
 
   begin(actorId: string, oldGeneration: bigint): void {
-    this.startHandoff(actorId, oldGeneration, { phase: 'relocating' });
+    this.startHandoff(actorId, oldGeneration, 'relocating');
   }
 
-  beginProvisional(actorId: string, operationId: string, oldGeneration: bigint): void {
-    this.startHandoff(actorId, oldGeneration, { phase: 'provisional', operationId });
+  beginProvisional(actorId: string, oldGeneration: bigint): void {
+    this.startHandoff(actorId, oldGeneration, 'provisional');
   }
 
   private startHandoff(
     actorId: string,
     oldGeneration: bigint,
-    transition:
-      | { readonly phase: 'relocating' }
-      | {
-          readonly phase: 'provisional';
-          readonly operationId: string;
-        }
+    phase: 'relocating' | 'provisional'
   ): void {
     if (this.active.has(actorId)) {
       throw new Error(`Actor '${actorId}' already has an active packet handoff.`);
@@ -363,8 +363,8 @@ export class ZLinkActorHandoffCoordinator {
       oldNodeRidHex: sourceEvidence.nodeRidHex,
       sourceEvidence,
       sourceOwner,
-      phase: transition.phase,
-      ...(transition.phase === 'provisional' ? { operationId: transition.operationId } : {}),
+      phase,
+      deferredJoin: phase === 'provisional',
       connectionBoundSealed: false,
       pending: [],
       nextIndex: 0,
@@ -381,14 +381,11 @@ export class ZLinkActorHandoffCoordinator {
     return this.active.get(actorId)?.phase === 'provisional';
   }
 
-  promoteProvisional(actorId: string, operationId: string): void {
+  promoteProvisional(actorId: string): void {
     const handoff = this.active.get(actorId);
-    if (handoff === undefined) {
+    if (handoff?.phase !== 'provisional') {
       throw new Error(`Actor '${actorId}' does not have a provisional packet handoff.`);
     }
-    if (handoff.phase !== 'provisional' || handoff.operationId !== operationId) {
-      throw new Error(`Actor '${actorId}' packet handoff belongs to another operation.`);
-    }
     handoff.phase = 'relocating';
   }
 
@@ -403,14 +400,13 @@ export class ZLinkActorHandoffCoordinator {
 
   async releaseDeferred(
     actorId: string,
-    operationId: string,
     dispatch?: ZLinkActorHandoffDispatch,
     admission?: ZLinkActorHandoffReplayAdmission
   ): Promise<void> {
     const handoff = this.active.get(actorId);
     if (handoff === undefined) return;
-    if (handoff.operationId !== operationId) {
-      throw new Error(`Actor '${actorId}' packet handoff belongs to another operation.`);
+    if (!handoff.deferredJoin) {
+      throw new Error(`Actor '${actorId}' packet handoff was not started by a deferred Join.`);
     }
     await this.releaseHandoff(actorId, handoff, dispatch ?? handoff.replay, admission);
   }
@@ -434,15 +430,14 @@ export class ZLinkActorHandoffCoordinator {
    */
   admitDeferredPrefix(
     actorId: string,
-    operationId: string,
     queue: ZLinkActorHandoffPrefixQueue,
     preparation?: ZLinkActorHandoffReplayPreparation,
     start: Promise<void> = Promise.resolve()
   ): ZLinkActorHandoffPrefixAdmission {
     const handoff = this.active.get(actorId);
     if (handoff === undefined) return { terminal: Promise.resolve() };
-    if (handoff.operationId !== operationId) {
-      throw new Error(`Actor '${actorId}' packet handoff belongs to another operation.`);
+    if (!handoff.deferredJoin) {
+      throw new Error(`Actor '${actorId}' packet handoff was not started by a deferred Join.`);
     }
     return this.admitHandoffPrefix(actorId, handoff, queue, preparation, start);
   }
@@ -740,6 +735,19 @@ export class ZLinkActorHandoffCoordinator {
     pending.reject?.(error);
   }
 
+  /**
+   * Expired-owner terminal of a relocation (spec 28 §4.4): every pending
+   * record without a terminal fails once with `reason`. The handoff stays
+   * active, so the source never dispatches the Actor again.
+   */
+  failPending(actorId: string, reason: unknown): void {
+    const handoff = this.active.get(actorId);
+    if (handoff === undefined) return;
+    for (const pending of handoff.pending.splice(0)) this.failReleasedPending(pending, reason);
+    handoff.snapshotIndex = -1;
+    handoff.pendingBytes = 0;
+  }
+
   cancel(actorId: string): void {
     const handoff = this.active.get(actorId);
     if (handoff === undefined) return;

package/src/runtime/actors/actor-local-native-join.ts

@@ -11,7 +11,7 @@ import type {
   ZLinkActorJoinOperationId,
   ZLinkMessageSerializer
 } from '../../contracts';
-import { ZLinkFrameworkErrorKind, ZLinkSpotKind } from '../../contracts';
+import { ZLinkSpotKind } from '../../contracts';
 import type { ZLinkActorJoinRuntimeResult } from './actor-runtime-contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendActorRef, ZLinkBackendMeshNode } from '../backend/contracts';
@@ -391,13 +391,7 @@ export class ZLinkLocalNativeActorJoin {
       //  (spec 32-framework-error-model:83-118); an OK terminal with no join
       //  control is a protocol violation.
       throw admission.terminalResult !== 0 || admission.failureErrno !== 0
-        ? remoteActorJoinFailureException(
-            node,
-            target,
-            admission.terminalResult,
-            admission.failureErrno,
-            message
-          )
+        ? wireReplyFailureException(admission.terminalResult, admission.failureErrno, message)
         : createInternalFrameworkException(
             ZLinkFrameworkInternalErrorKind.RequestProtocolError,
             message
@@ -419,9 +413,7 @@ export class ZLinkLocalNativeActorJoin {
     }
     if (admission.terminalResult !== 0 || admission.failureErrno !== 0) {
       closeMeshCompletion(admission);
-      throw remoteActorJoinFailureException(
-        node,
-        target,
+      throw wireReplyFailureException(
         admission.terminalResult,
         admission.failureErrno,
         `Actor admission failed for '${actor.context.actorId}' with result '${admission.terminalResult}' and errno '${admission.failureErrno}'.`
@@ -613,37 +605,6 @@ function canonicalHandoffRelocationId(handoffId: string): string {
   );
 }
 
-function remoteActorJoinFailureException(
-  node: ZLinkBackendMeshNode,
-  target: ZLinkSpotRouteTarget,
-  terminalResult: number,
-  failureErrno: number,
-  message: string
-) {
-  const failure = wireReplyFailureException(terminalResult, failureErrno, message);
-  const targetGeneration = target.targetNodeGeneration;
-  if (
-    failure.kind === ZLinkFrameworkErrorKind.DeadlineExceeded &&
-    targetGeneration !== undefined &&
-    targetGeneration !== 0n &&
-    !node
-      .peers()
-      .some(
-        (peer) =>
-          peer.state === 3 &&
-          peer.routingId !== null &&
-          routingIdsEqual(peer.routingId, target.targetNodeRid) &&
-          peer.lifecycleGeneration === targetGeneration
-      )
-  ) {
-    return createInternalFrameworkException(
-      ZLinkFrameworkInternalErrorKind.RouteNotConnected,
-      'wire Actor join target RouteMesh peer became unavailable'
-    );
-  }
-  return failure;
-}
-
 function runtimeActorMeshName(
   actor: ZLinkActor,
   state: ZLinkActorRuntimeState,

package/src/runtime/actors/actor-remote-joiner.ts

@@ -14,7 +14,6 @@ import { lookupNativeActorRef } from './actor-native-lookup';
 import { ZLinkPostCommitActorLocation } from './post-commit-actor-location';
 import { ZLinkLocalNativeActorJoin } from './actor-local-native-join';
 import { ZLinkPostCommitActorBinder } from './post-commit-actor-binder';
-import { operationIdentityKey } from '../foundation/operation-identity';
 import type { ZLinkActorJoinRelocation } from './actor-join-relocation';
 
 export interface ZLinkActorNativeJoinCoordinatorOptions {
@@ -71,28 +70,12 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
     });
   }
 
-  beginDeferredJoin(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: import('../../contracts').ZLinkActorJoinOperationId
-  ): void {
-    this.options.sourceTransfer?.beginDeferredActorHandoff?.(
-      actor,
-      state,
-      operationIdentityKey(operationId)
-    );
+  beginDeferredJoin(actor: ZLinkActor, state: ZLinkActorRuntimeState): void {
+    this.options.sourceTransfer?.beginDeferredActorHandoff?.(actor, state);
   }
 
-  async abortDeferredJoin(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: import('../../contracts').ZLinkActorJoinOperationId
-  ): Promise<void> {
-    await this.options.sourceTransfer?.cancelDeferredActorHandoff?.(
-      actor,
-      state,
-      operationIdentityKey(operationId)
-    );
+  async abortDeferredJoin(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void> {
+    await this.options.sourceTransfer?.cancelDeferredActorHandoff?.(actor, state);
   }
 
   async joinSpot(
@@ -184,7 +167,6 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
     operationId: import('../../contracts').ZLinkActorJoinOperationId | undefined
   ): ZLinkActorJoinRuntimeResult<Message> {
     if (operationId === undefined || this.options.sourceTransfer === undefined) return result;
-    const key = operationIdentityKey(operationId);
     return {
       ...result,
       finalizeDeferredJoin: async () => {
@@ -192,11 +174,10 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
           await this.options.sourceTransfer!.completeDeferredActorHandoff?.(
             actor,
             target,
-            result.actor,
-            key
+            result.actor
           );
         } else {
-          await this.options.sourceTransfer!.cancelDeferredActorHandoff?.(actor, state, key);
+          await this.options.sourceTransfer!.cancelDeferredActorHandoff?.(actor, state);
         }
       }
     };

package/src/runtime/actors/actor-runtime-contracts.ts

@@ -16,6 +16,7 @@ import type { ZLinkLocationLifecycle } from '../locations';
 import type { ZLinkActorRuntimeState } from './actor-runtime-state';
 import type { ZLinkActorTransferRegistry } from './actor-transfer-registry';
 import type { ZLinkRuntimeAdmissionGate } from '../admission';
+import type { ZLinkActivationAdmission } from '../activation-admission';
 
 export interface ZLinkActorJoinRuntimeResult<TReply> {
   readonly accepted: boolean;
@@ -61,6 +62,7 @@ export interface ZLinkActorManagerOptions {
   readonly shutdownSignal?: AbortSignal;
   readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
   readonly admission?: ZLinkRuntimeAdmissionGate;
+  readonly activationAdmission?: ZLinkActivationAdmission;
   readonly placementCreate?: (
     actorId: string,
     actorType: string,
@@ -92,16 +94,8 @@ export interface ZLinkActorJoinCoordinator {
    * lookup. This is an internal ordering fence; it is not part of the public
    * actor context contract.
    */
-  beginDeferredJoin?(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: import('../../contracts').ZLinkActorJoinOperationId
-  ): void;
-  abortDeferredJoin?(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: import('../../contracts').ZLinkActorJoinOperationId
-  ): Promise<void>;
+  beginDeferredJoin?(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
+  abortDeferredJoin?(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
   joinSpot(
     actor: ZLinkActor,
     state: ZLinkActorRuntimeState,

package/src/runtime/actors/actor-source-transfer.ts

@@ -27,36 +27,23 @@ export interface ZLinkPreparedActorSource {
 
 export interface ZLinkActorSourceTransfer {
   /** Starts the ingress handoff before target route lookup. */
-  beginDeferredActorHandoff?(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: string
-  ): void;
+  beginDeferredActorHandoff?(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
   /** Changes a provisional ingress fence into a relocation handoff. */
-  promoteDeferredActorHandoff?(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: string
-  ): void;
+  promoteDeferredActorHandoff?(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
   /** Finishes a same-node deferred Join handoff after completion callback. */
   completeDeferredActorHandoff?(
     actor: ZLinkActor,
     target: ZLinkSpotRouteTarget,
-    targetActorRef: ActorRef,
-    operationId: string
+    targetActorRef: ActorRef
   ): Promise<void>;
   /** Releases an early handoff when Join cannot commit. */
-  cancelDeferredActorHandoff?(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    operationId: string
-  ): Promise<void>;
+  cancelDeferredActorHandoff?(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
   prepareSource(
     actor: ZLinkActor,
     state: ZLinkActorRuntimeState,
     signal?: AbortSignal,
     lifecycleAuthority?: 'framework' | 'core',
-    deferredOperationId?: string,
+    deferredJoin?: boolean,
     relocation?: ServiceWireOperationId
   ): Promise<ZLinkPreparedActorSource>;
 }

package/src/runtime/actors/deferred-join-completion.ts

@@ -0,0 +1,40 @@
+import type { ActorRef, ZLinkActorJoinOperationId } from '../../contracts';
+
+/**
+ * The Accepted completion of a deferred cross-node Join. Spot Actor membership
+ * sections 4-5: the public OperationId, the optional reply and the delivery
+ * state live only while the current source and target processes run. The
+ * completion is never written to a Store and never replayed after a restart.
+ */
+export interface ZLinkDeferredJoinCompletion {
+  readonly operationId: ZLinkActorJoinOperationId;
+  readonly actor: ActorRef;
+  readonly rawReply: Buffer;
+  readonly replyContentType?: string;
+}
+
+export function createDeferredJoinCompletion(
+  actorId: string,
+  operationId: ZLinkActorJoinOperationId,
+  actor: ActorRef,
+  rawReply: Uint8Array,
+  replyContentType?: string
+): ZLinkDeferredJoinCompletion {
+  if (
+    actorId.length === 0 ||
+    actor.actorId !== actorId ||
+    actor.objectGeneration <= 0n ||
+    (operationId.high === 0n && operationId.low === 0n)
+  ) {
+    throw new Error('Deferred Join completion identity is invalid.');
+  }
+  if (replyContentType !== undefined && replyContentType.length === 0) {
+    throw new TypeError('Deferred Join reply content type must be non-empty.');
+  }
+  return {
+    operationId,
+    actor,
+    rawReply: Buffer.from(rawReply),
+    ...(replyContentType === undefined ? {} : { replyContentType })
+  };
+}

package/src/runtime/actors/index.ts

@@ -69,12 +69,9 @@ export {
   type ZLinkRemoteBoundSessionTarget
 } from './actor-runtime-state';
 export {
-  isDeferredJoinAcceptedRootPublication,
-  ZLinkDeferredJoinAcceptedJournal,
-  type ZLinkDeferredJoinAcceptedRoot,
-  type ZLinkDeferredJoinRootIdentity,
-  type ZLinkDeferredJoinDeliveryCursor
-} from './deferred-join-accepted-journal';
+  createDeferredJoinCompletion,
+  type ZLinkDeferredJoinCompletion
+} from './deferred-join-completion';
 export {
   decodeActorAuthorityIdentity,
   decodeRelocatingActorAuthorityIdentity,
@@ -687,9 +684,25 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       if (request !== undefined && createRequest.nativeRequest !== undefined) {
         state.setCreateRequestPayload(createRequest.nativeRequest.data());
       }
-      const operation = state.getOrStartCreation(actorType, failIfExists, () =>
-        this.creation.createActor(actorId, actorType, state, createRequest, claimLocation, signal)
-      );
+      const operation = state.getOrStartCreation(actorType, failIfExists, async () => {
+        const meshName = state.meshName ?? this.options.actorMeshNameProvider?.(actorType);
+        const release =
+          meshName === undefined
+            ? undefined
+            : await this.options.activationAdmission?.acquire(meshName, signal);
+        try {
+          return await this.creation.createActor(
+            actorId,
+            actorType,
+            state,
+            createRequest,
+            claimLocation,
+            signal
+          );
+        } finally {
+          release?.();
+        }
+      });
       if (operation.created) {
         void operation.task.then(
           (result) => {

package/src/runtime/admission.ts

@@ -5,7 +5,11 @@ import {
 export class ZLinkRuntimeAdmissionGate {
   private readonly meshes = new Map<string, ZLinkMeshAdmissionState>();
 
-  constructor(private readonly ownerAdmissionOpen: () => boolean = () => true) {}
+  /**
+   * Location runtime §5: the host's single new-work decision (local admission deadline and host
+   * execution combination). A host without a Location Store has no such block.
+   */
+  constructor(readonly ownerAdmissionOpen: () => boolean = () => true) {}
 
   get acceptsNewWork(): boolean {
     if (!this.ownerAdmissionOpen()) return false;

package/src/runtime/backend/contracts/index.ts

@@ -369,8 +369,7 @@ export interface ZLinkBackendMeshNode {
     actor: ZLinkBackendActorRef,
     expectedBindingGeneration: bigint,
     parts: MessageLike | readonly MessageLike[],
-    flags?: number,
-    actorFence?: ZLinkBackendActorSessionSendFence
+    flags?: number
   ): Promise<SubmitResult>;
   closeActorBoundSession(
     actor: ZLinkBackendActorRef,
@@ -413,20 +412,12 @@ export interface ZLinkBackendActorRef {
   readonly generation: bigint;
 }
 
-export interface ZLinkBackendActorSessionSendFence {
-  readonly targetNodeGeneration: bigint;
-  readonly authorityOwnerGeneration: bigint;
-  readonly ownerLeaseGeneration: bigint;
-}
-
 export interface ZLinkBackendActorSessionNode {
-  actorNodeGeneration?(actor: ZLinkBackendActorRef): bigint | undefined;
   sendActorBoundSession(
     actor: ZLinkBackendActorRef,
     expectedBindingGeneration: bigint,
     parts: readonly Message[],
-    flags: number,
-    actorFence?: ZLinkBackendActorSessionSendFence
+    flags: number
   ): Promise<ZLinkSubmitResult>;
   closeActorBoundSession(
     actor: ZLinkBackendActorRef,
@@ -720,7 +711,6 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
   recvActorLifecycle(flags: ZLinkBackendRecvFlags): unknown | null;
   drainReply(): number;
   drainChannelReply(subjectHandle: bigint): number;
-  recvRoute(result: Received, flags: ZLinkBackendRecvFlags): boolean;
   setDispatchHandler(handler: (info: ZLinkBackendSpotDispatchInfo) => void): void;
   requestToChannel(
     channelName: string,
@@ -788,7 +778,6 @@ export interface ZLinkMonitoringBackendAdapter {
 }
 
 export interface ZLinkBackendAdapterFactory {
-  createReceived(): Received;
   createTopicMessage(): TopicMessage;
   createChannelAdapter(): ZLinkChannelBackendAdapter;
   createMeshAdapter(): ZLinkMeshBackendAdapter;

package/src/runtime/backend/mesh-actor-session-node-adapter.ts

@@ -2,26 +2,18 @@ import { SubmitResult } from './runtime-values';
 import { ZLinkSubmitStatus } from '../messaging/submission-result';
 import type { ZLinkBackendActorSessionNode, ZLinkBackendMeshNode } from './contracts';
 import { closeMeshCompletion, type ZLinkMeshCompletionTable } from './mesh-completion-table';
-import { routingIdsEqual } from '../routing-id';
 
 export function meshActorSessionNodeAdapter(
   node: ZLinkBackendMeshNode,
   completions?: ZLinkMeshCompletionTable
 ): ZLinkBackendActorSessionNode {
   return {
-    actorNodeGeneration(actor) {
-      const status = node.status();
-      return routingIdsEqual(status.routingId, actor.nodeRid)
-        ? status.lifecycleGeneration
-        : undefined;
-    },
-    async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags, actorFence) {
+    async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags) {
       const result = await node.sendActorBoundSession(
         actor,
         expectedBindingGeneration,
         parts as never,
-        flags,
-        actorFence
+        flags
       );
       switch (result) {
         case SubmitResult.Ok:

package/src/runtime/backend/node/node-backend-adapter-factory.ts

@@ -6,7 +6,6 @@ import type {
   ZLinkBackendDealerSocket,
   ZLinkBackendPublisherSocket,
   ZLinkBackendReadablePoller,
-  ZLinkBackendReceived,
   ZLinkBackendRouterSocket,
   ZLinkBackendSocket,
   ZLinkBackendSocketMonitor,
@@ -17,21 +16,12 @@ import type {
   ZLinkMonitoringBackendAdapter,
   ZLinkStreamBackendAdapter
 } from '../contracts';
-import {
-  closeWithBusyRetry,
-  isContextTerminatedError,
-  zlink,
-  type ZLinkBindingModule
-} from './node-backend-adapter-support';
+import { closeBindingHandle, zlink, type ZLinkBindingModule } from './node-backend-adapter-support';
 import { wrapMonitorSocket } from './node-monitor-backend-adapter';
 import { nodeEventLoopPollerOf, wrapSocket } from './node-socket-backend-adapter';
 import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
 
 export class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
-  createReceived(): ZLinkBackendReceived {
-    return new zlink.Received();
-  }
-
   createTopicMessage(): TopicMessage {
     return new zlink.TopicMessage();
   }
@@ -96,7 +86,8 @@ class ZLinkNodeChannelBackendAdapter implements ZLinkChannelBackendAdapter {
 
 class ZLinkNodeStreamBackendAdapter implements ZLinkStreamBackendAdapter {
   createStreamSocket(context: ZLinkBackendContext): ZLinkBackendStreamSocket {
-    const socket = zlink.createStreamSocket(asNodeContext(context));
+    const nodeContext = asNodeContext(context);
+    const socket = zlink.createStreamSocket(nodeContext);
     socket.options.recvMode = zlink.StreamRecvMode.Packet;
     return wrapSocket(socket, true) as unknown as ZLinkBackendStreamSocket;
   }
@@ -148,19 +139,8 @@ class ZLinkNodeBackendContext implements ZLinkBackendContext {
   }
 
   async dispose(): Promise<void> {
-    // Terminal cleanup shuts the context down before terminating it, the same
-    // sequence the .NET reference binding runs inside `Context.Dispose()`
-    // (`zlink_ctx_shutdown` then `zlink_ctx_term`). Without the shutdown signal
-    // termination can block forever waiting on the reaper even after every
-    // socket this runtime owns has been closed.
-    try {
-      this.nativeInstance.shutdown();
-    } catch (error) {
-      if (!isContextTerminatedError(error)) {
-        throw error;
-      }
-    }
-    await closeWithBusyRetry(this.nativeInstance);
+    // Binding Context.close() shuts down and then terminates the native context.
+    closeBindingHandle(this.nativeInstance);
   }
 
   close(): void {