@zlink-systems/framework 0.30.0 → 0.30.1

package/src/runtime/host/entry-actor-runtime.ts

@@ -33,6 +33,10 @@ export class ZLinkEntryActorRuntimeService implements ZLinkEntryActorRuntime {
     return this.options.actorManager()?.getState(actorId)?.actor;
   }
 
+  async releaseMembers(meshName: string): Promise<void> {
+    await this.options.actorManager()?.releaseSpotActorMembers(meshName);
+  }
+
   async commitActorTransaction(actor: ZLinkActor, onJoined: () => Promise<void>): Promise<void> {
     const state = this.options.actorManager()?.getState(actor.context.actorId);
     const entryNode = this.options.spotNodeRuntime()?.primaryMeshNode;

package/src/runtime/host/index.ts

@@ -3,6 +3,7 @@ import { currentApplicationJobOrigin } from '../application-jobs/application-job
 import { listAllMeshNodeDescriptors } from '../locations/location-store-pages';
 import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import { randomBytes, randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
 import {
   type ActorRef,
   type RoutingId,
@@ -244,7 +245,7 @@ export class ZLinkFrameworkRuntimeHost
   private readonly lifecycleSink?: string[];
   private executionState?: ZLinkFrameworkExecutionState;
   private runtimeState = ZLinkFrameworkRuntimeState.Preparing;
-  private runtimeSequence = 0n;
+  private runtimeStatus?: ZLinkFrameworkRuntimeStatus;
   private readonly runtimeObservationSource = Symbol('zlink.framework-runtime');
   private runtimeDeadline?: Date;
   private shutdownDeadline?: AbortController;
@@ -334,24 +335,15 @@ export class ZLinkFrameworkRuntimeHost
     this.runtimeEventPublisher =
       options.runtimeEventPublisher ?? new DefaultZLinkRuntimeEventPublisher();
     this.metrics = new ZLinkRuntimeMetrics(options.registration.metrics?.meterProvider);
+    const handlerStartGate = options.providerResolver?.get?.(
+      ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE as unknown as Type<ZLinkInternalApplicationJobQueueHandlerStartGate>
+    );
     this.applicationJobQueue = new ApplicationJobQueue(
       resolveApplicationJobQueueConfiguration(options.registration.applicationJobQueue, () =>
         nodeEffectiveProcessorCount(options.registration.worker?.maxThreads)
       ),
       undefined,
-      () => {
-        try {
-          return (
-            this.options.providerResolver
-              ?.get?.(
-                ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE as unknown as Type<ZLinkInternalApplicationJobQueueHandlerStartGate>
-              )
-              ?.shouldHoldPermitBeforeHandler() === true
-          );
-        } catch {
-          return false;
-        }
-      },
+      handlerStartGate?.shouldHoldPermitBeforeHandler.bind(handlerStartGate),
       (error) =>
         (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException(
           'logger-provider',
@@ -786,6 +778,7 @@ export class ZLinkFrameworkRuntimeHost
     this.serviceRelocation = new ZLinkHostServiceRelocationRuntime({
       registration: options.registration,
       targetAdmissionSealed: () => this.shutdownOperationStartedAt !== undefined,
+      sourceQuiescenceChanged: () => this.publishCurrentRuntimeStatus(),
       providerResolver: options.providerResolver,
       locationStore: () => this.locationOwner.currentStores?.locationStore,
       currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
@@ -876,6 +869,10 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   get status(): ZLinkFrameworkRuntimeStatus {
+    return this.publishCurrentRuntimeStatus();
+  }
+
+  private buildRuntimeStatus(): ZLinkFrameworkRuntimeStatus {
     return {
       state: this.runtimeState,
       isReady: runtimeStateIsReady(this.runtimeState),
@@ -885,8 +882,8 @@ export class ZLinkFrameworkRuntimeHost
       deadline: this.runtimeDeadline,
       relocationResult: this.runtimeRelocationResult,
       terminationResult: this.runtimeTerminationResult,
-      sequence: this.runtimeSequence,
-      observedAt: new Date()
+      sequence: this.runtimeStatus?.sequence ?? 0n,
+      observedAt: this.runtimeStatus?.observedAt ?? new Date()
     };
   }
 
@@ -904,10 +901,11 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   observe(signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkFrameworkRuntimeStatus>> {
+    const status = this.status;
     const queue = new RuntimeEventQueue<ZLinkFrameworkRuntimeStatus>(undefined, signal);
     this.runtimeObservers.add(queue);
     queue.onClose(() => this.runtimeObservers.delete(queue));
-    this.publishRuntimeStatus(queue, this.status);
+    this.publishRuntimeStatus(queue, status);
     return queue;
   }
 
@@ -1130,6 +1128,9 @@ export class ZLinkFrameworkRuntimeHost
         );
         const drain = await shutdown;
         await unscopedStreamDrain;
+        if (drain.kind === 'forceStopped' && drain.error !== undefined) {
+          this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('host shutdown', drain.error);
+        }
         await this.stop();
         if (drain.kind === 'forceStopped') {
           return this.completeTermination({
@@ -1277,12 +1278,25 @@ export class ZLinkFrameworkRuntimeHost
   private setRuntimeState(state: ZLinkFrameworkRuntimeState): void {
     if (this.runtimeState === state) return;
     this.runtimeState = state;
-    this.runtimeSequence += 1n;
     this.notifyTopologyHostStateChanged();
-    const status = this.status;
+    this.publishCurrentRuntimeStatus();
+  }
+
+  private publishCurrentRuntimeStatus(): ZLinkFrameworkRuntimeStatus {
+    const current = this.buildRuntimeStatus();
+    if (this.runtimeStatus !== undefined && isDeepStrictEqual(this.runtimeStatus, current)) {
+      return this.runtimeStatus;
+    }
+    const status = {
+      ...current,
+      sequence: (this.runtimeStatus?.sequence ?? 0n) + 1n,
+      observedAt: new Date()
+    };
+    this.runtimeStatus = status;
     for (const observer of this.runtimeObservers) {
       this.publishRuntimeStatus(observer, status);
     }
+    return status;
   }
 
   private publishRuntimeStatus(
@@ -2781,13 +2795,68 @@ export class ZLinkFrameworkRuntimeHost
     };
   }
 
-  private async dispatchMeshRecord(
+  private dispatchMeshNodeRecord(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal
+  ): void | Promise<void> {
+    const control = this.serviceRelocation.tryHandleControl(meshName, record, signal);
+    if (control instanceof Promise)
+      return control.then((handled) =>
+        handled ? undefined : this.dispatchMeshNodePayload(meshName, record, signal)
+      );
+    if (!control) return this.dispatchMeshNodePayload(meshName, record, signal);
+  }
+
+  private dispatchMeshNodePayload(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal
+  ): void | Promise<void> {
+    if (record.kind === ReceiveKind.NodeRequest && record.parts.length === 1) {
+      const terminal = decodeRemoteActorSourceLeaveTerminal(record.parts[0]!.data());
+      if (terminal !== undefined) {
+        return this.completeFormalSourceLeave(record, terminal);
+      }
+    }
+    const channelRuntime = this.channelRuntime;
+    if (channelRuntime === undefined) {
+      throw new ZLinkConfigurationException(
+        'MeshNode node-direct dispatch requires the channel runtime.'
+      );
+    }
+    return channelRuntime.dispatchMeshRoute(meshName, record, signal);
+  }
+
+  private async completeFormalSourceLeave(
+    record: ReceiveRecord,
+    terminal: NonNullable<ReturnType<typeof decodeRemoteActorSourceLeaveTerminal>>
+  ): Promise<void> {
+    const completed = await this.spotManager?.completeFormalSourceLeaveTerminal(
+      terminal.actorId,
+      terminal.transferId,
+      terminal.succeeded
+    );
+    if (completed !== true) {
+      throw new ZLinkConfigurationException(
+        `Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`
+      );
+    }
+    if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
+      throw new ZLinkConfigurationException(
+        `Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`
+      );
+    }
+    return;
+  }
+
+  private dispatchMeshRecord(
     applicationJobOrigin: () => ApplicationJobOrigin,
     meshName: string,
     owner: ReadyRecord,
     record: ReceiveRecord,
     signal?: AbortSignal
-  ): Promise<void> {
+  ): void | Promise<void> {
     if (record.operationKind === OperationKind.ActorJoin) {
       if (this.spotManager === undefined) {
         throw new ZLinkConfigurationException(
@@ -2796,107 +2865,8 @@ export class ZLinkFrameworkRuntimeHost
       }
       return this.spotManager.dispatchMeshActorJoin(meshName, owner, record);
     }
-    if (record.kind === ReceiveKind.ActorBinding) {
-      if (record.kindData?.kind !== 'actorBinding') {
-        throw new ZLinkConfigurationException(
-          'MeshNode Actor binding record has no binding generation.'
-        );
-      }
-      const binding = record.kindData;
-      const replyBindingFailure = (kind: ZLinkFrameworkInternalErrorKind): void => {
-        const terminal = internalFrameworkWireReply(kind);
-        if (
-          record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== SubmitResult.Ok
-        ) {
-          throw new ZLinkConfigurationException(
-            `MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`
-          );
-        }
-      };
-      const replyBindingSuccess = (): void => {
-        if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
-          throw new ZLinkConfigurationException(
-            `MeshNode Actor binding target '${binding.actor.actorId}' acknowledgement failed.`
-          );
-        }
-      };
-      const state = this.actorManager?.getState(binding.actor.actorId);
-      const nativeActorRef = state?.nativeActorRef;
-      if (
-        state === undefined ||
-        nativeActorRef === undefined ||
-        nativeActorRef.actorId !== binding.actor.actorId ||
-        !routingIdsEqual(nativeActorRef.nodeRid, binding.actor.nodeRid)
-      ) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      if (nativeActorRef.generation !== binding.actor.generation) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorGenerationStale);
-        return;
-      }
-      const node =
-        state.meshName === meshName ? this.spotNodeRuntime?.meshNode(meshName) : undefined;
-      const localStatus = node?.status();
-      // ownsLocation tracks local cleanup responsibility, not Actor authority.
-      // A relocation target can exact-read committed authority without owning that cleanup.
-      if (
-        localStatus === undefined ||
-        !routingIdsEqual(localStatus.routingId, binding.actor.nodeRid) ||
-        localStatus.lifecycleGeneration !== binding.actorNodeGeneration ||
-        state.locationGeneration !== binding.authorityOwnerGeneration ||
-        state.isMoving
-      ) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      const sessionOwnerIsLocal =
-        routingIdsEqual(localStatus.routingId, binding.sessionNodeRid) &&
-        localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
-      if (binding.transition === 'tombstone') {
-        const actorRef: ActorRef = {
-          actorId: binding.actor.actorId,
-          objectGeneration: binding.actor.generation,
-          meshName,
-          nodeRid: binding.actor.nodeRid
-        };
-        if (sessionOwnerIsLocal) {
-          releaseApplicationJobPermitBeforeHandler();
-          await this.streamBindingRuntime.retireRemoteBinding(
-            actorRef,
-            binding.sessionRid,
-            binding.bindingGeneration,
-            signal
-          );
-        }
-        state.retireBoundSessionBinding(binding);
-        replyBindingSuccess();
-        return;
-      }
-      const target = this.boundSessionRelay.boundSessions.resolveRemoteBoundSessionTarget(
-        binding.sessionNodeRid,
-        binding.sessionRid
-      );
-      if (target === undefined) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      const installed = state.installBoundSessionBinding({
-        ...target,
-        sessionNodeRid: binding.sessionNodeRid,
-        sessionRid: binding.sessionRid,
-        sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
-        sessionOwnerId: binding.sessionOwnerId,
-        sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
-        bindingGeneration: binding.bindingGeneration
-      });
-      if (!installed) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      replyBindingSuccess();
-      return Promise.resolve();
-    }
+    if (record.kind === ReceiveKind.ActorBinding)
+      return this.dispatchMeshActorBinding(meshName, record, signal);
     switch (record.kind) {
       case ReceiveKind.TransferControl:
         if (record.kindData?.kind !== 'transferControl') {
@@ -2919,41 +2889,11 @@ export class ZLinkFrameworkRuntimeHost
       }
       case ReceiveKind.NodeSend:
       case ReceiveKind.NodeRequest: {
-        return this.admission.run(meshName, 'RouteMesh node dispatch', async () => {
-          if (await this.serviceRelocation.tryHandleControl(meshName, record, signal)) {
-            return;
-          }
-          if (record.kind === ReceiveKind.NodeRequest && record.parts.length === 1) {
-            const terminal = decodeRemoteActorSourceLeaveTerminal(record.parts[0]!.data());
-            if (terminal !== undefined) {
-              if (
-                (await this.spotManager?.completeFormalSourceLeaveTerminal(
-                  terminal.actorId,
-                  terminal.transferId,
-                  terminal.succeeded
-                )) !== true
-              ) {
-                throw new ZLinkConfigurationException(
-                  `Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`
-                );
-              }
-              if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
-                throw new ZLinkConfigurationException(
-                  `Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`
-                );
-              }
-              return;
-            }
-          }
-          const channelRuntime = this.channelRuntime;
-          if (channelRuntime === undefined) {
-            throw new ZLinkConfigurationException(
-              'MeshNode node-direct dispatch requires the channel runtime.'
-            );
-          }
-          return await channelRuntime.dispatchMeshRoute(meshName, record, signal);
-        });
+        return this.admission.run(meshName, 'RouteMesh node dispatch', () =>
+          this.dispatchMeshNodeRecord(meshName, record, signal)
+        );
       }
+
       case ReceiveKind.SpotSend:
       case ReceiveKind.SpotRequest:
       case ReceiveKind.SpotMulticast:
@@ -2995,6 +2935,111 @@ export class ZLinkFrameworkRuntimeHost
     }
   }
 
+  private async dispatchMeshActorBinding(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal
+  ): Promise<void> {
+    if (record.kindData?.kind !== 'actorBinding') {
+      throw new ZLinkConfigurationException(
+        'MeshNode Actor binding record has no binding generation.'
+      );
+    }
+    const binding = record.kindData;
+    const replyBindingFailure = (kind: ZLinkFrameworkInternalErrorKind): void => {
+      const terminal = internalFrameworkWireReply(kind);
+      if (
+        record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== SubmitResult.Ok
+      ) {
+        throw new ZLinkConfigurationException(
+          `MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`
+        );
+      }
+    };
+    const replyBindingSuccess = (): void => {
+      if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
+        throw new ZLinkConfigurationException(
+          `MeshNode Actor binding target '${binding.actor.actorId}' acknowledgement failed.`
+        );
+      }
+    };
+    const state = this.actorManager?.getState(binding.actor.actorId);
+    const nativeActorRef = state?.nativeActorRef;
+    if (
+      state === undefined ||
+      nativeActorRef === undefined ||
+      nativeActorRef.actorId !== binding.actor.actorId ||
+      !routingIdsEqual(nativeActorRef.nodeRid, binding.actor.nodeRid)
+    ) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    if (nativeActorRef.generation !== binding.actor.generation) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorGenerationStale);
+      return;
+    }
+    const node = state.meshName === meshName ? this.spotNodeRuntime?.meshNode(meshName) : undefined;
+    const localStatus = node?.status();
+    // ownsLocation tracks local cleanup responsibility, not Actor authority.
+    // A relocation target can exact-read committed authority without owning that cleanup.
+    if (
+      localStatus === undefined ||
+      !routingIdsEqual(localStatus.routingId, binding.actor.nodeRid) ||
+      localStatus.lifecycleGeneration !== binding.actorNodeGeneration ||
+      state.locationGeneration !== binding.authorityOwnerGeneration ||
+      state.isMoving
+    ) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    const sessionOwnerIsLocal =
+      routingIdsEqual(localStatus.routingId, binding.sessionNodeRid) &&
+      localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
+    if (binding.transition === 'tombstone') {
+      const actorRef: ActorRef = {
+        actorId: binding.actor.actorId,
+        objectGeneration: binding.actor.generation,
+        meshName,
+        nodeRid: binding.actor.nodeRid
+      };
+      if (sessionOwnerIsLocal) {
+        releaseApplicationJobPermitBeforeHandler();
+        await this.streamBindingRuntime.retireRemoteBinding(
+          actorRef,
+          binding.sessionRid,
+          binding.bindingGeneration,
+          signal
+        );
+      }
+      state.retireBoundSessionBinding(binding);
+      replyBindingSuccess();
+      return;
+    }
+    const target = this.boundSessionRelay.boundSessions.resolveRemoteBoundSessionTarget(
+      binding.sessionNodeRid,
+      binding.sessionRid
+    );
+    if (target === undefined) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    const installed = state.installBoundSessionBinding({
+      ...target,
+      sessionNodeRid: binding.sessionNodeRid,
+      sessionRid: binding.sessionRid,
+      sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
+      sessionOwnerId: binding.sessionOwnerId,
+      sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
+      bindingGeneration: binding.bindingGeneration
+    });
+    if (!installed) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    replyBindingSuccess();
+    return Promise.resolve();
+  }
+
   private submitLocalMeshRoute(
     meshName: string,
     sourceNodeRid: string,

package/src/runtime/host/remote-bound-session-relay.ts

@@ -845,24 +845,16 @@ function validateSessionRelocationRouteAgainstSeal(
   route: ServiceSessionRelocationRoute,
   sealed: ServiceSessionRelocationSealed
 ): void {
-  const sameCoordinator =
-    route.coordinator.ownerId === sealed.coordinator.ownerId &&
-    route.coordinator.leaseGeneration === sealed.coordinator.leaseGeneration &&
-    route.coordinator.nodeRid === sealed.coordinator.nodeRid &&
-    route.coordinator.nodeGeneration === sealed.coordinator.nodeGeneration &&
-    route.coordinator.expectedAuthorityStoreVersion ===
-      sealed.coordinator.expectedAuthorityStoreVersion;
   const sameSession =
-    route.session.sessionOwnerNodeRid === sealed.session.sessionOwnerNodeRid &&
+    routingIdsEqual(route.session.sessionOwnerNodeRid, sealed.session.sessionOwnerNodeRid) &&
     route.session.sessionOwnerNodeGeneration === sealed.session.sessionOwnerNodeGeneration &&
     route.session.sessionOwnerId === sealed.session.sessionOwnerId &&
     route.session.sessionOwnerLeaseGeneration === sealed.session.sessionOwnerLeaseGeneration &&
-    route.session.sessionRid === sealed.session.sessionRid &&
+    routingIdsEqual(route.session.sessionRid, sealed.session.sessionRid) &&
     route.session.bindingGeneration === sealed.session.bindingGeneration;
   if (
     route.relocation.high !== sealed.relocation.high ||
     route.relocation.low !== sealed.relocation.low ||
-    !sameCoordinator ||
     !sameSession ||
     route.actor.actorId !== sealed.actor.actor.actorId ||
     route.actor.generation !== sealed.actor.actor.generation
@@ -871,17 +863,4 @@ function validateSessionRelocationRouteAgainstSeal(
       `Session relocation '${serviceWireBarrierKey(route)}' changed its command 42 fence.`
     );
   }
-  if (route.route.action === 'commit') {
-    if (route.route.previousAuthorityOwnerGeneration !== sealed.actor.authorityOwnerGeneration) {
-      throw new ServiceWireProtocolError(
-        `Session relocation '${serviceWireBarrierKey(route)}' changed its source authority fence.`
-      );
-    }
-    return;
-  }
-  if (route.route.currentAuthorityOwnerGeneration !== sealed.actor.authorityOwnerGeneration) {
-    throw new ServiceWireProtocolError(
-      `Session relocation '${serviceWireBarrierKey(route)}' abort changed its authority fence.`
-    );
-  }
 }

package/src/runtime/host/route-mesh-runtime.ts

@@ -588,7 +588,7 @@ export class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshRuntime {
           this.options.forceStopResources(meshName).catch(() => undefined)
         )
       );
-      result = { kind: 'forceStopped', reason };
+      result = { kind: 'forceStopped', reason, error };
       for (const [meshName, state] of entries) {
         this.transition(meshName, state, ZLinkTopologyState.Failed);
       }

package/src/runtime/host/service-relocation-control.ts

@@ -1,5 +1,6 @@
 import {
   SERVICE_WIRE_MAJOR_OFFSET,
+  SERVICE_WIRE_COMMAND_OFFSET,
   SERVICE_WIRE_PREFIX_SIZE
 } from '../foundation/service-wire-binary-primitives';
 import {
@@ -27,14 +28,19 @@ export function decodeServiceRelocationControlRequest(
   const bytes = Buffer.isBuffer(payload)
     ? payload
     : Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);
+  if (serviceRelocationControlCommand(bytes) === undefined) return undefined;
+  return decodeMaintenanceRelocationControl(bytes);
+}
+
+export function serviceRelocationControlCommand(payload: Uint8Array): number | undefined {
   if (
-    bytes.byteLength < SERVICE_WIRE_PREFIX_SIZE ||
-    bytes[0] !== SERVICE_WIRE_MAGIC[0] ||
-    bytes[1] !== SERVICE_WIRE_MAGIC[1] ||
-    bytes[SERVICE_WIRE_MAJOR_OFFSET] !== SERVICE_WIRE_MAJOR
+    payload.byteLength < SERVICE_WIRE_PREFIX_SIZE ||
+    payload[0] !== SERVICE_WIRE_MAGIC[0] ||
+    payload[1] !== SERVICE_WIRE_MAGIC[1] ||
+    payload[SERVICE_WIRE_MAJOR_OFFSET] !== SERVICE_WIRE_MAJOR
   )
     return undefined;
-  return decodeMaintenanceRelocationControl(bytes);
+  return payload[SERVICE_WIRE_COMMAND_OFFSET];
 }
 
 export function encodeServiceRelocationControlResponse(