@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,3008 @@
+import type {
+  ServiceActorRef,
+  ServiceSessionBinding,
+  ServiceSpotRef
+} from './service-stateful-registry';
+import { operationRequiresReply } from './service-runtime-contracts';
+import { ServiceWireProtocolError } from './service-wire-m6a-codec';
+import { isCanonicalWireReplyTerminal } from '../framework-errors-internal';
+import { routingIdsEqual } from '../routing-id';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR,
+  ServiceWireCommand,
+  ServiceWireFlag
+} from './service-wire-constants.generated';
+import {
+  decodeCanonicalServiceWireText,
+  decodeServiceWireRoutingId,
+  encodeCanonicalServiceWireText,
+  encodeServiceWireRoutingId
+} from './service-wire-binary-primitives';
+import {
+  decodeActorCreate49 as decodeGeneratedActorCreate49,
+  decodeActorJoin28,
+  decodeRelocationCutover34 as decodeGeneratedRelocationCutover34,
+  decodeRelocationData31 as decodeGeneratedRelocationData31,
+  decodeRelocationFailed53 as decodeGeneratedRelocationFailed53,
+  decodeRelocationPrepare40 as decodeGeneratedRelocationPrepare40,
+  decodeRelocationReady30 as decodeGeneratedRelocationReady30,
+  decodeRelocationState52 as decodeGeneratedRelocationState52,
+  decodeReplyRelay33 as decodeGeneratedReplyRelay33,
+  decodeReplyRelayAck46 as decodeGeneratedReplyRelayAck46,
+  decodeSessionRelocationRoute44 as decodeGeneratedSessionRelocationRoute44,
+  decodeSessionRelocationSeal42 as decodeGeneratedSessionRelocationSeal42,
+  decodeSessionRelocationSealed43 as decodeGeneratedSessionRelocationSealed43,
+  decodeUserSpotClose48 as decodeGeneratedUserSpotClose48,
+  decodeUserSpotCreate47 as decodeGeneratedUserSpotCreate47,
+  encodeActorCreate49 as encodeGeneratedActorCreate49,
+  encodeRelocationCutover34 as encodeGeneratedRelocationCutover34,
+  encodeRelocationData31 as encodeGeneratedRelocationData31,
+  encodeRelocationFailed53 as encodeGeneratedRelocationFailed53,
+  encodeRelocationPrepare40 as encodeGeneratedRelocationPrepare40,
+  encodeRelocationReady30 as encodeGeneratedRelocationReady30,
+  encodeRelocationState52 as encodeGeneratedRelocationState52,
+  encodeReplyRelay33 as encodeGeneratedReplyRelay33,
+  encodeReplyRelayAck46 as encodeGeneratedReplyRelayAck46,
+  encodeSessionRelocationRoute44 as encodeGeneratedSessionRelocationRoute44,
+  encodeSessionRelocationSeal42 as encodeGeneratedSessionRelocationSeal42,
+  encodeSessionRelocationSealed43 as encodeGeneratedSessionRelocationSealed43,
+  encodeUserSpotClose48 as encodeGeneratedUserSpotClose48,
+  encodeUserSpotCreate47 as encodeGeneratedUserSpotCreate47,
+  type ActorCreate49 as GeneratedActorCreate49,
+  type RelocationObjectIdentity as GeneratedRelocationObjectIdentity,
+  type ReplyRelay33 as GeneratedReplyRelay33,
+  type ServiceWireCoordinatorFence as GeneratedCoordinatorFence,
+  type ServiceWireRequestSourceFence as GeneratedRequestSourceFence,
+  type ServiceWireRouteFence as GeneratedRouteFence,
+  type ServiceWireTargetFence as GeneratedTargetFence,
+  type SessionRelocationRoute44 as GeneratedSessionRelocationRoute44,
+  type SessionRelocationSeal42 as GeneratedSessionRelocationSeal42,
+  type SessionRelocationSealed43 as GeneratedSessionRelocationSealed43,
+  type UserSpotClose48 as GeneratedUserSpotClose48,
+  type UserSpotCreate47 as GeneratedUserSpotCreate47
+} from '../protocol/service_wire_pilot_codec.generated';
+
+const PREFIX_SIZE = 5;
+const MAGIC_0 = SERVICE_WIRE_MAGIC[0];
+const MAGIC_1 = SERVICE_WIRE_MAGIC[1];
+const MAJOR = SERVICE_WIRE_MAJOR;
+
+export const M6bServiceWireCommand = ServiceWireCommand;
+
+export interface ServiceWireOperationId {
+  readonly high: bigint;
+  readonly low: bigint;
+}
+
+export interface ServiceWireRelocationCoordinatorFence {
+  readonly ownerId: string;
+  readonly leaseGeneration: bigint;
+  readonly nodeRid: string;
+  readonly nodeGeneration: bigint;
+  readonly expectedAuthorityStoreVersion: string;
+}
+
+export interface ServiceWireRequestSourceFence {
+  readonly ownerId: string;
+  readonly leaseGeneration: bigint;
+  readonly nodeRid: string;
+  readonly nodeGeneration: bigint;
+}
+
+export interface ServiceMaintenanceReplyRelay {
+  readonly relocation: ServiceWireOperationId;
+  readonly targetAttemptGeneration: bigint;
+  readonly coordinator: ServiceWireRelocationCoordinatorFence;
+  readonly operation: ServiceWireOperationId;
+  readonly replyRouteId: bigint;
+  readonly participantId: bigint;
+  readonly sequence: bigint;
+  readonly terminalResult: number;
+  readonly failureCode: number;
+  readonly payload?: {
+    readonly packetName: string;
+    readonly contentType: string;
+    readonly bytes: Uint8Array;
+  };
+}
+
+export interface ServiceMaintenanceReplyRelayAck {
+  readonly relocation: ServiceWireOperationId;
+  readonly coordinator: ServiceWireRelocationCoordinatorFence;
+  readonly operation: ServiceWireOperationId;
+  readonly replyRouteId: bigint;
+  readonly requestSource: ServiceWireRequestSourceFence;
+  readonly status: 'terminalReceived' | 'alreadyTerminal';
+}
+
+export type ServiceWireRelocationRole = 'source' | 'target' | 'coordinator';
+
+export interface ServiceWireRelocationTarget {
+  readonly nodeRid: string;
+  readonly nodeGeneration: bigint;
+  readonly ownerId: string;
+  readonly ownerLeaseGeneration: bigint;
+}
+
+export type ServiceWireRelocationObject =
+  | {
+      readonly kind: 'actor';
+      readonly actorId: string;
+      readonly objectGeneration: bigint;
+      readonly expectedAuthorityOwnerGeneration: bigint;
+    }
+  | {
+      readonly kind: 'userSpot';
+      readonly spotId: string;
+      readonly objectGeneration: bigint;
+      readonly expectedAuthorityOwnerGeneration: bigint;
+    }
+  | {
+      readonly kind: 'instanceSpot';
+      readonly stableType: string;
+      readonly spotId: string;
+      readonly objectGeneration: bigint;
+    };
+
+/** Shared CRC-32C wire bounds for the direct relocation payload transfer. */
+export const RELOCATION_PAYLOAD_TOTAL_LENGTH_MAX = 274_877_906_944n;
+export const RELOCATION_PAYLOAD_CHUNK_COUNT_MAX = 4096;
+export const RELOCATION_STATE_CHUNK_DATA_MAX_BYTES = 67_108_864;
+
+interface ServiceWireRelocationBase {
+  readonly relocation: ServiceWireOperationId;
+  readonly targetAttemptGeneration: bigint;
+  readonly coordinator: ServiceWireRelocationCoordinatorFence;
+}
+
+export interface ServiceMaintenanceRelocationPrepare extends ServiceWireRelocationBase {
+  readonly kind: 'prepare';
+  readonly target: ServiceWireRelocationTarget;
+  readonly initiatorRole: ServiceWireRelocationRole;
+  readonly object: ServiceWireRelocationObject;
+  readonly sourceNodeRid: string;
+  readonly sourceNodeGeneration: bigint;
+  /** Total encoded byte length of the directly transferred relocation payload. */
+  readonly payloadTotalLength: bigint;
+  /** Number of relocationState chunks that carry the payload. */
+  readonly payloadChunkCount: number;
+  /** CRC-32C (Castagnoli) over the fully assembled payload bytes. */
+  readonly payloadChecksumCrc32c: number;
+  readonly applicationVersion: bigint;
+  /** NODE-INTERNAL; serialized as extra frames after canonical command 40. */
+  readonly nodeInternalBoundSessions?: readonly {
+    readonly participantKey: string;
+    readonly payload: Uint8Array;
+  }[];
+}
+
+export interface ServiceMaintenanceRelocationReady extends ServiceWireRelocationBase {
+  readonly kind: 'ready';
+  readonly target: ServiceWireRelocationTarget;
+  readonly object: ServiceWireRelocationObject;
+  readonly senderRole: ServiceWireRelocationRole;
+}
+
+/** Explicit target-side pre-cutover relocation failure (command 53). */
+export interface ServiceMaintenanceRelocationFailed extends ServiceWireRelocationBase {
+  readonly kind: 'failed';
+  readonly target: ServiceWireRelocationTarget;
+  readonly object: ServiceWireRelocationObject;
+  readonly senderRole: ServiceWireRelocationRole;
+  readonly failureCode: number;
+}
+
+export interface ServiceWireFrozenRecord {
+  readonly recordKind: number;
+  readonly sourceKind: number;
+  readonly source: ServiceWireRequestSourceFence;
+  readonly sourceSpotId?: string;
+  readonly sourceActor?: { readonly actorId: string; readonly generation: bigint };
+  readonly sourceSessionRid?: string;
+  readonly sourceBindingGeneration?: bigint;
+  readonly sourceSessionSequence?: bigint;
+  readonly hasMetadata: boolean;
+  readonly operationId: ServiceWireOperationId;
+  readonly operationKind: number;
+  readonly replyRouteId?: bigint;
+  /** Decoded routing/application body used by the target temporary queue owner. */
+  readonly target?:
+    | {
+        readonly kind: 'spot';
+        readonly spotId: string;
+        readonly generation: bigint;
+        readonly targetNodeRid: string;
+        readonly targetNodeGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+      }
+    | {
+        readonly kind: 'actor';
+        readonly actorId: string;
+        readonly generation: bigint;
+        readonly targetNodeRid: string;
+        readonly targetNodeGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+      };
+  readonly applicationPayload?: NonNullable<ServiceMaintenanceReplyRelay['payload']>;
+  readonly canonicalBytes: Buffer;
+}
+
+export interface ServiceMaintenanceRelocationData extends ServiceWireRelocationBase {
+  readonly kind: 'data';
+  readonly senderRole: ServiceWireRelocationRole;
+  readonly object: ServiceWireRelocationObject;
+  readonly frozenRecord: ServiceWireFrozenRecord;
+}
+
+export interface ServiceMaintenanceRelocationCutover extends ServiceWireRelocationBase {
+  readonly kind: 'cutover';
+  readonly senderRole: ServiceWireRelocationRole;
+  readonly object: ServiceWireRelocationObject;
+  /** Number of boundary relay records sent before this cutover. */
+  readonly boundaryRecordCount: bigint;
+  /** CRC-32C over the concatenated canonical bytes of those relay records. */
+  readonly boundaryChecksumCrc32c: number;
+}
+
+/** One relocation payload chunk (command 52), sent one-way on the ordered connection. */
+export interface ServiceMaintenanceRelocationState extends ServiceWireRelocationBase {
+  readonly kind: 'state';
+  readonly senderRole: ServiceWireRelocationRole;
+  readonly object: ServiceWireRelocationObject;
+  readonly chunkOrdinal: number;
+  readonly chunkData: Uint8Array;
+}
+
+export type ServiceMaintenanceRelocationControl =
+  | ServiceMaintenanceRelocationPrepare
+  | ServiceMaintenanceRelocationReady
+  | ServiceMaintenanceRelocationFailed
+  | ServiceMaintenanceRelocationData
+  | ServiceMaintenanceRelocationCutover
+  | ServiceMaintenanceRelocationState;
+
+export const M6bServiceWireFlag = ServiceWireFlag;
+
+export interface ServiceSpotRouteFence {
+  readonly spot: ServiceSpotRef;
+  readonly targetNodeRid: string;
+  readonly targetNodeGeneration: bigint;
+  readonly authorityOwnerGeneration: bigint;
+  /** Schema spot-route-fence expectedOwnerLeaseGeneration. */
+  readonly ownerLeaseGeneration: bigint;
+}
+
+export interface ServiceDirectSpotRouteFence extends ServiceSpotRouteFence {
+  readonly ownerLeaseGeneration: bigint;
+  readonly storeVersion: string;
+}
+
+export interface ServiceActorRouteFence {
+  readonly actor: ServiceActorRef;
+  readonly targetNodeGeneration: bigint;
+  readonly authorityOwnerGeneration: bigint;
+  readonly ownerLeaseGeneration: bigint;
+}
+
+/**
+ * The authority fence carried by a bound-session replacement notice.  This
+ * command is deliberately separate from the legacy Actor message fence: the
+ * receiver validates the transport source against this authority target and
+ * must not resolve a local Actor object for the retired session.
+ */
+export interface ServiceBoundSessionActorAuthority {
+  readonly actor: ServiceActorRef;
+  readonly targetNodeGeneration: bigint;
+  readonly authorityOwnerGeneration: bigint;
+  readonly ownerLeaseGeneration: bigint;
+}
+
+export interface ServiceSessionRelocationOwnerFence {
+  readonly sessionOwnerNodeRid: string;
+  readonly sessionOwnerNodeGeneration: bigint;
+  readonly sessionOwnerId: string;
+  readonly sessionOwnerLeaseGeneration: bigint;
+  readonly sessionRid: string;
+  readonly bindingGeneration: bigint;
+}
+
+export interface ServiceSessionRelocationSeal {
+  readonly relocation: ServiceWireOperationId;
+  readonly coordinator: ServiceWireRelocationCoordinatorFence;
+  readonly senderRole: 'source' | 'coordinator';
+  readonly actor: ServiceBoundSessionActorAuthority;
+  readonly session: ServiceSessionRelocationOwnerFence;
+}
+
+export interface ServiceSessionRelocationSealed {
+  readonly relocation: ServiceWireOperationId;
+  readonly coordinator: ServiceWireRelocationCoordinatorFence;
+  readonly actor: ServiceBoundSessionActorAuthority;
+  readonly session: ServiceSessionRelocationOwnerFence;
+}
+
+export type ServiceSessionRelocationRoute =
+  | {
+      readonly relocation: ServiceWireOperationId;
+      readonly coordinator: ServiceWireRelocationCoordinatorFence;
+      readonly senderRole: 'target' | 'coordinator';
+      readonly actor: ServiceActorRef;
+      readonly session: ServiceSessionRelocationOwnerFence;
+      readonly route: {
+        readonly action: 'commit';
+        readonly previousAuthorityOwnerGeneration: bigint;
+        readonly targetAuthorityOwnerGeneration: bigint;
+        readonly targetNodeRid: string;
+        readonly targetNodeGeneration: bigint;
+      };
+    }
+  | {
+      readonly relocation: ServiceWireOperationId;
+      readonly coordinator: ServiceWireRelocationCoordinatorFence;
+      readonly senderRole: 'source' | 'coordinator';
+      readonly actor: ServiceActorRef;
+      readonly session: ServiceSessionRelocationOwnerFence;
+      readonly route: {
+        readonly action: 'abort';
+        readonly currentAuthorityOwnerGeneration: bigint;
+      };
+    };
+
+export function serviceSessionRelocationIdentityKey(
+  value: ServiceSessionRelocationSeal | ServiceSessionRelocationSealed | ServiceSessionRelocationRoute
+): string {
+  const actor = 'targetNodeGeneration' in value.actor
+    ? value.actor.actor
+    : value.actor;
+  //  Session owner가 seal을 대조할 때 쓰는 값만 넣는다 — Session과 Actor binding
+  //  §8.1 "Session owner는 다음 값만 검증한다". coordinator identity는 transport가
+  //  검증하는 wire fence이므로 여기서 다시 대조하지 않는다.
+  return [
+    value.relocation.high.toString(),
+    value.relocation.low.toString(),
+    actor.actorId,
+    actor.generation.toString(),
+    value.session.sessionRid,
+    value.session.bindingGeneration.toString()
+  ].join(':');
+}
+
+function toGeneratedRoutingId(value: string, field: string): Uint8Array {
+  return encodeServiceWireRoutingId(value as never, field, 0xff, fail);
+}
+
+function fromGeneratedRoutingId(value: Uint8Array, field: string): string {
+  return decodeServiceWireRoutingId(value, field, 0xff, fail) as string;
+}
+
+function toGeneratedReservation(
+  value: ServiceUserSpotReservationFence
+): GeneratedUserSpotCreate47['reservation'] {
+  return {
+    ...value,
+    targetNodeRid: toGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid')
+  };
+}
+
+function fromGeneratedReservation(
+  value: GeneratedUserSpotCreate47['reservation']
+): ServiceUserSpotReservationFence {
+  return {
+    ...value,
+    targetNodeRid: fromGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid')
+  };
+}
+
+function toGeneratedUserSpotCreate(
+  value: Omit<ServiceUserSpotCreateRecord, 'kind'>
+): GeneratedUserSpotCreate47 {
+  return {
+    ...value,
+    sourceNodeRid: toGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    reservation: toGeneratedReservation(value.reservation)
+  };
+}
+
+function fromGeneratedUserSpotCreate(
+  value: GeneratedUserSpotCreate47
+): ServiceUserSpotCreateRecord {
+  return {
+    kind: 'userSpotCreate',
+    ...value,
+    sourceNodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    reservation: fromGeneratedReservation(value.reservation)
+  };
+}
+
+function toGeneratedUserSpotClose(
+  value: Omit<ServiceUserSpotCloseRecord, 'kind'>
+): GeneratedUserSpotClose48 {
+  return {
+    ...value,
+    sourceNodeRid: toGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    target: {
+      spotId: value.target.spotId,
+      objectGeneration: value.target.objectGeneration,
+      targetNodeRid: toGeneratedRoutingId(value.target.targetNodeRid, 'targetNodeRid'),
+      targetNodeGeneration: value.target.targetNodeGeneration,
+      expectedAuthorityOwnerGeneration: value.target.authorityOwnerGeneration,
+      expectedStoreVersion: value.target.expectedStoreVersion
+    }
+  };
+}
+
+function fromGeneratedUserSpotClose(
+  value: GeneratedUserSpotClose48
+): ServiceUserSpotCloseRecord {
+  return {
+    kind: 'userSpotClose',
+    correlation: value.correlation,
+    operation: value.operation,
+    sourceNodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    sourceNodeGeneration: value.sourceNodeGeneration,
+    target: {
+      spotId: value.target.spotId,
+      objectGeneration: value.target.objectGeneration,
+      targetNodeRid: fromGeneratedRoutingId(value.target.targetNodeRid, 'targetNodeRid'),
+      targetNodeGeneration: value.target.targetNodeGeneration,
+      authorityOwnerGeneration: value.target.expectedAuthorityOwnerGeneration,
+      expectedStoreVersion: value.target.expectedStoreVersion
+    },
+    deadlineUnixMs: value.deadlineUnixMs
+  };
+}
+
+function toGeneratedActorCreate(
+  value: Omit<ServiceActorCreateRecord, 'kind'>
+): GeneratedActorCreate49 {
+  return {
+    ...value,
+    sourceNodeRid: toGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    reservation: toGeneratedReservation(value.reservation)
+  };
+}
+
+function fromGeneratedActorCreate(value: GeneratedActorCreate49): ServiceActorCreateRecord {
+  return {
+    kind: 'actorCreate',
+    ...value,
+    sourceNodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    reservation: fromGeneratedReservation(value.reservation)
+  };
+}
+
+function toGeneratedCoordinatorFence(
+  value: ServiceWireRelocationCoordinatorFence
+): GeneratedCoordinatorFence {
+  return {
+    coordinatorOwnerId: value.ownerId,
+    coordinatorLeaseGeneration: value.leaseGeneration,
+    coordinatorNodeRid: toGeneratedRoutingId(value.nodeRid, 'coordinatorNodeRid'),
+    coordinatorNodeGeneration: value.nodeGeneration,
+    expectedAuthorityStoreVersion: value.expectedAuthorityStoreVersion
+  };
+}
+
+function fromGeneratedCoordinatorFence(
+  value: GeneratedCoordinatorFence
+): ServiceWireRelocationCoordinatorFence {
+  return {
+    ownerId: value.coordinatorOwnerId,
+    leaseGeneration: value.coordinatorLeaseGeneration,
+    nodeRid: fromGeneratedRoutingId(value.coordinatorNodeRid, 'coordinatorNodeRid'),
+    nodeGeneration: value.coordinatorNodeGeneration,
+    expectedAuthorityStoreVersion: value.expectedAuthorityStoreVersion
+  };
+}
+
+function toGeneratedTargetFence(value: ServiceWireRelocationTarget): GeneratedTargetFence {
+  return {
+    targetNodeRid: toGeneratedRoutingId(value.nodeRid, 'targetNodeRid'),
+    targetNodeGeneration: value.nodeGeneration,
+    targetOwnerId: value.ownerId,
+    targetOwnerLeaseGeneration: value.ownerLeaseGeneration
+  };
+}
+
+function fromGeneratedTargetFence(value: GeneratedTargetFence): ServiceWireRelocationTarget {
+  return {
+    nodeRid: fromGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid'),
+    nodeGeneration: value.targetNodeGeneration,
+    ownerId: value.targetOwnerId,
+    ownerLeaseGeneration: value.targetOwnerLeaseGeneration
+  };
+}
+
+function toGeneratedRequestSourceFence(
+  value: ServiceWireRequestSourceFence
+): GeneratedRequestSourceFence {
+  return {
+    sourceOwnerId: value.ownerId,
+    sourceOwnerLeaseGeneration: value.leaseGeneration,
+    sourceNodeRid: toGeneratedRoutingId(value.nodeRid, 'sourceNodeRid'),
+    sourceNodeGeneration: value.nodeGeneration
+  };
+}
+
+function fromGeneratedRequestSourceFence(
+  value: GeneratedRequestSourceFence
+): ServiceWireRequestSourceFence {
+  return {
+    ownerId: value.sourceOwnerId,
+    leaseGeneration: value.sourceOwnerLeaseGeneration,
+    nodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    nodeGeneration: value.sourceNodeGeneration
+  };
+}
+
+function toGeneratedRelocationObject(
+  value: ServiceWireRelocationObject
+): GeneratedRelocationObjectIdentity {
+  switch (value.kind) {
+    case 'actor':
+      return {
+        objectKind: 'actor',
+        actorId: value.actorId,
+        objectGeneration: value.objectGeneration,
+        expectedAuthorityOwnerGeneration: value.expectedAuthorityOwnerGeneration
+      };
+    case 'userSpot':
+      return {
+        objectKind: 'userSpot',
+        spotId: value.spotId,
+        objectGeneration: value.objectGeneration,
+        expectedAuthorityOwnerGeneration: value.expectedAuthorityOwnerGeneration
+      };
+    case 'instanceSpot':
+      return {
+        objectKind: 'instanceSpot',
+        instanceType: value.stableType,
+        spotId: value.spotId,
+        objectGeneration: value.objectGeneration
+      };
+  }
+}
+
+function fromGeneratedRelocationObject(
+  value: GeneratedRelocationObjectIdentity
+): ServiceWireRelocationObject {
+  switch (value.objectKind) {
+    case 'actor':
+      return {
+        kind: 'actor',
+        actorId: value.actorId,
+        objectGeneration: value.objectGeneration,
+        expectedAuthorityOwnerGeneration: value.expectedAuthorityOwnerGeneration
+      };
+    case 'userSpot':
+      return {
+        kind: 'userSpot',
+        spotId: value.spotId,
+        objectGeneration: value.objectGeneration,
+        expectedAuthorityOwnerGeneration: value.expectedAuthorityOwnerGeneration
+      };
+    case 'instanceSpot':
+      return {
+        kind: 'instanceSpot',
+        stableType: value.instanceType,
+        spotId: value.spotId,
+        objectGeneration: value.objectGeneration
+      };
+  }
+}
+
+function toGeneratedRouteFence(value: ServiceBoundSessionActorAuthority): GeneratedRouteFence {
+  return {
+    id: value.actor.actorId,
+    generation: value.actor.generation,
+    targetNodeRid: toGeneratedRoutingId(value.actor.nodeRid, 'targetNodeRid'),
+    targetNodeGeneration: value.targetNodeGeneration,
+    expectedAuthorityOwnerGeneration: value.authorityOwnerGeneration,
+    expectedOwnerLeaseGeneration: value.ownerLeaseGeneration
+  };
+}
+
+function fromGeneratedRouteFence(value: GeneratedRouteFence): ServiceBoundSessionActorAuthority {
+  return {
+    actor: {
+      actorId: value.id,
+      generation: value.generation,
+      nodeRid: fromGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid')
+    },
+    targetNodeGeneration: value.targetNodeGeneration,
+    authorityOwnerGeneration: value.expectedAuthorityOwnerGeneration,
+    ownerLeaseGeneration: value.expectedOwnerLeaseGeneration
+  };
+}
+
+function toGeneratedSessionOwnerFence(value: ServiceSessionRelocationOwnerFence) {
+  return {
+    sessionOwnerNodeRid: toGeneratedRoutingId(value.sessionOwnerNodeRid, 'sessionOwnerNodeRid'),
+    sessionOwnerNodeGeneration: value.sessionOwnerNodeGeneration,
+    sessionOwnerId: value.sessionOwnerId,
+    sessionOwnerLeaseGeneration: value.sessionOwnerLeaseGeneration,
+    sessionRid: toGeneratedRoutingId(value.sessionRid, 'sessionRid'),
+    bindingGeneration: value.bindingGeneration
+  };
+}
+
+function fromGeneratedSessionOwnerFence(value: {
+  readonly sessionOwnerNodeRid: Uint8Array;
+  readonly sessionOwnerNodeGeneration: bigint;
+  readonly sessionOwnerId: string;
+  readonly sessionOwnerLeaseGeneration: bigint;
+  readonly sessionRid: Uint8Array;
+  readonly bindingGeneration: bigint;
+}): ServiceSessionRelocationOwnerFence {
+  return {
+    sessionOwnerNodeRid: fromGeneratedRoutingId(value.sessionOwnerNodeRid, 'sessionOwnerNodeRid'),
+    sessionOwnerNodeGeneration: value.sessionOwnerNodeGeneration,
+    sessionOwnerId: value.sessionOwnerId,
+    sessionOwnerLeaseGeneration: value.sessionOwnerLeaseGeneration,
+    sessionRid: fromGeneratedRoutingId(value.sessionRid, 'sessionRid'),
+    bindingGeneration: value.bindingGeneration
+  };
+}
+
+function toGeneratedSessionRelocationSeal(
+  value: ServiceSessionRelocationSeal
+): GeneratedSessionRelocationSeal42 {
+  return {
+    relocation: value.relocation,
+    coordinator: toGeneratedCoordinatorFence(value.coordinator),
+    senderRole: value.senderRole,
+    actor: toGeneratedRouteFence(value.actor),
+    ...toGeneratedSessionOwnerFence(value.session)
+  };
+}
+
+function fromGeneratedSessionRelocationSeal(
+  value: GeneratedSessionRelocationSeal42
+): ServiceSessionRelocationSeal {
+  return {
+    relocation: value.relocation,
+    coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+    senderRole: value.senderRole as ServiceSessionRelocationSeal['senderRole'],
+    actor: fromGeneratedRouteFence(value.actor),
+    session: fromGeneratedSessionOwnerFence(value)
+  };
+}
+
+function toGeneratedSessionRelocationSealed(
+  value: ServiceSessionRelocationSealed
+): GeneratedSessionRelocationSealed43 {
+  return {
+    relocation: value.relocation,
+    coordinator: toGeneratedCoordinatorFence(value.coordinator),
+    actor: toGeneratedRouteFence(value.actor),
+    ...toGeneratedSessionOwnerFence(value.session)
+  };
+}
+
+function fromGeneratedSessionRelocationSealed(
+  value: GeneratedSessionRelocationSealed43
+): ServiceSessionRelocationSealed {
+  return {
+    relocation: value.relocation,
+    coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+    actor: fromGeneratedRouteFence(value.actor),
+    session: fromGeneratedSessionOwnerFence(value)
+  };
+}
+
+function toGeneratedSessionRelocationRoute(
+  value: ServiceSessionRelocationRoute
+): GeneratedSessionRelocationRoute44 {
+  const route = value.route.action === 'commit'
+    ? {
+        ...value.route,
+        targetNodeRid: toGeneratedRoutingId(value.route.targetNodeRid, 'targetNodeRid')
+      }
+    : value.route;
+  return {
+    relocation: value.relocation,
+    coordinator: toGeneratedCoordinatorFence(value.coordinator),
+    senderRole: value.senderRole,
+    actor: {
+      actorId: value.actor.actorId,
+      objectGeneration: value.actor.generation
+    },
+    ...toGeneratedSessionOwnerFence(value.session),
+    route
+  };
+}
+
+function fromGeneratedSessionRelocationRoute(
+  value: GeneratedSessionRelocationRoute44
+): ServiceSessionRelocationRoute {
+  const common = {
+    relocation: value.relocation,
+    coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+    actor: { actorId: value.actor.actorId, generation: value.actor.objectGeneration, nodeRid: '' },
+    session: fromGeneratedSessionOwnerFence(value)
+  };
+  return value.route.action === 'commit'
+    ? {
+        ...common,
+        senderRole: value.senderRole as 'target' | 'coordinator',
+        route: {
+          ...value.route,
+          targetNodeRid: fromGeneratedRoutingId(value.route.targetNodeRid, 'targetNodeRid')
+        }
+      }
+    : {
+        ...common,
+        senderRole: value.senderRole as 'source' | 'coordinator',
+        route: value.route
+      };
+}
+
+function toGeneratedRelocationBase(value: ServiceWireRelocationBase) {
+  return {
+    relocation: value.relocation,
+    targetAttemptGeneration: value.targetAttemptGeneration,
+    coordinator: toGeneratedCoordinatorFence(value.coordinator)
+  };
+}
+
+function fromGeneratedRelocationBase(value: {
+  readonly relocation: ServiceWireOperationId;
+  readonly targetAttemptGeneration: bigint;
+  readonly coordinator: GeneratedCoordinatorFence;
+}) {
+  return {
+    relocation: value.relocation,
+    targetAttemptGeneration: value.targetAttemptGeneration,
+    coordinator: fromGeneratedCoordinatorFence(value.coordinator)
+  };
+}
+
+function fromGeneratedRelocationPrepare(
+  value: ReturnType<typeof decodeGeneratedRelocationPrepare40>
+): ServiceMaintenanceRelocationPrepare {
+  return {
+    kind: 'prepare',
+    ...fromGeneratedRelocationBase(value),
+    target: fromGeneratedTargetFence(value.target),
+    initiatorRole: value.initiatorRole,
+    object: fromGeneratedRelocationObject(value.object),
+    sourceNodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+    sourceNodeGeneration: value.sourceNodeGeneration,
+    payloadTotalLength: value.payloadTotalLength,
+    payloadChunkCount: value.payloadChunkCount,
+    payloadChecksumCrc32c: value.payloadChecksumCrc32c,
+    applicationVersion: value.applicationVersion
+  };
+}
+
+function fromGeneratedRelocationReady(
+  value: ReturnType<typeof decodeGeneratedRelocationReady30>
+): ServiceMaintenanceRelocationReady {
+  return {
+    kind: 'ready',
+    ...fromGeneratedRelocationBase(value),
+    target: fromGeneratedTargetFence(value.target),
+    object: fromGeneratedRelocationObject(value.object),
+    senderRole: value.senderRole
+  };
+}
+
+function fromGeneratedRelocationFailed(
+  value: ReturnType<typeof decodeGeneratedRelocationFailed53>
+): ServiceMaintenanceRelocationFailed {
+  return {
+    kind: 'failed',
+    ...fromGeneratedRelocationBase(value),
+    target: fromGeneratedTargetFence(value.target),
+    object: fromGeneratedRelocationObject(value.object),
+    senderRole: value.senderRole,
+    failureCode: value.failureCode
+  };
+}
+
+function fromGeneratedRelocationData(
+  value: ReturnType<typeof decodeGeneratedRelocationData31>
+): ServiceMaintenanceRelocationData {
+  return {
+    kind: 'data',
+    ...fromGeneratedRelocationBase(value),
+    senderRole: value.senderRole,
+    object: fromGeneratedRelocationObject(value.object),
+    frozenRecord: decodeServiceWireFrozenRecord(value.record)
+  };
+}
+
+function fromGeneratedRelocationCutover(
+  value: ReturnType<typeof decodeGeneratedRelocationCutover34>
+): ServiceMaintenanceRelocationCutover {
+  return {
+    kind: 'cutover',
+    ...fromGeneratedRelocationBase(value),
+    senderRole: value.senderRole,
+    object: fromGeneratedRelocationObject(value.object),
+    boundaryRecordCount: value.boundaryRecordCount,
+    boundaryChecksumCrc32c: value.boundaryChecksumCrc32c
+  };
+}
+
+function fromGeneratedRelocationState(
+  value: ReturnType<typeof decodeGeneratedRelocationState52>
+): ServiceMaintenanceRelocationState {
+  return {
+    kind: 'state',
+    ...fromGeneratedRelocationBase(value),
+    senderRole: value.senderRole,
+    object: fromGeneratedRelocationObject(value.object),
+    chunkOrdinal: value.chunkOrdinal,
+    chunkData: Buffer.from(value.chunkData)
+  };
+}
+
+function toGeneratedReplyRelay(value: ServiceMaintenanceReplyRelay): GeneratedReplyRelay33 {
+  return {
+    operation: value.operation,
+    replyRouteId: value.replyRouteId,
+    context: {
+      contextKind: 'maintenanceRelocation',
+      relocation: value.relocation,
+      targetAttemptGeneration: value.targetAttemptGeneration,
+      coordinator: toGeneratedCoordinatorFence(value.coordinator),
+      participantId: value.participantId,
+      sequence: value.sequence
+    },
+    terminalResult: value.terminalResult,
+    failureCode: value.failureCode,
+    ...(value.payload === undefined ? {} : {
+      payload: {
+        packetName: value.payload.packetName,
+        contentType: value.payload.contentType,
+        payload: value.payload.bytes
+      }
+    })
+  };
+}
+
+function fromGeneratedReplyRelay(value: GeneratedReplyRelay33): ServiceMaintenanceReplyRelay {
+  if (value.context.contextKind !== 'maintenanceRelocation') {
+    fail('replyRelay context must be maintenanceRelocation.');
+  }
+  return {
+    relocation: value.context.relocation,
+    targetAttemptGeneration: value.context.targetAttemptGeneration,
+    coordinator: fromGeneratedCoordinatorFence(value.context.coordinator),
+    operation: value.operation,
+    replyRouteId: value.replyRouteId,
+    participantId: value.context.participantId,
+    sequence: value.context.sequence,
+    terminalResult: value.terminalResult,
+    failureCode: value.failureCode,
+    ...(value.payload === undefined ? {} : {
+      payload: {
+        packetName: value.payload.packetName,
+        contentType: value.payload.contentType,
+        bytes: Buffer.from(value.payload.payload)
+      }
+    })
+  };
+}
+
+export interface ServiceRetiredBoundSessionRouteFence {
+  readonly sessionOwnerNodeRid: string;
+  readonly sessionOwnerNodeGeneration: bigint;
+  readonly sessionOwnerId: string;
+  readonly sessionOwnerLeaseGeneration: bigint;
+  readonly sessionRid: string;
+  readonly retiredBindingGeneration: bigint;
+}
+
+export interface ServiceBoundSessionSource {
+  readonly sessionRid: string;
+  readonly bindingGeneration: bigint;
+  readonly sequence: bigint;
+}
+
+export interface ServiceInstanceRouteFence {
+  readonly targetNodeRid: string;
+  readonly targetNodeGeneration: bigint;
+  readonly targetSpotId: string;
+  readonly objectGeneration: bigint;
+  readonly ownerId: string;
+  readonly authorityOwnerGeneration: bigint;
+  readonly leaseGeneration: bigint;
+  readonly storeVersion: string;
+}
+
+export interface ServiceInstanceActivationTarget {
+  readonly targetNodeRid: string;
+  readonly targetNodeGeneration: bigint;
+  readonly targetSpotId: string;
+  readonly stableType: string;
+  readonly descriptorVersion: string;
+}
+
+export interface ServiceUserSpotReservationFence {
+  readonly reservationId: string;
+  readonly expectedStoreVersion: string;
+  readonly objectGeneration: bigint;
+  readonly authorityOwnerGeneration: bigint;
+  readonly targetNodeRid: string;
+  readonly targetNodeGeneration: bigint;
+  readonly targetOwnerId: string;
+  readonly targetOwnerLeaseGeneration: bigint;
+  readonly pendingCapacityDelta: number;
+}
+
+export interface ServiceUserSpotCreateRecord {
+  readonly kind: 'userSpotCreate';
+  readonly correlation: bigint;
+  readonly operation: { readonly high: bigint; readonly low: bigint };
+  readonly sourceNodeRid: string;
+  readonly sourceNodeGeneration: bigint;
+  readonly spotId: string;
+  readonly stableType: string;
+  readonly reservation: ServiceUserSpotReservationFence;
+  readonly deadlineUnixMs: bigint;
+}
+
+export interface ServiceActorCreateRecord {
+  readonly kind: 'actorCreate';
+  readonly correlation: bigint;
+  readonly operation: { readonly high: bigint; readonly low: bigint };
+  readonly sourceNodeRid: string;
+  readonly sourceNodeGeneration: bigint;
+  readonly actorId: string;
+  readonly stableType: string;
+  readonly reservation: ServiceUserSpotReservationFence;
+  readonly deadlineUnixMs: bigint;
+}
+
+export interface ServiceUserSpotCloseRecord {
+  readonly kind: 'userSpotClose';
+  readonly correlation: bigint;
+  readonly operation: { readonly high: bigint; readonly low: bigint };
+  readonly sourceNodeRid: string;
+  readonly sourceNodeGeneration: bigint;
+  readonly target: {
+    readonly spotId: string;
+    readonly objectGeneration: bigint;
+    readonly targetNodeRid: string;
+    readonly targetNodeGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly expectedStoreVersion: string;
+  };
+  readonly deadlineUnixMs: bigint;
+}
+
+export type ServiceMessageFollowRoute =
+  | {
+      readonly kind: 'actor';
+      readonly actor: ServiceActorRef;
+      readonly targetNodeRid: string;
+      readonly targetNodeGeneration: bigint;
+      readonly authorityOwnerGeneration: bigint;
+      readonly ownerLeaseGeneration: bigint;
+    }
+  | {
+      readonly kind: 'spot';
+      readonly spot: ServiceSpotRef;
+      readonly targetNodeRid: string;
+      readonly targetNodeGeneration: bigint;
+      readonly authorityOwnerGeneration: bigint;
+      readonly ownerLeaseGeneration: bigint;
+    };
+
+export interface ServiceMessageFollowRecord {
+  readonly kind: 'messageFollow';
+  readonly source: ServiceMessageFollowRoute;
+  readonly target: ServiceMessageFollowRoute;
+  readonly hopCount: number;
+  readonly queuedMessages: number;
+  readonly queuedBytes: number;
+  readonly originalOperation: ServiceWireOperationId;
+  readonly originalReplyRouteId: bigint;
+}
+
+export type ServiceBoundSessionTransition =
+  | { readonly state: 'active'; readonly generation: bigint }
+  | { readonly state: 'tombstone'; readonly retiredGeneration: bigint };
+
+export type ServiceStatefulWireRecord =
+  | {
+      readonly kind: 'spotSend' | 'spotRequest';
+      readonly correlation?: bigint;
+      readonly sourceSpotId: string;
+      readonly target: ServiceDirectSpotRouteFence;
+    }
+  | {
+      readonly kind: 'logicalMulticast';
+      readonly channelName: string;
+      readonly topic: string;
+      readonly sourceSpotId: string;
+    }
+  | {
+      readonly kind: 'actorSend' | 'actorRequest';
+      readonly correlation?: bigint;
+      readonly sourceActor?: ServiceActorRef;
+      readonly target: ServiceActorRouteFence;
+      readonly boundSession?: ServiceBoundSessionSource;
+    }
+  | {
+      readonly kind: 'actorLookup';
+      readonly correlation: bigint;
+      readonly actorId: string;
+    }
+  | {
+      readonly kind: 'actorDestroy';
+      readonly correlation: bigint;
+      readonly actor: ServiceActorRouteFence;
+    }
+  | {
+      readonly kind: 'actorJoin';
+      readonly correlation: bigint;
+      readonly actor: ServiceActorRouteFence;
+      readonly entry: boolean;
+      readonly target: ServiceSpotRouteFence;
+    }
+  | {
+      readonly kind: 'boundSessionSend';
+      readonly actor: ServiceActorRouteFence;
+      readonly expectedBindingGeneration: bigint;
+    }
+  | {
+      readonly kind: 'boundSessionBind';
+      readonly correlation: bigint;
+      readonly actor: ServiceActorRouteFence;
+      readonly sessionRid: string;
+      readonly binding: ServiceBoundSessionTransition;
+    }
+  | {
+      readonly kind: 'boundSessionReplaced';
+      readonly actorAuthority: ServiceBoundSessionActorAuthority;
+      readonly retiredSession: ServiceRetiredBoundSessionRouteFence;
+    }
+  | {
+      readonly kind: 'instanceSpot';
+      readonly activation: 'ready';
+      readonly route: ServiceInstanceRouteFence;
+      readonly sourceNodeGeneration: bigint;
+      readonly sourceNodeRid: string;
+      readonly sourceSpotId?: string;
+      readonly operationKind: 'send' | 'request';
+      readonly operation: { readonly high: bigint; readonly low: bigint };
+      readonly replyRouteId?: bigint;
+    }
+  | {
+      readonly kind: 'instanceSpot';
+      readonly activation: 'missing';
+      readonly target: ServiceInstanceActivationTarget;
+      readonly sourceNodeGeneration: bigint;
+      readonly sourceNodeRid: string;
+      readonly sourceSpotId?: string;
+      readonly operationKind: 'send' | 'request';
+      readonly operation: { readonly high: bigint; readonly low: bigint };
+      readonly deadlineUnixMs: bigint;
+      readonly replyRouteId?: bigint;
+    }
+  | ServiceUserSpotCreateRecord
+  | ServiceUserSpotCloseRecord
+  | ServiceActorCreateRecord
+  | ServiceMessageFollowRecord;
+
+export type ServiceStatefulReplyTail =
+  | {
+      readonly kind: 'actorLookup';
+      readonly actor: ServiceActorRef;
+      readonly spot: ServiceSpotRef;
+      readonly membershipEpoch: bigint;
+      readonly authorityOwnerGeneration: bigint;
+    }
+  | {
+      readonly kind: 'actorJoin';
+      readonly joinResult: 0 | 1;
+      readonly spot?: ServiceSpotRef;
+      readonly membershipEpoch?: bigint;
+      /** Target's advertised valid receive chunk cap. 0 = not advertised (accepted only). */
+      readonly receiveChunkLimitBytes?: number;
+    }
+  | {
+      readonly kind: 'streamBind';
+      readonly bindingGeneration: bigint;
+      readonly authorityOwnerGeneration: bigint;
+    }
+  | {
+      readonly kind: 'userSpotCreate';
+      readonly createResult: 'existing' | 'created' | 'rejected';
+      readonly spotId: string;
+      readonly objectGeneration: bigint;
+    }
+  | {
+      readonly kind: 'userSpotClose';
+      readonly closed: boolean;
+    }
+  | {
+      readonly kind: 'actorCreate';
+      readonly createResult: 'existing' | 'created' | 'rejected';
+      readonly actor?: ServiceActorRef & { readonly nodeRid: string };
+    };
+
+export interface ServiceStatefulReply {
+  readonly correlation: bigint;
+  readonly terminalResult: number;
+  readonly failureCode: number;
+  readonly tail?: ServiceStatefulReplyTail;
+}
+
+export function encodeSpotHeader(
+  kind: 'spotSend' | 'spotRequest',
+  sourceSpotId: string,
+  target: ServiceDirectSpotRouteFence,
+  correlation?: bigint
+): Buffer {
+  return concat(
+    prefix(kind === 'spotSend'
+      ? M6bServiceWireCommand.spotSend
+      : M6bServiceWireCommand.spotRequest),
+    ...(kind === 'spotRequest' ? [u64(requirePositive(correlation, 'correlation'))] : []),
+    rid(sourceSpotId, 'sourceSpotId'),
+    directSpotFence(target)
+  );
+}
+
+export function encodeActorHeader(
+  kind: 'actorSend' | 'actorRequest',
+  target: ServiceActorRouteFence,
+  correlation?: bigint,
+  sourceActor?: ServiceActorRef,
+  boundSession?: ServiceBoundSessionSource
+): Buffer {
+  const flags = boundSession === undefined
+    ? 0
+    : M6bServiceWireFlag.boundSession | M6bServiceWireFlag.sourceSpotId;
+  return concat(
+    prefix(
+      kind === 'actorSend'
+        ? M6bServiceWireCommand.actorSend
+        : M6bServiceWireCommand.actorRequest,
+      flags
+    ),
+    ...(kind === 'actorRequest' ? [u64(requirePositive(correlation, 'correlation'))] : []),
+    optionalActor(sourceActor),
+    actorFence(target),
+    ...(boundSession === undefined
+      ? []
+      : [
+          rid(boundSession.sessionRid, 'sourceSessionRid'),
+          u64(boundSession.bindingGeneration),
+          u64(boundSession.sequence)
+        ])
+  );
+}
+
+export function encodeLogicalMulticastHeader(
+  channelName: string,
+  topic: string,
+  sourceSpotId: string
+): Buffer {
+  return concat(
+    prefix(M6bServiceWireCommand.logicalMulticast),
+    text8(channelName, 'channelName'),
+    text8(topic, 'topic'),
+    rid(sourceSpotId, 'sourceSpotId')
+  );
+}
+
+export function encodeActorLookupHeader(correlation: bigint, actorId: string): Buffer {
+  return concat(
+    prefix(M6bServiceWireCommand.actorLookup),
+    u64(correlation),
+    text8(actorId, 'actorId')
+  );
+}
+
+export function encodeActorDestroyHeader(
+  correlation: bigint,
+  actor: ServiceActorRouteFence
+): Buffer {
+  return concat(prefix(M6bServiceWireCommand.actorDestroy), u64(correlation), actorFence(actor));
+}
+
+export function encodeBoundSessionSendHeader(
+  actor: ServiceActorRouteFence,
+  expectedBindingGeneration: bigint
+): Buffer {
+  return concat(
+    prefix(M6bServiceWireCommand.boundSessionSend),
+    actorFence(actor),
+    u64(expectedBindingGeneration)
+  );
+}
+
+export function encodeBoundSessionBindHeader(
+  correlation: bigint,
+  actor: ServiceActorRouteFence,
+  sessionRid: string,
+  binding: ServiceBoundSessionTransition
+): Buffer {
+  const body = binding.state === 'active'
+    ? u64(binding.generation)
+    : u64(binding.retiredGeneration);
+  return concat(
+    prefix(M6bServiceWireCommand.boundSessionBind),
+    u64(correlation),
+    actorFence(actor),
+    rid(sessionRid, 'sessionRid'),
+    Buffer.of(binding.state === 'active' ? 1 : 2),
+    u16(body.byteLength),
+    body
+  );
+}
+
+export function encodeBoundSessionReplacedHeader(
+  actorAuthority: ServiceBoundSessionActorAuthority,
+  retiredSession: ServiceRetiredBoundSessionRouteFence
+): Buffer {
+  return concat(
+    prefix(M6bServiceWireCommand.boundSessionReplaced),
+    actorAuthorityFence(actorAuthority),
+    rid(retiredSession.sessionOwnerNodeRid, 'sessionOwnerNodeRid'),
+    u64(retiredSession.sessionOwnerNodeGeneration),
+    text8(retiredSession.sessionOwnerId, 'sessionOwnerId'),
+    u64(retiredSession.sessionOwnerLeaseGeneration),
+    rid(retiredSession.sessionRid, 'sessionRid'),
+    u64(retiredSession.retiredBindingGeneration)
+  );
+}
+
+/** Encodes canonical service-wire command 42. */
+export function encodeSessionRelocationSeal(value: ServiceSessionRelocationSeal): Buffer {
+  return Buffer.from(encodeGeneratedSessionRelocationSeal42(
+    toGeneratedSessionRelocationSeal(value)
+  ));
+}
+
+/** Decodes canonical service-wire command 42. */
+export function decodeSessionRelocationSeal(frame: Uint8Array): ServiceSessionRelocationSeal {
+  return fromGeneratedSessionRelocationSeal(decodeGeneratedSessionRelocationSeal42(frame));
+}
+
+/** Encodes canonical service-wire command 43. */
+export function encodeSessionRelocationSealed(value: ServiceSessionRelocationSealed): Buffer {
+  return Buffer.from(encodeGeneratedSessionRelocationSealed43(
+    toGeneratedSessionRelocationSealed(value)
+  ));
+}
+
+/** Decodes canonical service-wire command 43. */
+export function decodeSessionRelocationSealed(frame: Uint8Array): ServiceSessionRelocationSealed {
+  return fromGeneratedSessionRelocationSealed(decodeGeneratedSessionRelocationSealed43(frame));
+}
+
+/** Encodes canonical service-wire command 44. */
+export function encodeSessionRelocationRoute(value: ServiceSessionRelocationRoute): Buffer {
+  return Buffer.from(encodeGeneratedSessionRelocationRoute44(
+    toGeneratedSessionRelocationRoute(value)
+  ));
+}
+
+/** Decodes canonical service-wire command 44. */
+export function decodeSessionRelocationRoute(frame: Uint8Array): ServiceSessionRelocationRoute {
+  return fromGeneratedSessionRelocationRoute(decodeGeneratedSessionRelocationRoute44(frame));
+}
+
+export function encodeInstanceSpotHeader(
+  route: ServiceInstanceRouteFence,
+  sourceNodeGeneration: bigint,
+  sourceNodeRid: string,
+  sourceSpotId: string | undefined,
+  operationKind: 'send' | 'request',
+  operation: { readonly high: bigint; readonly low: bigint },
+  replyRouteId?: bigint,
+  hasMetadata = false
+): Buffer {
+  const routeBody = concat(
+    rid(route.targetNodeRid, 'targetNodeRid'),
+    u64(route.targetNodeGeneration),
+    rid(route.targetSpotId, 'targetSpotId'),
+    u64(route.objectGeneration),
+    text8(route.ownerId, 'ownerId'),
+    u64(route.authorityOwnerGeneration),
+    u64(route.leaseGeneration),
+    text16(route.storeVersion, 'storeVersion')
+  );
+  if (
+    operationKind === 'send'
+    && (operation.high !== 0n || operation.low !== 0n || replyRouteId !== undefined)
+  ) {
+    throw new RangeError('Instance Spot send must not carry an operation or reply route.');
+  }
+  if (operationKind === 'request' && operation.high === 0n && operation.low === 0n) {
+    throw new RangeError('Instance Spot request requires a non-zero operation.');
+  }
+  return concat(
+    prefix(
+      M6bServiceWireCommand.instanceSpot,
+      hasMetadata ? M6bServiceWireFlag.metadata : 0
+    ),
+    Buffer.of(1),
+    u16(routeBody.byteLength),
+    routeBody,
+    u64Any(sourceNodeGeneration),
+    rid(sourceNodeRid, 'sourceNodeRid'),
+    optionalRid(sourceSpotId),
+    Buffer.of(operationKind === 'send' ? 1 : 2),
+    u64Any(operation.high),
+    u64Any(operation.low),
+    ...(operationKind === 'request'
+      ? [u64(requirePositive(replyRouteId, 'replyRouteId'))]
+      : [])
+  );
+}
+
+export function encodeInstanceSpotActivationHeader(
+  target: ServiceInstanceActivationTarget,
+  sourceNodeGeneration: bigint,
+  sourceNodeRid: string,
+  sourceSpotId: string | undefined,
+  operationKind: 'send' | 'request',
+  operation: { readonly high: bigint; readonly low: bigint },
+  deadlineUnixMs: bigint,
+  replyRouteId?: bigint,
+  hasMetadata = false
+): Buffer {
+  if (operation.high === 0n && operation.low === 0n) {
+    throw new RangeError('Instance Spot activation requires a non-zero operation identity.');
+  }
+  if (deadlineUnixMs <= 0n) {
+    throw new RangeError('Instance Spot activation requires a positive deadline.');
+  }
+  if (operationKind === 'send' && replyRouteId !== undefined) {
+    throw new RangeError('Instance Spot send must not carry a reply route.');
+  }
+  const targetBody = concat(
+    rid(target.targetNodeRid, 'targetNodeRid'),
+    u64(target.targetNodeGeneration),
+    rid(target.targetSpotId, 'targetSpotId'),
+    text16(target.stableType, 'stableType'),
+    text16(target.descriptorVersion, 'descriptorVersion')
+  );
+  return concat(
+    prefix(
+      M6bServiceWireCommand.instanceSpot,
+      hasMetadata ? M6bServiceWireFlag.metadata : 0
+    ),
+    Buffer.of(2),
+    u16(targetBody.byteLength),
+    targetBody,
+    u64Any(sourceNodeGeneration),
+    rid(sourceNodeRid, 'sourceNodeRid'),
+    optionalRid(sourceSpotId),
+    Buffer.of(operationKind === 'send' ? 1 : 2),
+    u64Any(operation.high),
+    u64Any(operation.low),
+    u64(deadlineUnixMs),
+    ...(operationKind === 'request'
+      ? [u64(requirePositive(replyRouteId, 'replyRouteId'))]
+      : [])
+  );
+}
+
+export function encodeUserSpotCreateHeader(record: Omit<ServiceUserSpotCreateRecord, 'kind'>): Buffer {
+  return Buffer.from(encodeGeneratedUserSpotCreate47(toGeneratedUserSpotCreate(record)));
+}
+
+export function encodeActorCreateHeader(record: Omit<ServiceActorCreateRecord, 'kind'>): Buffer {
+  return Buffer.from(encodeGeneratedActorCreate49(toGeneratedActorCreate(record)));
+}
+
+export function encodeUserSpotCloseHeader(record: Omit<ServiceUserSpotCloseRecord, 'kind'>): Buffer {
+  return Buffer.from(encodeGeneratedUserSpotClose48(toGeneratedUserSpotClose(record)));
+}
+
+export function encodeMessageFollowHeader(
+  record: Omit<ServiceMessageFollowRecord, 'kind'>
+): Buffer {
+  validateMessageFollowRecord(record);
+  const body = concat(
+    messageFollowRoute(record.source),
+    messageFollowRoute(record.target),
+    Buffer.of(record.hopCount),
+    u32(record.queuedMessages, 'queuedMessages'),
+    u32(record.queuedBytes, 'queuedBytes'),
+    u64Any(record.originalOperation.high),
+    u64Any(record.originalOperation.low),
+    u64Any(record.originalReplyRouteId)
+  );
+  if (body.byteLength > 16 * 1024 * 1024) {
+    throw new RangeError('Message Follow body exceeds 16 MiB.');
+  }
+  return concat(
+    prefix(M6bServiceWireCommand.messageFollow),
+    Buffer.of(1),
+    u32(body.byteLength, 'messageFollow.length'),
+    body
+  );
+}
+
+export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireRecord {
+  switch (frame[3]) {
+    case M6bServiceWireCommand.userSpotCreate:
+      return fromGeneratedUserSpotCreate(decodeGeneratedUserSpotCreate47(frame));
+    case M6bServiceWireCommand.userSpotClose:
+      return fromGeneratedUserSpotClose(decodeGeneratedUserSpotClose48(frame));
+    case M6bServiceWireCommand.actorCreate:
+      return fromGeneratedActorCreate(decodeGeneratedActorCreate49(frame));
+  }
+  const reader = new Reader(frame);
+  const command = reader.prefix();
+  switch (command.command) {
+    case M6bServiceWireCommand.spotSend:
+    case M6bServiceWireCommand.spotRequest: {
+      requireFlags(command.flags, 0);
+      const request = command.command === M6bServiceWireCommand.spotRequest;
+      const correlation = request ? reader.nonZeroU64('correlation') : undefined;
+      const sourceSpotId = reader.rid('sourceSpotId');
+      const target = reader.directSpotFence();
+      reader.end();
+      return {
+        kind: request ? 'spotRequest' : 'spotSend',
+        ...(correlation === undefined ? {} : { correlation }),
+        sourceSpotId,
+        target
+      };
+    }
+    case M6bServiceWireCommand.actorSend:
+    case M6bServiceWireCommand.actorRequest: {
+      const request = command.command === M6bServiceWireCommand.actorRequest;
+      const hasBinding = command.flags !== 0;
+      requireFlags(
+        command.flags,
+        hasBinding
+          ? M6bServiceWireFlag.boundSession | M6bServiceWireFlag.sourceSpotId
+          : 0
+      );
+      const correlation = request ? reader.nonZeroU64('correlation') : undefined;
+      const sourceActor = reader.optionalActor();
+      const target = reader.actorFence();
+      const boundSession = hasBinding
+        ? {
+            sessionRid: reader.rid('sourceSessionRid'),
+            bindingGeneration: reader.nonZeroU64('sourceBindingGeneration'),
+            sequence: reader.nonZeroU64('sourceSessionSequence')
+          }
+        : undefined;
+      reader.end();
+      return {
+        kind: request ? 'actorRequest' : 'actorSend',
+        ...(correlation === undefined ? {} : { correlation }),
+        ...(sourceActor === undefined ? {} : { sourceActor }),
+        target,
+        ...(boundSession === undefined ? {} : { boundSession })
+      };
+    }
+    case M6bServiceWireCommand.logicalMulticast: {
+      requireFlags(command.flags, 0);
+      const result = {
+        kind: 'logicalMulticast' as const,
+        channelName: reader.text8('channelName'),
+        topic: reader.text8('topic'),
+        sourceSpotId: reader.rid('sourceSpotId')
+      };
+      reader.end();
+      return result;
+    }
+    case M6bServiceWireCommand.actorLookup: {
+      requireFlags(command.flags, 0);
+      const result = {
+        kind: 'actorLookup' as const,
+        correlation: reader.nonZeroU64('correlation'),
+        actorId: reader.text8('actorId')
+      };
+      reader.end();
+      return result;
+    }
+    case M6bServiceWireCommand.actorDestroy: {
+      requireFlags(command.flags, 0);
+      const result = {
+        kind: 'actorDestroy' as const,
+        correlation: reader.nonZeroU64('correlation'),
+        actor: reader.actorFence()
+      };
+      reader.end();
+      return result;
+    }
+    case M6bServiceWireCommand.actorJoin: {
+      // Command 28 is canonical-only; the generated codec owns its validation.
+      const decoded = decodeActorJoin28([frame]);
+      return {
+        kind: 'actorJoin',
+        correlation: decoded.correlation,
+        actor: {
+          actor: {
+            actorId: decoded.actor.id,
+            generation: decoded.actor.generation,
+            nodeRid: Buffer.from(decoded.actor.targetNodeRid).toString('utf8')
+          },
+          targetNodeGeneration: decoded.actor.targetNodeGeneration,
+          authorityOwnerGeneration: decoded.actor.expectedAuthorityOwnerGeneration,
+          ownerLeaseGeneration: decoded.actor.expectedOwnerLeaseGeneration
+        },
+        entry: decoded.entry,
+        target: {
+          spot: {
+            spotId: decoded.targetSpot.id,
+            generation: decoded.targetSpot.generation
+          },
+          targetNodeRid: Buffer.from(decoded.targetSpot.targetNodeRid).toString('utf8'),
+          targetNodeGeneration: decoded.targetSpot.targetNodeGeneration,
+          authorityOwnerGeneration: decoded.targetSpot.expectedAuthorityOwnerGeneration,
+          ownerLeaseGeneration: decoded.targetSpot.expectedOwnerLeaseGeneration
+        }
+      };
+    }
+    case M6bServiceWireCommand.boundSessionSend: {
+      requireFlags(command.flags, 0);
+      const actor = reader.actorFence();
+      const expectedBindingGeneration = reader.nonZeroU64('expectedBindingGeneration');
+      reader.end();
+      return { kind: 'boundSessionSend', actor, expectedBindingGeneration };
+    }
+    case M6bServiceWireCommand.boundSessionBind: {
+      requireFlags(command.flags, 0);
+      const correlation = reader.nonZeroU64('correlation');
+      const actor = reader.actorFence();
+      const sessionRid = reader.rid('sessionRid');
+      const state = reader.u8('bindingState');
+      const bodyLength = reader.u16('bindingBodyLength');
+      if (bodyLength !== 8) fail('Binding transition body must contain one u64.');
+      const generation = reader.nonZeroU64('bindingGeneration');
+      reader.end();
+      if (state !== 1 && state !== 2) fail('Unknown binding transition state.');
+      return {
+        kind: 'boundSessionBind',
+        correlation,
+        actor,
+        sessionRid,
+        binding: state === 1
+          ? { state: 'active', generation }
+          : { state: 'tombstone', retiredGeneration: generation }
+      };
+    }
+    case M6bServiceWireCommand.boundSessionReplaced: {
+      requireFlags(command.flags, 0);
+      const actor = reader.actorRef('actorAuthority.actor');
+      const targetNodeRid = reader.rid('actorAuthority.targetNodeRid');
+      const actorAuthority = {
+        actor: { ...actor, nodeRid: targetNodeRid },
+        targetNodeGeneration: reader.nonZeroU64('actorAuthority.targetNodeGeneration'),
+        authorityOwnerGeneration: reader.nonZeroU64(
+          'actorAuthority.expectedAuthorityOwnerGeneration'
+        ),
+        ownerLeaseGeneration: reader.nonZeroU64(
+          'actorAuthority.expectedOwnerLeaseGeneration'
+        )
+      };
+      const retiredSession = {
+        sessionOwnerNodeRid: reader.rid('sessionOwnerNodeRid'),
+        sessionOwnerNodeGeneration: reader.nonZeroU64('sessionOwnerNodeGeneration'),
+        sessionOwnerId: reader.text8('sessionOwnerId'),
+        sessionOwnerLeaseGeneration: reader.nonZeroU64('sessionOwnerLeaseGeneration'),
+        sessionRid: reader.rid('sessionRid'),
+        retiredBindingGeneration: reader.nonZeroU64('retiredBindingGeneration')
+      };
+      reader.end();
+      return { kind: 'boundSessionReplaced', actorAuthority, retiredSession };
+    }
+    case M6bServiceWireCommand.instanceSpot: {
+      if ((command.flags & ~M6bServiceWireFlag.metadata) !== 0) {
+        fail(`Invalid command flags '${command.flags}'.`);
+      }
+      const version = reader.u8('instanceRoute.version');
+      if (version !== 1 && version !== 2) fail('Unsupported Instance route version.');
+      const routeLength = reader.u16('instanceRoute.length');
+      const routeEnd = reader.offset + routeLength;
+      const commonTarget = {
+        targetNodeRid: reader.rid('targetNodeRid'),
+        targetNodeGeneration: reader.nonZeroU64('targetNodeGeneration'),
+        targetSpotId: reader.rid('targetSpotId')
+      };
+      const route: ServiceInstanceRouteFence | undefined = version === 1
+        ? {
+            ...commonTarget,
+            objectGeneration: reader.nonZeroU64('objectGeneration'),
+            ownerId: reader.text8('ownerId'),
+            authorityOwnerGeneration: reader.nonZeroU64('authorityOwnerGeneration'),
+            leaseGeneration: reader.nonZeroU64('leaseGeneration'),
+            storeVersion: reader.text16('storeVersion')
+          }
+        : undefined;
+      const target: ServiceInstanceActivationTarget | undefined = version === 2
+        ? {
+            ...commonTarget,
+            stableType: reader.text16('stableType'),
+            descriptorVersion: reader.text16('descriptorVersion')
+          }
+        : undefined;
+      if (reader.offset !== routeEnd) fail('Invalid Instance route body length.');
+      const sourceNodeGeneration = reader.nonZeroU64('sourceNodeGeneration');
+      const sourceNodeRid = reader.rid('sourceNodeRid');
+      const sourceSpotId = reader.optionalRid('sourceSpotId');
+      const operationValue = reader.u8('operationKind');
+      if (operationValue !== 1 && operationValue !== 2) fail('Unknown Instance operation kind.');
+      const operation = {
+        high: reader.u64('operation.high'),
+        low: reader.u64('operation.low')
+      };
+      const operationKind = operationValue === 1 ? 'send' as const : 'request' as const;
+      if (version === 1 && (
+        (operationKind === 'send' && (operation.high !== 0n || operation.low !== 0n))
+        || (operationKind === 'request' && operation.high === 0n && operation.low === 0n)
+      )) {
+        fail('Invalid Instance operation identity.');
+      }
+      if (version === 2 && operation.high === 0n && operation.low === 0n) {
+        fail('Instance activation requires a non-zero operation identity.');
+      }
+      const deadlineUnixMs = version === 2
+        ? reader.nonZeroU64('deadlineUnixMs')
+        : undefined;
+      const replyRouteId = operationKind === 'request'
+        ? reader.nonZeroU64('replyRouteId')
+        : undefined;
+      reader.end();
+      const common = {
+        kind: 'instanceSpot' as const,
+        sourceNodeGeneration,
+        sourceNodeRid,
+        ...(sourceSpotId === undefined ? {} : { sourceSpotId }),
+        operationKind,
+        operation,
+        ...(replyRouteId === undefined ? {} : { replyRouteId })
+      };
+      return version === 1
+        ? { ...common, activation: 'ready', route: route! }
+        : {
+            ...common,
+            activation: 'missing',
+            target: target!,
+            deadlineUnixMs: deadlineUnixMs!
+          };
+    }
+    case M6bServiceWireCommand.messageFollow: {
+      requireFlags(command.flags, 0);
+      if (reader.u8('messageFollow.version') !== 1) {
+        fail('Unsupported Message Follow version.');
+      }
+      const length = reader.u32('messageFollow.length');
+      const end = reader.offset + length;
+      if (length > 16 * 1024 * 1024 || end > reader.bytes.byteLength) {
+        fail('Invalid Message Follow body length.');
+      }
+      const record: ServiceMessageFollowRecord = {
+        kind: 'messageFollow',
+        source: reader.messageFollowRoute('source'),
+        target: reader.messageFollowRoute('target'),
+        hopCount: reader.u8('hopCount'),
+        queuedMessages: reader.u32('queuedMessages'),
+        queuedBytes: reader.u32('queuedBytes'),
+        originalOperation: reader.operationId('originalOperation'),
+        originalReplyRouteId: reader.u64('originalReplyRouteId')
+      };
+      if (reader.offset !== end) fail('Invalid Message Follow body length.');
+      reader.end();
+      validateMessageFollowRecord(record, fail);
+      return record;
+    }
+    default:
+      fail(`Command '${command.command}' is not owned by the M6B codec.`);
+  }
+}
+
+export function encodeStatefulReply(
+  correlation: bigint,
+  terminalResult: number,
+  failureCode: number,
+  tail?: ServiceStatefulReplyTail
+): Buffer {
+  const tailBytes = tail === undefined ? Buffer.alloc(0) : encodeReplyTail(tail);
+  return concat(
+    prefix(20),
+    u64(correlation),
+    u32(terminalResult, 'terminalResult'),
+    u32(failureCode, 'failureCode'),
+    tailBytes
+  );
+}
+
+/** Encodes canonical maintenance relocation commands 30, 31, 34, 40, 52, and 53. */
+export function encodeMaintenanceRelocationControl(
+  value: ServiceMaintenanceRelocationControl
+): Buffer {
+  switch (value.kind) {
+    case 'prepare':
+      return Buffer.from(encodeGeneratedRelocationPrepare40({
+        ...toGeneratedRelocationBase(value),
+        target: toGeneratedTargetFence(value.target),
+        initiatorRole: value.initiatorRole,
+        object: toGeneratedRelocationObject(value.object),
+        sourceNodeRid: toGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+        sourceNodeGeneration: value.sourceNodeGeneration,
+        payloadTotalLength: value.payloadTotalLength,
+        payloadChunkCount: value.payloadChunkCount,
+        payloadChecksumCrc32c: value.payloadChecksumCrc32c,
+        applicationVersion: value.applicationVersion
+      }));
+    case 'ready':
+      return Buffer.from(encodeGeneratedRelocationReady30({
+        ...toGeneratedRelocationBase(value),
+        target: toGeneratedTargetFence(value.target),
+        object: toGeneratedRelocationObject(value.object),
+        senderRole: value.senderRole
+      }));
+    case 'failed':
+      return Buffer.from(encodeGeneratedRelocationFailed53({
+        ...toGeneratedRelocationBase(value),
+        target: toGeneratedTargetFence(value.target),
+        object: toGeneratedRelocationObject(value.object),
+        senderRole: value.senderRole,
+        failureCode: value.failureCode
+      }));
+    case 'data':
+      return Buffer.from(encodeGeneratedRelocationData31({
+        ...toGeneratedRelocationBase(value),
+        senderRole: value.senderRole,
+        object: toGeneratedRelocationObject(value.object),
+        record: encodeServiceWireFrozenRecord(value.frozenRecord)
+      }));
+    case 'cutover':
+      return Buffer.from(encodeGeneratedRelocationCutover34({
+        ...toGeneratedRelocationBase(value),
+        senderRole: value.senderRole,
+        object: toGeneratedRelocationObject(value.object),
+        boundaryRecordCount: value.boundaryRecordCount,
+        boundaryChecksumCrc32c: value.boundaryChecksumCrc32c
+      }));
+    case 'state':
+      return Buffer.from(encodeGeneratedRelocationState52({
+        ...toGeneratedRelocationBase(value),
+        senderRole: value.senderRole,
+        object: toGeneratedRelocationObject(value.object),
+        chunkOrdinal: value.chunkOrdinal,
+        chunkData: value.chunkData
+      }));
+  }
+}
+
+/** Decodes canonical maintenance relocation commands and rejects malformed vectors. */
+export function decodeMaintenanceRelocationControl(
+  frame: Uint8Array
+): ServiceMaintenanceRelocationControl {
+  switch (frame[3]) {
+    case M6bServiceWireCommand.relocationPrepare:
+      return fromGeneratedRelocationPrepare(decodeGeneratedRelocationPrepare40(frame));
+    case M6bServiceWireCommand.relocationReady:
+      return fromGeneratedRelocationReady(decodeGeneratedRelocationReady30(frame));
+    case M6bServiceWireCommand.relocationFailed:
+      return fromGeneratedRelocationFailed(decodeGeneratedRelocationFailed53(frame));
+    case M6bServiceWireCommand.relocationData:
+      return fromGeneratedRelocationData(decodeGeneratedRelocationData31(frame));
+    case M6bServiceWireCommand.relocationCutover:
+      return fromGeneratedRelocationCutover(decodeGeneratedRelocationCutover34(frame));
+    case M6bServiceWireCommand.relocationState:
+      return fromGeneratedRelocationState(decodeGeneratedRelocationState52(frame));
+    default:
+      fail(`Unsupported maintenance relocation command '${frame.length > 3 ? frame[3] : -1}'.`);
+  }
+}
+
+/** Encodes canonical service-wire command 33 for a maintenance terminal relay. */
+export function encodeMaintenanceReplyRelay(
+  value: ServiceMaintenanceReplyRelay
+): readonly Buffer[] {
+  return encodeGeneratedReplyRelay33(toGeneratedReplyRelay(value)).map(Buffer.from);
+}
+
+/** Decodes canonical service-wire command 33 and rejects non-maintenance contexts. */
+export function decodeMaintenanceReplyRelay(
+  frames: readonly Uint8Array[]
+): ServiceMaintenanceReplyRelay {
+  return fromGeneratedReplyRelay(decodeGeneratedReplyRelay33(frames));
+}
+
+/** Encodes canonical service-wire command 46. */
+export function encodeMaintenanceReplyRelayAck(value: ServiceMaintenanceReplyRelayAck): Buffer {
+  return Buffer.from(encodeGeneratedReplyRelayAck46({
+    relocation: value.relocation,
+    coordinator: toGeneratedCoordinatorFence(value.coordinator),
+    operation: value.operation,
+    replyRouteId: value.replyRouteId,
+    requestSource: toGeneratedRequestSourceFence(value.requestSource),
+    status: value.status
+  }));
+}
+
+/** Decodes canonical service-wire command 46. */
+export function decodeMaintenanceReplyRelayAck(frame: Uint8Array): ServiceMaintenanceReplyRelayAck {
+  const value = decodeGeneratedReplyRelayAck46(frame);
+  return {
+    relocation: value.relocation,
+    coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+    operation: value.operation,
+    replyRouteId: value.replyRouteId,
+    requestSource: fromGeneratedRequestSourceFence(value.requestSource),
+    status: value.status
+  };
+}
+
+export function decodeStatefulReply(
+  frame: Uint8Array,
+  expectedCorrelation: bigint,
+  operationKind: 'spotRequest' | 'actorRequest' | 'actorLookup' | 'actorDestroy' | 'actorJoin' | 'streamBind'
+    | 'streamUnbind'
+    | 'instanceSpotRequest' | 'userSpotCreate' | 'userSpotClose' | 'actorCreate',
+  hasPayload = false
+): ServiceStatefulReply {
+  const reader = new Reader(frame);
+  const command = reader.prefix();
+  if (command.command !== 20 || command.flags !== 0) fail('Invalid stateful reply prefix.');
+  const correlation = reader.nonZeroU64('correlation');
+  if (correlation !== expectedCorrelation) fail('Stateful reply correlation mismatch.');
+  const terminalResult = reader.u32('terminalResult');
+  const failureCode = reader.u32('failureCode');
+  validateReplyTerminal(terminalResult, failureCode, hasPayload);
+  let tail: ServiceStatefulReplyTail | undefined;
+  if (terminalResult === 0) {
+    if (operationKind === 'actorLookup') {
+      tail = {
+        kind: 'actorLookup',
+        actor: reader.actorRef('actor'),
+        spot: {
+          spotId: reader.rid('spotId'),
+          generation: reader.nonZeroU64('spotGeneration')
+        },
+        membershipEpoch: reader.nonZeroU64('membershipEpoch'),
+        authorityOwnerGeneration: reader.nonZeroU64('authorityOwnerGeneration')
+      };
+    } else if (operationKind === 'actorJoin') {
+      const joinResult = reader.u32('joinResult');
+      if (joinResult !== 0 && joinResult !== 1) fail('Invalid actor join result.');
+      const bodyLength = reader.u16('joinBodyLength');
+      const bodyEnd = reader.offset + bodyLength;
+      let spot: ServiceSpotRef | undefined;
+      if (joinResult === 0) {
+        spot = reader.spotRef();
+        const membershipEpoch = reader.nonZeroU64('membershipEpoch');
+        // Tolerant of frames from an unpatched encoder that stops after
+        // membershipEpoch: 0 means "not advertised".
+        const receiveChunkLimitBytes = reader.offset === bodyEnd
+          ? 0
+          : (() => {
+              const value = reader.u32('receiveChunkLimitBytes');
+              if (value > RELOCATION_STATE_CHUNK_DATA_MAX_BYTES) {
+                fail('receiveChunkLimitBytes exceeds the relocation state chunk data bound.');
+              }
+              return value;
+            })();
+        if (reader.offset !== bodyEnd) fail('Invalid actor join body length.');
+        tail = { kind: 'actorJoin', joinResult, spot, membershipEpoch, receiveChunkLimitBytes };
+      } else {
+        const hasSpot = reader.bool8('hasSpot');
+        const optionalLength = reader.u16('optionalSpotLength');
+        const optionalEnd = reader.offset + optionalLength;
+        if (hasSpot) spot = reader.spotRef();
+        if (reader.offset !== optionalEnd) fail('Invalid optional Spot body length.');
+        if (reader.offset !== bodyEnd) fail('Invalid actor join body length.');
+        tail = { kind: 'actorJoin', joinResult, ...(spot === undefined ? {} : { spot }) };
+      }
+    } else if (operationKind === 'streamBind') {
+      tail = {
+        kind: 'streamBind',
+        bindingGeneration: reader.nonZeroU64('bindingGeneration'),
+        authorityOwnerGeneration: reader.nonZeroU64('authorityOwnerGeneration')
+      };
+    } else if (operationKind === 'userSpotCreate') {
+      const createResult = reader.u8('createResult');
+      if (createResult < 1 || createResult > 3) fail('Invalid User Spot create result.');
+      tail = {
+        kind: 'userSpotCreate',
+        createResult: (['existing', 'created', 'rejected'] as const)[createResult - 1]!,
+        spotId: reader.rid('spotId'),
+        objectGeneration: reader.nonZeroU64('objectGeneration')
+      };
+    } else if (operationKind === 'userSpotClose') {
+      tail = {
+        kind: 'userSpotClose',
+        closed: reader.bool8('closed')
+      };
+    } else if (operationKind === 'actorCreate') {
+      const createResult = reader.u8('createResult');
+      if (createResult < 1 || createResult > 3) fail('Invalid Actor create result.');
+      const length = reader.u16('creationLength');
+      const end = reader.offset + length;
+      if (end > reader.bytes.byteLength) fail('Truncated Actor create terminal.');
+      const result = (['existing', 'created', 'rejected'] as const)[createResult - 1]!;
+      const actor = result === 'rejected'
+        ? undefined
+        : {
+            nodeRid: reader.rid('actor.nodeRid'),
+            actorId: reader.text8('actor.actorId'),
+            generation: reader.nonZeroU64('actor.objectGeneration')
+          };
+      if (reader.offset !== end) fail('Invalid Actor create terminal length.');
+      tail = {
+        kind: 'actorCreate',
+        createResult: result,
+        ...(actor === undefined ? {} : { actor })
+      };
+    }
+  }
+  reader.end();
+  return {
+    correlation,
+    terminalResult,
+    failureCode,
+    ...(tail === undefined ? {} : { tail })
+  };
+}
+
+export function sessionBindingFromWire(
+  actor: ServiceActorRef,
+  sessionRid: string,
+  sessionOwnerNodeRid: string,
+  generation: bigint,
+  membershipEpoch: bigint,
+  sessionOwnerNodeGeneration?: bigint,
+  sessionOwnerId?: string,
+  sessionOwnerLeaseGeneration?: bigint
+): ServiceSessionBinding {
+  return {
+    actor,
+    sessionRid,
+    sessionOwnerNodeRid,
+    ...(sessionOwnerNodeGeneration === undefined ? {} : { sessionOwnerNodeGeneration }),
+    ...(sessionOwnerId === undefined ? {} : { sessionOwnerId }),
+    ...(sessionOwnerLeaseGeneration === undefined ? {} : { sessionOwnerLeaseGeneration }),
+    bindingGeneration: generation,
+    membershipEpoch
+  };
+}
+
+function encodeReplyTail(tail: ServiceStatefulReplyTail): Buffer {
+  switch (tail.kind) {
+    case 'actorLookup':
+      return concat(
+        actorRef(tail.actor),
+        rid(tail.spot.spotId, 'spotId'),
+        u64(tail.spot.generation),
+        u64(tail.membershipEpoch),
+        u64(tail.authorityOwnerGeneration)
+      );
+    case 'actorJoin': {
+      if (tail.joinResult === 0) {
+        if (tail.spot === undefined) fail('Accepted actor join requires a SpotRef.');
+        if (tail.membershipEpoch === undefined) {
+          fail('Accepted actor join requires a membership epoch.');
+        }
+        const receiveChunkLimitBytes = tail.receiveChunkLimitBytes ?? 0;
+        if (receiveChunkLimitBytes < 0
+          || receiveChunkLimitBytes > RELOCATION_STATE_CHUNK_DATA_MAX_BYTES) {
+          fail('receiveChunkLimitBytes exceeds the relocation state chunk data bound.');
+        }
+        const body = concat(
+          spotRef(tail.spot),
+          u64(tail.membershipEpoch),
+          u32(receiveChunkLimitBytes, 'receiveChunkLimitBytes')
+        );
+        return concat(u32(0, 'joinResult'), u16(body.byteLength), body);
+      }
+      const optional = tail.spot === undefined
+        ? concat(Buffer.of(0), u16(0))
+        : (() => {
+            const body = spotRef(tail.spot);
+            return concat(Buffer.of(1), u16(body.byteLength), body);
+          })();
+      return concat(u32(1, 'joinResult'), u16(optional.byteLength), optional);
+    }
+    case 'streamBind':
+      return concat(u64(tail.bindingGeneration), u64(tail.authorityOwnerGeneration));
+    case 'userSpotCreate':
+      return concat(
+        Buffer.of((['existing', 'created', 'rejected'] as const).indexOf(tail.createResult) + 1),
+        rid(tail.spotId, 'spotId'),
+        u64(tail.objectGeneration)
+      );
+    case 'userSpotClose':
+      return Buffer.of(tail.closed ? 1 : 0);
+    case 'actorCreate': {
+      const selected = tail.actor === undefined
+        ? Buffer.alloc(0)
+        : concat(
+            rid(tail.actor.nodeRid, 'actor.nodeRid'),
+            text8(tail.actor.actorId, 'actor.actorId'),
+            u64(tail.actor.generation)
+          );
+      return concat(
+        Buffer.of((['existing', 'created', 'rejected'] as const).indexOf(tail.createResult) + 1),
+        u16(selected.byteLength),
+        selected
+      );
+    }
+  }
+}
+
+function wireId(value: ServiceWireOperationId, name: string): Buffer {
+  if (value.high === 0n && value.low === 0n) {
+    throw new RangeError(`${name} must not be zero.`);
+  }
+  return concat(u64Any(value.high), u64Any(value.low));
+}
+
+function validateReplyTerminal(
+  terminalResult: number,
+  failureCode: number,
+  hasPayload: boolean
+): void {
+  if (hasPayload && terminalResult !== 0) {
+    throw new RangeError('Failed stateful reply must not carry a payload.');
+  }
+  if (!isCanonicalWireReplyTerminal(terminalResult, failureCode)) {
+    throw new RangeError('Stateful reply terminalResult does not match its framework failureCode.');
+  }
+}
+
+function validateRelocationPhase(value: number): void {
+  const phases = ['none', 'preparing', 'captured', 'prepared', 'committed',
+    'activating', 'activated', 'cleaning', 'completed', 'aborted'] as const;
+  if (!Number.isInteger(value) || value < 0 || value >= phases.length) {
+    fail('Invalid relocationData control phase.');
+  }
+}
+
+function applicationPayload(value: NonNullable<ServiceMaintenanceReplyRelay['payload']>): Buffer {
+  const body = concat(
+    text8(value.packetName, 'packetName'),
+    text8(value.contentType, 'contentType'),
+    u32(value.bytes.byteLength, 'payload.length'),
+    value.bytes
+  );
+  return concat(Buffer.of(1), u32(body.byteLength, 'applicationPayload.length'), body);
+}
+
+function prefix(command: number, flags = 0): Buffer {
+  return Buffer.from([MAGIC_0, MAGIC_1, MAJOR, command, flags]);
+}
+
+function actorFence(value: ServiceActorRouteFence): Buffer {
+  return concat(
+    actorRef(value.actor),
+    rid(value.actor.nodeRid, 'targetNodeRid'),
+    u64(value.targetNodeGeneration),
+    u64(value.authorityOwnerGeneration),
+    u64(value.ownerLeaseGeneration)
+  );
+}
+
+function actorAuthorityFence(value: ServiceBoundSessionActorAuthority): Buffer {
+  return concat(
+    actorRef(value.actor),
+    rid(value.actor.nodeRid, 'targetNodeRid'),
+    u64(value.targetNodeGeneration),
+    u64(value.authorityOwnerGeneration),
+    u64(value.ownerLeaseGeneration)
+  );
+}
+
+function spotFence(value: ServiceSpotRouteFence): Buffer {
+  return concat(
+    spotRef(value.spot),
+    rid(value.targetNodeRid, 'targetNodeRid'),
+    u64(value.targetNodeGeneration),
+    u64(value.authorityOwnerGeneration),
+    u64(value.ownerLeaseGeneration)
+  );
+}
+
+function directSpotFence(value: ServiceDirectSpotRouteFence): Buffer {
+  return concat(
+    spotFence(value),
+    text16(value.storeVersion, 'storeVersion')
+  );
+}
+
+function messageFollowRoute(value: ServiceMessageFollowRoute): Buffer {
+  const body = value.kind === 'actor'
+    ? concat(
+        actorRef(value.actor),
+        rid(value.targetNodeRid, 'targetNodeRid'),
+        u64(value.targetNodeGeneration),
+        u64(value.authorityOwnerGeneration),
+        u64(value.ownerLeaseGeneration)
+      )
+    : concat(
+        spotRef(value.spot),
+        rid(value.targetNodeRid, 'targetNodeRid'),
+        u64(value.targetNodeGeneration),
+        u64(value.authorityOwnerGeneration),
+        u64(value.ownerLeaseGeneration)
+      );
+  return concat(Buffer.of(value.kind === 'actor' ? 1 : 2), u16(body.byteLength), body);
+}
+
+function validateMessageFollowRecord(
+  value: Omit<ServiceMessageFollowRecord, 'kind'>,
+  invalid: (message: string) => never = (message) => { throw new RangeError(message); }
+): void {
+  if (value.source.kind !== value.target.kind) {
+    invalid('Message Follow source and target object kinds differ.');
+  }
+  const sameObject = value.source.kind === 'actor' && value.target.kind === 'actor'
+    ? value.source.actor.actorId === value.target.actor.actorId
+      && value.source.actor.generation === value.target.actor.generation
+    : value.source.kind === 'spot' && value.target.kind === 'spot'
+      ? value.source.spot.spotId === value.target.spot.spotId
+        && value.source.spot.generation === value.target.spot.generation
+      : false;
+  if (!sameObject) invalid('Message Follow source and target object identities differ.');
+  if (!Number.isInteger(value.hopCount) || value.hopCount < 1 || value.hopCount > 8) {
+    invalid('Message Follow hopCount must be in 1..8.');
+  }
+  if (!Number.isInteger(value.queuedMessages)
+      || value.queuedMessages < 0
+      || value.queuedMessages > 0xffff_ffff) {
+    invalid('Message Follow queuedMessages must be a u32.');
+  }
+  if (!Number.isInteger(value.queuedBytes)
+      || value.queuedBytes < 0
+      || value.queuedBytes > 0xffff_ffff) {
+    invalid('Message Follow queuedBytes must be a u32.');
+  }
+  if (value.originalOperation.high === 0n && value.originalOperation.low === 0n) {
+    invalid('Message Follow originalOperation must not be zero.');
+  }
+  if (value.originalReplyRouteId < 0n
+      || value.originalReplyRouteId > 0xffff_ffff_ffff_ffffn) {
+    invalid('Message Follow originalReplyRouteId must be a u64.');
+  }
+}
+
+function actorRef(value: ServiceActorRef): Buffer {
+  return concat(text8(value.actorId, 'actorId'), u64(value.generation));
+}
+
+function optionalActor(value: ServiceActorRef | undefined): Buffer {
+  return value === undefined
+    ? Buffer.of(0)
+    : concat(text8(value.actorId, 'sourceActorId'), u64(value.generation));
+}
+
+function spotRef(value: ServiceSpotRef): Buffer {
+  return concat(rid(value.spotId, 'spotId'), u64(value.generation));
+}
+
+function rid(value: string, name: string): Buffer {
+  const bytes = encodeServiceWireRoutingId(value, name, 0xff, outOfRange);
+  return concat(Buffer.of(bytes.byteLength), bytes);
+}
+
+function text8(value: string, name: string): Buffer {
+  return sized8(value, name);
+}
+
+function text16(value: string, name: string): Buffer {
+  const bytes = encodeCanonicalServiceWireText(value, name, 0xffff, outOfRange);
+  return concat(u16(bytes.byteLength), bytes);
+}
+
+function optionalRid(value: string | undefined): Buffer {
+  return value === undefined ? Buffer.of(0) : rid(value, 'sourceSpotId');
+}
+
+function sized8(value: string, name: string): Buffer {
+  const bytes = encodeCanonicalServiceWireText(value, name, 0xff, outOfRange);
+  return concat(Buffer.of(bytes.byteLength), bytes);
+}
+
+function u16(value: number): Buffer {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffff) fail('u16 value is out of range.');
+  const result = Buffer.alloc(2);
+  result.writeUInt16BE(value);
+  return result;
+}
+
+function u32(value: number, name: string): Buffer {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) {
+    throw new RangeError(`${name} must be a u32.`);
+  }
+  const result = Buffer.alloc(4);
+  result.writeUInt32BE(value);
+  return result;
+}
+
+function u64(value: bigint): Buffer {
+  requirePositive(value, 'u64');
+  const result = Buffer.alloc(8);
+  result.writeBigUInt64BE(value);
+  return result;
+}
+
+function u64Any(value: bigint): Buffer {
+  if (value < 0n || value > 0xffff_ffff_ffff_ffffn) {
+    throw new RangeError('u64 value is out of range.');
+  }
+  const result = Buffer.alloc(8);
+  result.writeBigUInt64BE(value);
+  return result;
+}
+
+function requirePositive(value: bigint | undefined, name: string): bigint {
+  if (value === undefined || value < 1n || value > 0xffff_ffff_ffff_ffffn) {
+    throw new RangeError(`${name} must be a non-zero u64.`);
+  }
+  return value;
+}
+
+function requireFlags(actual: number, expected: number): void {
+  if (actual !== expected) fail(`Invalid command flags '${actual}'.`);
+}
+
+function concat(...parts: readonly Uint8Array[]): Buffer {
+  return Buffer.concat(parts.map(part => Buffer.from(part)));
+}
+
+function fail(message: string): never {
+  throw new ServiceWireProtocolError(message);
+}
+
+function outOfRange(message: string): never {
+  throw new RangeError(message);
+}
+
+class Reader {
+  readonly bytes: Buffer;
+  offset = 0;
+
+  constructor(value: Uint8Array) {
+    this.bytes = Buffer.from(value);
+  }
+
+  get remaining(): number {
+    return this.bytes.byteLength - this.offset;
+  }
+
+  takeRemaining(): Buffer {
+    const value = Buffer.from(this.bytes.subarray(this.offset));
+    this.offset = this.bytes.byteLength;
+    return value;
+  }
+
+  prefix(): { readonly command: number; readonly flags: number } {
+    this.need(PREFIX_SIZE, 'prefix');
+    if (
+      this.bytes[this.offset] !== MAGIC_0
+      || this.bytes[this.offset + 1] !== MAGIC_1
+      || this.bytes[this.offset + 2] !== MAJOR
+    ) {
+      fail('Invalid service wire prefix.');
+    }
+    const command = this.bytes[this.offset + 3]!;
+    const flags = this.bytes[this.offset + 4]!;
+    this.offset += PREFIX_SIZE;
+    return { command, flags };
+  }
+
+  u8(name: string): number {
+    this.need(1, name);
+    return this.bytes[this.offset++]!;
+  }
+
+  bool8(name: string): boolean {
+    const value = this.u8(name);
+    if (value !== 0 && value !== 1) fail(`${name} must be bool8.`);
+    return value === 1;
+  }
+
+  u16(name: string): number {
+    this.need(2, name);
+    const value = this.bytes.readUInt16BE(this.offset);
+    this.offset += 2;
+    return value;
+  }
+
+  u32(name: string): number {
+    this.need(4, name);
+    const value = this.bytes.readUInt32BE(this.offset);
+    this.offset += 4;
+    return value;
+  }
+
+  nonZeroU64(name: string): bigint {
+    this.need(8, name);
+    const value = this.bytes.readBigUInt64BE(this.offset);
+    this.offset += 8;
+    if (value === 0n) fail(`${name} must be a non-zero u64.`);
+    return value;
+  }
+
+  u64(name: string): bigint {
+    this.need(8, name);
+    const value = this.bytes.readBigUInt64BE(this.offset);
+    this.offset += 8;
+    return value;
+  }
+
+  operationId(name: string): ServiceWireOperationId {
+    const value = {
+      high: this.u64(`${name}.high`),
+      low: this.u64(`${name}.low`)
+    };
+    if (value.high === 0n && value.low === 0n) fail(`${name} must not be zero.`);
+    return value;
+  }
+
+  rid(name: string): string {
+    return this.opaque8(name);
+  }
+
+  text8(name: string): string {
+    return this.sized8(name);
+  }
+
+  text16(name: string): string {
+    const length = this.u16(`${name}.length`);
+    if (length === 0) fail(`${name} must not be empty.`);
+    this.need(length, name);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return decodeCanonicalServiceWireText(bytes, name, fail);
+  }
+
+  optionalRid(name: string): string | undefined {
+    const length = this.u8(`${name}.length`);
+    if (length === 0) return undefined;
+    this.need(length, name);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return decodeServiceWireRoutingId(bytes, name, 0xff, fail);
+  }
+
+  actorRef(name: string): ServiceActorRef {
+    return {
+      nodeRid: '',
+      actorId: this.text8(`${name}.actorId`),
+      generation: this.nonZeroU64(`${name}.generation`)
+    };
+  }
+
+  optionalActor(): ServiceActorRef | undefined {
+    const length = this.u8('sourceActorId.length');
+    if (length === 0) return undefined;
+    this.need(length, 'sourceActorId');
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    const actorId = decodeCanonicalServiceWireText(bytes, 'sourceActorId', fail);
+    return {
+      nodeRid: '',
+      actorId,
+      generation: this.nonZeroU64('sourceActorGeneration')
+    };
+  }
+
+  spotRef(): ServiceSpotRef {
+    return {
+      spotId: this.rid('spotId'),
+      generation: this.nonZeroU64('spotGeneration')
+    };
+  }
+
+  actorFence(): ServiceActorRouteFence {
+    const actor = this.actorRef('actor');
+    const targetNodeRid = this.rid('targetNodeRid');
+    return {
+      actor: { ...actor, nodeRid: targetNodeRid },
+      targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+      authorityOwnerGeneration: this.nonZeroU64('authorityOwnerGeneration'),
+      ownerLeaseGeneration: this.nonZeroU64('ownerLeaseGeneration')
+    };
+  }
+
+  spotFence(): ServiceSpotRouteFence {
+    const spot = this.spotRef();
+    return {
+      spot,
+      targetNodeRid: this.rid('targetNodeRid'),
+      targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+      authorityOwnerGeneration: this.nonZeroU64('authorityOwnerGeneration'),
+      ownerLeaseGeneration: this.nonZeroU64('ownerLeaseGeneration')
+    };
+  }
+
+  directSpotFence(): ServiceDirectSpotRouteFence {
+    return {
+      ...this.spotFence(),
+      storeVersion: this.text16('storeVersion')
+    };
+  }
+
+  messageFollowRoute(name: string): ServiceMessageFollowRoute {
+    const kind = this.u8(`${name}.objectKind`);
+    const length = this.u16(`${name}.length`);
+    const end = this.offset + length;
+    if (end > this.bytes.byteLength) fail(`Truncated Message Follow ${name} route.`);
+    let value: ServiceMessageFollowRoute;
+    if (kind === 1) {
+      const actor = this.actorRef(`${name}.actor`);
+      value = {
+        kind: 'actor',
+        actor,
+        targetNodeRid: this.rid(`${name}.targetNodeRid`),
+        targetNodeGeneration: this.nonZeroU64(`${name}.targetNodeGeneration`),
+        authorityOwnerGeneration: this.nonZeroU64(`${name}.authorityOwnerGeneration`),
+        ownerLeaseGeneration: this.nonZeroU64(`${name}.ownerLeaseGeneration`)
+      };
+    } else if (kind === 2) {
+      value = {
+        kind: 'spot',
+        spot: this.spotRef(),
+        targetNodeRid: this.rid(`${name}.targetNodeRid`),
+        targetNodeGeneration: this.nonZeroU64(`${name}.targetNodeGeneration`),
+        authorityOwnerGeneration: this.nonZeroU64(`${name}.authorityOwnerGeneration`),
+        ownerLeaseGeneration: this.nonZeroU64(`${name}.ownerLeaseGeneration`)
+      };
+    } else {
+      fail(`Unknown Message Follow ${name} object kind.`);
+    }
+    if (this.offset !== end) fail(`Invalid Message Follow ${name} route length.`);
+    return value;
+  }
+
+  end(): void {
+    if (this.remaining !== 0) fail('Service wire record has trailing bytes.');
+  }
+
+  private sized8(name: string): string {
+    const length = this.u8(`${name}.length`);
+    if (length === 0) fail(`${name} must not be empty.`);
+    this.need(length, name);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return decodeCanonicalServiceWireText(bytes, name, fail);
+  }
+
+  private opaque8(name: string): string {
+    const length = this.u8(`${name}.length`);
+    if (length === 0) fail(`${name} must not be empty.`);
+    this.need(length, name);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return decodeServiceWireRoutingId(bytes, name, 0xff, fail);
+  }
+
+  private need(count: number, name: string): void {
+    if (count < 0 || count > this.remaining) fail(`Truncated ${name}.`);
+  }
+}
+
+export function decodeServiceWireFrozenRecord(bytes: Uint8Array): ServiceWireFrozenRecord {
+  const reader = new FrozenReader(bytes);
+  const record = decodeServiceWireFrozenRecordFrom(reader);
+  reader.end('frozen record');
+  return { ...record, canonicalBytes: Buffer.from(bytes) };
+}
+
+/**
+ * Consumes exactly one canonical frozen record at `offset`.  Relocation
+ * saved-work is a vector of back-to-back records, so its boundary is the
+ * record grammar itself rather than an enclosing length field.
+ */
+export function decodeServiceWireFrozenRecordPrefix(
+  bytes: Uint8Array,
+  offset = 0
+): { readonly record: ServiceWireFrozenRecord; readonly length: number } {
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset >= bytes.byteLength) {
+    fail('Frozen record offset is outside the encoded bytes.');
+  }
+  const reader = new FrozenReader(bytes.subarray(offset));
+  const record = decodeServiceWireFrozenRecordFrom(reader);
+  return {
+    record: { ...record, canonicalBytes: Buffer.from(bytes.subarray(offset, offset + reader.position)) },
+    length: reader.position
+  };
+}
+
+function decodeServiceWireFrozenRecordFrom(reader: FrozenReader): ServiceWireFrozenRecord {
+  const recordKind = reader.u8('recordKind');
+  if (recordKind < 1 || recordKind > 14) fail('Invalid frozen record kind.');
+  const sourceKind = reader.u8('sourceKind');
+  if (sourceKind < 1 || sourceKind > 4) fail('Invalid frozen source kind.');
+  const sourceReader = reader.body16('frozen source');
+  const source: ServiceWireRequestSourceFence = {
+    nodeRid: sourceReader.rid8('sourceNodeRid'),
+    nodeGeneration: sourceReader.nonZeroU64('sourceNodeGeneration'),
+    ownerId: sourceReader.text8('sourceOwnerId'),
+    leaseGeneration: sourceReader.nonZeroU64('sourceOwnerLeaseGeneration')
+  };
+  let sourceSpotId: string | undefined;
+  let sourceActor: ServiceWireFrozenRecord['sourceActor'];
+  let sourceSessionRid: string | undefined;
+  let sourceBindingGeneration: bigint | undefined;
+  let sourceSessionSequence: bigint | undefined;
+  if (sourceKind === 2) {
+    sourceSpotId = sourceReader.text8('sourceSpotId');
+  } else if (sourceKind === 3 || sourceKind === 4) {
+    sourceActor = {
+      actorId: sourceReader.text8('sourceActorId'),
+      generation: sourceReader.nonZeroU64('sourceActorGeneration')
+    };
+    if (sourceKind === 4) {
+      sourceSessionRid = sourceReader.rid8('sourceSessionRid');
+      sourceBindingGeneration = sourceReader.nonZeroU64('sourceBindingGeneration');
+      sourceSessionSequence = sourceReader.nonZeroU64('sourceSessionSequence');
+    }
+  }
+  sourceReader.end('frozen source');
+  if ([8, 12, 13].includes(recordKind) && sourceKind !== 1) {
+    fail('Infrastructure frozen record requires a node source.');
+  }
+  const hasMetadata = reader.bool8('hasMetadata');
+  if (hasMetadata) {
+    if (!((recordKind >= 1 && recordKind <= 7)
+      || recordKind === 9 || recordKind === 10 || recordKind === 14)) {
+      fail('Metadata is forbidden for this frozen record kind.');
+    }
+    reader.metadata();
+  }
+  const operationId = {
+    high: reader.u64('operationId.high'),
+    low: reader.u64('operationId.low')
+  };
+  const operationKind = reader.u32('operationKind');
+  if (operationKind > 15) fail('Invalid frozen operation kind.');
+  const replyReader = reader.body16('frozen reply route');
+  const requiresReply = operationRequiresReply(operationKind);
+  const replyRouteId = requiresReply
+    ? replyReader.nonZeroU64('replyRouteId')
+    : undefined;
+  replyReader.end('frozen reply route');
+  const body = reader.frozenBody(recordKind);
+  validateFrozenOperationMatrix(recordKind, operationKind, operationId, replyRouteId,
+    body.instanceOperationKind);
+  return {
+    recordKind,
+    sourceKind,
+    source,
+    ...(sourceSpotId === undefined ? {} : { sourceSpotId }),
+    ...(sourceActor === undefined ? {} : { sourceActor }),
+    ...(sourceSessionRid === undefined ? {} : { sourceSessionRid }),
+    ...(sourceBindingGeneration === undefined ? {} : { sourceBindingGeneration }),
+    ...(sourceSessionSequence === undefined ? {} : { sourceSessionSequence }),
+    hasMetadata,
+    operationId,
+    operationKind,
+    ...(replyRouteId === undefined ? {} : { replyRouteId }),
+    ...(body.target === undefined ? {} : { target: body.target }),
+    ...(body.applicationPayload === undefined
+      ? {}
+      : { applicationPayload: body.applicationPayload }),
+    canonicalBytes: Buffer.alloc(0)
+  };
+}
+
+export function encodeServiceWireFrozenRecord(record: ServiceWireFrozenRecord): Buffer {
+  if (record.canonicalBytes.byteLength === 0) {
+    throw new RangeError('Canonical frozen record bytes must not be empty.');
+  }
+  const decoded = decodeServiceWireFrozenRecord(record.canonicalBytes);
+  if (!sameFrozenRecordSummary(decoded, record)) {
+    throw new RangeError('Frozen record summary does not match its canonical bytes.');
+  }
+  return Buffer.from(record.canonicalBytes);
+}
+
+export function encodeServiceWireFrozenActorApplicationRecord(input: {
+  readonly source: ServiceWireRequestSourceFence;
+  readonly target: {
+    readonly actorId: string;
+    readonly objectGeneration: bigint;
+    readonly nodeRid: string;
+    readonly nodeGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly ownerLeaseGeneration: bigint;
+  };
+  readonly operationId: ServiceWireOperationId;
+  readonly replyRouteId?: bigint;
+  readonly payload: NonNullable<ServiceMaintenanceReplyRelay['payload']>;
+}): ServiceWireFrozenRecord {
+  const request = input.replyRouteId !== undefined;
+  const sourceBody = concat(
+    rid(input.source.nodeRid, 'sourceNodeRid'),
+    u64(input.source.nodeGeneration),
+    text8(input.source.ownerId, 'sourceOwnerId'),
+    u64(input.source.leaseGeneration)
+  );
+  const replyBody = request ? u64(input.replyRouteId!) : Buffer.alloc(0);
+  const bytes = concat(
+    Buffer.of(request ? 10 : 9),
+    Buffer.of(1), u16(sourceBody.byteLength), sourceBody,
+    Buffer.of(0),
+    wireId(input.operationId, 'operationId'),
+    u32(request ? 4 : 0, 'operationKind'),
+    u16(replyBody.byteLength), replyBody,
+    text8(input.target.actorId, 'targetActorId'),
+    u64(input.target.objectGeneration),
+    rid(input.target.nodeRid, 'targetNodeRid'),
+    u64(input.target.nodeGeneration),
+    u64(input.target.authorityOwnerGeneration),
+    u64(input.target.ownerLeaseGeneration),
+    applicationPayload(input.payload)
+  );
+  return decodeServiceWireFrozenRecord(bytes);
+}
+
+function sameFrozenRecordSummary(left: ServiceWireFrozenRecord, right: ServiceWireFrozenRecord): boolean {
+  return left.recordKind === right.recordKind
+    && left.sourceKind === right.sourceKind
+    && routingIdsEqual(left.source.nodeRid, right.source.nodeRid)
+    && left.source.nodeGeneration === right.source.nodeGeneration
+    && left.source.ownerId === right.source.ownerId
+    && left.source.leaseGeneration === right.source.leaseGeneration
+    && left.sourceSpotId === right.sourceSpotId
+    && left.sourceActor?.actorId === right.sourceActor?.actorId
+    && left.sourceActor?.generation === right.sourceActor?.generation
+    && left.sourceSessionRid === right.sourceSessionRid
+    && left.sourceBindingGeneration === right.sourceBindingGeneration
+    && left.sourceSessionSequence === right.sourceSessionSequence
+    && left.hasMetadata === right.hasMetadata
+    && left.operationId.high === right.operationId.high
+    && left.operationId.low === right.operationId.low
+    && left.operationKind === right.operationKind
+    && left.replyRouteId === right.replyRouteId
+    && left.canonicalBytes.equals(right.canonicalBytes);
+}
+
+function validateFrozenOperationMatrix(
+  recordKind: number,
+  operationKind: number,
+  operationId: ServiceWireOperationId,
+  replyRouteId: bigint | undefined,
+  instanceOperationKind: number | undefined
+): void {
+  const zero = operationId.high === 0n && operationId.low === 0n;
+  let valid = false;
+  if ([1, 3, 7, 12, 13].includes(recordKind)) valid = operationKind === 0 && zero;
+  else if (recordKind === 2) valid = operationKind === 1 && !zero;
+  else if (recordKind === 4) valid = operationKind === 2 && !zero;
+  else if (recordKind === 5 || recordKind === 9) valid = operationKind === 0 && !zero;
+  else if (recordKind === 6) valid = operationKind === 3 && !zero;
+  else if (recordKind === 10) valid = operationKind === 4 && !zero;
+  else if (recordKind === 8) {
+    valid = operationKind === 0 && zero
+      || [6, 7, 8].includes(operationKind) && !zero;
+  } else if (recordKind === 11) valid = operationKind >= 1 && operationKind <= 15 && !zero;
+  else if (recordKind === 14 && instanceOperationKind !== undefined) {
+    valid = instanceOperationKind === 1
+      ? operationKind === 0 && zero
+      : operationKind === 12 && !zero;
+  }
+  if (!valid) fail('Frozen record kind, operation kind, and operation ID do not match.');
+  if (operationRequiresReply(operationKind) !== (replyRouteId !== undefined)) {
+    fail('Frozen reply route does not match the operation kind.');
+  }
+}
+
+class FrozenReader {
+  private offset = 0;
+  private readonly bytes: Buffer;
+
+  constructor(bytes: Buffer | Uint8Array) {
+    this.bytes = Buffer.isBuffer(bytes)
+      ? bytes
+      : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+
+  private get remaining(): number {
+    return this.bytes.byteLength - this.offset;
+  }
+
+  get position(): number {
+    return this.offset;
+  }
+
+  u8(name: string): number {
+    this.need(1, name);
+    return this.bytes[this.offset++]!;
+  }
+
+  bool8(name: string): boolean {
+    const value = this.u8(name);
+    if (value !== 0 && value !== 1) fail(`${name} must be bool8.`);
+    return value === 1;
+  }
+
+  u16(name: string): number {
+    this.need(2, name);
+    const value = this.bytes.readUInt16BE(this.offset);
+    this.offset += 2;
+    return value;
+  }
+
+  u32(name: string): number {
+    this.need(4, name);
+    const value = this.bytes.readUInt32BE(this.offset);
+    this.offset += 4;
+    return value;
+  }
+
+  u64(name: string): bigint {
+    this.need(8, name);
+    const value = this.bytes.readBigUInt64BE(this.offset);
+    this.offset += 8;
+    return value;
+  }
+
+  nonZeroU64(name: string): bigint {
+    const value = this.u64(name);
+    if (value === 0n) fail(`${name} must be a non-zero u64.`);
+    return value;
+  }
+
+  text8(name: string): string {
+    const length = this.u8(`${name}.length`);
+    if (length === 0) fail(`${name} must not be empty.`);
+    return this.textBody(length, name);
+  }
+
+  rid8(name: string): string {
+    const length = this.u8(`${name}.length`);
+    if (length === 0) fail(`${name} must not be empty.`);
+    this.need(length, name);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return decodeServiceWireRoutingId(bytes, name, 0xff, fail);
+  }
+
+  text16(name: string, allowEmpty = false): string {
+    const length = this.u16(`${name}.length`);
+    if (!allowEmpty && length === 0) fail(`${name} must not be empty.`);
+    return this.textBody(length, name);
+  }
+
+  body16(name: string): FrozenReader {
+    const length = this.u16(`${name}.length`);
+    this.need(length, name);
+    const body = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return new FrozenReader(body);
+  }
+
+  applicationPayload(): NonNullable<ServiceMaintenanceReplyRelay['payload']> {
+    if (this.u8('applicationPayload.version') !== 1) {
+      fail('Application payload envelope version must be one.');
+    }
+    const body = this.body32('application payload');
+    const packetName = body.text8('packetName');
+    const contentType = body.text8('contentType');
+    const payloadLength = body.u32('payloadLength');
+    const bytes = body.take(payloadLength, 'payload');
+    body.end('application payload');
+    return { packetName, contentType, bytes };
+  }
+
+  metadata(): void {
+    const start = this.offset;
+    if (this.u8('metadata.version') !== 1) fail('Metadata frame version must be one.');
+    const count = this.u8('metadata.count');
+    const keys = new Set<string>();
+    for (let index = 0; index < count; index++) {
+      const key = this.text8('metadata.key');
+      if (keys.has(key)) fail('Metadata keys must be unique.');
+      keys.add(key);
+      this.text16('metadata.value', true);
+      if (this.offset - start > 1024) fail('Metadata frame exceeds 1024 encoded bytes.');
+    }
+  }
+
+  frozenBody(recordKind: number): {
+    readonly instanceOperationKind?: number;
+    readonly target?: ServiceWireFrozenRecord['target'];
+    readonly applicationPayload?: NonNullable<ServiceMaintenanceReplyRelay['payload']>;
+  } {
+    if (recordKind === 1 || recordKind === 2) {
+      return { applicationPayload: this.applicationPayload() };
+    }
+    else if (recordKind === 3 || recordKind === 4) {
+      this.text8('channelName');
+      return { applicationPayload: this.applicationPayload() };
+    } else if (recordKind === 5 || recordKind === 6) {
+      return {
+        target: this.spotRoute(),
+        applicationPayload: this.applicationPayload()
+      };
+    } else if (recordKind === 7) {
+      this.text8('channelName');
+      this.text8('topic');
+      return { applicationPayload: this.applicationPayload() };
+    } else if (recordKind === 8) this.actorControl();
+    else if (recordKind === 9 || recordKind === 10) {
+      return {
+        target: this.actorRoute(),
+        applicationPayload: this.applicationPayload()
+      };
+    } else if (recordKind === 11) {
+      const terminalResult = this.u32('terminalResult');
+      const failureCode = this.u32('failureCode');
+      const hasPayload = this.bool8('hasPayload');
+      validateReplyTerminal(terminalResult, failureCode, hasPayload);
+      return hasPayload
+        ? { applicationPayload: this.applicationPayload() }
+        : {};
+    } else if (recordKind === 12) this.sendReadyDestination();
+    else if (recordKind === 13) {
+      validateRelocationPhase(this.u8('phase'));
+      const role = this.u8('role');
+      if (role < 1 || role > 3) fail('Invalid relocation control role.');
+      const relocation = { high: this.u64('relocation.high'), low: this.u64('relocation.low') };
+      if (relocation.high === 0n && relocation.low === 0n) fail('Relocation ID must not be zero.');
+      this.relocationObject();
+      validateReplyTerminal(this.u32('terminalResult'), this.u32('failureCode'), false);
+    } else if (recordKind === 14) {
+      this.instanceRoute();
+      this.nonZeroU64('instanceSourceNodeGeneration');
+      const operationKind = this.u8('instanceOperationKind');
+      if (operationKind < 1 || operationKind > 2) fail('Invalid Instance activation operation kind.');
+      const applicationPayload = this.applicationPayload();
+      return { instanceOperationKind: operationKind, applicationPayload };
+    }
+    return {};
+  }
+
+  private spotRoute(): Extract<NonNullable<ServiceWireFrozenRecord['target']>, { kind: 'spot' }> {
+    const spot = this.spotIdentity();
+    return {
+      kind: 'spot',
+      ...spot,
+      targetNodeRid: this.rid8('targetNodeRid'),
+      targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+      authorityOwnerGeneration: this.nonZeroU64('expectedAuthorityOwnerGeneration'),
+      ownerLeaseGeneration: this.nonZeroU64('expectedOwnerLeaseGeneration')
+    };
+  }
+
+  private actorRoute(): Extract<NonNullable<ServiceWireFrozenRecord['target']>, { kind: 'actor' }> {
+    const actor = this.actorIdentity();
+    return {
+      kind: 'actor',
+      ...actor,
+      targetNodeRid: this.rid8('targetNodeRid'),
+      targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+      authorityOwnerGeneration: this.nonZeroU64('expectedAuthorityOwnerGeneration'),
+      ownerLeaseGeneration: this.nonZeroU64('expectedOwnerLeaseGeneration')
+    };
+  }
+
+  private actorIdentity(): { readonly actorId: string; readonly generation: bigint } {
+    return {
+      actorId: this.text8('actorId'),
+      generation: this.nonZeroU64('actorGeneration')
+    };
+  }
+
+  private spotIdentity(): { readonly spotId: string; readonly generation: bigint } {
+    return {
+      spotId: this.text8('spotId'),
+      generation: this.nonZeroU64('spotGeneration')
+    };
+  }
+
+  private membershipSnapshot(): void {
+    this.actorIdentity();
+    this.spotIdentity();
+  }
+
+  private optionalMembershipSnapshot(): void {
+    const present = this.bool8('hasMembership');
+    const body = this.body16('optionalMembership');
+    if (present) body.membershipSnapshot();
+    body.end('optional membership');
+  }
+
+  private actorControl(): void {
+    const lifecycle = this.u8('actorLifecycleKind');
+    if (lifecycle < 1 || lifecycle > 5) fail('Invalid Actor lifecycle kind.');
+    const body = this.body16('actorControl');
+    if (lifecycle === 1 || lifecycle === 4 || lifecycle === 5) body.membershipSnapshot();
+    else if (lifecycle === 2) {
+      body.optionalMembershipSnapshot();
+      body.membershipSnapshot();
+    } else {
+      body.membershipSnapshot();
+      body.membershipSnapshot();
+    }
+    body.end('Actor control');
+  }
+
+  private sendReadyDestination(): void {
+    const kind = this.u8('destinationKind');
+    if (kind < 1 || kind > 5) fail('Invalid send-ready destination kind.');
+    const body = this.body16('send-ready destination');
+    if (kind === 1 || kind === 2) body.text8('destination');
+    else if (kind === 3) body.spotRoute();
+    else {
+      body.actorRoute();
+      if (kind === 5) body.nonZeroU64('bindingGeneration');
+    }
+    body.end('send-ready destination');
+  }
+
+  private instanceRoute(): void {
+    const kind = this.u8('instanceRouteKind');
+    if (kind < 1 || kind > 2) fail('Invalid Instance route kind.');
+    const body = this.body16('Instance route');
+    body.rid8('targetNodeRid');
+    body.nonZeroU64('targetNodeGeneration');
+    body.text8('targetSpotId');
+    if (kind === 1) {
+      body.nonZeroU64('objectGeneration');
+      body.text8('ownerId');
+      body.nonZeroU64('authorityOwnerGeneration');
+      body.nonZeroU64('leaseGeneration');
+      body.text16('storeVersion');
+    } else {
+      body.text8('targetMeshName');
+      body.text8('stableType');
+      body.text8('targetDescriptorVersion');
+      body.nonZeroU64('deadlineUnixMs');
+    }
+    body.end('Instance route');
+  }
+
+  private relocationObject(): void {
+    const kind = this.u8('relocationObjectKind');
+    const body = this.body16('relocation object');
+    if (kind === 1) {
+      body.text8('actorId');
+      body.nonZeroU64('actorGeneration');
+      body.nonZeroU64('expectedAuthorityOwnerGeneration');
+    } else if (kind === 2) {
+      body.text8('spotId');
+      body.nonZeroU64('spotGeneration');
+      body.nonZeroU64('expectedAuthorityOwnerGeneration');
+    } else if (kind === 3) {
+      body.text8('stableType');
+      body.text8('spotId');
+      body.nonZeroU64('objectGeneration');
+    } else fail('Invalid relocation object kind.');
+    body.end('relocation object');
+  }
+
+  private body32(name: string): FrozenReader {
+    const length = this.u32(`${name}.length`);
+    this.need(length, name);
+    const body = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return new FrozenReader(body);
+  }
+
+  private take(length: number, name: string): Buffer {
+    this.need(length, name);
+    const value = Buffer.from(this.bytes.subarray(this.offset, this.offset + length));
+    this.offset += length;
+    return value;
+  }
+
+  private textBody(length: number, name: string): string {
+    this.need(length, name);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return decodeCanonicalServiceWireText(bytes, name, fail);
+  }
+
+  private need(length: number, name: string): void {
+    if (length < 0 || length > this.remaining) fail(`Truncated ${name}.`);
+  }
+
+  end(name: string): void {
+    if (this.remaining !== 0) fail(`${name} has trailing bytes.`);
+  }
+}