@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -1,27 +1,24 @@
-import type {
-  ServiceActorRef,
-  ServiceSessionBinding,
-  ServiceSpotRef
-} from './service-stateful-registry';
-import { operationRequiresReply } from './service-runtime-contracts';
-import { ServiceWireProtocolError } from './service-wire-m6a-codec';
+import { UINT64_MAX, ZlinkStreamContentType } from '@zlink-systems/stream-wire';
+import { RELOCATION_STATE_CHUNK_DATA_MAX_BYTES } from '../../contracts/Configuration/InternalDefaults';
 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';
+  decodeActorRequestCommand,
+  decodeActorSendCommand,
+  decodeMetadataFrame,
+  decodeInstanceRouteV1,
+  decodeSpotRequestCommand,
+  decodeSpotSendCommand,
+  encodeActorRequestCommand,
+  encodeActorSendCommand,
+  encodeApplicationPayloadEnvelopeV1,
+  encodeInstanceRouteV1,
+  encodeSpotRequestCommand,
+  encodeSpotSendCommand,
+  type ServiceWireDecoderContext
+} from '../protocol/service_wire_codec.generated';
 import {
-  decodeActorCreate49 as decodeGeneratedActorCreate49,
   decodeActorJoin28,
+  decodeActorCreate49 as decodeGeneratedActorCreate49,
   decodeRelocationCutover34 as decodeGeneratedRelocationCutover34,
   decodeRelocationData31 as decodeGeneratedRelocationData31,
   decodeRelocationFailed53 as decodeGeneratedRelocationFailed53,
@@ -50,20 +47,45 @@ import {
   encodeUserSpotClose48 as encodeGeneratedUserSpotClose48,
   encodeUserSpotCreate47 as encodeGeneratedUserSpotCreate47,
   type ActorCreate49 as GeneratedActorCreate49,
+  type ServiceWireCoordinatorFence as GeneratedCoordinatorFence,
   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 ServiceWireTargetFence as GeneratedTargetFence,
   type UserSpotClose48 as GeneratedUserSpotClose48,
   type UserSpotCreate47 as GeneratedUserSpotCreate47
 } from '../protocol/service_wire_pilot_codec.generated';
+import { routingIdsEqual } from '../routing-id';
+import { operationRequiresReply } from './service-runtime-contracts';
+import type {
+  ServiceActorRef,
+  ServiceSessionBinding,
+  ServiceSpotRef
+} from './service-stateful-registry';
+import {
+  decodeCanonicalServiceWireText,
+  decodeServiceWireRoutingId,
+  encodeCanonicalServiceWireText,
+  encodeServiceWireRoutingId,
+  SERVICE_WIRE_PREFIX_SIZE
+} from './service-wire-binary-primitives';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR,
+  ServiceWireCommand,
+  ServiceWireFlag
+} from './service-wire-constants.generated';
+import { APPLICATION_PAYLOAD_VERSION, ServiceWireProtocolError } from './service-wire-m6a-codec';
+const MESSAGE_FOLLOW_MAX_BODY_BYTES = 16 * 1024 * 1024;
+const MESSAGE_FOLLOW_VERSION = 1;
+const INSTANCE_ROUTE_VERSION = 1;
+const INSTANCE_ACTIVATION_VERSION = 2;
 
-const PREFIX_SIZE = 5;
+const PREFIX_SIZE = SERVICE_WIRE_PREFIX_SIZE;
 const MAGIC_0 = SERVICE_WIRE_MAGIC[0];
 const MAGIC_1 = SERVICE_WIRE_MAGIC[1];
 const MAJOR = SERVICE_WIRE_MAJOR;
