@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/host/instance-activation-authority.d.ts

@@ -17,9 +17,9 @@ export declare class ZLinkInstanceActivationAuthority implements ServiceAsyncIns
     private readonly pending;
     constructor(options: ZLinkInstanceActivationAuthorityOptions);
     read(target: ServiceInstanceActivationTarget): Promise<ServiceInstanceAuthorityRead>;
-    reserve(activation: Omit<ServiceInstanceActivationRecoveryEnvelope, 'targetMeshName'>): Promise<ServiceInstanceAuthorityReserve>;
+    reserve(activation: Omit<ServiceInstanceActivationRecoveryEnvelope, 'targetMeshName'>, signal?: AbortSignal): Promise<ServiceInstanceAuthorityReserve>;
     resume(target: ServiceInstanceActivationTarget, pending: ServicePendingInstanceActivation): Promise<ServiceInstanceActivationReservation>;
-    commit(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation, spot: ServiceSpotState): Promise<{
+    commit(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation, spot: ServiceSpotState, deadlineUnixMs?: bigint): Promise<{
         readonly kind: 'committed' | 'lost';
         readonly route: ServiceInstanceRouteFence;
     }>;
@@ -28,6 +28,5 @@ export declare class ZLinkInstanceActivationAuthority implements ServiceAsyncIns
     private requireOwner;
     private deleteOrphan;
     private awaitConcurrentActivation;
-    private awaitClosingRelease;
     private requirePending;
 }

package/dist/runtime/host/instance-activation-authority.js

@@ -7,7 +7,6 @@ const contracts_1 = require("../../contracts");
 const service_authority_payload_codec_1 = require("../foundation/service-authority-payload-codec");
 const routing_id_1 = require("../routing-id");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
-const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
 const relocation_blob_1 = require("../locations/relocation-blob");
 const service_instance_activation_recovery_codec_1 = require("../foundation/service-instance-activation-recovery-codec");
 const CREATION_REQUEST_RETENTION_MS = 24 * 60 * 60 * 1_000;
@@ -23,7 +22,7 @@ class ZLinkInstanceActivationAuthority {
         const current = await this.options.store.readAuthority(authorityKey(target.targetSpotId));
         return current.kind === 'snapshot' ? readyRead(current, target) : { kind: 'missing' };
     }
-    async reserve(activation) {
+    async reserve(activation, signal) {
         const target = activation.target;
         const owner = this.requireOwner();
         const requestBytes = (0, service_instance_activation_recovery_codec_1.encodeInstanceActivationRecoveryEnvelope)({
@@ -38,13 +37,12 @@ class ZLinkInstanceActivationAuthority {
             throw new Error('Instance activation requires a Relocation Store.');
         }
         const requestHash = (0, node_crypto_1.createHash)('sha256').update(requestBytes).digest();
-        const stored = await (0, relocation_blob_1.putNewRelocationBlob)(relocationStore, requestBytes, CREATION_REQUEST_RETENTION_MS);
-        const storedRead = await relocationStore.read(stored.reference);
+        const stored = await (0, relocation_blob_1.putNewRelocationBlob)(relocationStore, requestBytes, CREATION_REQUEST_RETENTION_MS, signal);
+        const storedRead = await relocationStore.read(stored.reference, signal);
         if (stored.reference.value.length === 0 ||
             stored.expiresAt.getTime() <= stored.storeNow.getTime() ||
             storedRead.kind !== 'found' ||
-            (0, service_relocation_runtime_1.crc32c)(storedRead.bytes) !== (0, service_relocation_runtime_1.crc32c)(requestBytes) ||
-            !Buffer.from(storedRead.bytes).equals(requestBytes)) {
+            Buffer.compare(storedRead.bytes, requestBytes) !== 0) {
             await this.deleteOrphan(stored.reference);
             throw new Error('Relocation Store returned an invalid creation request receipt.');
         }
@@ -84,16 +82,7 @@ class ZLinkInstanceActivationAuthority {
                             count: 1
                         }
                     }
-                });
-                if (reserved.kind === 'conflict' || reserved.kind === 'alreadyExists') {
-                    const existingState = reserved.current.kind === 'snapshot'
-                        ? (0, service_authority_payload_codec_1.decodeServiceInstanceAuthorityPayload)(reserved.current.payload)?.state
-                        : undefined;
-                    if (existingState === 'closing') {
-                        await this.awaitClosingRelease(target, activation.deadlineUnixMs);
-                        continue;
-                    }
-                }
+                }, undefined, activation.deadlineUnixMs);
                 if (reserved.kind !== 'alreadyExists')
                     break;
                 this.options.metrics?.recordInstanceSpotClaimConflict(this.options.meshName, target.stableType, 'already_exists');
