@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/foundation/service-stateful-runtime.ts

@@ -1,3 +1,7 @@
+import { requestTerminalError } from '../messaging/request-deadline';
+import type { PendingOperation } from './operation-registry';
+import type { RequestRuntime } from './request-runtime';
+import { inspectRuntime } from '../internal-observation';
 import { awaitWithAbort, isAbortError } from '../abort';
 import { decodeChannelHeader } from '../channels/channel-envelope';
 import { ZLinkBufferMessage } from '../backend/runtime-message';
@@ -19,7 +23,7 @@ import {
   ZLinkDispatchMessageKind,
   ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import { requestDurableService } from './durable-service-request';
+import { admitServiceRequest, requestDurableService } from './durable-service-request';
 import { shouldCompactBackingArray } from '../admission';
 import { RequestResult, SubmitResult, isZLinkBackendResultError } from '../backend/runtime-values';
 import type { ZLinkDispatchErrorReporter } from '../channels/dispatch-error-reporter';
@@ -38,7 +42,7 @@ import {
   type ActorJoin28
 } from '../protocol/service_wire_pilot_codec.generated';
 import { canonicalActorJoinHandoffId, routingIdBytes } from './actor-join-recovery-codec';
-import { OperationRegistry } from './operation-registry';
+import { OperationCancelledError, OperationRegistry } from './operation-registry';
 import {
   MessageFollowSuppressionRegistry,
   type MessageFollowSuppressionFence
@@ -119,12 +123,14 @@ import {
   SERVICE_WIRE_MAJOR,
   SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE
 } from './service-wire-constants.generated';
+import { copyPayloadBytes } from '../../contracts/Common/payload-slab';
 import {
   ServiceWireProtocolError,
   decodeApplicationPayload,
   decodeApplicationPayloadView,
   decodeMultipartApplicationParts,
   encodeApplicationPayload,
+  encodeOwnedApplicationPayload,
   type ServiceApplicationPayload
 } from './service-wire-m6a-codec';
 
@@ -163,6 +169,7 @@ interface ServiceSpotMessageFollowState {
 export interface ServiceStatefulResult {
   readonly terminalResult: number;
   readonly failureCode: number;
+  readonly failureMessage?: string;
   readonly payload?: ServiceApplicationPayload;
   readonly kindData?: ReceiveKindData;
   readonly applicationMetadata?: Buffer;
@@ -173,7 +180,7 @@ export interface ServiceStatefulResult {
   };
 }
 
-export interface ServiceStatefulPendingOperation {
+export interface ServiceStatefulPendingOperation extends PendingOperation<ServiceStatefulResult> {
   readonly id: bigint;
   readonly promise: Promise<ServiceStatefulResult>;
 }
@@ -442,6 +449,28 @@ export interface ServiceUserSpotOperationHandler {
  * remain in the common mailbox, where a claimed Spot or Actor owner is serial.
  */
 export class ServiceStatefulRuntime {
+  [inspectRuntime]() {
+    return Object.freeze({
+      canonicalActorJoinHandoffs: this.canonicalActorJoinHandoffs.size,
+      spotRoutes: this.spotRoutes.size,
+      instanceRoute: (spotId: string) => {
+        const route = this.instanceIntents.get(spotId)?.route;
+        return route === undefined ? undefined : Object.freeze({ ...route });
+      },
+      directSpotRoute: (spotId: string) => {
+        const route = this.directSpotRoutes.get(directSpotKey(spotId));
+        return route === undefined
+          ? undefined
+          : Object.freeze({ ...route, spot: Object.freeze({ ...route.spot }) });
+      },
+      spotMessageFollow: Object.freeze(
+        [...this.spotMessageFollow.values()].map((state) =>
+          Object.freeze({ queuedCount: state.queuedCount, queuedBytes: state.queuedBytes })
+        )
+      )
+    });
+  }
+
   //  Captured at module load, before any application turn exists: running a
   //  callback through this snapshot detaches every AsyncLocalStorage context
   //  (Spot serial turn, execution area, flow) so local loopback ingress
@@ -450,7 +479,7 @@ export class ServiceStatefulRuntime {
 
   readonly registry: ServiceStatefulRegistry;
 
-  private readonly operations: ServiceTerminalOperationRegistry<ServiceStatefulResult, bigint>;
+  readonly operations: ServiceTerminalOperationRegistry<ServiceStatefulResult, bigint>;
   private readonly sessionDeliveries = new Map<string, ServiceSessionDelivery>();
   /**
    * A local Actor owner can replace its own session binding before the
@@ -494,7 +523,7 @@ export class ServiceStatefulRuntime {
   private dispatchErrors?: ZLinkDispatchErrorReporter;
   private sessionOwnerDescriptors?: ServiceSessionOwnerDescriptors;
   private dispatchErrorMeshName?: string;
-  private readonly admittedUserSpotOperations = new Map<
+  readonly admittedUserSpotOperations = new Map<
     string,
     {
       readonly request: string;
@@ -517,10 +546,15 @@ export class ServiceStatefulRuntime {
     private readonly raw: RawServiceMeshRuntime,
     readonly nodeRid: string,
     readonly nodeGeneration: bigint,
-    onPendingOperationsChanged?: () => void
+    onPendingOperationsChanged?: () => void,
+    private readonly requests?: RequestRuntime
   ) {
     this.operations = new ServiceTerminalOperationRegistry(
-      new OperationRegistry(undefined, onPendingOperationsChanged)
+      requests?.operations<ServiceStatefulResult, bigint>() ??
+        new OperationRegistry(undefined, onPendingOperationsChanged, (reason) =>
+          requestTerminalError('Request', reason)
+        ),
+      requests === undefined ? undefined : () => {}
     );
     this.registry = new ServiceStatefulRegistry(nodeRid, nodeGeneration);
     this.registry.createEntrySpot(nodeRid);
@@ -1519,15 +1553,18 @@ export class ServiceStatefulRuntime {
     requested: ServiceDirectSpotRouteFence,
     payload: ServiceApplicationPayload,
     timeoutMs: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>,
+    receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): ServiceStatefulPendingOperation {
-    const pending = this.operations.register(timeoutMs);
+    const pending =
+      (requestOperation as PendingOperation<ServiceStatefulResult> | undefined) ??
+      this.operations.register(timeoutMs);
     const target = this.acceptSpotAuthority(requested);
     if (target === undefined) {
-      this.operations.reply(
-        pending.id,
-        internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale)
-      );
+      const result = internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      if (receiver === undefined) pending.reply(result);
+      else receiver.operationCompleted(pending.id, result, undefined);
       return pending;
     }
     const header = encodeSpotHeader('spotRequest', sourceSpotId, target, pending.id, {
@@ -1541,7 +1578,8 @@ export class ServiceStatefulRuntime {
       timeoutMs,
       'spotRequest',
       undefined,
-      onAdmitted
+      onAdmitted,
+      receiver
     );
     return pending;
   }
@@ -1578,16 +1616,20 @@ export class ServiceStatefulRuntime {
     sourceActor?: ServiceActorRef,
     boundSession?: { readonly sessionRid: string; readonly bindingGeneration: bigint },
     onAdmitted?: () => void,
-    routeFence?: ServiceActorRouteFence
+    routeFence?: ServiceActorRouteFence,
+    requestOperation?: PendingOperation<unknown>,
+    receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): ServiceStatefulPendingOperation {
     const operationLow = this.nextMessageFollowOperation++;
-    const pending = this.operations.register(timeoutMs, 'registry', operationLow);
+    const pending =
+      (requestOperation as PendingOperation<ServiceStatefulResult> | undefined) ??
+      this.operations.register(timeoutMs, 'registry', operationLow);
+    this.operations.setContext(pending.id, operationLow);
     const route = routeFence ?? this.tryActorFence(target);
     if (route === undefined) {
-      this.operations.reply(
-        pending.id,
-        internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale)
-      );
+      const result = internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      if (receiver !== undefined) receiver.operationCompleted(pending.id, result, undefined);
+      else pending.reply(result);
       return pending;
     }
     const header = encodeActorHeader(
@@ -1610,7 +1652,8 @@ export class ServiceStatefulRuntime {
       timeoutMs,
       'actorRequest',
       undefined,
-      onAdmitted
+      onAdmitted,
+      receiver
     );
     return pending;
   }
@@ -1712,9 +1755,13 @@ export class ServiceStatefulRuntime {
     sourceSpotId?: string,
     metadataFrame?: Uint8Array,
     instanceIntent = false,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>,
+    receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): ServiceStatefulPendingOperation {
-    const pending = this.operations.register(timeoutMs);
+    const pending =
+      (requestOperation as PendingOperation<ServiceStatefulResult> | undefined) ??
+      this.operations.register(timeoutMs);
     this.submitRequest(
       pending,
       route.targetNodeRid,
@@ -1738,7 +1785,8 @@ export class ServiceStatefulRuntime {
       timeoutMs,
       'instanceSpotRequest',
       undefined,
-      onAdmitted
+      onAdmitted,
+      receiver
     );
     return pending;
   }
@@ -1748,7 +1796,8 @@ export class ServiceStatefulRuntime {
     payload: ServiceApplicationPayload,
     timeoutMs: number,
     sourceSpotId?: string,
-    metadataFrame?: Uint8Array
+    metadataFrame?: Uint8Array,
+    requestOperation?: PendingOperation<unknown>
   ): ServiceStatefulPendingOperation {
     const deadlineUnixMs = BigInt(Date.now() + timeoutMs);
     const payloadFrame = encodeApplicationPayload(payload);
@@ -1757,7 +1806,9 @@ export class ServiceStatefulRuntime {
       payloadFrame,
       deadlineUnixMs,
       sourceSpotId,
-      metadataFrame
+      metadataFrame,
+      undefined,
+      requestOperation
     );
   }
 
@@ -1767,10 +1818,13 @@ export class ServiceStatefulRuntime {
     deadlineUnixMs: bigint,
     sourceSpotId?: string,
     metadataFrame?: Uint8Array,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ): ServiceStatefulPendingOperation {
     const timeoutMs = remainingDeadlineMs(deadlineUnixMs);
-    const pending = this.operations.register(timeoutMs);
+    const pending =
+      (requestOperation as PendingOperation<ServiceStatefulResult> | undefined) ??
+      this.operations.register(timeoutMs);
     this.submitRequest(
       pending,
       target.targetNodeRid,
@@ -1822,9 +1876,9 @@ export class ServiceStatefulRuntime {
       queueMicrotask(() => {
         try {
           this.registry.destroyActor(actor);
-          this.operations.reply(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+          pending.reply({ terminalResult: RequestResult.Ok, failureCode: 0 });
         } catch (error) {
-          this.operations.reply(pending.id, failure(error));
+          pending.reply(failure(error));
         }
       });
       return pending;
@@ -1843,10 +1897,7 @@ export class ServiceStatefulRuntime {
     timeoutMs: number
   ): ServiceStatefulPendingOperation {
     const deadlineMs = performance.now() + timeoutMs;
-    const pending = this.operations.register(
-      timeoutMs,
-      targetNodeRid === this.nodeRid ? 'registry' : 'sender'
-    );
+    const pending = this.operations.register(timeoutMs, 'registry', undefined, deadlineMs);
     const target = this.trySpotFence(targetNodeRid, {
       ...targetSpot,
       generation: targetSpotGeneration
@@ -1866,10 +1917,7 @@ export class ServiceStatefulRuntime {
     timeoutMs: number
   ): ServiceStatefulPendingOperation {
     const deadlineMs = performance.now() + timeoutMs;
-    const pending = this.operations.register(
-      timeoutMs,
-      targetNodeRid === this.nodeRid ? 'registry' : 'sender'
-    );
+    const pending = this.operations.register(timeoutMs, 'registry', undefined, deadlineMs);
     const target = this.trySpotFence(targetNodeRid, {
       ...targetSpot,
       generation: targetSpotGeneration
@@ -1889,10 +1937,7 @@ export class ServiceStatefulRuntime {
     timeoutMs: number
   ): ServiceStatefulPendingOperation {
     const deadlineMs = performance.now() + timeoutMs;
-    const pending = this.operations.register(
-      timeoutMs,
-      targetNodeRid === this.nodeRid ? 'registry' : 'sender'
-    );
+    const pending = this.operations.register(timeoutMs, 'registry', undefined, deadlineMs);
     this.submitActorJoin(
       pending,
       actor,
@@ -1913,10 +1958,7 @@ export class ServiceStatefulRuntime {
     timeoutMs: number
   ): ServiceStatefulPendingOperation {
     const deadlineMs = performance.now() + timeoutMs;
-    const pending = this.operations.register(
-      timeoutMs,
-      targetNodeRid === this.nodeRid ? 'registry' : 'sender'
-    );
+    const pending = this.operations.register(timeoutMs, 'registry', undefined, deadlineMs);
     this.submitActorJoin(
       pending,
       actor,
@@ -1951,9 +1993,9 @@ export class ServiceStatefulRuntime {
           currentMembershipEpoch: transition.currentMembershipEpoch,
           resultCode: 0
         });
-        this.operations.reply(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+        pending.reply({ terminalResult: RequestResult.Ok, failureCode: 0 });
       } catch (error) {
-        this.operations.reply(pending.id, failure(error));
+        pending.reply(failure(error));
       }
     });
     return pending;
@@ -1969,11 +2011,10 @@ export class ServiceStatefulRuntime {
     close?: () => Promise<void>
   ): ServiceStatefulPendingOperation {
     const deadlineMs = performance.now() + timeoutMs;
-    const pending = this.operations.register(timeoutMs, 'sender');
+    const pending = this.operations.register(timeoutMs, 'registry', undefined, deadlineMs);
     const sessionOwner = this.localSessionOwner();
     if (sessionOwner === undefined) {
-      this.operations.reply(
-        pending.id,
+      pending.reply(
         failure(
           createInternalFrameworkException(
             ZLinkFrameworkInternalErrorKind.RouteNotConnected,
@@ -2027,7 +2068,7 @@ export class ServiceStatefulRuntime {
           } else {
             this.sessionDeliveries.set(deliveryKey, { ...delivery, binding: previous });
           }
-          this.operations.reply(pending.id, {
+          pending.reply({
             terminalResult: RequestResult.Ok,
             failureCode: 0
           });
@@ -2036,7 +2077,7 @@ export class ServiceStatefulRuntime {
         const binding = this.registry.installSessionBinding(localBinding);
         installedDelivery = { ...delivery, binding };
         this.sessionDeliveries.set(deliveryKey, installedDelivery);
-        this.operations.reply(pending.id, {
+        pending.reply({
           terminalResult: RequestResult.Ok,
           failureCode: 0,
           kindData: undefined
@@ -2065,7 +2106,7 @@ export class ServiceStatefulRuntime {
         ) {
           this.sessionDeliveries.delete(deliveryKey);
         }
-        this.operations.reply(pending.id, failure(error));
+        pending.reply(failure(error));
       }
       return pending;
     }
@@ -2079,7 +2120,7 @@ export class ServiceStatefulRuntime {
         generation
       });
     } catch (error) {
-      this.operations.fail(pending.id, error);
+      pending.replyFailure(error);
       return pending;
     }
     void this.requestDurableOperation(
@@ -2087,13 +2128,12 @@ export class ServiceStatefulRuntime {
       [header],
       pending.id,
       'streamBind',
-      deadlineMs
+      pending
     ).then(
       (reply) => this.completeRemoteReply(pending, actor.nodeRid, 'streamBind', undefined, reply),
-      (error) => this.operations.fail(pending.id, error)
+      (error) => pending.replyFailure(error)
     );
-    return {
-      id: pending.id,
+    return Object.assign(Object.create(pending) as ServiceStatefulPendingOperation, {
       promise: pending.promise.then((result) => {
         if (result.terminalResult === RequestResult.Ok && result.streamBinding !== undefined) {
           const committed: ServiceSessionDelivery = {
@@ -2125,7 +2165,7 @@ export class ServiceStatefulRuntime {
         }
         return result;
       })
-    };
+    });
   }
 
   closeBoundSession(
@@ -2136,8 +2176,7 @@ export class ServiceStatefulRuntime {
     const pending = this.operations.register(timeoutMs);
     const binding = this.registry.binding(actor);
     if (binding === undefined) {
-      this.operations.reply(
-        pending.id,
+      pending.reply(
         internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorSessionNotBound)
       );
       return pending;
@@ -2165,8 +2204,14 @@ export class ServiceStatefulRuntime {
       )[0]!
     );
     const reply = routingIdsEqual(binding.sessionOwnerNodeRid, this.nodeRid)
-      ? this.requestLocalInfrastructure(header, pending.id, timeoutMs)
-      : this.raw.requestService(binding.sessionOwnerNodeRid, [header], timeoutMs);
+      ? this.requestLocalInfrastructure(header, pending.id, pending)
+      : requestDurableService(
+          this.raw,
+          binding.sessionOwnerNodeRid,
+          [header],
+          pending,
+          'boundSessionClose'
+        );
     void reply.then(
       (parts) =>
         this.completeRemoteReply(
@@ -2176,7 +2221,7 @@ export class ServiceStatefulRuntime {
           undefined,
           parts
         ),
-      (error) => this.operations.fail(pending.id, error)
+      (error) => pending.replyFailure(error)
     );
     return pending;
   }
@@ -2194,19 +2239,16 @@ export class ServiceStatefulRuntime {
       !routingIdsEqual(delivery.binding.sessionRid, sessionRid) ||
       delivery.binding.bindingGeneration !== expectedBindingGeneration
     ) {
-      this.operations.reply(
-        pending.id,
-        internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale)
-      );
+      pending.reply(internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale));
       return pending;
     }
     this.sessionDeliveries.delete(actorKey(actor));
     if (actor.nodeRid === this.nodeRid) {
       try {
         this.registry.unbindSession(actor, expectedBindingGeneration);
-        this.operations.reply(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+        pending.reply({ terminalResult: RequestResult.Ok, failureCode: 0 });
       } catch (error) {
-        this.operations.reply(pending.id, failure(error));
+        pending.reply(failure(error));
       }
       return pending;
     }
@@ -2278,7 +2320,9 @@ export class ServiceStatefulRuntime {
   }
 
   expireOperations(nowMs: number, turnDeadlineMs: number): number {
-    return this.operations.expire(nowMs, turnDeadlineMs);
+    return this.requests === undefined && nowMs >= this.operations.nextDeadlineMs()
+      ? this.operations.expire(nowMs, turnDeadlineMs)
+      : 0;
   }
 
   get pendingOperationCount(): number {
@@ -2287,7 +2331,7 @@ export class ServiceStatefulRuntime {
 
   /** The next stateful request expiry, as a lower bound. */
   nextMaintenanceDeadlineMs(): number {
-    return this.operations.nextDeadlineMs();
+    return this.requests === undefined ? this.operations.nextDeadlineMs() : Infinity;
   }
 
   close(): void {
@@ -2396,7 +2440,7 @@ export class ServiceStatefulRuntime {
           ? record.parts.length >= 2
             ? record.parts[record.parts.length - 1]
             : undefined
-          : encodeApplicationPayload(canonicalPayload);
+          : encodeOwnedApplicationPayload(canonicalPayload);
       try {
         return await this.handleIngress(
           record,
@@ -2462,7 +2506,7 @@ export class ServiceStatefulRuntime {
     }
   }
 
-  private async handleIngress(
+  async handleIngress(
     ingress: RawServiceIngressRecord,
     record: ServiceStatefulWireRecord,
     payloadFrame: Buffer | undefined,
@@ -2555,6 +2599,62 @@ export class ServiceStatefulRuntime {
           ) {
             throw new ServiceStaleGenerationError('binding', record.target.actor.actorId);
           }
+          if (
+            !this.registry.acceptBoundSessionSequence(
+              record.target.actor,
+              record.boundSession.bindingGeneration,
+              record.boundSession.sequence
+            )
+          ) {
+            const error = new ZLinkFrameworkException(
+              ZLinkFrameworkErrorKind.InvalidOperation,
+              'Bound Session relay sequence does not increase.'
+            );
+            const reporter = this.dispatchErrors;
+            if (record.kind === 'actorRequest') {
+              if (reporter?.captureEnabled() === true) {
+                reporter.report({
+                  surface: ZLinkDispatchErrorSurface.StreamSession,
+                  messageKind: ZLinkDispatchMessageKind.Request,
+                  reason: ZLinkDispatchErrorReason.StaleTarget,
+                  action: ZLinkDispatchErrorAction.ReplyError,
+                  meshName: this.dispatchErrorMeshName,
+                  sourceRid: ingress.sourceRoutingId,
+                  actorId: record.target.actor.actorId,
+                  correlationId: record.correlation?.toString(),
+                  error
+                });
+              }
+              const result = failure(error);
+              this.replyWire(
+                ingress,
+                record.correlation!,
+                result.terminalResult,
+                result.failureCode
+              );
+              return 'infrastructure';
+            }
+            const tracePoint = flowIfEnabled(reporter?.flow, ZLinkMessageFlowOutcome.Dropped);
+            if (tracePoint !== undefined) {
+              tracePoint.trace({
+                outcome: ZLinkMessageFlowOutcome.Dropped,
+                surface: ZLinkDispatchErrorSurface.StreamSession,
+                messageKind: ZLinkDispatchMessageKind.Send,
+                packetName: decodeApplicationPayloadView(payloadFrame!).packetName,
+                ...(this.dispatchErrorMeshName === undefined
+                  ? {}
+                  : { meshName: this.dispatchErrorMeshName }),
+                ...(record.correlation === undefined
+                  ? {}
+                  : { correlationId: record.correlation.toString() }),
+                sourceRid: ingress.sourceRoutingId,
+                actorId: record.target.actor.actorId,
+                streamSessionId: record.boundSession.sessionRid,
+                errorReason: ZLinkDispatchErrorReason.StaleTarget
+              });
+            }
+            return 'application';
+          }
         }
         return this.enqueueApplicationFrame(
           ingress,
@@ -2714,7 +2814,7 @@ export class ServiceStatefulRuntime {
     return !lifecycle.isMaterialized(applicationTarget);
   }
 
-  private enqueueActivatedInstanceSpot(
+  enqueueActivatedInstanceSpot(
     ingress: RawServiceIngressRecord,
     record: Extract<ServiceStatefulWireRecord, { readonly kind: 'instanceSpot' }>,
     payloadFrame: Buffer,
@@ -2795,7 +2895,7 @@ export class ServiceStatefulRuntime {
     return result;
   }
 
-  private async continueMissingInstanceActivation(
+  async continueMissingInstanceActivation(
     ingress: RawServiceIngressRecord,
     record: Extract<
       ServiceStatefulWireRecord,
@@ -2894,7 +2994,7 @@ export class ServiceStatefulRuntime {
    * record only of a message whose handler turn started before it; a message queued
    * behind that Close is not counted, so it cannot hold the Close it follows.
    */
-  private activationTerminalCompletion(
+  activationTerminalCompletion(
     target: ServiceInstanceActivationTarget,
     route: ServiceInstanceRouteFence
   ): {
@@ -2941,7 +3041,7 @@ export class ServiceStatefulRuntime {
     return { onTerminalCompletion, onHandlerTurnStarted };
   }
 
-  private instanceApplicationTerminalCompletion(
+  instanceApplicationTerminalCompletion(
     target: ServiceInstanceApplicationTarget
   ): (() => Promise<void>) | undefined {
     const lifecycle = this.instanceApplicationLifecycle;
@@ -3011,7 +3111,7 @@ export class ServiceStatefulRuntime {
     for (const waiter of waiters) waiter();
   }
 
-  private finishMissingInstanceActivationFailure(
+  finishMissingInstanceActivationFailure(
     ingress: RawServiceIngressRecord,
     record: Extract<
       ServiceStatefulWireRecord,
@@ -3179,7 +3279,7 @@ export class ServiceStatefulRuntime {
     return { intent, route: current };
   }
 
-  private validateInstanceIngress(
+  validateInstanceIngress(
     ingress: RawServiceIngressRecord,
     record: Extract<ServiceStatefulWireRecord, { readonly kind: 'instanceSpot' }>
   ): void {
@@ -3281,7 +3381,7 @@ export class ServiceStatefulRuntime {
       : undefined;
   }
 
-  private activateMissingInstanceAsync(
+  activateMissingInstanceAsync(
     record: Extract<
       ServiceStatefulWireRecord,
       { readonly kind: 'instanceSpot'; readonly activation: 'missing' }
@@ -3352,7 +3452,7 @@ export class ServiceStatefulRuntime {
     return operation;
   }
 
-  private async runMissingInstanceActivation(
+  async runMissingInstanceActivation(
     record: Extract<
       ServiceStatefulWireRecord,
       { readonly kind: 'instanceSpot'; readonly activation: 'missing' }
@@ -3716,7 +3816,7 @@ export class ServiceStatefulRuntime {
             }
           })
     };
-    const applicationFrame = payloadFrame ?? encodeApplicationPayload(emptyPayload());
+    const applicationFrame = payloadFrame ?? encodeOwnedApplicationPayload(emptyPayload());
     return this.enqueueLifecycleFrame(
       ingress,
       `spot:${record.target.spot.spotId}`,
@@ -4218,7 +4318,7 @@ export class ServiceStatefulRuntime {
     );
   }
 
-  private enqueueApplicationFrame(
+  enqueueApplicationFrame(
     ingress: RawServiceIngressRecord,
     owner: string,
     payloadFrame: Buffer,
@@ -4302,7 +4402,7 @@ export class ServiceStatefulRuntime {
         channelName,
         topic,
         sourceSpotId,
-        encodeApplicationPayload(payload),
+        encodeOwnedApplicationPayload(payload),
         sourceNodeRid,
         applicationJobOwner
       );
@@ -4644,34 +4744,52 @@ export class ServiceStatefulRuntime {
     operationKind: 'userSpotCreate' | 'userSpotClose' | 'actorCreate',
     timeoutMs: number
   ): Promise<ServiceUserSpotOperationResult> {
-    const parts = await this.requestDurableOperation(
+    const deadlineMs = performance.now() + Math.max(1, timeoutMs);
+    const pending = this.operations.register(
+      Math.max(1, timeoutMs),
+      'registry',
+      undefined,
+      deadlineMs
+    );
+    const completed = (parts: readonly Buffer[]) => {
+      try {
+        if (parts.length < 1 || parts.length > 2) {
+          throw new ServiceWireProtocolError('Invalid creation operation reply parts.');
+        }
+        const decoded = decodeStatefulReply(
+          parts[0]!,
+          correlation,
+          operationKind,
+          parts.length >= 2
+        );
+        if (decoded.terminalResult !== RequestResult.Ok && parts.length !== 1) {
+          throw new ServiceWireProtocolError('Failed creation operation reply carries a payload.');
+        }
+        if (operationKind === 'userSpotClose' && parts.length !== 1) {
+          throw new ServiceWireProtocolError('User Spot close reply carries a payload.');
+        }
+        const value: ServiceUserSpotOperationResult = {
+          terminalResult: decoded.terminalResult,
+          failureCode: decoded.failureCode,
+          ...(decoded.tail === undefined ? {} : { tail: decoded.tail as never }),
+          ...(parts.length === 2 ? { payload: decodeApplicationPayload(parts[1]!) } : {})
+        };
+        pending.complete(value);
+      } catch (error) {
+        pending.fail(translateWireReplyDecodeError(error));
+      }
+    };
+    const failed = (error: unknown) => {
+      pending.fail(error);
+    };
+    void this.requestDurableOperation(
       targetNodeRid,
       [header],
       correlation,
       operationKind,
-      performance.now() + Math.max(1, timeoutMs)
-    );
-    // A received envelope, including a decode failure, ends sender replay.
-    try {
-      if (parts.length < 1 || parts.length > 2) {
-        throw new ServiceWireProtocolError('Invalid creation operation reply parts.');
-      }
-      const decoded = decodeStatefulReply(parts[0]!, correlation, operationKind, parts.length >= 2);
-      if (decoded.terminalResult !== RequestResult.Ok && parts.length !== 1) {
-        throw new ServiceWireProtocolError('Failed creation operation reply carries a payload.');
-      }
-      if (operationKind === 'userSpotClose' && parts.length !== 1) {
-        throw new ServiceWireProtocolError('User Spot close reply carries a payload.');
-      }
-      return {
-        terminalResult: decoded.terminalResult,
-        failureCode: decoded.failureCode,
-        ...(decoded.tail === undefined ? {} : { tail: decoded.tail as never }),
-        ...(parts.length === 2 ? { payload: decodeApplicationPayload(parts[1]!) } : {})
-      };
-    } catch (error) {
-      throw translateWireReplyDecodeError(error);
-    }
+      pending
+    ).then(completed, failed);
+    return pending.promise;
   }
 
   private async requestDurableOperation(
@@ -4679,44 +4797,31 @@ export class ServiceStatefulRuntime {
     parts: readonly Buffer[],
     correlation: bigint,
     operationKind: 'userSpotCreate' | 'userSpotClose' | 'actorCreate' | 'streamBind' | 'actorJoin',
-    deadlineMs: number
+    pending: PendingOperation<unknown>
   ): Promise<readonly Buffer[]> {
     this.requireOpen();
     if (targetNodeRid === this.nodeRid) {
-      return this.requestLocalInfrastructure(
-        parts[0]!,
-        correlation,
-        Math.ceil(deadlineMs - performance.now())
-      );
+      return this.requestLocalInfrastructure(parts[0]!, correlation, pending);
     }
-    return requestDurableService(this.raw, targetNodeRid, parts, deadlineMs, operationKind);
+    return requestDurableService(this.raw, targetNodeRid, parts, pending, operationKind);
   }
 
   private requestLocalInfrastructure(
     header: Buffer,
     requestSequence: bigint,
-    timeoutMs: number
+    pending: PendingOperation<unknown>
   ): Promise<readonly Buffer[]> {
     return new Promise((resolve, reject) => {
-      let settled = false;
-      const fail = (error: unknown) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        reject(error);
-      };
-      const timer = setTimeout(() => {
-        fail(new Error('Local infrastructure request timed out.'));
-      }, timeoutMs);
-      const finish = (parts: readonly Uint8Array[]) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
+      const finish: NonNullable<ServiceMailboxRecord['reply']> = (parts) => {
         resolve(parts.map((part) => Buffer.from(part)));
       };
       void (async () => {
         const applicationJobOwner = await this.raw.reserveLocalIngress();
         try {
+          if (!pending.isPending()) {
+            await pending.promise;
+            throw new OperationCancelledError(pending.id, 'Request is already terminal.');
+          }
           const result = await this.ingress({
             command: header[SERVICE_WIRE_COMMAND_OFFSET]!,
             flags: header[SERVICE_WIRE_FLAGS_OFFSET]!,
@@ -4727,22 +4832,21 @@ export class ServiceStatefulRuntime {
             applicationJobOwner
           });
           if (result !== 'infrastructure') {
-            fail(
-              new ServiceWireProtocolError(
-                `Local infrastructure request was rejected as '${result ?? 'unsupported'}'.`
-              )
+            throw new ServiceWireProtocolError(
+              `Local infrastructure request was rejected as '${result ?? 'unsupported'}'.`
             );
           }
         } finally {
           applicationJobOwner.close();
         }
-      })().catch(fail);
+      })().catch(reject);
     });
   }
 
   private async submitOneWay(targetNodeRid: string, parts: readonly Buffer[]): Promise<number> {
     this.requireOpen();
     if (targetNodeRid === this.nodeRid) {
+      parts = copyRetainedServiceFrames(parts);
       const applicationJobOwner = await this.raw.reserveLocalIngress();
       if (captureZLinkExecutionTurn() !== undefined) {
         //  The sender is inside a Spot serial turn. Running ingress inline
@@ -4814,9 +4918,11 @@ export class ServiceStatefulRuntime {
       | 'streamUnbind'
       | 'instanceSpotRequest',
     actor?: ServiceActorRef,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): void {
     if (targetNodeRid === this.nodeRid) {
+      parts = copyRetainedServiceFrames(parts);
       const deadlineUnixMs = BigInt(Date.now() + Math.max(0, timeoutMs));
       const capacityStop = new AbortController();
       void pending.promise.then(
@@ -4826,7 +4932,7 @@ export class ServiceStatefulRuntime {
       void (async () => {
         const applicationJobOwner = await this.raw.reserveLocalIngress(capacityStop.signal);
         try {
-          if (!this.operations.isPending(pending.id)) return;
+          if (!pending.isPending()) return;
           const localIngress: RawServiceIngressRecord = {
             command: parts[0]![SERVICE_WIRE_COMMAND_OFFSET]!,
             flags: parts[0]![SERVICE_WIRE_FLAGS_OFFSET]!,
@@ -4841,19 +4947,71 @@ export class ServiceStatefulRuntime {
             pending,
             operationKind,
             actor,
-            deadlineUnixMs
+            deadlineUnixMs,
+            receiver
           );
         } catch (error) {
-          this.operations.reply(pending.id, failure(error));
+          receiver === undefined
+            ? pending.reply(failure(error))
+            : receiver.operationFailed(pending.id, error, undefined);
         } finally {
           applicationJobOwner.close();
         }
-      })().catch((error) => this.operations.reply(pending.id, failure(error)));
+      })().catch((error) =>
+        receiver === undefined
+          ? pending.reply(failure(error))
+          : receiver.operationFailed(pending.id, error, undefined)
+      );
       return;
     }
-    void this.raw.requestService(targetNodeRid, parts, timeoutMs, onAdmitted).then(
+    if (receiver !== undefined) {
+      const completion = {
+        operationCompleted: (_id: bigint, reply: readonly Buffer[]) =>
+          this.completeRemoteReply(pending, targetNodeRid, operationKind, actor, reply, receiver),
+        operationFailed: (_id: bigint, error: unknown) =>
+          receiver.operationFailed(pending.id, error, undefined)
+      };
+      if (this.raw.isPeerRouteReady(targetNodeRid) === true) {
+        this.raw.requestService(targetNodeRid, parts, timeoutMs, onAdmitted, pending, completion);
+        return;
+      }
+      admitServiceRequest(
+        this.raw,
+        targetNodeRid,
+        pending,
+        (remaining, finished) => {
+          this.raw.requestService(targetNodeRid, parts, remaining, onAdmitted, pending, {
+            operationCompleted: (id, reply) => {
+              finished();
+              completion.operationCompleted(id, reply);
+            },
+            operationFailed: (id, error) => {
+              finished();
+              completion.operationFailed(id, error);
+            }
+          });
+        },
+        (error) => completion.operationFailed(pending.id, error),
+        operationKind
+      );
+      return;
+    }
+    const reply =
+      this.raw.isPeerRouteReady(targetNodeRid) === true
+        ? this.raw.requestService(targetNodeRid, parts, timeoutMs, onAdmitted, pending)
+        : requestDurableService(
+            this.raw,
+            targetNodeRid,
+            parts,
+            pending,
+            operationKind,
+            undefined,
+            undefined,
+            onAdmitted
+          );
+    void reply.then(
       (reply) => this.completeRemoteReply(pending, targetNodeRid, operationKind, actor, reply),
-      (error) => this.operations.fail(pending.id, error)
+      (error) => pending.replyFailure(error)
     );
   }
 
@@ -4871,10 +5029,7 @@ export class ServiceStatefulRuntime {
         ? this.tryActorFence(actor)
         : this.acceptCanonicalActorFence(actor, canonical.actorFence);
     if (target === undefined || actorRoute === undefined) {
-      this.operations.reply(
-        pending.id,
-        internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale)
-      );
+      pending.reply(internalFrameworkWireReply(ZLinkFrameworkInternalErrorKind.ActorLocationStale));
       return;
     }
     if (canonical !== undefined) {
@@ -4914,7 +5069,7 @@ export class ServiceStatefulRuntime {
       }).map((frame) => Buffer.from(frame));
     } catch (error) {
       this.canonicalActorJoinHandoffs.delete(pending.id);
-      this.operations.fail(pending.id, error);
+      pending.replyFailure(error);
       return;
     }
     if (targetNodeRid === this.nodeRid) {
@@ -4928,22 +5083,16 @@ export class ServiceStatefulRuntime {
       );
       return;
     }
-    void this.requestDurableOperation(
-      targetNodeRid,
-      parts,
-      pending.id,
-      'actorJoin',
-      deadlineMs
-    ).then(
+    void this.requestDurableOperation(targetNodeRid, parts, pending.id, 'actorJoin', pending).then(
       (reply) => this.completeRemoteReply(pending, targetNodeRid, 'actorJoin', actor, reply),
       (error) => {
         this.canonicalActorJoinHandoffs.delete(pending.id);
-        this.operations.fail(pending.id, error);
+        pending.replyFailure(error);
       }
     );
   }
 
-  private async submitLocalRequest(
+  async submitLocalRequest(
     ingress: RawServiceIngressRecord,
     pending: ServiceStatefulPendingOperation,
     operationKind:
@@ -4956,7 +5105,8 @@ export class ServiceStatefulRuntime {
       | 'streamUnbind'
       | 'instanceSpotRequest',
     actor?: ServiceActorRef,
-    deadlineUnixMs?: bigint
+    deadlineUnixMs?: bigint,
+    receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): Promise<void> {
     const canonicalActorJoin =
       operationKind === 'actorJoin' ? decodeActorJoin28(ingress.parts) : undefined;
@@ -4969,15 +5119,14 @@ export class ServiceStatefulRuntime {
         ? ingress.parts.length < 2
           ? undefined
           : ingress.parts[1]
-        : encodeApplicationPayload({
+        : encodeOwnedApplicationPayload({
             packetName: canonicalActorJoin.payload.packetName,
             contentType: canonicalActorJoin.payload.contentType,
             payload: Buffer.from(canonicalActorJoin.payload.payload)
           });
     if (decoded.kind === 'actorLookup') {
       const found = this.registry.actor(decoded.actorId);
-      this.operations.reply(
-        pending.id,
+      pending.reply(
         found === undefined
           ? { terminalResult: RequestResult.NotFound, failureCode: ACTOR_ROUTE_NOT_FOUND }
           : {
@@ -4991,9 +5140,9 @@ export class ServiceStatefulRuntime {
     if (decoded.kind === 'actorDestroy') {
       try {
         this.registry.destroyActor(decoded.actor.actor);
-        this.operations.reply(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+        pending.reply({ terminalResult: RequestResult.Ok, failureCode: 0 });
       } catch (error) {
-        this.operations.reply(pending.id, failure(error));
+        pending.reply(failure(error));
       }
       return;
     }
@@ -5002,11 +5151,19 @@ export class ServiceStatefulRuntime {
       failureCode,
       replyPayload,
       tail
-    ) =>
-      this.operations.reply(
-        pending.id,
-        this.resultFromReply(terminalResult, failureCode, replyPayload, tail, this.nodeRid, actor)
+    ) => {
+      const result = this.resultFromReply(
+        terminalResult,
+        failureCode,
+        replyPayload,
+        tail,
+        this.nodeRid,
+        actor
       );
+      if (receiver === undefined) return pending.reply(result);
+      receiver.operationCompleted(pending.id, result, undefined);
+      return true;
+    };
     if (decoded.kind === 'spotRequest') {
       this.validateDirectSpotFence(decoded.target);
       this.enqueueApplicationFrame(ingress, `spot:${decoded.target.spot.spotId}`, payloadFrame!, {
@@ -5075,7 +5232,7 @@ export class ServiceStatefulRuntime {
       this.enqueueLifecycleFrame(
         ingress,
         `spot:${decoded.target.spot.spotId}`,
-        payloadFrame ?? encodeApplicationPayload(emptyPayload()),
+        payloadFrame ?? encodeOwnedApplicationPayload(emptyPayload()),
         {
           receiveKind: ReceiveKind.SpotControl,
           operationKind: OperationKind.ActorJoin,
@@ -5092,7 +5249,7 @@ export class ServiceStatefulRuntime {
                   payload: Buffer.from(canonicalActorJoin.payload.payload)
                 }
               }),
-          isPending: () => this.operations.isPending(pending.id),
+          isPending: () => pending.isPending(),
           ...(deadlineUnixMs === undefined ? {} : { deadlineUnixMs }),
           onTerminalCompletion: () => completeOnJoinDispatchTerminal?.(),
           reply: (terminalResult, failureCode, replyPayload, tail) => {
@@ -5101,7 +5258,7 @@ export class ServiceStatefulRuntime {
               terminalResult === RequestResult.Ok &&
               tail?.kind === 'actorJoin' &&
               tail.joinResult === 0;
-            if (acceptedJoin && this.operations.isPending(pending.id)) {
+            if (acceptedJoin && pending.isPending()) {
               // Commit membership now, but keep the source operation behind
               // target OnJoinedActor. Entry finishes on this record; User
               // Spot lifecycle finishes on the Joined control below.
@@ -5158,9 +5315,9 @@ export class ServiceStatefulRuntime {
             this.nodeRid
           );
         }
-        this.operations.reply(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+        pending.reply({ terminalResult: RequestResult.Ok, failureCode: 0 });
       } catch (error) {
-        this.operations.reply(pending.id, failure(error));
+        pending.reply(failure(error));
       }
       return;
     }
@@ -5178,7 +5335,7 @@ export class ServiceStatefulRuntime {
       );
       return;
     }
-    this.operations.reply(pending.id, {
+    pending.reply({
       terminalResult: RequestResult.ProtocolError,
       failureCode: 0
     });
@@ -5186,7 +5343,7 @@ export class ServiceStatefulRuntime {
   }
 
   private completeRemoteReply(
-    pending: Pick<ServiceStatefulPendingOperation, 'id'>,
+    pending: Pick<ServiceStatefulPendingOperation, 'id' | 'reply' | 'replyFailure'>,
     targetNodeRid: string,
     operationKind:
       | 'spotRequest'
@@ -5199,7 +5356,8 @@ export class ServiceStatefulRuntime {
       | 'boundSessionClose'
       | 'instanceSpotRequest',
     actor: ServiceActorRef | undefined,
-    reply: readonly Buffer[]
+    reply: readonly Buffer[],
+    receiver?: import('./operation-registry').OperationObserver<unknown, unknown>
   ): void {
     const canonicalActorJoinHandoffId =
       operationKind === 'actorJoin' ? this.canonicalActorJoinHandoffs.get(pending.id) : undefined;
@@ -5208,23 +5366,23 @@ export class ServiceStatefulRuntime {
         throw new ServiceWireProtocolError('Invalid M6B reply parts.');
       const decoded = decodeStatefulReply(reply[0]!, pending.id, operationKind, reply.length >= 2);
       const payload = reply.length < 2 ? undefined : decodeApplicationPayload(reply[1]);
-      this.operations.reply(
-        pending.id,
-        this.resultFromReply(
-          decoded.terminalResult,
-          decoded.failureCode,
-          payload,
-          decoded.tail,
-          targetNodeRid,
-          actor,
-          canonicalActorJoinHandoffId
-        )
+      const result = this.resultFromReply(
+        decoded.terminalResult,
+        decoded.failureCode,
+        payload,
+        decoded.tail,
+        targetNodeRid,
+        actor,
+        canonicalActorJoinHandoffId
       );
+      if (receiver === undefined) pending.reply(result);
+      else receiver.operationCompleted(pending.id, result, undefined);
     } catch (error) {
       //  Spec 32-framework-error-model:58-60, 91-92 — an unprocessable remote
       //  reply (decode/shape failure) fails the awaiting operation with a
       //  Framework ProtocolError instead of leaking the codec's plain Error.
-      this.operations.fail(pending.id, translateWireReplyDecodeError(error));
+      if (receiver === undefined) pending.replyFailure(translateWireReplyDecodeError(error));
+      else receiver.operationFailed(pending.id, translateWireReplyDecodeError(error), undefined);
     } finally {
       if (operationKind === 'actorJoin') {
         this.canonicalActorJoinHandoffs.delete(pending.id);
@@ -5284,6 +5442,7 @@ export class ServiceStatefulRuntime {
     return {
       terminalResult,
       failureCode,
+      ...(tail?.kind === 'streamBindRejected' ? { failureMessage: tail.rejectionMessage } : {}),
       ...(payload === undefined ? {} : { payload }),
       ...(tail?.kind === 'streamBind'
         ? {
@@ -5297,7 +5456,7 @@ export class ServiceStatefulRuntime {
     };
   }
 
-  private validateActorFence(fence: ServiceActorRouteFence): ServiceActorState {
+  validateActorFence(fence: ServiceActorRouteFence): ServiceActorState {
     if (
       fence.actor.nodeRid !== this.nodeRid ||
       fence.targetNodeGeneration !== this.nodeGeneration
@@ -5311,7 +5470,7 @@ export class ServiceStatefulRuntime {
     return actor;
   }
 
-  private validateActorMessageFence(fence: ServiceActorRouteFence): ServiceActorState {
+  validateActorMessageFence(fence: ServiceActorRouteFence): ServiceActorState {
     if (
       fence.actor.nodeRid !== this.nodeRid ||
       fence.targetNodeGeneration !== this.nodeGeneration
@@ -5342,7 +5501,7 @@ export class ServiceStatefulRuntime {
     return spot;
   }
 
-  private validateDirectSpotFence(fence: ServiceSpotRouteFence): ServiceSpotState {
+  validateDirectSpotFence(fence: ServiceSpotRouteFence): ServiceSpotState {
     if (
       fence.targetNodeRid !== this.nodeRid ||
       fence.targetNodeGeneration !== this.nodeGeneration
@@ -5476,11 +5635,15 @@ export class ServiceStatefulRuntime {
                 1,
                 Math.min(30_000, Math.ceil(state.expiresAtMs - performance.now()))
               );
-              const reply = await this.raw.requestService(
+              const pending = this.raw.beginInfrastructureRequest(remainingMs);
+              const reply = await requestDurableService(
+                this.raw,
                 state.target.targetNodeRid,
                 parts,
-                remainingMs
+                pending,
+                'spot message follow'
               );
+              pending.complete(reply);
               this.raw.replyService(current.ingress, reply);
             } catch (error) {
               const result = failure(error);
@@ -5670,9 +5833,7 @@ export class ServiceStatefulRuntime {
 
   private tryEntrySpotFence(targetNodeRid: string): ServiceDirectSpotRouteFence | undefined {
     const targetNodeGeneration =
-      targetNodeRid === this.nodeRid
-        ? this.nodeGeneration
-        : this.raw.topology.peer(targetNodeRid)?.descriptor.lifecycleGeneration;
+      this.raw.peerLifecycleGeneration(targetNodeRid) ?? this.tryPeerGeneration(targetNodeRid);
     if (targetNodeGeneration === undefined) return undefined;
     return {
       spot: {
@@ -5715,8 +5876,10 @@ export class ServiceStatefulRuntime {
         ? current
         : undefined;
     }
-    const peer = this.raw.topology.peer(targetNodeRid);
-    if (peer?.descriptor.lifecycleGeneration !== targetNodeGeneration) {
+    if (
+      (this.raw.peerLifecycleGeneration(targetNodeRid) ?? this.tryPeerGeneration(targetNodeRid)) !==
+      targetNodeGeneration
+    ) {
       return undefined;
     }
     this.rememberSpotRoute(requested);
@@ -6311,6 +6474,10 @@ function emptyPayload(): ServiceApplicationPayload {
   };
 }
 
+function copyRetainedServiceFrames(parts: readonly Buffer[]): Buffer[] {
+  return parts.map((part) => copyPayloadBytes(part));
+}
+
 /**
  * The generated command-28 decoder is the canonical wire authority.  Keep
  * the stateful mailbox's internal record shape as an adapter only; it must