@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/actors/transferred-actor-rollback.ts

@@ -4,24 +4,18 @@ import { closeMeshCompletion } from '../backend';
 import { RequestResult } from '../backend/runtime-values';
 import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
 import type { ZLinkActorRuntimeState } from './actor-runtime-state';
-import { ZLinkActorRetryDelay } from './actor-retry-delay';
+import { createActorMembership } from './actor-lifecycle-snapshot';
 
 type ZLinkTransferredActorRollbackOptions = Pick<
   ZLinkActorManagerOptions,
-  | 'actorDestroyedCleanup'
-  | 'nativeActorNode'
-  | 'nativeActorNodeProvider'
-  | 'nativeActorCompletionTableProvider'
-  | 'shutdownSignal'
-  | 'metrics'
+  'nativeActorNode' | 'nativeActorNodeProvider' | 'nativeActorCompletionTableProvider'
 >;
 
 export class ZLinkTransferredActorRollbackCoordinator {
-  private readonly tasks = new Map<string, Promise<void>>();
-
   constructor(
     private readonly states: Map<string, ZLinkActorRuntimeState>,
-    private readonly options: ZLinkTransferredActorRollbackOptions
+    private readonly options: ZLinkTransferredActorRollbackOptions,
+    private readonly finalize: (actorId: string, state: ZLinkActorRuntimeState) => Promise<void>
   ) {}
 
   async rollback(actor: ZLinkActor, signal?: AbortSignal): Promise<void> {
@@ -37,54 +31,10 @@ export class ZLinkTransferredActorRollbackCoordinator {
 
     const actorRef = state.nativeActorRef;
     const node = this.options.nativeActorNode ?? this.options.nativeActorNodeProvider?.();
-    try {
-      if (node !== undefined && actorRef !== undefined) {
-        await this.destroyNativeActor(node, actorRef, signal);
-      }
-    } catch (error) {
-      this.schedule(actor, state, node, actorRef);
-      throw error;
-    }
-    this.complete(actor, state);
-  }
-
-  private schedule(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    node: ZLinkBackendMeshNode | undefined,
-    actorRef: ZLinkBackendActorRef | undefined
-  ): void {
-    if (this.tasks.has(actor.context.actorId)) {
-      return;
-    }
-    const task = this.retry(actor, state, node, actorRef).finally(() =>
-      this.tasks.delete(actor.context.actorId)
-    );
-    this.tasks.set(actor.context.actorId, task);
-  }
-
-  private async retry(
-    actor: ZLinkActor,
-    state: ZLinkActorRuntimeState,
-    node: ZLinkBackendMeshNode | undefined,
-    actorRef: ZLinkBackendActorRef | undefined
-  ): Promise<void> {
-    const retryDelay = new ZLinkActorRetryDelay();
-    while (
-      this.states.get(actor.context.actorId) === state &&
-      this.options.shutdownSignal?.aborted !== true
-    ) {
-      if (!(await retryDelay.wait(this.options.shutdownSignal))) return;
-      try {
-        if (node !== undefined && actorRef !== undefined) {
-          await this.destroyNativeActor(node, actorRef);
-        }
-        this.complete(actor, state);
-        return;
-      } catch {
-        // The tombstone prevents dispatch while the next retry is pending.
-      }
+    if (node !== undefined && actorRef !== undefined) {
+      await this.destroyNativeActor(node, actorRef, signal);
     }
+    await this.complete(actor, state);
   }
 
   private async destroyNativeActor(
@@ -116,13 +66,12 @@ export class ZLinkTransferredActorRollbackCoordinator {
     }
   }
 
-  private complete(actor: ZLinkActor, state: ZLinkActorRuntimeState): void {
+  private async complete(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void> {
     if (this.states.get(actor.context.actorId) !== state) {
       return;
     }
-    this.options.actorDestroyedCleanup?.(actor.context.actorId);
-    state.clearAfterDestroy();
-    this.states.delete(actor.context.actorId);
-    this.options.metrics?.change('zlink.actor.count', -1);
+    await state.getOrStartDestroy(createActorMembership(actor).actor.nodeRid, () =>
+      this.finalize(actor.context.actorId, state)
+    );
   }
 }

package/src/runtime/admission.ts

@@ -2,10 +2,21 @@ import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
 } from './framework-errors-internal';
+const BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
+
+/** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
+export function shouldCompactBackingArray(head: number, length: number): boolean {
+  return head >= BACKING_ARRAY_COMPACTION_MIN_HEAD && head * 2 >= length;
+}
+
 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;
@@ -188,7 +199,7 @@ function compactWaiters(state: ZLinkMeshAdmissionState): void {
   if (state.waiterCount === 0) {
     state.waiters.length = 0;
     state.waiterHead = 0;
-  } else if (state.waiterHead >= 1024 && state.waiterHead * 2 >= state.waiters.length) {
+  } else if (shouldCompactBackingArray(state.waiterHead, state.waiters.length)) {
     state.waiters.splice(0, state.waiterHead);
     state.waiterHead = 0;
   }

package/src/runtime/application-jobs/application-job-queue-scope.ts

@@ -43,12 +43,12 @@ export function hasApplicationJobPermit(): boolean {
 }
 
 /** Re-enters the captured permit scope when a serial executor runs later. */
-export function bindApplicationJobPermit<TResult>(
-  callback: () => Promise<TResult> | TResult
-): () => Promise<TResult> | TResult {
+export function bindApplicationJobPermit<TResult, TArgument>(
+  callback: (argument?: TArgument) => Promise<TResult> | TResult
+): (argument?: TArgument) => Promise<TResult> | TResult {
   const scope = applicationJobPermitScope.getStore();
   if (scope === undefined) return callback;
-  return () => applicationJobPermitScope.run(scope, callback);
+  return (argument?: TArgument) => applicationJobPermitScope.run(scope, callback, argument);
 }
 
 /**

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

@@ -141,14 +141,16 @@ export interface ZLinkBackendMeshNode {
     route: ServiceInstanceRouteFence,
     parts: MessageLike | readonly MessageLike[],
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    instanceIntent?: boolean
   ): Promise<SubmitResult>;
   requestInstanceSpot(
     route: ServiceInstanceRouteFence,
     parts: MessageLike | readonly MessageLike[],
     timeoutMs?: number,
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    instanceIntent?: boolean
   ): MeshOperationId;
   registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
   requestUserSpotCreate(
@@ -249,6 +251,12 @@ export interface ZLinkBackendMeshNode {
         readonly objectGeneration: bigint;
       }
     | undefined;
+  registerInstanceIntent?(
+    instanceType: string,
+    route: import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence,
+    expectedCurrentRoute?:
+      import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence | null
+  ): void;
   waitForInstanceApplicationQuiescence?(spotId: string, signal?: AbortSignal): Promise<void>;
   restoreUserSpotAuthority?(
     spotId: string,
@@ -269,7 +277,7 @@ export interface ZLinkBackendMeshNode {
     stableType: string,
     generation: bigint,
     authorityOwnerGeneration: bigint,
-    spotId: string,
+    spotId: string | undefined,
     spotGeneration: bigint,
     membershipEpoch: bigint
   ): ZLinkBackendActorRef;
@@ -369,8 +377,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 +420,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,
@@ -444,27 +443,6 @@ export interface ZLinkBackendActorRecvInfo {
   readonly flags: number;
 }
 
-export interface ZLinkBackendActorJoinInfo {
-  readonly sourceActor: ZLinkBackendActorRef;
-  readonly targetActor: ZLinkBackendActorRef;
-  readonly sourceNodeRid: RoutingId;
-  readonly sourceSpotId: RoutingId;
-  readonly targetNodeRid: RoutingId;
-  readonly targetSpotId: RoutingId;
-  readonly joinEpoch: bigint;
-  readonly flags: number;
-}
-
-export interface ZLinkBackendActorJoinRequest {
-  readonly info: ZLinkBackendActorJoinInfo;
-  readonly message: Message;
-}
-
-export interface ZLinkBackendActorJoinReplyOperation {
-  message(message: Message): ZLinkBackendActorJoinReplyOperation;
-  submit(): void;
-}
-
 export interface ZLinkBackendSpotDispatchInfo {
   readonly event: ZLinkBackendSpotDispatchEvent;
   readonly subjectKind?: number;
@@ -474,6 +452,7 @@ export interface ZLinkBackendSpotDispatchInfo {
 
 export interface ZLinkBackendSocketMonitorEvent {
   readonly nativeEvent: MonitorEventType;
+  readonly readyEdge: boolean;
   readonly routingId?: unknown;
   readonly localAddr: string;
   readonly remoteAddr: string;
@@ -572,6 +551,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
 }
 
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
+  sendTimeoutMs: number;
   sendHighWaterMark: number;
   noDrop: boolean;
   publish(topic: string, message: Message | readonly Message[]): void;
@@ -720,7 +700,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,
@@ -744,11 +723,6 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     payload: Message | readonly Message[],
     timeoutMs?: number
   ): Promise<readonly Message[]>;
-  recvActorJoin(flags: ZLinkBackendRecvFlags): ZLinkBackendActorJoinRequest | null;
-  replyActorJoin(
-    request: ZLinkBackendActorJoinRequest,
-    joinResultCode: number
-  ): ZLinkBackendActorJoinReplyOperation;
   dispose(): Promise<void>;
 }
 
@@ -788,7 +762,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

@@ -1,44 +1,20 @@
-import { SubmitResult } from './runtime-values';
-import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import { classifySubmitResult } 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:
-          return { status: ZLinkSubmitStatus.Submitted };
-        case SubmitResult.Backpressured:
-        case SubmitResult.NotAdmitted:
-          return { status: ZLinkSubmitStatus.Backpressured };
-        case SubmitResult.NotFound:
-        case SubmitResult.InvalidState:
-          return { status: ZLinkSubmitStatus.TargetNotFound };
-        case SubmitResult.NotConnected:
-          return { status: ZLinkSubmitStatus.RouteNotConnected };
-        case SubmitResult.Terminated:
-          return { status: ZLinkSubmitStatus.Shutdown };
-        default:
-          throw new Error(`Actor bound-session send failed with result '${result}'.`);
-      }
+      return classifySubmitResult(result, 'Actor bound-session send');
     },
     async closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs, signal) {
       if (completions === undefined) {

package/src/runtime/backend/mesh-dispatch-pump.ts

@@ -1,6 +1,11 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { availableParallelism } from 'node:os';
-import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+import type {
+  ApplicationJobPermitPort,
+  ApplicationJobQueuePort
+} from '../application-jobs/contracts';
+import { runZLinkExecutionArea } from '../execution';
 import {
   ReadyDomain,
   type ReadyBatch,
@@ -8,13 +13,20 @@ import {
   type ReceiveBatch,
   type ReceiveRecord
 } from '../foundation/service-runtime-contracts';
+import {
+  SERVICE_WIRE_COMMAND_OFFSET,
+  SERVICE_WIRE_MAJOR_OFFSET,
+  SERVICE_WIRE_PREFIX_SIZE
+} from '../foundation/service-wire-binary-primitives';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR
+} from '../foundation/service-wire-constants.generated';
 import type { ZLinkBackendMeshNode } from './contracts';
-import { runZLinkExecutionArea } from '../execution';
-import type {
-  ApplicationJobPermitPort,
-  ApplicationJobQueuePort
-} from '../application-jobs/contracts';
-import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+const DEFAULT_MESH_READY_CAPACITY = 32;
+
+const DEFAULT_MESH_PART_CAPACITY = 256;
 
 const MESH_DISPATCH_YIELD_RECORDS = 16;
 const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
@@ -45,21 +57,10 @@ export interface ZLinkMeshDispatchFailureContext {
   readonly commandId?: number;
 }
 
-class ZLinkMeshDispatchFailure extends Error {
-  constructor(
-    readonly context: ZLinkMeshDispatchFailureContext,
-    readonly dispatchCause: unknown
-  ) {
-    super('Mesh record dispatch failed.', { cause: dispatchCause });
-    this.name = 'ZLinkMeshDispatchFailure';
-  }
-}
-
 export class ZLinkMeshDispatchPump {
   private pendingDomains: number = ReadyDomain.None;
   private infrastructureScheduled = false;
   private disposed = false;
-  private infrastructureDrainPromise?: Promise<void>;
   private readonly activeDrains = new Set<Promise<void>>();
   private readonly idleApplicationWorkers = new Set<() => void>();
   private applicationWorkerCount = 0;
@@ -152,7 +153,7 @@ export class ZLinkMeshDispatchPump {
     const readyBatch = this.node.createReadyBatch(1);
     const receiveBatch = this.node.createReceiveBatch(
       MESH_DISPATCH_RECEIVE_CAPACITY,
-      this.options.partCapacity ?? 256
+      this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY
     );
     try {
       for (;;) {
@@ -179,12 +180,8 @@ export class ZLinkMeshDispatchPump {
     return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
   }
 
-  private reportDispatchError(error: unknown): void {
-    if (error instanceof ZLinkMeshDispatchFailure) {
-      this.options.reportError?.(error.dispatchCause, error.context);
-      return;
-    }
-    this.options.reportError?.(error);
+  private reportDispatchError(error: unknown, context?: ZLinkMeshDispatchFailureContext): void {
+    this.options.reportError?.(error, context);
   }
 
   /**
@@ -205,34 +202,23 @@ export class ZLinkMeshDispatchPump {
           runZLinkExecutionArea('infrastructure', () => this.drainInfrastructure())
         )
       )
-      .catch((error) => {
-        if (error instanceof ZLinkMeshDispatchFailure) {
-          this.options.reportError?.(error.dispatchCause, error.context);
-          return;
-        }
-        this.options.reportError?.(error);
-      });
+      .catch((error) => this.reportDispatchError(error));
     this.activeDrains.add(drain);
-    this.infrastructureDrainPromise = drain;
     void drain.finally(() => {
       this.activeDrains.delete(drain);
-      if (this.infrastructureDrainPromise === drain) {
-        this.infrastructureDrainPromise = undefined;
-        this.infrastructureScheduled = false;
-        if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-          this.scheduleInfrastructure();
-        }
+      this.infrastructureScheduled = false;
+      if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+        this.scheduleInfrastructure();
       }
     });
   }
 
   private async drainInfrastructure(): Promise<void> {
     const readyBatch = this.node.createReadyBatch(
-      Math.min(this.options.readyCapacity ?? 32, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET)
-    );
-    const receiveBatch = this.node.createReceiveBatch(
-      MESH_DISPATCH_RECEIVE_CAPACITY,
-      this.options.partCapacity ?? 256
+      Math.min(
+        this.options.readyCapacity ?? DEFAULT_MESH_READY_CAPACITY,
+        MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
+      )
     );
     try {
       while (!this.disposed) {
@@ -246,7 +232,7 @@ export class ZLinkMeshDispatchPump {
         const lifecycleBudgetExhausted = await this.drainDomain(
           ReadyDomain.Infrastructure,
           readyBatch,
-          receiveBatch,
+          undefined,
           MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
         );
         if (lifecycleBudgetExhausted) {
@@ -255,7 +241,6 @@ export class ZLinkMeshDispatchPump {
         }
       }
     } finally {
-      receiveBatch.close();
       readyBatch.close();
     }
   }
@@ -263,7 +248,7 @@ export class ZLinkMeshDispatchPump {
   private async drainDomain(
     domain: number,
     readyBatch: ReadyBatch,
-    receiveBatch: ReceiveBatch,
+    receiveBatch: ReceiveBatch | undefined,
     claimBudget?: number
   ): Promise<boolean> {
     let claimsDrained = 0;
@@ -285,85 +270,91 @@ export class ZLinkMeshDispatchPump {
         for (let index = 0; index < drained.records.length; index += 1) {
           const claim = readyBatch.takeClaim(index);
           claimsDrained += 1;
-          const owner = drained.records[index];
+          const owner = drained.records[index]!;
           // Raw ingress already attached one host permit to each record.
           // A claim that reserves admission here may receive only that permit's record.
-          try {
-            const capacity =
-              owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
-            for (;;) {
-              let claimPermit =
-                owner.terminalCompletion === true ||
-                owner.ordinaryIngressPreAdmitted === true ||
-                domain === ReadyDomain.Infrastructure
-                  ? undefined
-                  : await this.acquirePermit();
-              try {
-                if (this.capacityStop.signal.aborted) return false;
-                receiveBatch.reset(capacity);
-                const received = claim.recvBatch(receiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
-                if (!received.ok) break;
-                // This owner keeps its claim while it drains. Other owners and
-                // infrastructure may progress if one of its handlers suspends.
-                if (domain === ReadyDomain.Infrastructure) {
-                  this.infrastructureScheduled = false;
-                  this.infrastructureDrainPromise = undefined;
-                  if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-                    this.scheduleInfrastructure();
-                  }
-                }
+          const drainClaim = async () => {
+            let ownerReceiveBatch = receiveBatch;
+            try {
+              ownerReceiveBatch ??= this.node.createReceiveBatch(
+                MESH_DISPATCH_RECEIVE_CAPACITY,
+                this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY
+              );
+              const capacity =
+                owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
+              for (;;) {
+                let claimPermit =
+                  owner.terminalCompletion === true ||
+                  owner.ordinaryIngressPreAdmitted === true ||
+                  domain === ReadyDomain.Infrastructure
+                    ? undefined
+                    : await this.acquirePermit();
                 try {
-                  for (const record of received.records) {
-                    if (this.disposed) break;
-                    const permit = record.applicationJobPermit ?? claimPermit;
-                    if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
-                      throw new Error(
-                        'Pre-admitted raw ingress record lost its Application Job Queue permit.'
-                      );
-                    }
-                    this.recordsSinceYield += 1;
-                    const dispatch = async () => {
-                      try {
-                        await this.options.dispatch(drained.records[index], record);
-                      } catch (error) {
-                        throw new ZLinkMeshDispatchFailure(
-                          meshDispatchFailureContext(record),
-                          error
+                  if (this.capacityStop.signal.aborted) return;
+                  ownerReceiveBatch.reset(capacity);
+                  const received = claim.recvBatch(ownerReceiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
+                  if (!received.ok) break;
+                  // This owner keeps its claim while it drains, so its records stay in FIFO order.
+                  try {
+                    for (const record of received.records) {
+                      if (this.disposed) break;
+                      const permit = record.applicationJobPermit ?? claimPermit;
+                      if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
+                        throw new Error(
+                          'Pre-admitted raw ingress record lost its Application Job Queue permit.'
                         );
                       }
-                      await record.onTerminalCompletion?.();
-                    };
-                    if (permit === undefined) {
-                      await dispatch();
-                    } else {
-                      if (
-                        domain === ReadyDomain.Application &&
-                        record.applicationJobPermit === undefined
-                      )
-                        permit.markApplicationQueued();
-                      // The scope now owns this reservation, including failure
-                      // and detached handler handoff. Only unused permits remain
-                      // owned by the receive attempt's finally block.
-                      if (permit === claimPermit) claimPermit = undefined;
-                      await runWithApplicationJobPermit(permit, dispatch);
+                      this.recordsSinceYield += 1;
+                      const dispatch = async () => {
+                        try {
+                          await this.options.dispatch(owner, record);
+                          await record.onTerminalCompletion?.();
+                        } catch (error) {
+                          this.reportDispatchError(error, meshDispatchFailureContext(record));
+                        }
+                      };
+                      if (permit === undefined) {
+                        await dispatch();
+                      } else {
+                        if (
+                          domain === ReadyDomain.Application &&
+                          record.applicationJobPermit === undefined
+                        )
+                          permit.markApplicationQueued();
+                        // The scope now owns this reservation, including failure
+                        // and detached handler handoff. Only unused permits remain
+                        // owned by the receive attempt's finally block.
+                        if (permit === claimPermit) claimPermit = undefined;
+                        await runWithApplicationJobPermit(permit, dispatch);
+                      }
+                      const yieldTurn = this.yieldIfNeeded();
+                      if (yieldTurn !== undefined) await yieldTurn;
+                    }
+                  } finally {
+                    // Batch ownership includes records whose dispatch never began,
+                    // including on failure or shutdown in the middle of the batch.
+                    for (const record of received.records) {
+                      for (const part of record.parts) part.close();
+                      record.releaseRetainedIngress?.();
                     }
-                    const yieldTurn = this.yieldIfNeeded();
-                    if (yieldTurn !== undefined) await yieldTurn;
                   }
                 } finally {
-                  // Batch ownership includes records whose dispatch never began,
-                  // including on failure or shutdown in the middle of the batch.
-                  for (const record of received.records) {
-                    for (const part of record.parts) part.close();
-                    record.releaseRetainedIngress?.();
-                  }
+                  claimPermit?.releaseAfterInternalProcessing();
                 }
-              } finally {
-                claimPermit?.releaseAfterInternalProcessing();
               }
+            } finally {
+              claim.release();
+              if (receiveBatch === undefined) ownerReceiveBatch?.close();
             }
-          } finally {
-            claim.release();
+          };
+          // An application worker drains the one owner it claimed. Infrastructure owners
+          // drain independently, so a suspended owner does not hold the other claims.
+          if (receiveBatch !== undefined) {
+            await drainClaim();
+          } else {
+            const drain = drainClaim().catch((error) => this.reportDispatchError(error));
+            this.activeDrains.add(drain);
+            void drain.finally(() => this.activeDrains.delete(drain));
           }
         }
         if (claimBudget !== undefined && claimsDrained >= claimBudget) {
@@ -425,8 +416,11 @@ function meshDispatchFailureContext(record: ReceiveRecord): ZLinkMeshDispatchFai
 function serviceWireCommand(record: ReceiveRecord): number | undefined {
   if (record.parts.length !== 1) return undefined;
   const bytes = record.parts[0]!.data();
-  return bytes.byteLength >= 5 && bytes[0] === 0x5a && bytes[1] === 0x4d && bytes[2] === 1
-    ? bytes[3]
+  return bytes.byteLength >= SERVICE_WIRE_PREFIX_SIZE &&
+    bytes[0] === SERVICE_WIRE_MAGIC[0] &&
+    bytes[1] === SERVICE_WIRE_MAGIC[1] &&
+    bytes[SERVICE_WIRE_MAJOR_OFFSET] === SERVICE_WIRE_MAJOR
+    ? bytes[SERVICE_WIRE_COMMAND_OFFSET]
     : undefined;
 }