@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/foundation/service-relocation-object-owner.d.ts

@@ -3,6 +3,7 @@ import type { ServiceRelocationRestoreOwner, ServiceRelocationStaging } from './
 import type { ServiceRelocationEnvelope, ServiceRelocationMembership, ServiceRelocationParticipant, ServiceRelocationQueuedMessage, ServiceRelocationTimer } from './service-relocation-runtime';
 export interface ServiceRelocationSealedWork {
     readonly boundSessionState: Uint8Array;
+    readonly sessionBinding?: ServiceRelocationParticipant['sessionBinding'];
     readonly queuedMessages: readonly ServiceRelocationQueuedMessage[];
     readonly timers: readonly ServiceRelocationTimer[];
 }

package/dist/runtime/foundation/service-relocation-object-owner.js

@@ -102,6 +102,7 @@ class ServiceRelocationObjectCaptureOwner {
                 authorityOwnerGeneration: unit.authorityOwnerGeneration,
                 applicationState: Buffer.from(await unit.captureApplicationState(signal)),
                 boundSessionState: Buffer.from(work.boundSessionState),
+                ...(work.sessionBinding === undefined ? {} : { sessionBinding: work.sessionBinding }),
                 queuedMessages: work.queuedMessages.map((message) => ({
                     sequence: message.sequence,
                     payload: Buffer.from(message.payload)

package/dist/runtime/foundation/service-relocation-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { ZLinkPlacementObjectKind } from '../locations/internal-location-contracts';
+import { type RelocationEnvelopeV1 as GeneratedRelocationEnvelopeV1 } from '../protocol/service_wire_pilot_codec.generated';
 export interface ServiceRelocationParticipant {
     /** Wire-local participant ordinal; identity is projected from Location Store. */
     readonly participantId?: bigint;
@@ -17,6 +18,7 @@ export interface ServiceRelocationParticipant {
     readonly applicationStatePresent?: boolean;
     readonly applicationState: Uint8Array;
     readonly boundSessionState: Uint8Array;
+    readonly sessionBinding?: GeneratedRelocationEnvelopeV1['sessionBindings'][number];
     readonly queuedMessages: readonly ServiceRelocationQueuedMessage[];
     readonly timers: readonly ServiceRelocationTimer[];
 }

package/dist/runtime/foundation/service-relocation-runtime.js

@@ -480,6 +480,9 @@ function encodeServiceRelocationEnvelope(envelope, applicationVersion) {
             lastCompletedScheduledIndex: nonNegativeBigInt(timer.lastScheduledIndex, 'timer scheduled index'),
             nextScheduledAtUnixMilliseconds: nonNegativeUnixMilliseconds(timer.dueAtUnixMs, 'timer due time')
         })),
+        sessionBindings: participants.flatMap((participant, index) => participant.sessionBinding === undefined
+            ? []
+            : [{ ...participant.sessionBinding, participantId: BigInt(index + 1) }]),
         pendingTimerTicks: pending.map((value) => ({
             participantId: value.participantId,
             order: value.order,
@@ -510,11 +513,20 @@ function decodeServiceRelocationEnvelope(payload, aggregateGeneration) {
     if (aggregateId === undefined)
         throw new TypeError('Invalid relocation identity.');
     positiveBigInt(aggregateGeneration, 'aggregate generation');
+    const bindings = new Map(generated.sessionBindings.map((binding) => [binding.participantId, binding]));
+    for (const id of bindings.keys()) {
+        if (id > BigInt(generated.applicationStates.length))
+            throw new TypeError('Session binding participant is outside its inventory.');
+    }
     const participants = generated.applicationStates.map((state, index) => {
         if (state.participantId !== BigInt(index + 1)) {
             throw new TypeError('Application state participant order is invalid.');
         }
-        return wireParticipant(state.participantId, state.hasState, Buffer.from(state.payload));
+        const binding = bindings.get(state.participantId);
+        return {
+            ...wireParticipant(state.participantId, state.hasState, Buffer.from(state.payload)),
+            ...(binding === undefined ? {} : { sessionBinding: binding })
+        };
     });
     const byId = new Map(participants.map((value) => [value.participantId, value]));
     for (const work of generated.savedWork) {

package/dist/runtime/foundation/service-runtime-contracts.d.ts

@@ -343,6 +343,7 @@ export interface ServiceSpot {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     sendToSpot(targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
@@ -354,6 +355,7 @@ export interface ServiceSpot {
         timeoutMs?: number;
         applicationMetadata?: Buffer;
         routeFence?: ServiceDirectSpotRouteFence;
+        onAdmitted?: () => void;
         entrySpot?: boolean;
     }): MeshOperationId;
     publish(channelName: string, topic: string, parts: MessageLike | readonly MessageLike[], options?: {

package/dist/runtime/foundation/service-stateful-runtime.d.ts

@@ -270,7 +270,7 @@ export declare class ServiceStatefulRuntime {
     clearSubscriptions(spotId: string): void;
     publishLogicalMulticast(channelName: string, topic: string, payload: ServiceApplicationPayload, sourceSpotId?: string): Promise<void>;
     sendToSpot(sourceSpotId: string, requested: ServiceDirectSpotRouteFence, payload: ServiceApplicationPayload): Promise<number>;
-    requestToSpot(sourceSpotId: string, requested: ServiceDirectSpotRouteFence, payload: ServiceApplicationPayload, timeoutMs: number): ServiceStatefulPendingOperation;
+    requestToSpot(sourceSpotId: string, requested: ServiceDirectSpotRouteFence, payload: ServiceApplicationPayload, timeoutMs: number, onAdmitted?: () => void): ServiceStatefulPendingOperation;
     sendToActor(target: ServiceActorRef, _targetNodeGeneration: bigint, _authorityOwnerGeneration: bigint, payload: ServiceApplicationPayload, sourceActor?: ServiceActorRef, boundSession?: {
         readonly sessionRid: string;
         readonly bindingGeneration: bigint;
@@ -278,13 +278,13 @@ export declare class ServiceStatefulRuntime {
     requestToActor(target: ServiceActorRef, _targetNodeGeneration: bigint, _authorityOwnerGeneration: bigint, payload: ServiceApplicationPayload, timeoutMs: number, sourceActor?: ServiceActorRef, boundSession?: {
         readonly sessionRid: string;
         readonly bindingGeneration: bigint;
-    }): ServiceStatefulPendingOperation;
+    }, onAdmitted?: () => void): ServiceStatefulPendingOperation;
     sendToInstanceSpot(route: ServiceInstanceRouteFence, payload: ServiceApplicationPayload, sourceSpotId?: string, metadataFrame?: Uint8Array, instanceIntent?: boolean): Promise<number>;
     sendToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, payload: ServiceApplicationPayload, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array): Promise<number>;
     sendToMissingInstanceSpotFrame(target: ServiceInstanceColdActivationTarget, payloadFrame: Buffer, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array): Promise<number>;
-    requestToInstanceSpot(route: ServiceInstanceRouteFence, payload: ServiceApplicationPayload, timeoutMs: number, sourceSpotId?: string, metadataFrame?: Uint8Array, instanceIntent?: boolean): ServiceStatefulPendingOperation;
+    requestToInstanceSpot(route: ServiceInstanceRouteFence, payload: ServiceApplicationPayload, timeoutMs: number, sourceSpotId?: string, metadataFrame?: Uint8Array, instanceIntent?: boolean, onAdmitted?: () => void): ServiceStatefulPendingOperation;
     requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, payload: ServiceApplicationPayload, timeoutMs: number, sourceSpotId?: string, metadataFrame?: Uint8Array): ServiceStatefulPendingOperation;
-    requestToMissingInstanceSpotFrame(target: ServiceInstanceColdActivationTarget, payloadFrame: Buffer, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array): ServiceStatefulPendingOperation;
+    requestToMissingInstanceSpotFrame(target: ServiceInstanceColdActivationTarget, payloadFrame: Buffer, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array, onAdmitted?: () => void): ServiceStatefulPendingOperation;
     lookupRemoteActor(targetNodeRid: string, actorId: string, timeoutMs: number): ServiceStatefulPendingOperation;
     destroyActor(actor: ServiceActorRef, timeoutMs: number): ServiceStatefulPendingOperation;
     joinActor(actor: ServiceActorRef, targetNodeRid: string, targetSpot: ServiceSpotRef, targetSpotGeneration: bigint, payload: ServiceApplicationPayload | undefined, timeoutMs: number): ServiceStatefulPendingOperation;

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

@@ -7,7 +7,7 @@ const node_async_hooks_1 = require("node:async_hooks");
 const contracts_1 = require("../../contracts");
 const service_authority_payload_codec_1 = require("./service-authority-payload-codec");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
-const abort_1 = require("../abort");
+const durable_service_request_1 = require("./durable-service-request");
 const admission_1 = require("../admission");
 const runtime_values_1 = require("../backend/runtime-values");
 const message_flow_1 = require("../diagnostics/message-flow");
@@ -25,7 +25,6 @@ const service_stateful_wire_codec_1 = require("./service-stateful-wire-codec");
 const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
 const service_wire_constants_generated_1 = require("./service-wire-constants.generated");
 const service_wire_m6a_codec_1 = require("./service-wire-m6a-codec");
-const STATEFUL_OPERATION_RETRY_TICK_MS = 20;
 const MAX_NODE_TIMER_DELAY_MS = 2_147_483_647;
 const SPOT_MOVING = 34;
 const USER_SPOT_OPERATION_CAPACITY = 65_536;
@@ -92,7 +91,7 @@ class ServiceStatefulRuntime {
         this.operations = new service_stateful_registry_1.ServiceTerminalOperationRegistry(new operation_registry_1.OperationRegistry(undefined, onPendingOperationsChanged));
         this.registry = new service_stateful_registry_1.ServiceStatefulRegistry(nodeRid, nodeGeneration);
         this.registry.createEntrySpot(nodeRid);
-        raw.setServiceIngress((record) => this.ingress(record));
+        raw.setServiceIngress((record) => this.ingress(record), acceptsStatefulIngress);
     }
     setMailboxDropHandler(handler) {
         this.mailboxDropHandler = handler;
@@ -679,7 +678,7 @@ class ServiceStatefulRuntime {
         });
         return this.submitOneWay(target.targetNodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)]);
     }
-    requestToSpot(sourceSpotId, requested, payload, timeoutMs) {
+    requestToSpot(sourceSpotId, requested, payload, timeoutMs, onAdmitted) {
         const pending = this.operations.register(timeoutMs);
         const target = this.acceptSpotAuthority(requested);
         if (target === undefined) {
@@ -690,7 +689,7 @@ class ServiceStatefulRuntime {
             high: this.nodeGeneration,
             low: this.nextMessageFollowOperation++
         });
-        this.submitRequest(pending, target.targetNodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)], timeoutMs, 'spotRequest');
+        this.submitRequest(pending, target.targetNodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)], timeoutMs, 'spotRequest', undefined, onAdmitted);
         return pending;
     }
     async sendToActor(target, _targetNodeGeneration, _authorityOwnerGeneration, payload, sourceActor, boundSession) {
@@ -705,7 +704,7 @@ class ServiceStatefulRuntime {
             }, { high: this.nodeGeneration, low: this.nextMessageFollowOperation++ });
         return this.submitOneWay(target.nodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)]);
     }
-    requestToActor(target, _targetNodeGeneration, _authorityOwnerGeneration, payload, timeoutMs, sourceActor, boundSession) {
+    requestToActor(target, _targetNodeGeneration, _authorityOwnerGeneration, payload, timeoutMs, sourceActor, boundSession, onAdmitted) {
         const pending = this.operations.register(timeoutMs);
         const route = this.tryActorFence(target);
         if (route === undefined) {
@@ -718,7 +717,7 @@ class ServiceStatefulRuntime {
                 ...boundSession,
                 sequence: this.nextSessionSequence++
             }, { high: this.nodeGeneration, low: this.nextMessageFollowOperation++ });
-        this.submitRequest(pending, target.nodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)], timeoutMs, 'actorRequest');
+        this.submitRequest(pending, target.nodeRid, [header, (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)], timeoutMs, 'actorRequest', undefined, onAdmitted);
         return pending;
     }
     async sendToInstanceSpot(route, payload, sourceSpotId, metadataFrame, instanceIntent = false) {
@@ -737,12 +736,12 @@ class ServiceStatefulRuntime {
             payloadFrame
         ], metadataFrame));
     }
