@zlink-systems/framework 0.30.1 → 0.30.2

package/src/runtime/backend/node/node-raw-mesh-backend.ts

@@ -1,4 +1,6 @@
+import { routingIdsEqual } from '../../routing-id';
 import { requestDurableService } from '../../foundation/durable-service-request';
+import { encodeRoutingIdStorageHex, toBackendRoutingId } from '../../routing-id';
 import {
   decodeStreamWireFrame,
   decodeStreamWireHeader,
@@ -48,6 +50,8 @@ import {
 import {
   RawServiceMeshRuntime,
   RAW_MESH_RECEIVE_TIME_BUDGET_MS,
+  type RawServiceObservedRequest,
+  type RawServiceRequestObserver,
   type RawServiceRequestResult
 } from '../../foundation/raw-service-mesh-runtime';
 import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
@@ -85,6 +89,7 @@ import {
   type ServiceAsyncInstanceActivationAuthority,
   type ServiceInstanceApplicationLifecycle,
   type ServicePendingInstanceActivation,
+  type ServiceSessionOwnerDescriptors,
   type ServiceSpotMessageFollowSeal,
   type ServiceStatefulMailboxData,
   type ServiceStatefulPendingOperation,
@@ -116,9 +121,10 @@ import {
   ServiceWireFrameworkErrorCode
 } from '../../foundation/service-wire-constants.generated';
 import {
-  APPLICATION_PAYLOAD_MINIMUM_FIELD_BYTES,
-  APPLICATION_PAYLOAD_VERSION,
   decodeApplicationPayloadView,
+  decodeMultipartApplicationPayloadView,
+  decodeMultipartApplicationParts,
+  decodeMultipartParts,
   encodeMultipartApplicationPayload,
   ServiceWireProtocolError,
   type ServiceApplicationPayload
@@ -137,18 +143,20 @@ import {
   ZLinkBackendResultError,
   type ZLinkBackendMessageLike as MessageLike
 } from '../runtime-values';
-import { translateBindingResultError } from './node-backend-adapter-support';
-import { disconnectStreamPeer } from './node-socket-backend-adapter';
+import { translateBindingResultError, toNativeRoutingId } from './node-backend-adapter-support';
+import { disconnectSocketPeer } from './node-socket-backend-adapter';
 const DEFAULT_NATIVE_ACTIVE_CAPACITY = 10_000;
 const UNSTARTED_DIAGNOSTIC_ENDPOINT = 'inproc://not-started';
 
 const MULTIPART_PACKET_NAME = SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME;
 const MULTIPART_CONTENT_TYPE = SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
-const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 const MAX_DRAIN_RECORDS = 64;
-// Preserve the existing route observation/admission/liveness cadence. Only the binding
-// readable handler admits receive work; this timer never probes the socket.
+// The maintenance timer runs at the nearest management deadline and never
+// sooner than this. Only the binding readable handler admits receive work;
+// this timer never probes the socket.
 const MESH_BACKEND_MAINTENANCE_INTERVAL_MS = 1;
+/** The longest single timer delay Node accepts. */
+const MESH_BACKEND_MAINTENANCE_MAX_DELAY_MS = 2 ** 31 - 1;
 // Spec 08 §4.2 bounds the combined turn. Raw gets one equal share; stateful
 // can use the remaining turn, including time the raw registry did not consume.
 const MESH_BACKEND_RAW_MAINTENANCE_SHARE = 1 / 2;
@@ -185,15 +193,17 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   private stateful?: ServiceStatefulRuntime;
   private readyHandler?: (domains: number) => number;
   private maintenanceTimer?: NodeJS.Timeout;
-  private pumping = false;
+  private maintenanceDueMs = Number.POSITIVE_INFINITY;
+  private pumpTask?: Promise<void>;
   private readable = 0;
   private readonly onReadable = (receiveReady: boolean, routeReady: boolean): void => {
     if (receiveReady) this.readable |= 1;
     if (routeReady) this.readable |= 2;
-    if (!this.closed && !this.pumping) void this.pump();
+    this.pump();
   };
   private readonly onMaintenance = (): void => {
     this.maintenanceTimer = undefined;
+    this.maintenanceDueMs = Number.POSITIVE_INFINITY;
     if (this.closed) return;
     const nowMs = performance.now();
     const turnDeadlineMs = nowMs + RAW_MESH_RECEIVE_TIME_BUDGET_MS;
@@ -203,7 +213,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     );
     this.stateful?.expireOperations(nowMs, turnDeadlineMs);
     this.scheduleMaintenance();
-    void this.pump();
+    this.pump();
   };
   private readonly onPendingOperationsChanged = (): void => this.scheduleMaintenance();
   private nextPeerIntent = 1n;
@@ -228,6 +238,8 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord
   ) => void;
   private dispatchErrors?: ZLinkDispatchErrorReporter;
+  private sessionOwnerDescriptors?: ServiceSessionOwnerDescriptors;
+  private requestSourceAcceptance?: import('../contracts').ZLinkBackendRequestSourceAcceptance;
   private readonly peerDisconnectedHandlers = new Set<(endpoint: string) => void>();
   constructor(
     private readonly meshName: string,
@@ -284,6 +296,11 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     this.stateful?.setDispatchErrorReporter(reporter, this.meshName);
   }
 
+  setSessionOwnerDescriptors(source: ServiceSessionOwnerDescriptors): void {
+    this.sessionOwnerDescriptors = source;
+    this.stateful?.setSessionOwnerDescriptors(source);
+  }
+
   setProtocolErrorHandler(
     handler: (record: {
       readonly sourceNodeRid: string;
@@ -364,7 +381,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   }
 
   setRoutingId(routingId: unknown): void {
-    if (String(routingId) !== this.routingId) {
+    if (!routingIdsEqual(toBackendRoutingId(routingId), this.routingId)) {
       throw new Error('MeshNode routing id is immutable after construction.');
     }
   }
@@ -432,15 +449,21 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     if (this.dispatchErrors !== undefined) {
       this.stateful.setDispatchErrorReporter(this.dispatchErrors, this.meshName);
     }
+    if (this.sessionOwnerDescriptors !== undefined) {
+      this.stateful.setSessionOwnerDescriptors(this.sessionOwnerDescriptors);
+    }
     if (this.mailboxRecordDropped !== undefined) {
       this.stateful.setMailboxDropHandler(this.mailboxRecordDropped);
     }
     this.stateful.setMessageFollowHandler((record) => this.messageFollowHandler?.(record));
+    if (this.requestSourceAcceptance !== undefined) {
+      this.stateful.setRequestSourceAcceptance(this.requestSourceAcceptance);
+    }
     this.runtime = runtime;
     try {
       runtime.setReadableHandler(this.onReadable);
     } catch (error) {
-      this.close();
+      void this.close().catch((failure) => runtime.reportInfrastructureFailure(failure));
       throw error;
     }
     this.scheduleMaintenance();
@@ -464,25 +487,30 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     return await this.requireStateful().sendMessageFollowNotification(targetNodeRid, record);
   }
 
-  shutdown(_timeoutMs: number): RequestResultValue {
-    this.close();
+  async shutdown(_timeoutMs: number): Promise<RequestResultValue> {
+    await this.close();
     return RequestResult.Ok;
   }
 
+  cancelPendingOperations(reason: unknown): void {
+    this.stateful?.cancelPendingOperations(reason);
+    this.runtime?.cancelPendingOperations(reason);
+  }
+
   async publishDraining(): Promise<void> {
     for (const name of this.channels.keys()) this.channels.set(name, 0);
     await this.requireRuntime().updateLocalDescriptor({ state: 'draining' });
   }
 
-  close(): void {
-    if (this.closed) return;
+  async close(): Promise<void> {
+    this.closed = true;
     if (this.maintenanceTimer !== undefined) clearTimeout(this.maintenanceTimer);
     this.maintenanceTimer = undefined;
+    if (this.pumpTask !== undefined) await this.pumpTask;
     this.stateful?.close();
     this.stateful = undefined;
     this.runtime?.close();
     this.runtime = undefined;
-    this.closed = true;
   }
 
   addChannelName(name: string): void {
@@ -545,6 +573,13 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     return intent;
   }
 
+  setRequestSourceAcceptance(
+    acceptance: import('../contracts').ZLinkBackendRequestSourceAcceptance
+  ): void {
+    this.requestSourceAcceptance = acceptance;
+    this.stateful?.setRequestSourceAcceptance(acceptance);
+  }
+
   expectPeer(peer: {
     readonly nodeRoutingId: string;
     readonly endpoint: string;
@@ -629,6 +664,20 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     return this.requireRuntime().isObjectClientNodeDirectTarget(String(targetRid));
   }
 
+  waitForPeerRoute(
+    targetRid: unknown,
+    lifecycleGeneration: bigint,
+    deadlineUnixMs: bigint,
+    signal?: AbortSignal
+  ): Promise<void> {
+    return this.requireRuntime().waitForPeerRoute(
+      String(targetRid),
+      lifecycleGeneration,
+      deadlineUnixMs,
+      signal
+    );
+  }
+
   observePeerRoute(targetRid: unknown) {
     return this.requireRuntime().observePeerRoute(String(targetRid));
   }
@@ -716,9 +765,11 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       String(targetRid),
       encodeMultipartApplicationFrame(parts),
       options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
-      options?.onAdmitted
+      options?.onAdmitted,
+      this.requestObserver,
+      OperationKind.NodeRequest
     );
-    return this.observeCompletion(pending.id, OperationKind.NodeRequest, pending.promise);
+    return this.observedOperation(pending, OperationKind.NodeRequest);
   }
 
   async sendToChannel(
@@ -737,9 +788,11 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       channelName,
       encodeMultipartApplicationFrame(parts),
       options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
-      options?.onAdmitted
+      options?.onAdmitted,
+      this.requestObserver,
+      OperationKind.ChannelRequest
     );
-    return this.observeCompletion(pending.id, OperationKind.ChannelRequest, pending.promise);
+    return this.observedOperation(pending, OperationKind.ChannelRequest);
   }
 
   status() {
@@ -945,7 +998,8 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   }
 
   waitForInstanceApplicationQuiescence(spotId: string, signal?: AbortSignal): Promise<void> {
-    return this.requireStateful().waitForInstanceApplicationQuiescence(spotId, signal);
+    // Closing the stateful owner terminalizes its operations and clears these waiters.
+    return this.stateful?.waitForInstanceApplicationQuiescence(spotId, signal) ?? Promise.resolve();
   }
 
   restoreUserSpotAuthority(
@@ -1031,7 +1085,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         generation: actor.generation
       },
       String(sessionNodeRid),
-      String(sessionRid),
+      toBackendRoutingId(sessionRid),
       bindingGeneration
     );
   }
@@ -1163,7 +1217,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
 
   commitSpotMessageFollowIngress(
     seal: ServiceSpotMessageFollowSeal,
-    target: ServiceDirectSpotRouteFence,
+    target: ServiceDirectSpotRouteFence | null,
     durationMs: number
   ): Promise<boolean> {
     return this.requireStateful().commitSpotMessageFollowIngress(seal, target, durationMs);
@@ -1344,36 +1398,52 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
 
   async sendToActor(
     actor: ZLinkBackendActorRef,
-    parts: MessageLike | readonly MessageLike[]
+    parts: MessageLike | readonly MessageLike[],
+    options?: {
+      readonly flags?: number;
+      readonly routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
+    }
   ): Promise<SubmitResultValue> {
     return this.requireStateful().sendToActor(
       actor,
-      this.peerGeneration(String(actor.nodeRid)),
-      actor.generation,
-      encodeMultipart(parts)
+      encodeMultipart(parts),
+      undefined,
+      undefined,
+      options?.routeFence
     ) as Promise<SubmitResultValue>;
   }
 
   requestToActor(
     actor: ZLinkBackendActorRef,
     parts: MessageLike | readonly MessageLike[],
-    options?: { readonly timeoutMs?: number; readonly onAdmitted?: () => void }
+    options?: {
+      readonly timeoutMs?: number;
+      readonly onAdmitted?: () => void;
+      readonly routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
+    }
   ): MeshOperationId {
     return this.observeStateful(
       OperationKind.ActorRequest,
       this.requireStateful().requestToActor(
         actor,
-        this.peerGeneration(String(actor.nodeRid)),
-        actor.generation,
         encodeMultipart(parts),
         options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
         undefined,
         undefined,
-        options?.onAdmitted
+        options?.onAdmitted,
+        options?.routeFence
       )
     );
   }
 
+  acceptRelocatedActorTerminal(
+    operation: { readonly high: bigint; readonly low: bigint },
+    replyRouteId: bigint,
+    result: import('../../foundation/service-stateful-runtime').ServiceStatefulResult
+  ): 'terminalReceived' | 'alreadyTerminal' | undefined {
+    return this.requireStateful().acceptRelocatedActorTerminal(operation, replyRouteId, result);
+  }
+
   async actorSendToActor(
     source: ZLinkBackendActorRef,
     target: ZLinkBackendActorRef,
@@ -1381,8 +1451,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): Promise<SubmitResultValue> {
     return (await this.requireStateful().sendToActor(
       target,
-      this.peerGeneration(String(target.nodeRid)),
-      target.generation,
       encodeMultipart(parts),
       source
     )) as SubmitResultValue;
@@ -1398,8 +1466,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       OperationKind.ActorRequest,
       this.requireStateful().requestToActor(
         target,
-        this.peerGeneration(String(target.nodeRid)),
-        target.generation,
         encodeMultipart(parts),
         options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
         source,
@@ -1427,18 +1493,9 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     expectedBindingGeneration: bigint,
     timeoutMs: number = DEFAULT_REQUEST_TIMEOUT_MS
   ): MeshOperationId {
-    const binding = this.requireStateful().registry.binding(actor);
-    if (binding === undefined) {
-      return this.observeImmediateFailure(OperationKind.StreamUnbind, RequestResult.NotFound);
-    }
     return this.observeStateful(
       OperationKind.StreamUnbind,
-      this.requireStateful().unbindSession(
-        binding.sessionRid,
-        actor,
-        expectedBindingGeneration,
-        timeoutMs
-      )
+      this.requireStateful().closeBoundSession(actor, expectedBindingGeneration, timeoutMs)
     );
   }
 
@@ -1563,9 +1620,35 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     return result;
   }
 
+  /**
+   * Arms the one maintenance timer for the nearest management deadline
+   * (spec 08 §4.2): request expiry, liveness, or a pending peer handshake.
+   * An earlier deadline re-arms it; a later one keeps the armed time.
+   */
   private scheduleMaintenance(): void {
     if (this.closed) return;
-    this.maintenanceTimer ??= setTimeout(this.onMaintenance, MESH_BACKEND_MAINTENANCE_INTERVAL_MS);
+    const nowMs = performance.now();
+    const dueMs = Math.max(
+      nowMs + MESH_BACKEND_MAINTENANCE_INTERVAL_MS,
+      Math.min(
+        this.runtime?.nextMaintenanceDeadlineMs(nowMs) ?? Number.POSITIVE_INFINITY,
+        this.stateful?.nextMaintenanceDeadlineMs() ?? Number.POSITIVE_INFINITY
+      )
+    );
+    if (dueMs === Number.POSITIVE_INFINITY) {
+      if (this.maintenanceTimer !== undefined) clearTimeout(this.maintenanceTimer);
+      this.maintenanceTimer = undefined;
+      this.maintenanceDueMs = dueMs;
+      return;
+    }
+    if (this.maintenanceTimer === undefined || dueMs < this.maintenanceDueMs) {
+      if (this.maintenanceTimer !== undefined) clearTimeout(this.maintenanceTimer);
+      this.maintenanceTimer = setTimeout(
+        this.onMaintenance,
+        Math.min(MESH_BACKEND_MAINTENANCE_MAX_DELAY_MS, Math.ceil(dueMs - nowMs))
+      );
+      this.maintenanceDueMs = dueMs;
+    }
     const pending =
       (this.runtime?.pendingOperationCount ?? 0) + (this.stateful?.pendingOperationCount ?? 0) > 0;
     if (pending === this.maintenanceTimer.hasRef()) return;
@@ -1576,14 +1659,19 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     }
   }
 
-  private async pump(): Promise<void> {
-    if (this.isClosed() || this.pumping) return;
-    this.pumping = true;
+  private pump(): void {
+    if (this.closed || this.pumpTask !== undefined) return;
+    this.pumpTask = this.runPump(this.requireRuntime());
+  }
+
+  private async runPump(runtime: RawServiceMeshRuntime): Promise<void> {
+    // Publish pumpTask before any callback can signal readiness or begin close.
+    await Promise.resolve();
     try {
       do {
         const ready = this.readable;
         this.readable = 0;
-        const more = await this.requireRuntime().pumpBatch((ready & 1) !== 0, (ready & 2) !== 0);
+        const more = await runtime.pumpBatch((ready & 1) !== 0, (ready & 2) !== 0);
         if (more) {
           // Yield only after actual progress, retaining readiness across the
           // existing batch limits until receive reports no data.
@@ -1591,16 +1679,14 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
           await yieldToIO();
         }
       } while (!this.closed && this.readable !== 0);
+    } catch (error) {
+      runtime.reportInfrastructureFailure(error);
     } finally {
-      this.pumping = false;
+      this.pumpTask = undefined;
       this.scheduleMaintenance();
     }
   }
 
-  private isClosed(): boolean {
-    return this.closed;
-  }
-
   private notifyReady(): void {
     const runtime = this.runtime;
     let domains = ReadyDomain.None;
@@ -1613,6 +1699,26 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     if (domains !== ReadyDomain.None) this.readyHandler?.(domains);
   }
 
+  /**
+   * The raw registry takes a remote request's terminal and hands it here,
+   * where the Framework completion owner receives it in the same turn.
+   */
+  private readonly requestObserver: RawServiceRequestObserver = {
+    operationCompleted: (id, result, operationKind) =>
+      this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, result),
+    operationFailed: (id, error, operationKind) =>
+      this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, requestFailureResult(error))
+  };
+
+  private observedOperation(
+    pending: RawServiceObservedRequest,
+    operationKind: number
+  ): MeshOperationId {
+    return pending.promise === undefined
+      ? { high: 1n, low: pending.id }
+      : this.observeCompletion(pending.id, operationKind, pending.promise);
+  }
+
   private observeCompletion(
     low: bigint,
     operationKind: number,
@@ -1638,15 +1744,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     return id;
   }
 
-  private observeImmediateFailure(operationKind: number, terminalResult: number): MeshOperationId {
-    const low = this.nextPeerIntent++;
-    return this.observeCompletion(
-      low,
-      operationKind,
-      Promise.resolve({ terminalResult, failureCode: 0 })
-    );
-  }
-
   private deliverCompletion(
     operationId: MeshOperationId,
     operationKind: number,
@@ -1935,7 +2032,9 @@ class RawStreamSessionService implements StreamSessionService {
     return {
       state: this.state,
       lifecycleGeneration: 1n,
-      sessionCount: BigInt(new Set(bindings.map((value) => value.sessionRid)).size),
+      sessionCount: BigInt(
+        new Set(bindings.map((value) => encodeRoutingIdStorageHex(value.sessionRid))).size
+      ),
       bindingCount: BigInt(bindings.length),
       pendingMessageCount: 0n,
       pendingByteCount: 0n,
@@ -1964,7 +2063,8 @@ class RawStreamSessionService implements StreamSessionService {
       retiredSession: ServiceRetiredBoundSessionRouteFence,
       actor: ServiceActorRef
     ) => void,
-    actorAuthority?: StreamSessionActorAuthorityFence
+    actorAuthority?: StreamSessionActorAuthorityFence,
+    close?: () => Promise<void>
   ): MeshOperationId {
     this.requireStarted();
     const sessionKey = String(sessionRid);
@@ -1972,13 +2072,13 @@ class RawStreamSessionService implements StreamSessionService {
     return this.observe(
       OperationKind.StreamBind,
       this.stateful.bindSession(
-        sessionKey,
+        sessionRid,
         actor,
         timeoutMs,
-        (targetSessionRid, payloadFrame) =>
-          this.deliver(targetSessionRid, actor.actorId, payloadFrame),
+        (_targetSessionRid, payloadFrame) => this.deliver(sessionKey, actor.actorId, payloadFrame),
         onBindingReplaced,
-        actorAuthority
+        actorAuthority,
+        close
       )
     );
   }
@@ -1992,12 +2092,12 @@ class RawStreamSessionService implements StreamSessionService {
     this.requireStarted();
     return this.observe(
       OperationKind.StreamUnbind,
-      this.stateful.unbindSession(String(sessionRid), actor, expectedBindingGeneration, timeoutMs)
+      this.stateful.unbindSession(sessionRid, actor, expectedBindingGeneration, timeoutMs)
     );
   }
 
   bindings(sessionRid: RoutingId) {
-    return this.stateful.sessionBindings(String(sessionRid));
+    return this.stateful.sessionBindings(sessionRid);
   }
 
   async sendToActor(
@@ -2007,7 +2107,7 @@ class RawStreamSessionService implements StreamSessionService {
   ): Promise<SubmitResultValue> {
     this.requireStarted();
     return (await this.stateful.sendSessionToActor(
-      String(sessionRid),
+      sessionRid,
       actor,
       encodeMultipart(parts)
     )) as SubmitResultValue;
@@ -2028,7 +2128,7 @@ class RawStreamSessionService implements StreamSessionService {
     if (parts.length === 0) return false;
     const actorSlot = await serviceSessionBindingIngressPortIfRegistered(this)?.actorSlot(
       actorId,
-      sessionRid
+      target
     );
     if (actorSlot === undefined) return false;
     parts[0] = Buffer.from(streamFrameWithActorSlot(parts[0]!, actorSlot));
@@ -2047,7 +2147,7 @@ class RawStreamSessionService implements StreamSessionService {
         case SubmitResult.Terminated:
           // Let the socket monitor drive the existing STREAM close/unbind
           // lifecycle instead of maintaining a second session-close state.
-          disconnectStreamPeer(this.stream, target);
+          disconnectSocketPeer(this.stream, toNativeRoutingId(target));
           throw new ZLinkBackendResultError('submit', error.result, error.nativeErrno, {
             cause: error
           });
@@ -2296,7 +2396,11 @@ function decodeMultipartRecord(
   const header = record.parts[0]!;
   const command = header[SERVICE_WIRE_COMMAND_OFFSET]!;
   const payloadFrame = record.parts[1]!;
-  const application = decodeApplicationEnvelope(payloadFrame);
+  const parts = decodeMultipartApplicationParts(
+    payloadFrame,
+    ZLinkBufferMessage.fromOwned,
+    closeMultipartMessage
+  );
   const channelName = record.owner.startsWith('channel:')
     ? record.owner.slice('channel:'.length)
     : null;
@@ -2318,7 +2422,7 @@ function decodeMultipartRecord(
       : kind === ReceiveKind.ChannelRequest
         ? OperationKind.ChannelRequest
         : 0;
-  const ingressLifecycle = receiveIngressLifecycle(record);
+  const applicationJob = record.applicationJob;
   return {
     kind,
     domain: readyDomain(record.domain),
@@ -2331,22 +2435,38 @@ function decodeMultipartRecord(
     channelName,
     topic: null,
     applicationMetadata: null,
-    packetName: application.packetName,
-    contentType: application.contentType,
+    packetName: SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME,
+    contentType: SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE,
     kindData: null,
     terminalResult: 0,
     failureErrno: 0,
-    ...ingressLifecycle,
-    parts: decodeMultipart(application.payload),
+    applicationJobPermit: applicationJob,
+    releaseRetainedIngress: applicationJob === undefined ? undefined : releaseRecordApplicationJob,
+    parts,
     reply(parts) {
       if (record.correlation === undefined) return SubmitResult.InvalidState;
       runtime.reply(record, encodeMultipartApplicationFrame(parts));
       return SubmitResult.Ok;
     },
-    replyActorJoin: () => SubmitResult.NotSupported
+    replyActorJoin: replyActorJoinNotSupported
   };
 }
 
+/** Shared by every ordinary record: the record's own permit lease is its retained ingress. */
+function releaseRecordApplicationJob(this: {
+  readonly applicationJobPermit?: import('../../application-jobs/contracts').ApplicationJobPermitPort;
+}): void {
+  (
+    this.applicationJobPermit as
+      | import('../../application-jobs/application-ingress-record-owner').ApplicationJobRecordLease
+      | undefined
+  )?.close();
+}
+
+function replyActorJoinNotSupported(): SubmitResultValue {
+  return SubmitResult.NotSupported;
+}
+
 function decodeStatefulRecord(
   record: ServiceMailboxRecord,
   stateful: ServiceStatefulMailboxData
@@ -2362,7 +2482,7 @@ function decodeStatefulRecord(
     ? stateful.canonicalApplicationPayload
     : payloadFrame === undefined
       ? undefined
-      : decodeApplicationEnvelope(payloadFrame);
+      : decodeMultipartApplicationPayloadView(payloadFrame);
   const operationId =
     record.correlation === undefined
       ? { high: 0n, low: 0n }
@@ -2370,6 +2490,12 @@ function decodeStatefulRecord(
   const ingressLifecycle = receiveIngressLifecycle(record);
   return {
     kind: stateful.receiveKind,
+    get requestSource() {
+      return record.requestSource;
+    },
+    prepareDispatch:
+      record.sourcePreparationOwner === undefined ? undefined : prepareStatefulMailboxDispatch,
+    statefulMailboxRecord: record,
     domain: readyDomain(record.domain),
     sourceNodeRid: (record.sourceRoutingId as RoutingId | undefined) ?? null,
     sourceSpotId: (stateful.sourceSpotId as RoutingId | undefined) ?? null,
@@ -2468,6 +2594,17 @@ function receiveIngressLifecycle(record: ServiceMailboxRecord): {
       };
 }
 
+function prepareStatefulMailboxDispatch(
+  this: import('../../foundation/service-runtime-contracts').ReceiveRecord,
+  signal: AbortSignal
+): boolean | Promise<boolean> {
+  const mailboxRecord = this.statefulMailboxRecord;
+  const owner = mailboxRecord?.sourcePreparationOwner;
+  return mailboxRecord === undefined || owner === undefined
+    ? true
+    : owner.prepareDispatch(mailboxRecord, signal);
+}
+
 function readyOwner(
   owner: string,
   nodeRid: string,
@@ -2590,53 +2727,6 @@ function encodeMultipartApplicationFrame(parts: MessageLike | readonly MessageLi
   );
 }
 
-function decodeApplicationEnvelope(frame: Uint8Array) {
-  const bytes = Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength);
-  if (
-    bytes.length < APPLICATION_PAYLOAD_MINIMUM_FIELD_BYTES ||
-    bytes[0] !== APPLICATION_PAYLOAD_VERSION
-  ) {
-    throw new ServiceWireProtocolError('Invalid application envelope.');
-  }
-  const bodyLength = bytes.readUInt32BE(1);
-  if (bodyLength !== bytes.length - 5) {
-    throw new ServiceWireProtocolError('Invalid application envelope length.');
-  }
-  let offset = 5;
-  const packetLength = bytes[offset++]!;
-  if (packetLength === 0 || bytes.length - offset < packetLength + 1) {
-    throw new ServiceWireProtocolError('Invalid application envelope packet name.');
-  }
-  let packetName: string;
-  try {
-    packetName = FATAL_UTF8.decode(bytes.subarray(offset, offset + packetLength));
-  } catch {
-    throw new ServiceWireProtocolError('Invalid application envelope packet name.');
-  }
-  offset += packetLength;
-  const contentLength = bytes[offset++]!;
-  if (contentLength === 0 || bytes.length - offset < contentLength + 4) {
-    throw new ServiceWireProtocolError('Invalid application envelope content type.');
-  }
-  let contentType: string;
-  try {
-    contentType = FATAL_UTF8.decode(bytes.subarray(offset, offset + contentLength));
-  } catch {
-    throw new ServiceWireProtocolError('Invalid application envelope content type.');
-  }
-  offset += contentLength;
-  const payloadLength = bytes.readUInt32BE(offset);
-  offset += 4;
-  if (
-    packetName !== MULTIPART_PACKET_NAME ||
-    contentType !== MULTIPART_CONTENT_TYPE ||
-    payloadLength !== bytes.length - offset
-  ) {
-    throw new ServiceWireProtocolError('Unexpected M6A application payload.');
-  }
-  return { packetName, contentType, payload: bytes.subarray(offset) };
-}
-
 function decodeMultipart(payload: Uint8Array): FrameworkMessage[] {
   return decodeMultipartParts(payload, ZLinkBufferMessage.fromOwned, closeMultipartMessage);
 }
@@ -2649,45 +2739,6 @@ function borrowMultipartPart(part: Buffer): Buffer {
   return part;
 }
 
-function decodeMultipartParts<T>(
-  payload: Uint8Array,
-  materialize: (part: Buffer) => T,
-  release?: (part: T) => void
-): T[] {
-  const bytes = Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);
-  if (bytes.length < 4) throw new ServiceWireProtocolError('Truncated multipart payload.');
-  const count = bytes.readUInt32BE(0);
-  if (count === 0 || count > Math.floor((bytes.length - 4) / 4)) {
-    throw new ServiceWireProtocolError('Invalid multipart part count.');
-  }
-  const result = new Array<T>(count);
-  let offset = 4;
-  let index = 0;
-  try {
-    for (; index < count; index++) {
-      if (bytes.length - offset < 4) {
-        throw new ServiceWireProtocolError('Truncated multipart part length.');
-      }
-      const length = bytes.readUInt32BE(offset);
-      offset += 4;
-      if (bytes.length - offset < length) {
-        throw new ServiceWireProtocolError('Truncated multipart part.');
-      }
-      result[index] = materialize(bytes.subarray(offset, offset + length));
-      offset += length;
-    }
-    if (offset !== bytes.length) {
-      throw new ServiceWireProtocolError('Multipart payload has trailing bytes.');
-    }
-    return result;
-  } catch (error) {
-    if (release !== undefined) {
-      for (let retained = 0; retained < index; retained++) release(result[retained]!);
-    }
-    throw error;
-  }
-}
-
 function messageBytesView(value: MessageLike): Uint8Array {
   if (typeof value === 'object' && 'data' in value) {
     return value.data();