@@ -176,7 +165,7 @@ class ZLinkInstanceActivationAuthority {
         });
         return reservation;
     }
-    async commit(target, reservation, spot) {
+    async commit(target, reservation, spot, deadlineUnixMs) {
         const pending = this.requirePending(reservation);
         requireCommitIdentity(target, reservation, pending.creating, spot, this.options.meshName);
         let result;
@@ -208,7 +197,7 @@ class ZLinkInstanceActivationAuthority {
                         replayCursor: 0n
                     }
                 })
-            });
+            }, undefined, deadlineUnixMs);
         }
         catch (error) {
             if (error instanceof contracts_1.ZLinkFrameworkException)
@@ -366,26 +355,6 @@ class ZLinkInstanceActivationAuthority {
         }
         throw new Error(`Concurrent Instance activation for '${target.targetSpotId}' did not reach Ready before deadline.`);
     }
-    async awaitClosingRelease(target, deadlineUnixMs) {
-        const key = authorityKey(target.targetSpotId);
-        const deadlineMs = performance.now() + Number(deadlineUnixMs - BigInt(Date.now()));
-        while (performance.now() <= deadlineMs) {
-            const current = await this.options.store.readAuthority(key);
-            if (current.kind !== 'snapshot')
-                return;
-            const decoded = (0, service_authority_payload_codec_1.decodeServiceInstanceAuthorityPayload)(current.payload);
-            if (current.allocation.objectKind !== 'instance_spot' ||
-                current.allocation.stableType !== target.stableType ||
-                decoded?.kind !== 'instance_spot' ||
-                decoded.spotId !== target.targetSpotId) {
-                throw new Error('Instance authority changed to a different Spot while closing.');
-            }
-            if (decoded.state !== 'closing')
-                return;
-            await waitForActivationJoin(deadlineMs);
-        }
-        throw new Error(`Instance Spot '${target.targetSpotId}' close did not release authority before deadline.`);
-    }
     requirePending(reservation) {
         const pending = this.pending.get(reservation.token);
         if (pending === undefined || pending.creating.objectGeneration !== reservation.attempt) {
@@ -396,11 +365,11 @@ class ZLinkInstanceActivationAuthority {
 }
 exports.ZLinkInstanceActivationAuthority = ZLinkInstanceActivationAuthority;
 function readyRead(snapshot, target) {
-    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload);
+    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload) ??
+        (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(snapshot.payload);
     const creating = (0, service_authority_payload_codec_1.decodeServiceInstanceAuthorityPayload)(snapshot.payload);
     if (creating?.state === 'coldActivating' &&
         snapshot.allocation.objectKind === 'instance_spot' &&
-        snapshot.allocation.state === 'reserved' &&
         creating.stableType === target.stableType &&
         creating.spotId === target.targetSpotId &&
         creating.ownerId === snapshot.ownerId &&
@@ -413,7 +382,8 @@ function readyRead(snapshot, target) {
         return {
             kind: 'creating',
             objectGeneration: snapshot.objectGeneration,
-            authorityOwnerGeneration: snapshot.authorityOwnerGeneration
+            authorityOwnerGeneration: snapshot.authorityOwnerGeneration,
+            authority: snapshot
         };
     }
     if (decoded?.kind !== 'instance_spot' ||
@@ -430,10 +400,11 @@ function readyRead(snapshot, target) {
         target.targetNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration) {
         return { kind: 'missing' };
     }
-    return { kind: 'ready', route: routeFromSnapshot(snapshot) };
+    return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
 }
 function readyExisting(snapshot, target) {
-    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload);
+    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload) ??
+        (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(snapshot.payload);
     if (decoded?.kind !== 'instance_spot' ||
         decoded.stableType !== target.stableType ||
         decoded.spotId !== target.targetSpotId ||
@@ -446,7 +417,7 @@ function readyExisting(snapshot, target) {
         !(0, routing_id_1.routingIdsEqual)(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid)) {
         throw new Error('Existing Instance authority is not a matching Ready allocation.');
     }
-    return { kind: 'ready', route: routeFromSnapshot(snapshot) };
+    return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
 }
 async function waitForActivationJoin(deadlineMs) {
     const remaining = deadlineMs - performance.now();
@@ -473,7 +444,8 @@ function requireCommitIdentity(target, reservation, creating, spot, meshName) {
     }
 }
 function routeFromSnapshot(snapshot) {
-    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload);
+    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload) ??
+        (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(snapshot.payload);
     if (decoded?.kind !== 'instance_spot') {
         throw new Error('Instance authority is not Ready.');
     }

package/dist/runtime/host/location-runtime-owner.d.ts

@@ -39,7 +39,7 @@ export declare class ZLinkLocationRuntimeOwner {
     createSpotRouteResolver(spotMeshNames: readonly string[], spotRouterChannelIdByMesh: (meshName: string) => string, resolveLocalSpot?: (spotId: RoutingId) => import('../spots/spot-routing-internal').ZLinkSpotRouteTarget | undefined): ZLinkSpotRouteResolver | undefined;
     createActorLocationResolver(spotMeshNames: readonly string[]): ZLinkStoreLocationResolvers | undefined;
     ownerNodeRid(spotNodeRuntime?: ZLinkSpotNodeRuntimeManager): RoutingId;
-    startForRuntime(primaryMeshName: string | undefined, spotNodeRuntime: ZLinkSpotNodeRuntimeManager, channelRuntime: ZLinkChannelRuntimeManager): Promise<ZLinkLocationRuntime | undefined>;
+    startForRuntime(primaryMeshName: string | undefined, spotNodeRuntime: ZLinkSpotNodeRuntimeManager, channelRuntime: ZLinkChannelRuntimeManager, signal: AbortSignal, shutdownSignal: () => AbortSignal): Promise<ZLinkLocationRuntime | undefined>;
     clearForStop(): ZLinkLocationRuntimeStopSnapshot;
     private createRuntimeStores;
     private createAndRememberStores;

package/dist/runtime/host/location-runtime-owner.js

@@ -134,12 +134,12 @@ class ZLinkLocationRuntimeOwner {
         }
         return this.options.fallbackNodeRid;
     }
-    async startForRuntime(primaryMeshName, spotNodeRuntime, channelRuntime) {
+    async startForRuntime(primaryMeshName, spotNodeRuntime, channelRuntime, signal, shutdownSignal) {
         const runtime = this.ensureRuntime(primaryMeshName);
         if (runtime === undefined) {
             return undefined;
         }
-        await runtime.start(this.ownerNodeRid(spotNodeRuntime));
+        await runtime.start(this.ownerNodeRid(spotNodeRuntime), signal, shutdownSignal);
         const stores = this.currentStores;
         if (stores === undefined) {
             return runtime;

package/dist/runtime/host/remote-actor-join-receiver.d.ts

@@ -1,4 +1,4 @@
-import type { RoutingId, ZLinkRouteMessageContext } from '../../contracts';
+import type { RoutingId } from '../../contracts';
 import type { DefaultZLinkActorManager } from '../actors';
 import type { DefaultZLinkSpotManager } from '../spots';
 import type { ZLinkAuthorityStore } from '../locations/internal-store-contracts';
@@ -18,7 +18,7 @@ export interface ZLinkRemoteActorJoinReceiverOptions {
 export declare class ZLinkRemoteActorJoinReceiver {
     private readonly options;
     constructor(options: ZLinkRemoteActorJoinReceiverOptions);
-    receive(payload: unknown, routeContext: ZLinkRouteMessageContext): Promise<{
+    receive(payload: unknown): Promise<{
         readonly accepted: boolean;
         readonly actorNodeRid: string;
         readonly actorNodeRidHex?: string;

package/dist/runtime/host/remote-actor-join-receiver.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRemoteActorJoinReceiver = void 0;
 const runtime_message_1 = require("../backend/runtime-message");
-const actor_runtime_state_1 = require("../actors/actor-runtime-state");
 const actor_remote_wire_1 = require("../actors/actor-remote-wire");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
 const framework_errors_internal_1 = require("../framework-errors-internal");
@@ -12,7 +11,7 @@ class ZLinkRemoteActorJoinReceiver {
     constructor(options) {
         this.options = options;
     }
-    async receive(payload, routeContext) {
+    async receive(payload) {
         let join;
         try {
             join = (0, actor_remote_wire_1.decodeRemoteActorJoinPayload)(payload);
@@ -38,22 +37,10 @@ class ZLinkRemoteActorJoinReceiver {
             generation: BigInt(join.actorGeneration)
         };
         state.setNativeActorRef(actorRef);
-        const refreshedTarget = (0, actor_runtime_state_1.mergeRemoteBoundSessionTarget)({
-            routerChannelId: join.boundSessionRouterChannelId ??
-                join.routerChannelId ??
-                routeContext.channelName ??
-                '',
-            targetNodeRid: join.boundSessionTargetNodeRid ?? (0, routing_id_1.normalizeRoutingId)(routeContext.sourceNodeRid),
-            spotId: join.boundSessionSpotId ??
-                join.sourceSpotId ??
-                (0, routing_id_1.normalizeRoutingId)(routeContext.sourceNodeRid)
-        }, (0, actor_runtime_state_1.preferredRemoteBoundSessionTarget)(state.remoteBoundSessionTarget, state.boundSessionTransferTarget));
-        state.setRemoteBoundSessionTarget(refreshedTarget);
         const request = runtime_message_1.ZLinkBufferMessage.from(Buffer.from(join.request, 'base64'));
         try {
             const response = await this.requireSpotManager().admitActorJoin(join.spotId, actor, request, (spot) => {
                 state.setJoinedSpot(join.spotId, spot);
-                return () => state.clearJoinedSpot();
             }, undefined, undefined, join.requestContentType);
             const reply = response.reply;
             return {

package/dist/runtime/host/remote-actor-packet-target-store.d.ts

@@ -1,4 +1,4 @@
-import type { ActorRef, RoutingId, ZLinkSessionActor } from '../../contracts';
+import { type ActorRef, type RoutingId, type ZLinkSessionActor } from '../../contracts';
 import type { DefaultZLinkActorManager, ZLinkRemoteActorPacketTarget } from '../actors';
 import type { ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
 import type { MeshRouterResolver } from './mesh-router-resolver';
@@ -20,8 +20,9 @@ export declare class ZLinkRemoteActorPacketTargetStore {
     decodeFromWire(value: unknown): ZLinkRemoteActorPacketTarget | undefined;
     clear(actorId: string, expectedTenureKey?: string, expectedActor?: ZLinkSessionActor): void;
     cachedTargetForActor(actor: ZLinkSessionActor): ZLinkRemoteActorPacketTarget | undefined;
-    targetForState(actorId: string, routerChannelIdHint?: string): ZLinkRemoteActorPacketTarget | undefined;
+    targetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined;
     targetForActorRef(actorRef: ActorRef): ZLinkRemoteActorPacketTarget | undefined;
+    isLocalActorRef(actorRef: ActorRef): boolean;
     tenureKeyForActor(actor: ZLinkSessionActor): string;
     tenureKeyForActorRef(actorId: string, actorRef: ActorRef): string;
     rememberActorTarget(actor: ZLinkSessionActor, target: ZLinkRemoteActorPacketTarget, expectedTenureKey?: string): void;

package/dist/runtime/host/remote-actor-packet-target-store.js

@@ -4,7 +4,6 @@ exports.ZLinkRemoteActorPacketTargetStore = void 0;
 const contracts_1 = require("../../contracts");
 const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const routing_id_1 = require("../routing-id");
-const routing_id_2 = require("../routing-id");
 class ZLinkRemoteActorPacketTargetStore {
     options;
     sessionActorPacketTargets = new WeakMap();
@@ -63,53 +62,18 @@ class ZLinkRemoteActorPacketTargetStore {
             (actorIdEntry?.routeKey === routeKey ? actorIdEntry.target : undefined) ??
             this.targetForActorRef(actor.ref));
     }
-    targetForState(actorId, routerChannelIdHint) {
+    targetForState(actorId) {
         const state = this.options.actorManager()?.getState(actorId);
         if (state?.remoteActorPacketTarget !== undefined &&
             (state.spotId === undefined ||
-                (0, routing_id_2.routingIdsEqual)(state.remoteActorPacketTarget.spotId, state.spotId))) {
+                (0, routing_id_1.routingIdsEqual)(state.remoteActorPacketTarget.spotId, state.spotId))) {
             return state.remoteActorPacketTarget;
         }
-        const spotId = state?.spotId;
-        if (spotId !== undefined && state?.remoteActorPacketTarget !== undefined) {
-            //  The cached packet target refers to a different Spot than the
-            //  actor's current membership (the actor just moved Entry -> User).
-            //  Combining the stale target's node with the new Spot id fabricates
-            //  a route with no complete Ready authority fence, and the next
-            //  direct request then fails the fence check instead of resolving
-            //  the current owner route (spec 12 §direct payload uses the
-            //  Location Store's current owner route; spec 32:87 — an unavailable
-            //  route is Unavailable, not a fabricated hit). Publish no hint so
-            //  the source clears its cache and re-resolves completely.
-            return undefined;
-        }
-        const actorRef = state?.nativeActorRef;
-        const targetNodeRid = actorRef?.nodeRid ?? this.options.primaryNodeRid();
-        const routerChannelId = routerChannelIdHint ??
-            this.options.meshRouters.defaultSpotRouterChannelId() ??
-            this.options.meshRouters.defaultRouterChannelId();
-        const localNodeRid = this.options.primaryNodeRid();
-        if (spotId === undefined &&
-            targetNodeRid !== undefined &&
-            localNodeRid !== undefined &&
-            (0, routing_id_2.routingIdsEqual)(targetNodeRid, localNodeRid)) {
-            return undefined;
-        }
-        if (spotId === undefined || targetNodeRid === undefined || routerChannelId === undefined) {
-            return undefined;
-        }
-        return {
-            routerChannelId,
-            targetNodeRid: (0, routing_id_1.normalizeRoutingId)(targetNodeRid),
-            spotId: validateSpotId(spotId),
-            spotKind: contracts_1.ZLinkSpotKind.User,
-            ...(state?.spotGeneration === undefined ? {} : { targetSpotGeneration: state.spotGeneration })
-        };
+        return undefined;
     }
     targetForActorRef(actorRef) {
         const targetNodeRid = actorRef.nodeRid;
-        const localNodeRid = this.options.primaryNodeRid();
-        if (localNodeRid !== undefined && (0, routing_id_2.routingIdsEqual)(localNodeRid, targetNodeRid)) {
+        if (this.isLocalActorRef(actorRef)) {
             return undefined;
         }
         const meshName = actorRef.meshName;
@@ -127,6 +91,10 @@ class ZLinkRemoteActorPacketTargetStore {
             spotKind: contracts_1.ZLinkSpotKind.Entry
         };
     }
+    isLocalActorRef(actorRef) {
+        const localNodeRid = this.options.primaryNodeRid();
+        return localNodeRid !== undefined && (0, routing_id_1.routingIdsEqual)(localNodeRid, actorRef.nodeRid);
+    }
     tenureKeyForActor(actor) {
         return sessionActorPacketTargetTenureKey(actor);
     }
@@ -172,10 +140,3 @@ function sessionActorPacketTargetTenureKeyForRef(actorId, actorRef) {
         ref.ownerLeaseGeneration?.toString() ?? ''
     ].join(':');
 }
-function validateSpotId(value) {
-    const byteLength = Buffer.byteLength(value, 'utf8');
-    if (byteLength < 1 || byteLength > 255) {
-        throw new TypeError('SpotId must contain between 1 and 255 UTF-8 bytes.');
-    }
-    return value;
-}

package/dist/runtime/host/remote-bound-session-relay.d.ts

@@ -18,7 +18,7 @@ export interface ZLinkRemoteBoundSessionRelayOptions {
     readonly destroyedActorRefs: ReadonlyMap<string, ActorRef>;
     readonly boundSessionFactory: (actorId: string) => DefaultZLinkBoundSession;
     readonly updateRemoteActorPacketTarget: (actorId: string, value: unknown) => Promise<void>;
-    readonly actorPacketTargetForState: (actorId: string, routerChannelIdHint?: string) => ZLinkRemoteActorPacketTarget | undefined;
+    readonly actorPacketTargetForState: (actorId: string) => ZLinkRemoteActorPacketTarget | undefined;
     readonly reportOwnershipRefreshError?: (actorId: string, error: unknown) => void;
 }
 export declare class ZLinkRemoteBoundSessionRelay {
@@ -46,9 +46,8 @@ export declare class ZLinkRemoteBoundSessionRelay {
     private warnLateSessionRouteUpdate;
     private applyServiceWireSessionRelocationRoute;
     private validateServiceWireSessionRoute;
-    rememberRemoteBoundSessionTarget(actorId: string, target: ZLinkRemoteBoundSessionTarget | undefined): void;
     resolveRemoteBoundSessionTarget(sourceNodeRid: RoutingId, sourceSessionRid: RoutingId): ZLinkRemoteBoundSessionTarget | undefined;
-    actorPacketTargetForState(actorId: string, routerChannelIdHint?: string): ZLinkRemoteActorPacketTarget | undefined;
+    actorPacketTargetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined;
     clearOwnership(actorId: string): void;
     sendActorResponse(actor: ZLinkActor, packetName: string, requestSeq: bigint, response: unknown, replyOptions: ZLinkActorResponseOptions, fallbackBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, signal?: AbortSignal): Promise<void>;
     sendActorError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, fallbackBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, signal?: AbortSignal): Promise<void>;

package/dist/runtime/host/remote-bound-session-relay.js

@@ -74,15 +74,6 @@ class ZLinkRemoteBoundSessionRelay {
     async receiveRemoteBoundSessionSend(payload) {
         const send = (0, bound_session_wire_1.decodeRemoteBoundSessionSendPayload)(payload);
         await this.options.updateRemoteActorPacketTarget(send.actorId, send.actorPacketTarget);
-        const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwnerIfRegistered)(this.options.streamBindingRuntime());
-        const retained = await owner?.retainRelocationOutbound(send.actorId, {
-            deliver: () => this.deliverRemoteBoundSessionSend(send),
-            fail: (error) => this.options.reportOwnershipRefreshError?.(send.actorId, error)
-        }, send.relocationSealId);
-        if (retained === 'retained')
-            return { ok: true };
-        if (retained === 'rejected')
-            return { ok: false };
         return { ok: await this.deliverRemoteBoundSessionSend(send) };
     }
     async deliverRemoteBoundSessionSend(send) {
@@ -192,7 +183,7 @@ class ZLinkRemoteBoundSessionRelay {
             await owner.clearRelocation(actorId, error);
             void this.options
                 .streamBindingRuntime()
-                .disconnectBoundSession(actorId)
+                .closeSessionBinding(actorId, value.session)
                 .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(actorId, disconnectError));
             state.sealAbortCleanup?.();
         };
@@ -228,7 +219,7 @@ class ZLinkRemoteBoundSessionRelay {
                     await owner.clearRelocation(actorId, error);
                     void this.options
                         .streamBindingRuntime()
-                        .disconnectBoundSession(actorId)
+                        .closeSessionBinding(actorId, value.session)
                         .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(actorId, disconnectError));
                 }
             }
@@ -257,7 +248,6 @@ class ZLinkRemoteBoundSessionRelay {
         }
         const state = this.activeServiceWireRelocations.get(key);
         if (state === undefined) {
-            await (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.streamBindingRuntime()).discardRelocationOutbound(value.actor.actorId, key, new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${value.actor.actorId}' command 44 did not match an active command 42.`));
             this.warnLateSessionRouteUpdate(value);
             return;
         }
@@ -317,7 +307,7 @@ class ZLinkRemoteBoundSessionRelay {
             (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.streamBindingRuntime()).clearRelocation(state.actorId, error);
             await this.options
                 .streamBindingRuntime()
-                .disconnectBoundSession(state.actorId)
+                .closeSessionBinding(state.actorId, value.session)
                 .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(state.actorId, disconnectError));
             throw error;
         }
@@ -386,9 +376,6 @@ class ZLinkRemoteBoundSessionRelay {
             throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${value.actor.actor.actorId}' command 42 was fenced by its exact Session route.`);
         }
     }
-    rememberRemoteBoundSessionTarget(actorId, target) {
-        this.options.actorManager()?.getState(actorId)?.setRemoteBoundSessionTarget(target);
-    }
     resolveRemoteBoundSessionTarget(sourceNodeRid, sourceSessionRid) {
         const target = this.options.meshRouters.remoteBoundSessionTargetForSource(sourceNodeRid);
         if (target === undefined)
@@ -405,8 +392,8 @@ class ZLinkRemoteBoundSessionRelay {
             sessionRid: sourceSessionRid
         };
     }
-    actorPacketTargetForState(actorId, routerChannelIdHint) {
-        return this.options.actorPacketTargetForState(actorId, routerChannelIdHint);
+    actorPacketTargetForState(actorId) {
+        return this.options.actorPacketTargetForState(actorId);
     }
     clearOwnership(actorId) {
         this.actorOwnershipGenerations.delete(actorId);
@@ -433,7 +420,7 @@ class ZLinkRemoteBoundSessionRelay {
         const actorRef = currentActorRef(state, fallbackActorRef);
         const remoteTarget = fallbackBoundSessionTarget ?? state?.remoteBoundSessionTarget;
         if (remoteTarget !== undefined) {
-            await this.sendRemoteBoundSessionResponse(remoteTarget, actor.context.actorId, packetName, requestSeq, response, replyOptions, signal);
+            await this.sendRemoteBoundSessionResponse(remoteTarget, actor.context.actorId, packetName, requestSeq, response, replyOptions);
             return;
         }
         if (actorRef === undefined) {
@@ -457,7 +444,7 @@ class ZLinkRemoteBoundSessionRelay {
         const actorRef = currentActorRef(state, fallbackActorRef) ?? this.options.destroyedActorRefs.get(actorId);
         const remoteTarget = fallbackBoundSessionTarget ?? state?.remoteBoundSessionTarget;
         if (remoteTarget !== undefined) {
-            await this.sendRemoteBoundSessionError(remoteTarget, actorId, packetName, requestSeq, error, metadata, signal);
+            await this.sendRemoteBoundSessionError(remoteTarget, actorId, packetName, requestSeq, error, metadata);
             return;
         }
         if (actorRef === undefined) {
@@ -471,8 +458,8 @@ class ZLinkRemoteBoundSessionRelay {
             .streamBindingRuntime()
             .sendNativeBoundSessionError(actorSessionNode, actorRef, packetName, requestSeq, error, metadata, signal);
     }
-    async sendRemoteBoundSessionResponse(target, actorId, packetName, requestSeq, message, replyOptions, signal) {
-        const actorPacketTarget = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.options.actorPacketTargetForState(actorId, target.routerChannelId));
+    async sendRemoteBoundSessionResponse(target, actorId, packetName, requestSeq, message, replyOptions) {
+        const actorPacketTarget = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.options.actorPacketTargetForState(actorId));
         await this.sendRemoteBoundSessionControl(target, (0, bound_session_wire_1.encodeRemoteBoundSessionResponsePayload)({
             actorId,
             boundPacketName: packetName,
@@ -481,19 +468,19 @@ class ZLinkRemoteBoundSessionRelay {
             metadata: replyOptions.metadata,
             compressPayload: replyOptions.compressPayload,
             actorPacketTarget
-        }), signal);
+        }));
     }
-    async sendRemoteBoundSessionError(target, actorId, packetName, requestSeq, error, metadata, signal) {
+    async sendRemoteBoundSessionError(target, actorId, packetName, requestSeq, error, metadata) {
         await this.sendRemoteBoundSessionControl(target, (0, bound_session_wire_1.encodeRemoteBoundSessionErrorPayload)({
             actorId,
             boundPacketName: packetName,
             requestSeq,
             error,
             metadata,
-            actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.options.actorPacketTargetForState(actorId, target.routerChannelId))
-        }), signal);
+            actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.options.actorPacketTargetForState(actorId))
+        }));
     }
-    async sendRemoteBoundSessionControl(target, payload, signal) {
+    async sendRemoteBoundSessionControl(target, payload) {
         const packetName = payload.packetName;
         if (typeof packetName !== 'string') {
             throw new Error('Remote bound session control payload does not declare a packet name.');
@@ -502,7 +489,7 @@ class ZLinkRemoteBoundSessionRelay {
         if (submit === undefined) {
             throw new Error('Remote bound session node-direct transport is not available.');
         }
-        const result = await submit.call(this.options.routeTransport, target.routerChannelId, String(target.targetNodeRid), packetName, payload, signal);
+        const result = await submit.call(this.options.routeTransport, target.routerChannelId, String(target.targetNodeRid), packetName, payload);
         if (result.status !== submission_result_1.ZLinkSubmitStatus.Submitted) {
             throw new Error(`Remote bound session control '${packetName}' was not admitted` +
                 ` on '${target.routerChannelId}' for '${String(target.targetNodeRid)}'` +

package/dist/runtime/host/route-mesh-runtime.d.ts

@@ -1,4 +1,8 @@
-import { ZLinkFrameworkRuntimeState, type ZLinkObservedStatus, type ZLinkRouteMeshStatus, type ZLinkRouteMeshRuntime } from '../../contracts';
+import { ZLinkFrameworkRuntimeState, type ZLinkMeshNodeDescriptor, type ZLinkObservedStatus, type ZLinkRouteMeshRuntime, type ZLinkRouteMeshStatus } from '../../contracts';
+import type { ZLinkActivationAdmission } from '../activation-admission';
+import type { ZLinkRuntimeAdmissionGate } from '../admission';
+import type { ZLinkBackendMeshNode } from '../backend';
+import type { ZLinkSpotNodeOptions } from '../configuration';
 type ZLinkDrainForceReason = 'deadline_exceeded' | 'drain_state_publish_failed' | 'owner_cleanup_failed' | 'teardown_failed';
 type ZLinkMeshDrainResult = {
     readonly kind: 'drained';
@@ -7,11 +11,6 @@ type ZLinkMeshDrainResult = {
     readonly reason: ZLinkDrainForceReason;
     readonly error?: unknown;
 };
-import type { ZLinkBackendMeshNode } from '../backend';
-import type { ZLinkRuntimeAdmissionGate } from '../admission';
-import type { ZLinkActivationAdmission } from '../activation-admission';
-import type { ZLinkSpotNodeOptions } from '../configuration';
-import { type ZLinkMeshNodeDescriptor } from '../../contracts';
 export interface ZLinkRouteMeshRuntimeCoordinatorOptions {
     readonly meshNames: readonly string[];
     readonly meshOptions: ReadonlyMap<string, ZLinkSpotNodeOptions>;
@@ -38,9 +37,6 @@ export interface ZLinkLocalPlacementCounts {
 export declare class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshRuntime {
     private readonly options;
     private readonly states;
-    private readonly placementFingerprints;
-    private readonly peerFingerprints;
-    private readonly locationStoreHealthFingerprints;
     private placementObserver?;
     private hostOperation?;
     private shutdownOperation?;
@@ -48,6 +44,7 @@ export declare class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshR
     constructor(options: ZLinkRouteMeshRuntimeCoordinatorOptions);
     markServing(): void;
     snapshot(meshName: string): ZLinkRouteMeshStatus;
+    private buildSnapshot;
     observe(meshName: string, capacity?: number, signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkRouteMeshStatus>>;
     isReady(meshName: string): boolean;
     hostStateChanged(): void;
@@ -55,7 +52,7 @@ export declare class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshR
     drain(meshName: string, deadlineMs?: number, signal?: AbortSignal): Promise<ZLinkMeshDrainResult>;
     awaitDrained(meshName: string, signal?: AbortSignal): Promise<ZLinkMeshDrainResult>;
     drainHost(deadlineMs?: number, signal?: AbortSignal): Promise<ZLinkMeshDrainResult>;
-    shutdownHost(deadline?: number | Date, signal?: AbortSignal, remainingTimeoutMs?: number): Promise<ZLinkMeshDrainResult>;
+    shutdownHost(deadline: number | Date, signal: AbortSignal): Promise<ZLinkMeshDrainResult>;
     prepareHostRetire(deadlineMs: number): Promise<'prepared' | 'store_unavailable' | 'deadline_exceeded'>;
     /**
      * Relocates stateful resources without closing application transport.
@@ -66,12 +63,17 @@ export declare class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshR
     private performHostDrain;
     private performHostShutdown;
     private transition;
-    private seedPlacementFingerprint;
+    private publishCurrentStatus;
+    private publishSnapshot;
+    private publishStatus;
     private startPlacementObserver;
     private stopPlacementObserverIfIdle;
     private observePlacementChanges;
     private requireState;
 }
+export declare class ZLinkDrainingStatePublishError extends Error {
+    constructor(cause: unknown);
+}
 export declare class ZLinkRetiringRollbackError extends Error {
     constructor();
 }