@@ -148,7 +170,7 @@ export type ServiceWireRelocationObject =
 /** 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;
+export { RELOCATION_STATE_CHUNK_DATA_MAX_BYTES } from '../../contracts/Configuration/InternalDefaults';
 
 interface ServiceWireRelocationBase {
   readonly relocation: ServiceWireOperationId;
@@ -337,6 +359,7 @@ export type ServiceSessionRelocationRoute =
         readonly targetAuthorityOwnerGeneration: bigint;
         readonly targetNodeRid: string;
         readonly targetNodeGeneration: bigint;
+        readonly targetOwnerLeaseGeneration: bigint;
       };
     }
   | {
@@ -1015,8 +1038,10 @@ export type ServiceStatefulWireRecord =
   | {
       readonly kind: 'spotSend' | 'spotRequest';
       readonly correlation?: bigint;
+      readonly operation: ServiceWireOperationId;
+      readonly messageFollowHopCount: number;
       readonly sourceSpotId: string;
-      readonly target: ServiceDirectSpotRouteFence;
+      readonly target: ServiceSpotRouteFence;
     }
   | {
       readonly kind: 'logicalMulticast';
@@ -1027,6 +1052,8 @@ export type ServiceStatefulWireRecord =
   | {
       readonly kind: 'actorSend' | 'actorRequest';
       readonly correlation?: bigint;
+      readonly operation: ServiceWireOperationId;
+      readonly messageFollowHopCount: number;
       readonly sourceActor?: ServiceActorRef;
       readonly target: ServiceActorRouteFence;
       readonly boundSession?: ServiceBoundSessionSource;
@@ -1068,6 +1095,7 @@ export type ServiceStatefulWireRecord =
   | {
       readonly kind: 'instanceSpot';
       readonly activation: 'ready';
+      readonly instanceIntent: boolean;
       readonly route: ServiceInstanceRouteFence;
       readonly sourceNodeGeneration: bigint;
       readonly sourceNodeRid: string;
@@ -1137,20 +1165,68 @@ export interface ServiceStatefulReply {
   readonly tail?: ServiceStatefulReplyTail;
 }
 
+const STATEFUL_MESSAGE_CONTEXT: ServiceWireDecoderContext = {
+  effectiveCompleteMessageBytesMinusActualEnvelopeOverhead: 0xffff_fdf6,
+  effectiveCompleteMessageBytes: 0xffff_ffff
+};
+const STATEFUL_HEADER_PAYLOAD = {
+  packetName: 'wire',
+  contentType: ZlinkStreamContentType.Json,
+  payload: Buffer.from('{}')
+};
+
+function generatedSpotFence(target: ServiceSpotRouteFence) {
+  return {
+    spot: { spotId: target.spot.spotId, objectGeneration: target.spot.generation },
+    targetNodeRid: toGeneratedRoutingId(target.targetNodeRid, 'targetNodeRid'),
+    targetNodeGeneration: target.targetNodeGeneration,
+    expectedAuthorityOwnerGeneration: target.authorityOwnerGeneration,
+    expectedOwnerLeaseGeneration: target.ownerLeaseGeneration
+  };
+}
+
+function generatedActorFence(target: ServiceActorRouteFence) {
+  return {
+    actor: { actorId: target.actor.actorId, objectGeneration: target.actor.generation },
+    targetNodeRid: toGeneratedRoutingId(target.actor.nodeRid, 'targetNodeRid'),
+    targetNodeGeneration: target.targetNodeGeneration,
+    expectedAuthorityOwnerGeneration: target.authorityOwnerGeneration,
+    expectedOwnerLeaseGeneration: target.ownerLeaseGeneration
+  };
+}
+
 export function encodeSpotHeader(
   kind: 'spotSend' | 'spotRequest',
   sourceSpotId: string,
   target: ServiceDirectSpotRouteFence,
-  correlation?: bigint
+  correlation?: bigint,
+  operation: ServiceWireOperationId = { high: 0n, low: 1n },
+  messageFollowHopCount = 0,
+  metadataFrame?: Uint8Array
 ): Buffer {
-  return concat(
-    prefix(
-      kind === 'spotSend' ? M6bServiceWireCommand.spotSend : M6bServiceWireCommand.spotRequest
-    ),
-    ...(kind === 'spotRequest' ? [u64(requirePositive(correlation, 'correlation'))] : []),
-    rid(sourceSpotId, 'sourceSpotId'),
-    directSpotFence(target)
-  );
+  const common = {
+    flags: metadataFrame === undefined ? 0 : M6bServiceWireFlag.metadata,
+    operation,
+    messageFollowHopCount,
+    sourceSpotId,
+    targetSpot: generatedSpotFence(target),
+    payload: STATEFUL_HEADER_PAYLOAD,
+    ...(metadataFrame === undefined
+      ? {}
+      : { metadata: decodeMetadataFrame(metadataFrame, STATEFUL_MESSAGE_CONTEXT) })
+  };
+  const frames =
+    kind === 'spotSend'
+      ? encodeSpotSendCommand({ command: kind, ...common }, STATEFUL_MESSAGE_CONTEXT)
+      : encodeSpotRequestCommand(
+          {
+            command: kind,
+            ...common,
+            correlation: requirePositive(correlation, 'correlation')
+          },
+          STATEFUL_MESSAGE_CONTEXT
+        );
+  return Buffer.from(frames[0]!);
 }
 
 export function encodeActorHeader(
@@ -1158,28 +1234,46 @@ export function encodeActorHeader(
   target: ServiceActorRouteFence,
   correlation?: bigint,
   sourceActor?: ServiceActorRef,
-  boundSession?: ServiceBoundSessionSource
+  boundSession?: ServiceBoundSessionSource,
+  operation: ServiceWireOperationId = { high: 0n, low: 1n },
+  messageFollowHopCount = 0
 ): 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),
+  const common = {
+    flags,
+    operation,
+    messageFollowHopCount,
+    sourceActor:
+      sourceActor === undefined
+        ? { actorId: null }
+        : { actorId: sourceActor.actorId, generation: sourceActor.generation },
+    targetActor: generatedActorFence(target),
     ...(boundSession === undefined
-      ? []
-      : [
-          rid(boundSession.sessionRid, 'sourceSessionRid'),
-          u64(boundSession.bindingGeneration),
-          u64(boundSession.sequence)
-        ])
-  );
+      ? {}
+      : {
+          boundSessionTail: {
+            sourceSessionRid: toGeneratedRoutingId(boundSession.sessionRid, 'sourceSessionRid'),
+            sourceBindingGeneration: boundSession.bindingGeneration,
+            sourceSessionSequence: boundSession.sequence
+          }
+        }),
+    payload: STATEFUL_HEADER_PAYLOAD
+  };
+  const frames =
+    kind === 'actorSend'
+      ? encodeActorSendCommand({ command: kind, ...common }, STATEFUL_MESSAGE_CONTEXT)
+      : encodeActorRequestCommand(
+          {
+            command: kind,
+            ...common,
+            correlation: requirePositive(correlation, 'correlation')
+          },
+          STATEFUL_MESSAGE_CONTEXT
+        );
+  return Buffer.from(frames[0]!);
 }
 
 export function encodeLogicalMulticastHeader(
@@ -1300,17 +1394,25 @@ export function encodeInstanceSpotHeader(
   operationKind: 'send' | 'request',
   operation: { readonly high: bigint; readonly low: bigint },
   replyRouteId?: bigint,
-  hasMetadata = false
+  hasMetadata = false,
+  instanceIntent = 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')
+  const encodedRoute = encodeInstanceRouteV1(
+    {
+      routeKind: 'ready',
+      targetNodeRid: toGeneratedRoutingId(route.targetNodeRid, 'targetNodeRid'),
+      targetNodeGeneration: route.targetNodeGeneration,
+      targetSpotId: route.targetSpotId,
+      authority: {
+        objectGeneration: route.objectGeneration,
+        ownerId: route.ownerId,
+        authorityOwnerGeneration: route.authorityOwnerGeneration,
+        leaseGeneration: route.leaseGeneration,
+        storeVersion: route.storeVersion
+      },
+      instanceIntent: instanceIntent ? 'true' : 'false'
+    },
+    STATEFUL_MESSAGE_CONTEXT
   );
   if (
     operationKind === 'send' &&
@@ -1323,9 +1425,7 @@ export function encodeInstanceSpotHeader(
   }
   return concat(
     prefix(M6bServiceWireCommand.instanceSpot, hasMetadata ? M6bServiceWireFlag.metadata : 0),
-    Buffer.of(1),
-    u16(routeBody.byteLength),
-    routeBody,
+    encodedRoute,
     u64Any(sourceNodeGeneration),
     rid(sourceNodeRid, 'sourceNodeRid'),
     optionalRid(sourceSpotId),
@@ -1365,7 +1465,7 @@ export function encodeInstanceSpotActivationHeader(
   );
   return concat(
     prefix(M6bServiceWireCommand.instanceSpot, hasMetadata ? M6bServiceWireFlag.metadata : 0),
-    Buffer.of(2),
+    Buffer.of(INSTANCE_ACTIVATION_VERSION),
     u16(targetBody.byteLength),
     targetBody,
     u64Any(sourceNodeGeneration),
@@ -1409,18 +1509,24 @@ export function encodeMessageFollowHeader(
     u64Any(record.originalOperation.low),
     u64Any(record.originalReplyRouteId)
   );
-  if (body.byteLength > 16 * 1024 * 1024) {
-    throw new RangeError('Message Follow body exceeds 16 MiB.');
+  if (body.byteLength > MESSAGE_FOLLOW_MAX_BODY_BYTES) {
+    throw new RangeError(
+      `Message Follow body exceeds ${MESSAGE_FOLLOW_MAX_BODY_BYTES / (1024 * 1024)} MiB.`
+    );
   }
   return concat(
     prefix(M6bServiceWireCommand.messageFollow),
-    Buffer.of(1),
+    Buffer.of(MESSAGE_FOLLOW_VERSION),
     u32(body.byteLength, 'messageFollow.length'),
     body
   );
 }
 
-export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireRecord {
+export function decodeStatefulHeader(
+  frame: Uint8Array,
+  payloadFrame?: Uint8Array,
+  metadataFrame?: Uint8Array
+): ServiceStatefulWireRecord {
   switch (frame[3]) {
     case M6bServiceWireCommand.userSpotCreate:
       return fromGeneratedUserSpotCreate(decodeGeneratedUserSpotCreate47(frame));
@@ -1428,52 +1534,98 @@ export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireReco
       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.spotRequest:
     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 })
-      };
+      const frames = [
+        frame,
+        ...(metadataFrame === undefined ? [] : [metadataFrame]),
+        payloadFrame ??
+          encodeApplicationPayloadEnvelopeV1(STATEFUL_HEADER_PAYLOAD, STATEFUL_MESSAGE_CONTEXT)
+      ];
+      try {
+        if (
+          frame[3] === M6bServiceWireCommand.spotSend ||
+          frame[3] === M6bServiceWireCommand.spotRequest
+        ) {
+          const decoded =
+            frame[3] === M6bServiceWireCommand.spotSend
+              ? decodeSpotSendCommand(frames, STATEFUL_MESSAGE_CONTEXT)
+              : decodeSpotRequestCommand(frames, STATEFUL_MESSAGE_CONTEXT);
+          return {
+            kind: decoded.command,
+            ...(decoded.command === 'spotRequest' ? { correlation: decoded.correlation } : {}),
+            operation: decoded.operation,
+            messageFollowHopCount: decoded.messageFollowHopCount,
+            sourceSpotId: decoded.sourceSpotId,
+            target: {
+              spot: {
+                spotId: decoded.targetSpot.spot.spotId,
+                generation: decoded.targetSpot.spot.objectGeneration
+              },
+              targetNodeRid: fromGeneratedRoutingId(
+                decoded.targetSpot.targetNodeRid,
+                'targetNodeRid'
+              ),
+              targetNodeGeneration: decoded.targetSpot.targetNodeGeneration,
+              authorityOwnerGeneration: decoded.targetSpot.expectedAuthorityOwnerGeneration,
+              ownerLeaseGeneration: decoded.targetSpot.expectedOwnerLeaseGeneration
+            }
+          };
+        }
+        const decoded =
+          frame[3] === M6bServiceWireCommand.actorSend
+            ? decodeActorSendCommand(frames, STATEFUL_MESSAGE_CONTEXT)
+            : decodeActorRequestCommand(frames, STATEFUL_MESSAGE_CONTEXT);
+        const source = decoded.sourceActor;
+        return {
+          kind: decoded.command,
+          ...(decoded.command === 'actorRequest' ? { correlation: decoded.correlation } : {}),
+          operation: decoded.operation,
+          messageFollowHopCount: decoded.messageFollowHopCount,
+          ...(source.actorId === null
+            ? {}
+            : {
+                sourceActor: {
+                  nodeRid: '',
+                  actorId: source.actorId,
+                  generation: source.generation!
+                }
+              }),
+          target: {
+            actor: {
+              nodeRid: fromGeneratedRoutingId(decoded.targetActor.targetNodeRid, 'targetNodeRid'),
+              actorId: decoded.targetActor.actor.actorId,
+              generation: decoded.targetActor.actor.objectGeneration
+            },
+            targetNodeGeneration: decoded.targetActor.targetNodeGeneration,
+            authorityOwnerGeneration: decoded.targetActor.expectedAuthorityOwnerGeneration,
+            ownerLeaseGeneration: decoded.targetActor.expectedOwnerLeaseGeneration
+          },
+          ...(decoded.boundSessionTail === undefined
+            ? {}
+            : {
+                boundSession: {
+                  sessionRid: fromGeneratedRoutingId(
+                    decoded.boundSessionTail.sourceSessionRid,
+                    'sourceSessionRid'
+                  ),
+                  bindingGeneration: decoded.boundSessionTail.sourceBindingGeneration,
+                  sequence: decoded.boundSessionTail.sourceSessionSequence
+                }
+              })
+        };
+      } catch (error) {
+        throw new ServiceWireProtocolError(
+          error instanceof Error ? error.message : 'Invalid stateful message.'
+        );
+      }
     }
+  }
+  const reader = new Reader(frame);
+  const command = reader.prefix();
+  switch (command.command) {
     case M6bServiceWireCommand.logicalMulticast: {
       requireFlags(command.flags, 0);
       const result = {
@@ -1590,34 +1742,53 @@ export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireReco
       if ((command.flags & ~M6bServiceWireFlag.metadata) !== 0) {
         fail(`Invalid command flags '${command.flags}'.`);
       }
+      const routeStart = reader.offset;
       const version = reader.u8('instanceRoute.version');
-      if (version !== 1 && version !== 2) fail('Unsupported Instance route version.');
+      if (version !== INSTANCE_ROUTE_VERSION && version !== INSTANCE_ACTIVATION_VERSION)
+        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 generatedReadyRoute =
+        version === INSTANCE_ROUTE_VERSION
+          ? decodeInstanceRouteV1(
+              reader.bytes.subarray(routeStart, routeEnd),
+              STATEFUL_MESSAGE_CONTEXT
+            )
+          : undefined;
+      if (generatedReadyRoute !== undefined && generatedReadyRoute.routeKind !== 'ready') {
+        fail('Invalid Ready Instance route kind.');
+      }
+      const commonTarget =
+        generatedReadyRoute?.routeKind === 'ready'
+          ? {
+              targetNodeRid: fromGeneratedRoutingId(
+                generatedReadyRoute.targetNodeRid,
+                'targetNodeRid'
+              ),
+              targetNodeGeneration: generatedReadyRoute.targetNodeGeneration,
+              targetSpotId: generatedReadyRoute.targetSpotId
+            }
+          : {
+              targetNodeRid: reader.rid('targetNodeRid'),
+              targetNodeGeneration: reader.nonZeroU64('targetNodeGeneration'),
+              targetSpotId: reader.rid('targetSpotId')
+            };
       const route: ServiceInstanceRouteFence | undefined =
-        version === 1
+        generatedReadyRoute?.routeKind === 'ready'
           ? {
               ...commonTarget,
-              objectGeneration: reader.nonZeroU64('objectGeneration'),
-              ownerId: reader.text8('ownerId'),
-              authorityOwnerGeneration: reader.nonZeroU64('authorityOwnerGeneration'),
-              leaseGeneration: reader.nonZeroU64('leaseGeneration'),
-              storeVersion: reader.text16('storeVersion')
+              ...generatedReadyRoute.authority
             }
           : undefined;
       const target: ServiceInstanceActivationTarget | undefined =
-        version === 2
+        version === INSTANCE_ACTIVATION_VERSION
           ? {
               ...commonTarget,
               stableType: reader.text16('stableType'),
               descriptorVersion: reader.text16('descriptorVersion')
             }
           : undefined;
+      if (generatedReadyRoute !== undefined) reader.offset = routeEnd;
       if (reader.offset !== routeEnd) fail('Invalid Instance route body length.');
       const sourceNodeGeneration = reader.nonZeroU64('sourceNodeGeneration');
       const sourceNodeRid = reader.rid('sourceNodeRid');
@@ -1630,16 +1801,21 @@ export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireReco
       };
       const operationKind = operationValue === 1 ? ('send' as const) : ('request' as const);
       if (
-        version === 1 &&
+        version === INSTANCE_ROUTE_VERSION &&
         ((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) {
+      if (
+        version === INSTANCE_ACTIVATION_VERSION &&
+        operation.high === 0n &&
+        operation.low === 0n
+      ) {
         fail('Instance activation requires a non-zero operation identity.');
       }
-      const deadlineUnixMs = version === 2 ? reader.nonZeroU64('deadlineUnixMs') : undefined;
+      const deadlineUnixMs =
+        version === INSTANCE_ACTIVATION_VERSION ? reader.nonZeroU64('deadlineUnixMs') : undefined;
       const replyRouteId =
         operationKind === 'request' ? reader.nonZeroU64('replyRouteId') : undefined;
       reader.end();
@@ -1652,8 +1828,13 @@ export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireReco
         operation,
         ...(replyRouteId === undefined ? {} : { replyRouteId })
       };
-      return version === 1
-        ? { ...common, activation: 'ready', route: route! }
+      return version === INSTANCE_ROUTE_VERSION
+        ? {
+            ...common,
+            activation: 'ready',
+            route: route!,
+            instanceIntent: generatedReadyRoute!.instanceIntent === 'true'
+          }
         : {
             ...common,
             activation: 'missing',
@@ -1663,12 +1844,12 @@ export function decodeStatefulHeader(frame: Uint8Array): ServiceStatefulWireReco
     }
     case M6bServiceWireCommand.messageFollow: {
       requireFlags(command.flags, 0);
-      if (reader.u8('messageFollow.version') !== 1) {
+      if (reader.u8('messageFollow.version') !== MESSAGE_FOLLOW_VERSION) {
         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) {
+      if (length > MESSAGE_FOLLOW_MAX_BODY_BYTES || end > reader.bytes.byteLength) {
         fail('Invalid Message Follow body length.');
       }
       const record: ServiceMessageFollowRecord = {
@@ -2097,7 +2278,11 @@ function applicationPayload(value: NonNullable<ServiceMaintenanceReplyRelay['pay
     u32(value.bytes.byteLength, 'payload.length'),
     value.bytes
   );
-  return concat(Buffer.of(1), u32(body.byteLength, 'applicationPayload.length'), body);
+  return concat(
+    Buffer.of(APPLICATION_PAYLOAD_VERSION),
+    u32(body.byteLength, 'applicationPayload.length'),
+    body
+  );
 }
 
 function prefix(command: number, flags = 0): Buffer {
@@ -2124,20 +2309,6 @@ function actorAuthorityFence(value: ServiceBoundSessionActorAuthority): Buffer {
   );
 }
 
-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'
@@ -2196,7 +2367,7 @@ function validateMessageFollowRecord(
   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) {
+  if (value.originalReplyRouteId < 0n || value.originalReplyRouteId > UINT64_MAX) {
     invalid('Message Follow originalReplyRouteId must be a u64.');
   }
 }
@@ -2205,12 +2376,6 @@ 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));
 }
@@ -2262,7 +2427,7 @@ function u64(value: bigint): Buffer {
 }
 
 function u64Any(value: bigint): Buffer {
-  if (value < 0n || value > 0xffff_ffff_ffff_ffffn) {
+  if (value < 0n || value > UINT64_MAX) {
     throw new RangeError('u64 value is out of range.');
   }
   const result = Buffer.alloc(8);
@@ -2271,7 +2436,7 @@ function u64Any(value: bigint): Buffer {
 }
 
 function requirePositive(value: bigint | undefined, name: string): bigint {
-  if (value === undefined || value < 1n || value > 0xffff_ffff_ffff_ffffn) {
+  if (value === undefined || value < 1n || value > UINT64_MAX) {
     throw new RangeError(`${name} must be a non-zero u64.`);
   }
   return value;
@@ -2409,20 +2574,6 @@ class Reader {
     };
   }
 
-  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'),
@@ -2441,24 +2592,6 @@ class Reader {
     };
   }
 
-  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`);
@@ -2827,7 +2960,7 @@ class FrozenReader {
   }
 
   applicationPayload(): NonNullable<ServiceMaintenanceReplyRelay['payload']> {
-    if (this.u8('applicationPayload.version') !== 1) {
+    if (this.u8('applicationPayload.version') !== APPLICATION_PAYLOAD_VERSION) {
       fail('Application payload envelope version must be one.');
     }
     const body = this.body32('application payload');
@@ -2984,24 +3117,21 @@ class FrozenReader {
   }
 
   private instanceRoute(): void {
+    const start = this.offset;
     const kind = this.u8('instanceRouteKind');
     if (kind < 1 || kind > 2) fail('Invalid Instance route kind.');
     const body = this.body16('Instance route');
+    if (kind === INSTANCE_ROUTE_VERSION) {
+      decodeInstanceRouteV1(this.bytes.subarray(start, this.offset), STATEFUL_MESSAGE_CONTEXT);
+      return;
+    }
     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.text8('targetMeshName');
+    body.text8('stableType');
+    body.text8('targetDescriptorVersion');
+    body.nonZeroU64('deadlineUnixMs');
     body.end('Instance route');
   }