@zlink-systems/framework 0.10.0

package/dist/runtime/foundation/service-stateful-wire-codec.js

@@ -0,0 +1,2006 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M6bServiceWireFlag = exports.RELOCATION_STATE_CHUNK_DATA_MAX_BYTES = exports.RELOCATION_PAYLOAD_CHUNK_COUNT_MAX = exports.RELOCATION_PAYLOAD_TOTAL_LENGTH_MAX = exports.M6bServiceWireCommand = void 0;
+exports.serviceSessionRelocationIdentityKey = serviceSessionRelocationIdentityKey;
+exports.encodeSpotHeader = encodeSpotHeader;
+exports.encodeActorHeader = encodeActorHeader;
+exports.encodeLogicalMulticastHeader = encodeLogicalMulticastHeader;
+exports.encodeActorLookupHeader = encodeActorLookupHeader;
+exports.encodeActorDestroyHeader = encodeActorDestroyHeader;
+exports.encodeBoundSessionSendHeader = encodeBoundSessionSendHeader;
+exports.encodeBoundSessionBindHeader = encodeBoundSessionBindHeader;
+exports.encodeBoundSessionReplacedHeader = encodeBoundSessionReplacedHeader;
+exports.encodeSessionRelocationSeal = encodeSessionRelocationSeal;
+exports.decodeSessionRelocationSeal = decodeSessionRelocationSeal;
+exports.encodeSessionRelocationSealed = encodeSessionRelocationSealed;
+exports.decodeSessionRelocationSealed = decodeSessionRelocationSealed;
+exports.encodeSessionRelocationRoute = encodeSessionRelocationRoute;
+exports.decodeSessionRelocationRoute = decodeSessionRelocationRoute;
+exports.encodeInstanceSpotHeader = encodeInstanceSpotHeader;
+exports.encodeInstanceSpotActivationHeader = encodeInstanceSpotActivationHeader;
+exports.encodeUserSpotCreateHeader = encodeUserSpotCreateHeader;
+exports.encodeActorCreateHeader = encodeActorCreateHeader;
+exports.encodeUserSpotCloseHeader = encodeUserSpotCloseHeader;
+exports.encodeMessageFollowHeader = encodeMessageFollowHeader;
+exports.decodeStatefulHeader = decodeStatefulHeader;
+exports.encodeStatefulReply = encodeStatefulReply;
+exports.encodeMaintenanceRelocationControl = encodeMaintenanceRelocationControl;
+exports.decodeMaintenanceRelocationControl = decodeMaintenanceRelocationControl;
+exports.encodeMaintenanceReplyRelay = encodeMaintenanceReplyRelay;
+exports.decodeMaintenanceReplyRelay = decodeMaintenanceReplyRelay;
+exports.encodeMaintenanceReplyRelayAck = encodeMaintenanceReplyRelayAck;
+exports.decodeMaintenanceReplyRelayAck = decodeMaintenanceReplyRelayAck;
+exports.decodeStatefulReply = decodeStatefulReply;
+exports.sessionBindingFromWire = sessionBindingFromWire;
+exports.decodeServiceWireFrozenRecord = decodeServiceWireFrozenRecord;
+exports.decodeServiceWireFrozenRecordPrefix = decodeServiceWireFrozenRecordPrefix;
+exports.encodeServiceWireFrozenRecord = encodeServiceWireFrozenRecord;
+exports.encodeServiceWireFrozenActorApplicationRecord = encodeServiceWireFrozenActorApplicationRecord;
+const service_runtime_contracts_1 = require("./service-runtime-contracts");
+const service_wire_m6a_codec_1 = require("./service-wire-m6a-codec");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const routing_id_1 = require("../routing-id");
+const service_wire_constants_generated_1 = require("./service-wire-constants.generated");
+const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
+const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
+const PREFIX_SIZE = 5;
+const MAGIC_0 = service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[0];
+const MAGIC_1 = service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[1];
+const MAJOR = service_wire_constants_generated_1.SERVICE_WIRE_MAJOR;
+exports.M6bServiceWireCommand = service_wire_constants_generated_1.ServiceWireCommand;
+/** Shared CRC-32C wire bounds for the direct relocation payload transfer. */
+exports.RELOCATION_PAYLOAD_TOTAL_LENGTH_MAX = 274877906944n;
+exports.RELOCATION_PAYLOAD_CHUNK_COUNT_MAX = 4096;
+exports.RELOCATION_STATE_CHUNK_DATA_MAX_BYTES = 67_108_864;
+exports.M6bServiceWireFlag = service_wire_constants_generated_1.ServiceWireFlag;
+function serviceSessionRelocationIdentityKey(value) {
+    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, field) {
+    return (0, service_wire_binary_primitives_1.encodeServiceWireRoutingId)(value, field, 0xff, fail);
+}
+function fromGeneratedRoutingId(value, field) {
+    return (0, service_wire_binary_primitives_1.decodeServiceWireRoutingId)(value, field, 0xff, fail);
+}
+function toGeneratedReservation(value) {
+    return {
+        ...value,
+        targetNodeRid: toGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid')
+    };
+}
+function fromGeneratedReservation(value) {
+    return {
+        ...value,
+        targetNodeRid: fromGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid')
+    };
+}
+function toGeneratedUserSpotCreate(value) {
+    return {
+        ...value,
+        sourceNodeRid: toGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+        reservation: toGeneratedReservation(value.reservation)
+    };
+}
+function fromGeneratedUserSpotCreate(value) {
+    return {
+        kind: 'userSpotCreate',
+        ...value,
+        sourceNodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+        reservation: fromGeneratedReservation(value.reservation)
+    };
+}
+function toGeneratedUserSpotClose(value) {
+    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) {
+    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) {
+    return {
+        ...value,
+        sourceNodeRid: toGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+        reservation: toGeneratedReservation(value.reservation)
+    };
+}
+function fromGeneratedActorCreate(value) {
+    return {
+        kind: 'actorCreate',
+        ...value,
+        sourceNodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+        reservation: fromGeneratedReservation(value.reservation)
+    };
+}
+function toGeneratedCoordinatorFence(value) {
+    return {
+        coordinatorOwnerId: value.ownerId,
+        coordinatorLeaseGeneration: value.leaseGeneration,
+        coordinatorNodeRid: toGeneratedRoutingId(value.nodeRid, 'coordinatorNodeRid'),
+        coordinatorNodeGeneration: value.nodeGeneration,
+        expectedAuthorityStoreVersion: value.expectedAuthorityStoreVersion
+    };
+}
+function fromGeneratedCoordinatorFence(value) {
+    return {
+        ownerId: value.coordinatorOwnerId,
+        leaseGeneration: value.coordinatorLeaseGeneration,
+        nodeRid: fromGeneratedRoutingId(value.coordinatorNodeRid, 'coordinatorNodeRid'),
+        nodeGeneration: value.coordinatorNodeGeneration,
+        expectedAuthorityStoreVersion: value.expectedAuthorityStoreVersion
+    };
+}
+function toGeneratedTargetFence(value) {
+    return {
+        targetNodeRid: toGeneratedRoutingId(value.nodeRid, 'targetNodeRid'),
+        targetNodeGeneration: value.nodeGeneration,
+        targetOwnerId: value.ownerId,
+        targetOwnerLeaseGeneration: value.ownerLeaseGeneration
+    };
+}
+function fromGeneratedTargetFence(value) {
+    return {
+        nodeRid: fromGeneratedRoutingId(value.targetNodeRid, 'targetNodeRid'),
+        nodeGeneration: value.targetNodeGeneration,
+        ownerId: value.targetOwnerId,
+        ownerLeaseGeneration: value.targetOwnerLeaseGeneration
+    };
+}
+function toGeneratedRequestSourceFence(value) {
+    return {
+        sourceOwnerId: value.ownerId,
+        sourceOwnerLeaseGeneration: value.leaseGeneration,
+        sourceNodeRid: toGeneratedRoutingId(value.nodeRid, 'sourceNodeRid'),
+        sourceNodeGeneration: value.nodeGeneration
+    };
+}
+function fromGeneratedRequestSourceFence(value) {
+    return {
+        ownerId: value.sourceOwnerId,
+        leaseGeneration: value.sourceOwnerLeaseGeneration,
+        nodeRid: fromGeneratedRoutingId(value.sourceNodeRid, 'sourceNodeRid'),
+        nodeGeneration: value.sourceNodeGeneration
+    };
+}
+function toGeneratedRelocationObject(value) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    return {
+        relocation: value.relocation,
+        coordinator: toGeneratedCoordinatorFence(value.coordinator),
+        senderRole: value.senderRole,
+        actor: toGeneratedRouteFence(value.actor),
+        ...toGeneratedSessionOwnerFence(value.session)
+    };
+}
+function fromGeneratedSessionRelocationSeal(value) {
+    return {
+        relocation: value.relocation,
+        coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+        senderRole: value.senderRole,
+        actor: fromGeneratedRouteFence(value.actor),
+        session: fromGeneratedSessionOwnerFence(value)
+    };
+}
+function toGeneratedSessionRelocationSealed(value) {
+    return {
+        relocation: value.relocation,
+        coordinator: toGeneratedCoordinatorFence(value.coordinator),
+        actor: toGeneratedRouteFence(value.actor),
+        ...toGeneratedSessionOwnerFence(value.session)
+    };
+}
+function fromGeneratedSessionRelocationSealed(value) {
+    return {
+        relocation: value.relocation,
+        coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+        actor: fromGeneratedRouteFence(value.actor),
+        session: fromGeneratedSessionOwnerFence(value)
+    };
+}
+function toGeneratedSessionRelocationRoute(value) {
+    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) {
+    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,
+            route: {
+                ...value.route,
+                targetNodeRid: fromGeneratedRoutingId(value.route.targetNodeRid, 'targetNodeRid')
+            }
+        }
+        : {
+            ...common,
+            senderRole: value.senderRole,
+            route: value.route
+        };
+}
+function toGeneratedRelocationBase(value) {
+    return {
+        relocation: value.relocation,
+        targetAttemptGeneration: value.targetAttemptGeneration,
+        coordinator: toGeneratedCoordinatorFence(value.coordinator)
+    };
+}
+function fromGeneratedRelocationBase(value) {
+    return {
+        relocation: value.relocation,
+        targetAttemptGeneration: value.targetAttemptGeneration,
+        coordinator: fromGeneratedCoordinatorFence(value.coordinator)
+    };
+}
+function fromGeneratedRelocationPrepare(value) {
+    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) {
+    return {
+        kind: 'ready',
+        ...fromGeneratedRelocationBase(value),
+        target: fromGeneratedTargetFence(value.target),
+        object: fromGeneratedRelocationObject(value.object),
+        senderRole: value.senderRole
+    };
+}
+function fromGeneratedRelocationFailed(value) {
+    return {
+        kind: 'failed',
+        ...fromGeneratedRelocationBase(value),
+        target: fromGeneratedTargetFence(value.target),
+        object: fromGeneratedRelocationObject(value.object),
+        senderRole: value.senderRole,
+        failureCode: value.failureCode
+    };
+}
+function fromGeneratedRelocationData(value) {
+    return {
+        kind: 'data',
+        ...fromGeneratedRelocationBase(value),
+        senderRole: value.senderRole,
+        object: fromGeneratedRelocationObject(value.object),
+        frozenRecord: decodeServiceWireFrozenRecord(value.record)
+    };
+}
+function fromGeneratedRelocationCutover(value) {
+    return {
+        kind: 'cutover',
+        ...fromGeneratedRelocationBase(value),
+        senderRole: value.senderRole,
+        object: fromGeneratedRelocationObject(value.object),
+        boundaryRecordCount: value.boundaryRecordCount,
+        boundaryChecksumCrc32c: value.boundaryChecksumCrc32c
+    };
+}
+function fromGeneratedRelocationState(value) {
+    return {
+        kind: 'state',
+        ...fromGeneratedRelocationBase(value),
+        senderRole: value.senderRole,
+        object: fromGeneratedRelocationObject(value.object),
+        chunkOrdinal: value.chunkOrdinal,
+        chunkData: Buffer.from(value.chunkData)
+    };
+}
+function toGeneratedReplyRelay(value) {
+    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) {
+    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)
+            }
+        })
+    };
+}
+function encodeSpotHeader(kind, sourceSpotId, target, correlation) {
+    return concat(prefix(kind === 'spotSend'
+        ? exports.M6bServiceWireCommand.spotSend
+        : exports.M6bServiceWireCommand.spotRequest), ...(kind === 'spotRequest' ? [u64(requirePositive(correlation, 'correlation'))] : []), rid(sourceSpotId, 'sourceSpotId'), directSpotFence(target));
+}
+function encodeActorHeader(kind, target, correlation, sourceActor, boundSession) {
+    const flags = boundSession === undefined
+        ? 0
+        : exports.M6bServiceWireFlag.boundSession | exports.M6bServiceWireFlag.sourceSpotId;
+    return concat(prefix(kind === 'actorSend'
+        ? exports.M6bServiceWireCommand.actorSend
+        : exports.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)
+        ]));
+}
+function encodeLogicalMulticastHeader(channelName, topic, sourceSpotId) {
+    return concat(prefix(exports.M6bServiceWireCommand.logicalMulticast), text8(channelName, 'channelName'), text8(topic, 'topic'), rid(sourceSpotId, 'sourceSpotId'));
+}
+function encodeActorLookupHeader(correlation, actorId) {
+    return concat(prefix(exports.M6bServiceWireCommand.actorLookup), u64(correlation), text8(actorId, 'actorId'));
+}
+function encodeActorDestroyHeader(correlation, actor) {
+    return concat(prefix(exports.M6bServiceWireCommand.actorDestroy), u64(correlation), actorFence(actor));
+}
+function encodeBoundSessionSendHeader(actor, expectedBindingGeneration) {
+    return concat(prefix(exports.M6bServiceWireCommand.boundSessionSend), actorFence(actor), u64(expectedBindingGeneration));
+}
+function encodeBoundSessionBindHeader(correlation, actor, sessionRid, binding) {
+    const body = binding.state === 'active'
+        ? u64(binding.generation)
+        : u64(binding.retiredGeneration);
+    return concat(prefix(exports.M6bServiceWireCommand.boundSessionBind), u64(correlation), actorFence(actor), rid(sessionRid, 'sessionRid'), Buffer.of(binding.state === 'active' ? 1 : 2), u16(body.byteLength), body);
+}
+function encodeBoundSessionReplacedHeader(actorAuthority, retiredSession) {
+    return concat(prefix(exports.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. */
+function encodeSessionRelocationSeal(value) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeSessionRelocationSeal42)(toGeneratedSessionRelocationSeal(value)));
+}
+/** Decodes canonical service-wire command 42. */
+function decodeSessionRelocationSeal(frame) {
+    return fromGeneratedSessionRelocationSeal((0, service_wire_pilot_codec_generated_1.decodeSessionRelocationSeal42)(frame));
+}
+/** Encodes canonical service-wire command 43. */
+function encodeSessionRelocationSealed(value) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeSessionRelocationSealed43)(toGeneratedSessionRelocationSealed(value)));
+}
+/** Decodes canonical service-wire command 43. */
+function decodeSessionRelocationSealed(frame) {
+    return fromGeneratedSessionRelocationSealed((0, service_wire_pilot_codec_generated_1.decodeSessionRelocationSealed43)(frame));
+}
+/** Encodes canonical service-wire command 44. */
+function encodeSessionRelocationRoute(value) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeSessionRelocationRoute44)(toGeneratedSessionRelocationRoute(value)));
+}
+/** Decodes canonical service-wire command 44. */
+function decodeSessionRelocationRoute(frame) {
+    return fromGeneratedSessionRelocationRoute((0, service_wire_pilot_codec_generated_1.decodeSessionRelocationRoute44)(frame));
+}
+function encodeInstanceSpotHeader(route, sourceNodeGeneration, sourceNodeRid, sourceSpotId, operationKind, operation, replyRouteId, hasMetadata = false) {
+    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(exports.M6bServiceWireCommand.instanceSpot, hasMetadata ? exports.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'))]
+        : []));
+}
+function encodeInstanceSpotActivationHeader(target, sourceNodeGeneration, sourceNodeRid, sourceSpotId, operationKind, operation, deadlineUnixMs, replyRouteId, hasMetadata = false) {
+    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(exports.M6bServiceWireCommand.instanceSpot, hasMetadata ? exports.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'))]
+        : []));
+}
+function encodeUserSpotCreateHeader(record) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeUserSpotCreate47)(toGeneratedUserSpotCreate(record)));
+}
+function encodeActorCreateHeader(record) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeActorCreate49)(toGeneratedActorCreate(record)));
+}
+function encodeUserSpotCloseHeader(record) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeUserSpotClose48)(toGeneratedUserSpotClose(record)));
+}
+function encodeMessageFollowHeader(record) {
+    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(exports.M6bServiceWireCommand.messageFollow), Buffer.of(1), u32(body.byteLength, 'messageFollow.length'), body);
+}
+function decodeStatefulHeader(frame) {
+    switch (frame[3]) {
+        case exports.M6bServiceWireCommand.userSpotCreate:
+            return fromGeneratedUserSpotCreate((0, service_wire_pilot_codec_generated_1.decodeUserSpotCreate47)(frame));
+        case exports.M6bServiceWireCommand.userSpotClose:
+            return fromGeneratedUserSpotClose((0, service_wire_pilot_codec_generated_1.decodeUserSpotClose48)(frame));
+        case exports.M6bServiceWireCommand.actorCreate:
+            return fromGeneratedActorCreate((0, service_wire_pilot_codec_generated_1.decodeActorCreate49)(frame));
+    }
+    const reader = new Reader(frame);
+    const command = reader.prefix();
+    switch (command.command) {
+        case exports.M6bServiceWireCommand.spotSend:
+        case exports.M6bServiceWireCommand.spotRequest: {
+            requireFlags(command.flags, 0);
+            const request = command.command === exports.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 exports.M6bServiceWireCommand.actorSend:
+        case exports.M6bServiceWireCommand.actorRequest: {
+            const request = command.command === exports.M6bServiceWireCommand.actorRequest;
+            const hasBinding = command.flags !== 0;
+            requireFlags(command.flags, hasBinding
+                ? exports.M6bServiceWireFlag.boundSession | exports.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 exports.M6bServiceWireCommand.logicalMulticast: {
+            requireFlags(command.flags, 0);
+            const result = {
+                kind: 'logicalMulticast',
+                channelName: reader.text8('channelName'),
+                topic: reader.text8('topic'),
+                sourceSpotId: reader.rid('sourceSpotId')
+            };
+            reader.end();
+            return result;
+        }
+        case exports.M6bServiceWireCommand.actorLookup: {
+            requireFlags(command.flags, 0);
+            const result = {
+                kind: 'actorLookup',
+                correlation: reader.nonZeroU64('correlation'),
+                actorId: reader.text8('actorId')
+            };
+            reader.end();
+            return result;
+        }
+        case exports.M6bServiceWireCommand.actorDestroy: {
+            requireFlags(command.flags, 0);
+            const result = {
+                kind: 'actorDestroy',
+                correlation: reader.nonZeroU64('correlation'),
+                actor: reader.actorFence()
+            };
+            reader.end();
+            return result;
+        }
+        case exports.M6bServiceWireCommand.actorJoin: {
+            // Command 28 is canonical-only; the generated codec owns its validation.
+            const decoded = (0, service_wire_pilot_codec_generated_1.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 exports.M6bServiceWireCommand.boundSessionSend: {
+            requireFlags(command.flags, 0);
+            const actor = reader.actorFence();
+            const expectedBindingGeneration = reader.nonZeroU64('expectedBindingGeneration');
+            reader.end();
+            return { kind: 'boundSessionSend', actor, expectedBindingGeneration };
+        }
+        case exports.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 exports.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 exports.M6bServiceWireCommand.instanceSpot: {
+            if ((command.flags & ~exports.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 = 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 = 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' : 'request';
+            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',
+                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 exports.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 = {
+                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.`);
+    }
+}
+function encodeStatefulReply(correlation, terminalResult, failureCode, tail) {
+    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. */
+function encodeMaintenanceRelocationControl(value) {
+    switch (value.kind) {
+        case 'prepare':
+            return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeRelocationPrepare40)({
+                ...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((0, service_wire_pilot_codec_generated_1.encodeRelocationReady30)({
+                ...toGeneratedRelocationBase(value),
+                target: toGeneratedTargetFence(value.target),
+                object: toGeneratedRelocationObject(value.object),
+                senderRole: value.senderRole
+            }));
+        case 'failed':
+            return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeRelocationFailed53)({
+                ...toGeneratedRelocationBase(value),
+                target: toGeneratedTargetFence(value.target),
+                object: toGeneratedRelocationObject(value.object),
+                senderRole: value.senderRole,
+                failureCode: value.failureCode
+            }));
+        case 'data':
+            return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeRelocationData31)({
+                ...toGeneratedRelocationBase(value),
+                senderRole: value.senderRole,
+                object: toGeneratedRelocationObject(value.object),
+                record: encodeServiceWireFrozenRecord(value.frozenRecord)
+            }));
+        case 'cutover':
+            return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeRelocationCutover34)({
+                ...toGeneratedRelocationBase(value),
+                senderRole: value.senderRole,
+                object: toGeneratedRelocationObject(value.object),
+                boundaryRecordCount: value.boundaryRecordCount,
+                boundaryChecksumCrc32c: value.boundaryChecksumCrc32c
+            }));
+        case 'state':
+            return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeRelocationState52)({
+                ...toGeneratedRelocationBase(value),
+                senderRole: value.senderRole,
+                object: toGeneratedRelocationObject(value.object),
+                chunkOrdinal: value.chunkOrdinal,
+                chunkData: value.chunkData
+            }));
+    }
+}
+/** Decodes canonical maintenance relocation commands and rejects malformed vectors. */
+function decodeMaintenanceRelocationControl(frame) {
+    switch (frame[3]) {
+        case exports.M6bServiceWireCommand.relocationPrepare:
+            return fromGeneratedRelocationPrepare((0, service_wire_pilot_codec_generated_1.decodeRelocationPrepare40)(frame));
+        case exports.M6bServiceWireCommand.relocationReady:
+            return fromGeneratedRelocationReady((0, service_wire_pilot_codec_generated_1.decodeRelocationReady30)(frame));
+        case exports.M6bServiceWireCommand.relocationFailed:
+            return fromGeneratedRelocationFailed((0, service_wire_pilot_codec_generated_1.decodeRelocationFailed53)(frame));
+        case exports.M6bServiceWireCommand.relocationData:
+            return fromGeneratedRelocationData((0, service_wire_pilot_codec_generated_1.decodeRelocationData31)(frame));
+        case exports.M6bServiceWireCommand.relocationCutover:
+            return fromGeneratedRelocationCutover((0, service_wire_pilot_codec_generated_1.decodeRelocationCutover34)(frame));
+        case exports.M6bServiceWireCommand.relocationState:
+            return fromGeneratedRelocationState((0, service_wire_pilot_codec_generated_1.decodeRelocationState52)(frame));
+        default:
+            fail(`Unsupported maintenance relocation command '${frame.length > 3 ? frame[3] : -1}'.`);
+    }
+}
+/** Encodes canonical service-wire command 33 for a maintenance terminal relay. */
+function encodeMaintenanceReplyRelay(value) {
+    return (0, service_wire_pilot_codec_generated_1.encodeReplyRelay33)(toGeneratedReplyRelay(value)).map(Buffer.from);
+}
+/** Decodes canonical service-wire command 33 and rejects non-maintenance contexts. */
+function decodeMaintenanceReplyRelay(frames) {
+    return fromGeneratedReplyRelay((0, service_wire_pilot_codec_generated_1.decodeReplyRelay33)(frames));
+}
+/** Encodes canonical service-wire command 46. */
+function encodeMaintenanceReplyRelayAck(value) {
+    return Buffer.from((0, service_wire_pilot_codec_generated_1.encodeReplyRelayAck46)({
+        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. */
+function decodeMaintenanceReplyRelayAck(frame) {
+    const value = (0, service_wire_pilot_codec_generated_1.decodeReplyRelayAck46)(frame);
+    return {
+        relocation: value.relocation,
+        coordinator: fromGeneratedCoordinatorFence(value.coordinator),
+        operation: value.operation,
+        replyRouteId: value.replyRouteId,
+        requestSource: fromGeneratedRequestSourceFence(value.requestSource),
+        status: value.status
+    };
+}
+function decodeStatefulReply(frame, expectedCorrelation, operationKind, hasPayload = false) {
+    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;
+    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;
+            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 > exports.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'][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'][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 })
+    };
+}
+function sessionBindingFromWire(actor, sessionRid, sessionOwnerNodeRid, generation, membershipEpoch, sessionOwnerNodeGeneration, sessionOwnerId, sessionOwnerLeaseGeneration) {
+    return {
+        actor,
+        sessionRid,
+        sessionOwnerNodeRid,
+        ...(sessionOwnerNodeGeneration === undefined ? {} : { sessionOwnerNodeGeneration }),
+        ...(sessionOwnerId === undefined ? {} : { sessionOwnerId }),
+        ...(sessionOwnerLeaseGeneration === undefined ? {} : { sessionOwnerLeaseGeneration }),
+        bindingGeneration: generation,
+        membershipEpoch
+    };
+}
+function encodeReplyTail(tail) {
+    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 > exports.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'].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'].indexOf(tail.createResult) + 1), u16(selected.byteLength), selected);
+        }
+    }
+}
+function wireId(value, name) {
+    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, failureCode, hasPayload) {
+    if (hasPayload && terminalResult !== 0) {
+        throw new RangeError('Failed stateful reply must not carry a payload.');
+    }
+    if (!(0, framework_errors_internal_1.isCanonicalWireReplyTerminal)(terminalResult, failureCode)) {
+        throw new RangeError('Stateful reply terminalResult does not match its framework failureCode.');
+    }
+}
+function validateRelocationPhase(value) {
+    const phases = ['none', 'preparing', 'captured', 'prepared', 'committed',
+        'activating', 'activated', 'cleaning', 'completed', 'aborted'];
+    if (!Number.isInteger(value) || value < 0 || value >= phases.length) {
+        fail('Invalid relocationData control phase.');
+    }
+}
+function applicationPayload(value) {
+    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, flags = 0) {
+    return Buffer.from([MAGIC_0, MAGIC_1, MAJOR, command, flags]);
+}
+function actorFence(value) {
+    return concat(actorRef(value.actor), rid(value.actor.nodeRid, 'targetNodeRid'), u64(value.targetNodeGeneration), u64(value.authorityOwnerGeneration), u64(value.ownerLeaseGeneration));
+}
+function actorAuthorityFence(value) {
+    return concat(actorRef(value.actor), rid(value.actor.nodeRid, 'targetNodeRid'), u64(value.targetNodeGeneration), u64(value.authorityOwnerGeneration), u64(value.ownerLeaseGeneration));
+}
+function spotFence(value) {
+    return concat(spotRef(value.spot), rid(value.targetNodeRid, 'targetNodeRid'), u64(value.targetNodeGeneration), u64(value.authorityOwnerGeneration), u64(value.ownerLeaseGeneration));
+}
+function directSpotFence(value) {
+    return concat(spotFence(value), text16(value.storeVersion, 'storeVersion'));
+}
+function messageFollowRoute(value) {
+    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, invalid = (message) => { throw new RangeError(message); }) {
+    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 > 0xffffffffffffffffn) {
+        invalid('Message Follow originalReplyRouteId must be a u64.');
+    }
+}
+function actorRef(value) {
+    return concat(text8(value.actorId, 'actorId'), u64(value.generation));
+}
+function optionalActor(value) {
+    return value === undefined
+        ? Buffer.of(0)
+        : concat(text8(value.actorId, 'sourceActorId'), u64(value.generation));
+}
+function spotRef(value) {
+    return concat(rid(value.spotId, 'spotId'), u64(value.generation));
+}
+function rid(value, name) {
+    const bytes = (0, service_wire_binary_primitives_1.encodeServiceWireRoutingId)(value, name, 0xff, outOfRange);
+    return concat(Buffer.of(bytes.byteLength), bytes);
+}
+function text8(value, name) {
+    return sized8(value, name);
+}
+function text16(value, name) {
+    const bytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(value, name, 0xffff, outOfRange);
+    return concat(u16(bytes.byteLength), bytes);
+}
+function optionalRid(value) {
+    return value === undefined ? Buffer.of(0) : rid(value, 'sourceSpotId');
+}
+function sized8(value, name) {
+    const bytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(value, name, 0xff, outOfRange);
+    return concat(Buffer.of(bytes.byteLength), bytes);
+}
+function u16(value) {
+    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, name) {
+    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) {
+    requirePositive(value, 'u64');
+    const result = Buffer.alloc(8);
+    result.writeBigUInt64BE(value);
+    return result;
+}
+function u64Any(value) {
+    if (value < 0n || value > 0xffffffffffffffffn) {
+        throw new RangeError('u64 value is out of range.');
+    }
+    const result = Buffer.alloc(8);
+    result.writeBigUInt64BE(value);
+    return result;
+}
+function requirePositive(value, name) {
+    if (value === undefined || value < 1n || value > 0xffffffffffffffffn) {
+        throw new RangeError(`${name} must be a non-zero u64.`);
+    }
+    return value;
+}
+function requireFlags(actual, expected) {
+    if (actual !== expected)
+        fail(`Invalid command flags '${actual}'.`);
+}
+function concat(...parts) {
+    return Buffer.concat(parts.map(part => Buffer.from(part)));
+}
+function fail(message) {
+    throw new service_wire_m6a_codec_1.ServiceWireProtocolError(message);
+}
+function outOfRange(message) {
+    throw new RangeError(message);
+}
+class Reader {
+    bytes;
+    offset = 0;
+    constructor(value) {
+        this.bytes = Buffer.from(value);
+    }
+    get remaining() {
+        return this.bytes.byteLength - this.offset;
+    }
+    takeRemaining() {
+        const value = Buffer.from(this.bytes.subarray(this.offset));
+        this.offset = this.bytes.byteLength;
+        return value;
+    }
+    prefix() {
+        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) {
+        this.need(1, name);
+        return this.bytes[this.offset++];
+    }
+    bool8(name) {
+        const value = this.u8(name);
+        if (value !== 0 && value !== 1)
+            fail(`${name} must be bool8.`);
+        return value === 1;
+    }
+    u16(name) {
+        this.need(2, name);
+        const value = this.bytes.readUInt16BE(this.offset);
+        this.offset += 2;
+        return value;
+    }
+    u32(name) {
+        this.need(4, name);
+        const value = this.bytes.readUInt32BE(this.offset);
+        this.offset += 4;
+        return value;
+    }
+    nonZeroU64(name) {
+        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) {
+        this.need(8, name);
+        const value = this.bytes.readBigUInt64BE(this.offset);
+        this.offset += 8;
+        return value;
+    }
+    operationId(name) {
+        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) {
+        return this.opaque8(name);
+    }
+    text8(name) {
+        return this.sized8(name);
+    }
+    text16(name) {
+        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 (0, service_wire_binary_primitives_1.decodeCanonicalServiceWireText)(bytes, name, fail);
+    }
+    optionalRid(name) {
+        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 (0, service_wire_binary_primitives_1.decodeServiceWireRoutingId)(bytes, name, 0xff, fail);
+    }
+    actorRef(name) {
+        return {
+            nodeRid: '',
+            actorId: this.text8(`${name}.actorId`),
+            generation: this.nonZeroU64(`${name}.generation`)
+        };
+    }
+    optionalActor() {
+        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 = (0, service_wire_binary_primitives_1.decodeCanonicalServiceWireText)(bytes, 'sourceActorId', fail);
+        return {
+            nodeRid: '',
+            actorId,
+            generation: this.nonZeroU64('sourceActorGeneration')
+        };
+    }
+    spotRef() {
+        return {
+            spotId: this.rid('spotId'),
+            generation: this.nonZeroU64('spotGeneration')
+        };
+    }
+    actorFence() {
+        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() {
+        const spot = this.spotRef();
+        return {
+            spot,
+            targetNodeRid: this.rid('targetNodeRid'),
+            targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+            authorityOwnerGeneration: this.nonZeroU64('authorityOwnerGeneration'),
+            ownerLeaseGeneration: this.nonZeroU64('ownerLeaseGeneration')
+        };
+    }
+    directSpotFence() {
+        return {
+            ...this.spotFence(),
+            storeVersion: this.text16('storeVersion')
+        };
+    }
+    messageFollowRoute(name) {
+        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;
+        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() {
+        if (this.remaining !== 0)
+            fail('Service wire record has trailing bytes.');
+    }
+    sized8(name) {
+        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 (0, service_wire_binary_primitives_1.decodeCanonicalServiceWireText)(bytes, name, fail);
+    }
+    opaque8(name) {
+        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 (0, service_wire_binary_primitives_1.decodeServiceWireRoutingId)(bytes, name, 0xff, fail);
+    }
+    need(count, name) {
+        if (count < 0 || count > this.remaining)
+            fail(`Truncated ${name}.`);
+    }
+}
+function decodeServiceWireFrozenRecord(bytes) {
+    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.
+ */
+function decodeServiceWireFrozenRecordPrefix(bytes, offset = 0) {
+    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) {
+    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 = {
+        nodeRid: sourceReader.rid8('sourceNodeRid'),
+        nodeGeneration: sourceReader.nonZeroU64('sourceNodeGeneration'),
+        ownerId: sourceReader.text8('sourceOwnerId'),
+        leaseGeneration: sourceReader.nonZeroU64('sourceOwnerLeaseGeneration')
+    };
+    let sourceSpotId;
+    let sourceActor;
+    let sourceSessionRid;
+    let sourceBindingGeneration;
+    let sourceSessionSequence;
+    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 = (0, service_runtime_contracts_1.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)
+    };
+}
+function encodeServiceWireFrozenRecord(record) {
+    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);
+}
+function encodeServiceWireFrozenActorApplicationRecord(input) {
+    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, right) {
+    return left.recordKind === right.recordKind
+        && left.sourceKind === right.sourceKind
+        && (0, routing_id_1.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, operationKind, operationId, replyRouteId, instanceOperationKind) {
+    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 ((0, service_runtime_contracts_1.operationRequiresReply)(operationKind) !== (replyRouteId !== undefined)) {
+        fail('Frozen reply route does not match the operation kind.');
+    }
+}
+class FrozenReader {
+    offset = 0;
+    bytes;
+    constructor(bytes) {
+        this.bytes = Buffer.isBuffer(bytes)
+            ? bytes
+            : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    get remaining() {
+        return this.bytes.byteLength - this.offset;
+    }
+    get position() {
+        return this.offset;
+    }
+    u8(name) {
+        this.need(1, name);
+        return this.bytes[this.offset++];
+    }
+    bool8(name) {
+        const value = this.u8(name);
+        if (value !== 0 && value !== 1)
+            fail(`${name} must be bool8.`);
+        return value === 1;
+    }
+    u16(name) {
+        this.need(2, name);
+        const value = this.bytes.readUInt16BE(this.offset);
+        this.offset += 2;
+        return value;
+    }
+    u32(name) {
+        this.need(4, name);
+        const value = this.bytes.readUInt32BE(this.offset);
+        this.offset += 4;
+        return value;
+    }
+    u64(name) {
+        this.need(8, name);
+        const value = this.bytes.readBigUInt64BE(this.offset);
+        this.offset += 8;
+        return value;
+    }
+    nonZeroU64(name) {
+        const value = this.u64(name);
+        if (value === 0n)
+            fail(`${name} must be a non-zero u64.`);
+        return value;
+    }
+    text8(name) {
+        const length = this.u8(`${name}.length`);
+        if (length === 0)
+            fail(`${name} must not be empty.`);
+        return this.textBody(length, name);
+    }
+    rid8(name) {
+        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 (0, service_wire_binary_primitives_1.decodeServiceWireRoutingId)(bytes, name, 0xff, fail);
+    }
+    text16(name, allowEmpty = false) {
+        const length = this.u16(`${name}.length`);
+        if (!allowEmpty && length === 0)
+            fail(`${name} must not be empty.`);
+        return this.textBody(length, name);
+    }
+    body16(name) {
+        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() {
+        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() {
+        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();
+        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) {
+        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 {};
+    }
+    spotRoute() {
+        const spot = this.spotIdentity();
+        return {
+            kind: 'spot',
+            ...spot,
+            targetNodeRid: this.rid8('targetNodeRid'),
+            targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+            authorityOwnerGeneration: this.nonZeroU64('expectedAuthorityOwnerGeneration'),
+            ownerLeaseGeneration: this.nonZeroU64('expectedOwnerLeaseGeneration')
+        };
+    }
+    actorRoute() {
+        const actor = this.actorIdentity();
+        return {
+            kind: 'actor',
+            ...actor,
+            targetNodeRid: this.rid8('targetNodeRid'),
+            targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
+            authorityOwnerGeneration: this.nonZeroU64('expectedAuthorityOwnerGeneration'),
+            ownerLeaseGeneration: this.nonZeroU64('expectedOwnerLeaseGeneration')
+        };
+    }
+    actorIdentity() {
+        return {
+            actorId: this.text8('actorId'),
+            generation: this.nonZeroU64('actorGeneration')
+        };
+    }
+    spotIdentity() {
+        return {
+            spotId: this.text8('spotId'),
+            generation: this.nonZeroU64('spotGeneration')
+        };
+    }
+    membershipSnapshot() {
+        this.actorIdentity();
+        this.spotIdentity();
+    }
+    optionalMembershipSnapshot() {
+        const present = this.bool8('hasMembership');
+        const body = this.body16('optionalMembership');
+        if (present)
+            body.membershipSnapshot();
+        body.end('optional membership');
+    }
+    actorControl() {
+        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');
+    }
+    sendReadyDestination() {
+        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');
+    }
+    instanceRoute() {
+        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');
+    }
+    relocationObject() {
+        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');
+    }
+    body32(name) {
+        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);
+    }
+    take(length, name) {
+        this.need(length, name);
+        const value = Buffer.from(this.bytes.subarray(this.offset, this.offset + length));
+        this.offset += length;
+        return value;
+    }
+    textBody(length, name) {
+        this.need(length, name);
+        const bytes = this.bytes.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return (0, service_wire_binary_primitives_1.decodeCanonicalServiceWireText)(bytes, name, fail);
+    }
+    need(length, name) {
+        if (length < 0 || length > this.remaining)
+            fail(`Truncated ${name}.`);
+    }
+    end(name) {
+        if (this.remaining !== 0)
+            fail(`${name} has trailing bytes.`);
+    }
+}