-    requestToInstanceSpot(route, payload, timeoutMs, sourceSpotId, metadataFrame, instanceIntent = false) {
+    requestToInstanceSpot(route, payload, timeoutMs, sourceSpotId, metadataFrame, instanceIntent = false, onAdmitted) {
         const pending = this.operations.register(timeoutMs);
         this.submitRequest(pending, route.targetNodeRid, instanceOperationParts([
             (0, service_stateful_wire_codec_1.encodeInstanceSpotHeader)(route, this.nodeGeneration, this.nodeRid, sourceSpotId, 'request', { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id }, pending.id, metadataFrame !== undefined, instanceIntent),
             (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload)
-        ], metadataFrame), timeoutMs, 'instanceSpotRequest');
+        ], metadataFrame), timeoutMs, 'instanceSpotRequest', undefined, onAdmitted);
         return pending;
     }
     requestToMissingInstanceSpot(target, payload, timeoutMs, sourceSpotId, metadataFrame) {
@@ -750,13 +749,13 @@ class ServiceStatefulRuntime {
         const payloadFrame = (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload);
         return this.requestToMissingInstanceSpotFrame(target, payloadFrame, deadlineUnixMs, sourceSpotId, metadataFrame);
     }
-    requestToMissingInstanceSpotFrame(target, payloadFrame, deadlineUnixMs, sourceSpotId, metadataFrame) {
+    requestToMissingInstanceSpotFrame(target, payloadFrame, deadlineUnixMs, sourceSpotId, metadataFrame, onAdmitted) {
         const timeoutMs = remainingDeadlineMs(deadlineUnixMs);
         const pending = this.operations.register(timeoutMs);
         this.submitRequest(pending, target.targetNodeRid, instanceOperationParts([
             (0, service_stateful_wire_codec_1.encodeInstanceSpotActivationHeader)(target, this.nodeGeneration, this.nodeRid, sourceSpotId, 'request', { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id }, deadlineUnixMs, pending.id, metadataFrame !== undefined),
             payloadFrame
-        ], metadataFrame), timeoutMs, 'instanceSpotRequest');
+        ], metadataFrame), timeoutMs, 'instanceSpotRequest', undefined, onAdmitted);
         return pending;
     }
     lookupRemoteActor(targetNodeRid, actorId, timeoutMs) {
@@ -1072,25 +1071,6 @@ class ServiceStatefulRuntime {
         this.spotMessageFollow.clear();
     }
     async ingress(record) {
-        // These frozen relocation controls overlap the legacy stateful command
-        // number range (30-34). They are bare infrastructure records and must
-        // fall through to RawServiceMeshRuntime's relocation ingress instead of
-        // being decoded as stateful actor/spot work.
-        if (record.command === service_stateful_wire_codec_1.M6bServiceWireCommand.relocationReady ||
-            record.command === service_stateful_wire_codec_1.M6bServiceWireCommand.relocationData ||
-            record.command === service_stateful_wire_codec_1.M6bServiceWireCommand.replyRelay ||
-            record.command === service_stateful_wire_codec_1.M6bServiceWireCommand.relocationCutover) {
-            return undefined;
-        }
-        if (record.command < service_stateful_wire_codec_1.M6bServiceWireCommand.spotSend ||
-            (record.command > service_stateful_wire_codec_1.M6bServiceWireCommand.instanceSpot &&
-                record.command !== service_stateful_wire_codec_1.M6bServiceWireCommand.userSpotCreate &&
-                record.command !== service_stateful_wire_codec_1.M6bServiceWireCommand.userSpotClose &&
-                record.command !== service_stateful_wire_codec_1.M6bServiceWireCommand.actorCreate &&
-                record.command !== service_stateful_wire_codec_1.M6bServiceWireCommand.messageFollow &&
-                record.command !== service_stateful_wire_codec_1.M6bServiceWireCommand.boundSessionReplaced)) {
-            return undefined;
-        }
         let decoded;
         let canonicalActorJoin;
         try {
@@ -1329,12 +1309,14 @@ class ServiceStatefulRuntime {
         if (record.activation === 'missing' && this.asyncInstanceAuthority !== undefined) {
             const ownedIngress = shareIngressOwnership(ingress);
             void this.continueMissingInstanceActivation(ownedIngress, record, payloadFrame, localReply, metadataFrame).finally(() => ownedIngress.applicationJobOwner?.close());
+            ingress.onAdmitted?.();
             return 'infrastructure';
         }
         if (record.activation === 'ready' &&
             this.needsInstanceApplicationMaterialization(ingress, record)) {
             const ownedIngress = shareIngressOwnership(ingress);
             void this.continueReadyInstanceMaterialization(ownedIngress, record, payloadFrame, metadataFrame).finally(() => ownedIngress.applicationJobOwner?.close());
+            ingress.onAdmitted?.();
             return 'infrastructure';
         }
         const spot = this.requireInstanceActivation(ingress, record);
@@ -2380,8 +2362,10 @@ class ServiceStatefulRuntime {
             stateful,
             applicationJob
         });
-        if (accepted)
+        if (accepted) {
+            ingress.onAdmitted?.();
             return domain;
+        }
         applicationJob.close();
         if (stateful.reply !== undefined) {
             const result = failure((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `Mailbox owner '${owner}' no longer accepts work on this runtime.`));
@@ -2682,57 +2666,11 @@ class ServiceStatefulRuntime {
         }
     }
     async requestDurableOperation(targetNodeRid, parts, correlation, operationKind, deadlineMs) {
-        const stop = new AbortController();
-        const unobserve = this.raw.observePeerConnectionIntentRemoved((nodeRoutingId) => {
-            if (nodeRoutingId === targetNodeRid) {
-                stop.abort((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} target node lifecycle ended.`, true));
-            }
-        });
-        let wasAdmitted = false;
-        try {
-            // Only durable lifecycle operations replay these frozen frames. Received
-            // envelopes leave this loop before decoding, including failure terminals.
-            for (;;) {
-                this.requireOpen();
-                stop.signal.throwIfAborted();
-                const remainingMs = Math.ceil(deadlineMs - performance.now());
-                if (remainingMs <= 0)
-                    throw durableOperationExhausted(operationKind, wasAdmitted);
-                try {
-                    return await (0, abort_1.awaitWithAbort)(targetNodeRid === this.nodeRid
-                        ? this.requestLocalInfrastructure(parts[0], correlation, remainingMs)
-                        : this.raw.requestService(targetNodeRid, parts, remainingMs), stop.signal);
-                }
-                catch (error) {
-                    stop.signal.throwIfAborted();
-                    if (!durableRequestCanReplay(error))
-                        throw error;
-                    if (durableRequestWasAdmitted(error))
-                        wasAdmitted = true;
-                    const retryDelayMs = Math.min(STATEFUL_OPERATION_RETRY_TICK_MS, deadlineMs - performance.now());
-                    if (retryDelayMs <= 0) {
-                        throw durableOperationExhausted(operationKind, wasAdmitted, error);
-                    }
-                    let timer;
-                    try {
-                        await (0, abort_1.awaitWithAbort)(new Promise((resolve) => {
-                            timer = setTimeout(resolve, retryDelayMs);
-                        }), stop.signal);
-                    }
-                    finally {
-                        if (timer !== undefined)
-                            clearTimeout(timer);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            stop.signal.throwIfAborted();
-            throw error;
-        }
-        finally {
-            unobserve();
+        this.requireOpen();
+        if (targetNodeRid === this.nodeRid) {
+            return this.requestLocalInfrastructure(parts[0], correlation, Math.ceil(deadlineMs - performance.now()));
         }
+        return (0, durable_service_request_1.requestDurableService)(this.raw, targetNodeRid, parts, deadlineMs, operationKind);
     }
     requestLocalInfrastructure(header, requestSequence, timeoutMs) {
         return new Promise((resolve, reject) => {
@@ -2838,7 +2776,7 @@ class ServiceStatefulRuntime {
             ? runtime_values_1.SubmitResult.Ok
             : runtime_values_1.SubmitResult.NotConnected;
     }
-    submitRequest(pending, targetNodeRid, parts, timeoutMs, operationKind, actor) {
+    submitRequest(pending, targetNodeRid, parts, timeoutMs, operationKind, actor, onAdmitted) {
         if (targetNodeRid === this.nodeRid) {
             const deadlineUnixMs = BigInt(Date.now() + Math.max(0, timeoutMs));
             const capacityStop = new AbortController();
@@ -2853,6 +2791,7 @@ class ServiceStatefulRuntime {
                         flags: parts[0][service_wire_binary_primitives_1.SERVICE_WIRE_FLAGS_OFFSET],
                         sourceRoutingId: this.nodeRid,
                         requestSequence: pending.id,
+                        onAdmitted,
                         parts,
                         applicationJobOwner
                     };
@@ -2867,7 +2806,7 @@ class ServiceStatefulRuntime {
             })().catch((error) => this.operations.reply(pending.id, failure(error)));
             return;
         }
-        void this.raw.requestService(targetNodeRid, parts, timeoutMs).then((reply) => this.completeRemoteReply(pending, targetNodeRid, operationKind, actor, reply), (error) => this.operations.fail(pending.id, error));
+        void this.raw.requestService(targetNodeRid, parts, timeoutMs, onAdmitted).then((reply) => this.completeRemoteReply(pending, targetNodeRid, operationKind, actor, reply), (error) => this.operations.fail(pending.id, error));
     }
     submitActorJoin(pending, actor, targetNodeRid, target, payload, deadlineMs, canonical) {
         const actorRoute = canonical === undefined
@@ -3598,26 +3537,6 @@ function operationDeadline(deadlineUnixMs) {
 function operationReplayExpired(replayExpiresAtMs) {
     return performance.now() > replayExpiresAtMs;
 }
-function durableRequestWasAdmitted(error) {
-    // Request NotConnected includes Core handover of an admitted request. The
-    // submit/request phase, rather than the result number, owns this distinction.
-    return (0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request';
-}
-function durableOperationExhausted(operationKind, wasAdmitted, cause) {
-    return (0, framework_errors_internal_1.createInternalFrameworkException)(wasAdmitted
-        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded
-        : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} exhausted its end-to-end deadline.`, true, cause);
-}
-function durableRequestCanReplay(error) {
-    if (!(0, runtime_values_1.isZLinkBackendResultError)(error))
-        return false;
-    return error.operation === 'request'
-        ? error.result === runtime_values_1.RequestResult.NotConnected || error.result === runtime_values_1.RequestResult.TimedOut
-        : error.result === runtime_values_1.SubmitResult.NotConnected ||
-            error.result === runtime_values_1.SubmitResult.NotFound ||
-            error.result === runtime_values_1.SubmitResult.NotAdmitted ||
-            error.result === runtime_values_1.SubmitResult.Backpressured;
-}
 function remainingDeadlineMs(deadlineUnixMs) {
     const remainingMs = deadlineUnixMs - BigInt(Date.now());
     if (remainingMs <= 0n) {
@@ -3944,3 +3863,25 @@ function instanceOperationParts(headerAndPayload, metadataFrame) {
 function statefulMailboxData(record) {
     return record.stateful;
 }
+function acceptsStatefulIngress(command) {
+    // These frozen relocation controls overlap the legacy stateful command
+    // number range (30-34). They are bare infrastructure records and must
+    // fall through to RawServiceMeshRuntime's relocation ingress instead of
+    // being decoded as stateful actor/spot work.
+    if (command === service_stateful_wire_codec_1.M6bServiceWireCommand.relocationReady ||
+        command === service_stateful_wire_codec_1.M6bServiceWireCommand.relocationData ||
+        command === service_stateful_wire_codec_1.M6bServiceWireCommand.replyRelay ||
+        command === service_stateful_wire_codec_1.M6bServiceWireCommand.relocationCutover) {
+        return false;
+    }
+    if (command < service_stateful_wire_codec_1.M6bServiceWireCommand.spotSend ||
+        (command > service_stateful_wire_codec_1.M6bServiceWireCommand.instanceSpot &&
+            command !== service_stateful_wire_codec_1.M6bServiceWireCommand.userSpotCreate &&
+            command !== service_stateful_wire_codec_1.M6bServiceWireCommand.userSpotClose &&
+            command !== service_stateful_wire_codec_1.M6bServiceWireCommand.actorCreate &&
+            command !== service_stateful_wire_codec_1.M6bServiceWireCommand.messageFollow &&
+            command !== service_stateful_wire_codec_1.M6bServiceWireCommand.boundSessionReplaced)) {
+        return false;
+    }
+    return true;
+}

package/dist/runtime/foundation/service-stateful-wire-codec.d.ts

@@ -126,11 +126,6 @@ export interface ServiceMaintenanceRelocationPrepare extends ServiceWireRelocati
     /** CRC-32C (Castagnoli) over the fully assembled payload bytes. */
     readonly payloadChecksumCrc32c: number;
     readonly applicationVersion: bigint;
-    /** NODE-INTERNAL; serialized as extra frames after canonical command 40. */
-    readonly nodeInternalBoundSessions?: readonly {
-        readonly participantKey: string;
-        readonly payload: Uint8Array;
-    }[];
 }
 export interface ServiceMaintenanceRelocationReady extends ServiceWireRelocationBase {
     readonly kind: 'ready';

package/dist/runtime/foundation/service-topology-registry.d.ts

@@ -24,8 +24,13 @@ export interface ServiceNodeDescriptor {
     readonly activeCapacityUsed: number;
     readonly pendingCapacityUsed: number;
 }
-export interface AdmittedServicePeer {
+interface ServiceRouteAdmission {
     readonly descriptor: ServiceNodeDescriptor;
+    readonly descriptorBytes?: Uint8Array;
+    readonly connectionId?: string | bigint;
+    readonly remoteAdmitReceived?: boolean;
+}
+export interface AdmittedServicePeer extends ServiceRouteAdmission {
     readonly connectionId: string | bigint;
     readonly liveness?: ServiceLivenessConnection;
 }
@@ -46,15 +51,19 @@ export declare class ServiceTopologyRegistry {
     constructor(local: ServiceNodeDescriptor);
     localDescriptor(): ServiceNodeDescriptor;
     publishLocal(descriptor: ServiceNodeDescriptor): void;
-    admit(descriptor: ServiceNodeDescriptor, connectionId: string | bigint, expected?: ServicePeerAdmissionExpectation, admitLiveness?: () => ServiceLivenessConnection): PeerAdmissionResult;
+    admit(descriptor: ServiceNodeDescriptor, connectionId: string | bigint, expected?: ServicePeerAdmissionExpectation, admitLiveness?: () => ServiceLivenessConnection, command?: number, descriptorBytes?: Uint8Array): PeerAdmissionResult;
     disconnect(nodeRoutingId: string, connectionId: string | bigint): boolean;
     peer(nodeRoutingId: string): AdmittedServicePeer | undefined;
+    routeAdmission(nodeRoutingId: string): ServiceRouteAdmission | undefined;
+    admittedPeer(nodeRoutingId: string): AdmittedServicePeer | undefined;
     peers(): readonly AdmittedServicePeer[];
     private peersCore;
     notRequiredPeers(): readonly ServiceNodeDescriptor[];
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     forgetNotRequired(nodeRoutingId: string): void;
     knownDescriptor(nodeRoutingId: string): ServiceNodeDescriptor | undefined;
+    isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
+    private knownPeerDescriptor;
     hasKnownChannelTarget(channelName: string): boolean;
     private remember;
     selectChannel(channelName: string, isReady?: (peer: AdmittedServicePeer) => boolean): AdmittedServicePeer | undefined;
@@ -72,3 +81,4 @@ export declare class ServiceTopologyRegistry {
 }
 export declare function validateDescriptor(descriptor: ServiceNodeDescriptor): void;
 export declare function sameServiceNodeDescriptor(left: ServiceNodeDescriptor, right: ServiceNodeDescriptor): boolean;
+export {};

package/dist/runtime/foundation/service-topology-registry.js

@@ -35,13 +35,13 @@ class ServiceTopologyRegistry {
         }
         this.local = cloneDescriptor(descriptor);
         for (const [nodeRoutingId, remote] of this.notRequiredByRid) {
-            if (!(0, route_mesh_connection_policy_1.descriptorConnectionNotRequired)(this.local, remote)) {
+            if (!(0, route_mesh_connection_policy_1.descriptorConnectionNotRequired)(this.local, remote.descriptor)) {
                 this.notRequiredByRid.delete(nodeRoutingId);
             }
         }
         this.rebuildSelections();
     }
-    admit(descriptor, connectionId, expected, admitLiveness) {
+    admit(descriptor, connectionId, expected, admitLiveness, command = service_wire_constants_generated_1.ServiceWireCommand.hello, descriptorBytes) {
         try {
             validateDescriptor(descriptor);
             if (typeof connectionId === 'string')
@@ -63,32 +63,46 @@ class ServiceTopologyRegistry {
                 descriptor.lifecycleGeneration !== expected.lifecycleGeneration)) {
             return 'invalidDescriptor';
         }
+        const current = this.peersByRid.get(descriptor.nodeRoutingId);
+        const previous = current ?? this.notRequiredByRid.get(descriptor.nodeRoutingId);
+        const receivedAdmit = command === service_wire_constants_generated_1.ServiceWireCommand.admit ||
+            (previous?.connectionId === connectionId && previous.remoteAdmitReceived === true);
+        if (previous !== undefined &&
+            previous.descriptor.lifecycleGeneration === descriptor.lifecycleGeneration) {
+            const existing = previous.descriptor;
+            if (descriptor.descriptorRevision < existing.descriptorRevision ||
+                (descriptor.descriptorRevision === existing.descriptorRevision &&
+                    !(previous.descriptorBytes !== undefined && descriptorBytes !== undefined
+                        ? Buffer.compare(previous.descriptorBytes, descriptorBytes) === 0
+                        : sameServiceNodeDescriptor(existing, descriptor))) ||
+                (descriptor.descriptorRevision > existing.descriptorRevision &&
+                    command !== service_wire_constants_generated_1.ServiceWireCommand.update))
+                return 'staleDescriptor';
+            if (descriptor.descriptorRevision > existing.descriptorRevision &&
+                !sameImmutableDescriptor(existing, descriptor))
+                return 'invalidDescriptor';
+        }
+        else if (command === service_wire_constants_generated_1.ServiceWireCommand.update) {
+            return 'staleDescriptor';
+        }
+        const admission = {
+            descriptor: cloneDescriptor(descriptor),
+            ...(descriptorBytes === undefined ? {} : { descriptorBytes: Buffer.from(descriptorBytes) }),
+            connectionId,
+            remoteAdmitReceived: receivedAdmit
+        };
         if ((0, route_mesh_connection_policy_1.descriptorConnectionNotRequired)(this.local, descriptor)) {
             this.peersByRid.delete(descriptor.nodeRoutingId);
             this.remember(descriptor);
-            this.notRequiredByRid.set(descriptor.nodeRoutingId, cloneDescriptor(descriptor));
+            this.notRequiredByRid.set(descriptor.nodeRoutingId, admission);
             this.rebuildSelections();
             return 'notRequired';
         }
         this.notRequiredByRid.delete(descriptor.nodeRoutingId);
-        const current = this.peersByRid.get(descriptor.nodeRoutingId);
-        if (current !== undefined &&
-            current.descriptor.lifecycleGeneration === descriptor.lifecycleGeneration &&
-            descriptor.descriptorRevision > current.descriptor.descriptorRevision &&
-            !sameImmutableDescriptor(current.descriptor, descriptor)) {
-            return 'invalidDescriptor';
-        }
-        if (current !== undefined &&
-            current.descriptor.lifecycleGeneration === descriptor.lifecycleGeneration &&
-            (current.descriptor.descriptorRevision > descriptor.descriptorRevision ||
-                (current.descriptor.descriptorRevision === descriptor.descriptorRevision &&
-                    !sameServiceNodeDescriptor(current.descriptor, descriptor)))) {
-            return 'staleDescriptor';
-        }
         // Core selects the one route per RID (Core ROUTER §10.1); an admission on
         // that route replaces the admission of a route it replaced.
         this.peersByRid.set(descriptor.nodeRoutingId, {
-            descriptor: cloneDescriptor(descriptor),
+            ...admission,
             connectionId,
             liveness: admitLiveness?.() ?? current?.liveness
         });
@@ -105,9 +119,15 @@ class ServiceTopologyRegistry {
         return true;
     }
     peer(nodeRoutingId) {
-        const peer = this.peersByRid.get(nodeRoutingId);
+        const peer = this.admittedPeer(nodeRoutingId);
         return peer === undefined ? undefined : clonePeer(peer);
     }
+    routeAdmission(nodeRoutingId) {
+        return this.peersByRid.get(nodeRoutingId) ?? this.notRequiredByRid.get(nodeRoutingId);
+    }
+    admittedPeer(nodeRoutingId) {
+        return this.peersByRid.get(nodeRoutingId);
+    }
     peers() {
         return this.peersCore();
     }
@@ -118,8 +138,8 @@ class ServiceTopologyRegistry {
     }
     notRequiredPeers() {
         return [...this.notRequiredByRid.values()]
-            .sort((left, right) => compareOrdinal(left.nodeRoutingId, right.nodeRoutingId))
-            .map(cloneDescriptor);
+            .sort((left, right) => compareOrdinal(left.descriptor.nodeRoutingId, right.descriptor.nodeRoutingId))
+            .map((peer) => cloneDescriptor(peer.descriptor));
     }
     replaceDiscoveredNotRequired(descriptors) {
         const next = new Map();
@@ -128,13 +148,16 @@ class ServiceTopologyRegistry {
             if (descriptor.meshName === this.local.meshName &&
                 descriptor.nodeRoutingId !== this.local.nodeRoutingId &&
                 (0, route_mesh_connection_policy_1.descriptorConnectionNotRequired)(this.local, descriptor)) {
-                next.set(descriptor.nodeRoutingId, cloneDescriptor(descriptor));
+                next.set(descriptor.nodeRoutingId, {
+                    ...this.notRequiredByRid.get(descriptor.nodeRoutingId),
+                    descriptor: cloneDescriptor(descriptor)
+                });
             }
         }
         this.notRequiredByRid.clear();
-        for (const [nodeRoutingId, descriptor] of next) {
-            this.notRequiredByRid.set(nodeRoutingId, descriptor);
-            this.remember(descriptor);
+        for (const [nodeRoutingId, admission] of next) {
+            this.notRequiredByRid.set(nodeRoutingId, admission);
+            this.remember(admission.descriptor);
         }
         this.rebuildSelections();
     }
@@ -143,10 +166,21 @@ class ServiceTopologyRegistry {
             this.rebuildSelections();
     }
     knownDescriptor(nodeRoutingId) {
-        const admitted = this.peersByRid.get(nodeRoutingId)?.descriptor;
-        const descriptor = admitted ?? this.notRequiredByRid.get(nodeRoutingId) ?? this.knownByRid.get(nodeRoutingId);
+        const descriptor = this.knownPeerDescriptor(nodeRoutingId);
         return descriptor === undefined ? undefined : cloneDescriptor(descriptor);
     }
+    isObjectClientNodeDirectTarget(nodeRoutingId) {
+        const descriptor = nodeRoutingId === this.local.nodeRoutingId
+            ? this.local
+            : this.knownPeerDescriptor(nodeRoutingId);
+        return descriptor?.objectRole === 'client';
+    }
+    knownPeerDescriptor(nodeRoutingId) {
+        const admitted = this.peersByRid.get(nodeRoutingId)?.descriptor;
+        return (admitted ??
+            this.notRequiredByRid.get(nodeRoutingId)?.descriptor ??
+            this.knownByRid.get(nodeRoutingId));
+    }
     hasKnownChannelTarget(channelName) {
         requireText(channelName, 'channelName');
         return [...this.knownByRid.values()].some((descriptor) => (descriptor.state === 'serving' ||

package/dist/runtime/foundation/service-wire-m6a-codec.d.ts

@@ -66,11 +66,11 @@ export declare class ServiceWireProtocolError extends Error {
 }
 export declare function encodeNodeSendHeader(): Buffer;
 export declare function encodeNodeRequestHeader(correlation: bigint): Buffer;
-export declare function decodeNodeRequestHeader(frame: Uint8Array): bigint;
+export declare function decodeNodeRequestHeader(frame: Uint8Array, header?: ServiceWireHeader): bigint;
 export declare function encodeChannelSendHeader(channelName: string): Buffer;
-export declare function decodeChannelSendHeader(frame: Uint8Array): string;
+export declare function decodeChannelSendHeader(frame: Uint8Array, header?: ServiceWireHeader): string;
 export declare function encodeChannelRequestHeader(correlation: bigint, channelName: string): Buffer;
-export declare function decodeChannelRequestHeader(frame: Uint8Array): {
+export declare function decodeChannelRequestHeader(frame: Uint8Array, header?: ServiceWireHeader): {
     readonly correlation: bigint;
     readonly channelName: string;
 };