@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -515,6 +515,9 @@ export type ServiceStatefulReplyTail = {
     readonly kind: 'streamBind';
     readonly bindingGeneration: bigint;
     readonly authorityOwnerGeneration: bigint;
+} | {
+    readonly kind: 'streamBindRejected';
+    readonly rejectionMessage: string;
 } | {
     readonly kind: 'userSpotCreate';
     readonly createResult: 'existing' | 'created' | 'rejected';

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

@@ -40,6 +40,7 @@ const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.g
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
 const framework_errors_internal_1 = require("../framework-errors-internal");
+const runtime_values_1 = require("../backend/runtime-values");
 const service_wire_codec_generated_2 = require("../protocol/service_wire_codec.generated");
 const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
 const routing_id_2 = require("../routing-id");
@@ -1226,6 +1227,12 @@ function decodeStatefulReply(frame, expectedCorrelation, operationKind, hasPaylo
             };
         }
     }
+    else if (operationKind === 'streamBind' && terminalResult === runtime_values_1.RequestResult.Rejected) {
+        tail = {
+            kind: 'streamBindRejected',
+            rejectionMessage: reader.text16('rejectionMessage')
+        };
+    }
     reader.end();
     return {
         correlation,
@@ -1275,6 +1282,8 @@ function encodeReplyTail(tail) {
         }
         case 'streamBind':
             return concat(u64(tail.bindingGeneration), u64(tail.authorityOwnerGeneration));
+        case 'streamBindRejected':
+            return concat(text16(tail.rejectionMessage, 'rejectionMessage'));
         case 'userSpotCreate':
             return concat(Buffer.of(['existing', 'created', 'rejected'].indexOf(tail.createResult) + 1), rid(tail.spotId, 'spotId'), u64(tail.objectGeneration));
         case 'userSpotClose':
@@ -1385,6 +1394,12 @@ function rid(value, name) {
 function text8(value, name) {
     return sized8(value, name);
 }
+function text16(value, name) {
+    const bytes = (0, service_wire_binary_primitives_1.encodeCanonicalServiceWireText)(value, name, 0xffff, outOfRange);
+    if (bytes.byteLength === 0)
+        fail(`${name} must not be empty.`);
+    return concat(u16(bytes.byteLength), bytes);
+}
 function optionalRid(value) {
     return value === undefined ? Buffer.of(0) : rid(value, 'sourceSpotId');
 }

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

@@ -56,6 +56,8 @@ export declare class ServiceTopologyRegistry {
     peer(nodeRoutingId: string): AdmittedServicePeer | undefined;
     routeAdmission(nodeRoutingId: string): ServiceRouteAdmission | undefined;
     admittedPeer(nodeRoutingId: string): AdmittedServicePeer | undefined;
+    hasRemoteAdmit(nodeRoutingId: string, connectionId?: string | bigint): boolean;
+    readyPeer(nodeRoutingId: string): AdmittedServicePeer | undefined;
     peers(): readonly AdmittedServicePeer[];
     private peersCore;
     notRequiredPeers(): readonly ServiceNodeDescriptor[];

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

@@ -128,6 +128,14 @@ class ServiceTopologyRegistry {
     admittedPeer(nodeRoutingId) {
         return this.peersByRid.get(nodeRoutingId);
     }
+    hasRemoteAdmit(nodeRoutingId, connectionId) {
+        const admission = this.routeAdmission(nodeRoutingId);
+        return (admission?.remoteAdmitReceived === true &&
+            (connectionId === undefined || admission.connectionId === connectionId));
+    }
+    readyPeer(nodeRoutingId) {
+        return this.hasRemoteAdmit(nodeRoutingId) ? this.admittedPeer(nodeRoutingId) : undefined;
+    }
     peers() {
         return this.peersCore();
     }
@@ -204,7 +212,7 @@ class ServiceTopologyRegistry {
             peer: clonePeer(peer),
             channel: selectableChannel(peer.descriptor, channelName)
         }))
-            .filter((value) => value.channel !== undefined), (value) => value.channel.weight, (value) => value.peer.descriptor.nodeRoutingId, (left, right) => compareOrdinal(left.peer.descriptor.nodeRoutingId, right.peer.descriptor.nodeRoutingId), (value) => isReady(value.peer))?.peer;
+            .filter((value) => value.channel !== undefined), (value) => value.channel.weight, (value) => value.peer.descriptor.nodeRoutingId, (left, right) => compareOrdinal(left.peer.descriptor.nodeRoutingId, right.peer.descriptor.nodeRoutingId), (value) => this.readyPeer(value.peer.descriptor.nodeRoutingId) !== undefined && isReady(value.peer))?.peer;
     }
     selectPlacement(isReady = () => true) {
         return this.selectWeightedCycle('placement', () => [...this.peersByRid.values()]
@@ -216,7 +224,7 @@ class ServiceTopologyRegistry {
                 descriptor.activeCapacityUsed < descriptor.activeCapacityLimit &&
                 descriptor.pendingCapacityUsed < descriptor.pendingCapacityLimit);
         })
-            .map(clonePeer), (peer) => peer.descriptor.placementWeight, (peer) => peer.descriptor.nodeRoutingId, (left, right) => compareOrdinal(left.descriptor.nodeRoutingId, right.descriptor.nodeRoutingId), isReady);
+            .map(clonePeer), (peer) => peer.descriptor.placementWeight, (peer) => peer.descriptor.nodeRoutingId, (left, right) => compareOrdinal(left.descriptor.nodeRoutingId, right.descriptor.nodeRoutingId), (peer) => this.readyPeer(peer.descriptor.nodeRoutingId) !== undefined && isReady(peer));
     }
     selectObjectPlacement(stableType, isReady = () => true) {
         return this.selectObjectPlacementWithStatus(stableType, isReady).descriptor;
@@ -249,7 +257,9 @@ class ServiceTopologyRegistry {
             descriptor.pendingCapacityUsed < descriptor.pendingCapacityLimit);
         if (withCapacity.length === 0)
             return { status: 'capacity', eligible: [] };
-        const weighted = withCapacity.filter((descriptor) => descriptor.placementWeight > 0);
+        const weighted = withCapacity.filter((descriptor) => descriptor.placementWeight > 0 &&
+            (descriptor.nodeRoutingId === this.local.nodeRoutingId ||
+                this.readyPeer(descriptor.nodeRoutingId) !== undefined));
         return { status: weighted.some(isReady) ? 'available' : 'unavailable', eligible: weighted };
     }
     instanceSpotPlacementTypes() {

package/dist/runtime/foundation/service-wire-constants.generated.d.ts

@@ -110,3 +110,4 @@ export declare const ServiceWireExactTerminalByFailureCode: {
     readonly 35: 105;
 };
 export declare const isValidServiceWireTerminalFailure: (terminal: number, failureCode: number) => boolean;
+export declare function recoverRequestCorrelation(bytes: Uint8Array): bigint | undefined;

package/dist/runtime/foundation/service-wire-constants.generated.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidServiceWireTerminalFailure = exports.ServiceWireExactTerminalByFailureCode = exports.ServiceWireBoundaryTerminalResults = exports.ServiceWireFrameworkErrorCode = exports.ServiceWireFlag = exports.ServiceWireCommand = exports.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE = exports.SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME = exports.SERVICE_WIRE_REQUIRED_CAPABILITY = exports.SERVICE_WIRE_METADATA_BYTES = exports.SERVICE_WIRE_MAJOR = exports.SERVICE_WIRE_MAGIC = void 0;
+exports.recoverRequestCorrelation = recoverRequestCorrelation;
 // Generated from service-wire-v1.schema.json. Do not edit.
 exports.SERVICE_WIRE_MAGIC = [90, 77];
 exports.SERVICE_WIRE_MAJOR = 1;
@@ -132,3 +133,14 @@ const isValidServiceWireTerminalFailure = (terminal, failureCode) => {
     return exports.ServiceWireExactTerminalByFailureCode[failureCode] === terminal;
 };
 exports.isValidServiceWireTerminalFailure = isValidServiceWireTerminalFailure;
+function recoverRequestCorrelation(bytes) {
+    if (bytes.length < 13
+        || bytes[0] !== 90 || bytes[1] !== 77
+        || bytes[2] !== 1
+        || ![17, 19, 22, 25, 26, 27, 28, 38, 47, 48, 49, 54].includes(bytes[3]))
+        return undefined;
+    let correlation = 0n;
+    for (let index = 5; index < 13; ++index)
+        correlation = (correlation << 8n) | BigInt(bytes[index]);
+    return correlation === 0n ? undefined : correlation;
+}

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

@@ -78,12 +78,16 @@ export declare function decodeChannelRequestHeader(frame: Uint8Array, header?: S
 export declare function encodeReplyHeader(correlation: bigint, terminalResult?: number, failureCode?: number, tail?: Uint8Array): Buffer;
 export declare function decodeReplyHeader(frame: Uint8Array): ServiceReplyHeader;
 export declare function encodeApplicationPayload(payload: ServiceApplicationPayload): Buffer;
+/** Encodes a retained internal application frame with its own backing store. */
+export declare function encodeOwnedApplicationPayload(payload: ServiceApplicationPayload): Buffer;
 /**
  * Encodes the framework multipart payload directly into its M6A application
  * frame. The caller supplies borrowed message views; this function performs
  * the single ownership copy needed for the outbound frame.
  */
-export declare function encodeMultipartApplicationPayload(parts: readonly Uint8Array[], packetName: string, contentType: string): Buffer;
+export declare function encodeMultipartApplicationPayload(parts: readonly (Uint8Array | string)[], packetName: string, contentType: string): Buffer;
+/** Encodes bare multipart bytes with the same writer as application frames. */
+export declare function encodeMultipartPayload(parts: readonly (Uint8Array | string)[]): Buffer;
 export declare function decodeApplicationPayload(frame: Uint8Array): ServiceApplicationPayload;
 /**
  * Decodes only the M6A envelope fields and returns a view of its payload.

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

@@ -11,7 +11,9 @@ exports.decodeChannelRequestHeader = decodeChannelRequestHeader;
 exports.encodeReplyHeader = encodeReplyHeader;
 exports.decodeReplyHeader = decodeReplyHeader;
 exports.encodeApplicationPayload = encodeApplicationPayload;
+exports.encodeOwnedApplicationPayload = encodeOwnedApplicationPayload;
 exports.encodeMultipartApplicationPayload = encodeMultipartApplicationPayload;
+exports.encodeMultipartPayload = encodeMultipartPayload;
 exports.decodeApplicationPayload = decodeApplicationPayload;
 exports.decodeApplicationPayloadView = decodeApplicationPayloadView;
 exports.decodeMultipartApplicationPayloadView = decodeMultipartApplicationPayloadView;
@@ -24,6 +26,7 @@ exports.encodeReject = encodeReject;
 exports.decodeReject = decodeReject;
 exports.decodeHeader = decodeHeader;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
+const payload_slab_1 = require("../../contracts/Common/payload-slab");
 const EndpointNotation_1 = require("../../contracts/Configuration/EndpointNotation");
 const service_topology_registry_1 = require("./service-topology-registry");
 const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
@@ -141,7 +144,14 @@ function decodeReplyHeader(frame) {
     return result;
 }
 function encodeApplicationPayload(payload) {
-    const result = allocateApplicationPayload(payload.packetName, payload.contentType, payload.payload.byteLength);
+    return encodeApplicationPayloadWith(payload, payload_slab_1.allocatePayloadBytes);
+}
+/** Encodes a retained internal application frame with its own backing store. */
+function encodeOwnedApplicationPayload(payload) {
+    return encodeApplicationPayloadWith(payload, allocateOwnedPayloadBytes);
+}
+function encodeApplicationPayloadWith(payload, allocate) {
+    const result = allocateApplicationPayload(payload.packetName, payload.contentType, payload.payload.byteLength, allocate);
     result.set(payload.payload, result.byteLength - payload.payload.byteLength);
     return result;
 }
@@ -151,31 +161,52 @@ function encodeApplicationPayload(payload) {
  * the single ownership copy needed for the outbound frame.
  */
 function encodeMultipartApplicationPayload(parts, packetName, contentType) {
+    const multipartLength = multipartPayloadLength(parts);
+    const result = allocateApplicationPayload(packetName, contentType, multipartLength, payload_slab_1.allocatePayloadBytes);
+    writeMultipartPayload(result, result.byteLength - multipartLength, parts);
+    return result;
+}
+/** Encodes bare multipart bytes with the same writer as application frames. */
+function encodeMultipartPayload(parts) {
+    const result = Buffer.alloc(multipartPayloadLength(parts));
+    writeMultipartPayload(result, 0, parts);
+    return result;
+}
+function multipartPartLength(part) {
+    return typeof part === 'string' ? Buffer.byteLength(part, 'utf8') : part.byteLength;
+}
+function multipartPayloadLength(parts) {
     if (parts.length === 0)
         fail('Multipart payload must contain at least one part.');
     if (parts.length > MAX_U32)
         fail('Multipart part count exceeds u32.');
-    let multipartLength = 4;
-    for (const part of parts) {
-        if (part.byteLength > MAX_U32)
+    let length = 4;
+    for (let index = 0; index < parts.length; index += 1) {
+        const partLength = multipartPartLength(parts[index]);
+        if (partLength > MAX_U32)
             fail('Multipart part exceeds u32.');
-        multipartLength += 4 + part.byteLength;
-        if (multipartLength > MAX_U32)
+        length += 4 + partLength;
+        if (length > MAX_U32)
             fail('Multipart payload exceeds u32.');
     }
-    const result = allocateApplicationPayload(packetName, contentType, multipartLength);
-    let offset = result.byteLength - multipartLength;
+    return length;
+}
+function writeMultipartPayload(result, offset, parts) {
     result.writeUInt32BE(parts.length, offset);
     offset += 4;
-    for (const part of parts) {
-        result.writeUInt32BE(part.byteLength, offset);
+    for (let index = 0; index < parts.length; index += 1) {
+        const part = parts[index];
+        const length = multipartPartLength(part);
+        result.writeUInt32BE(length, offset);
         offset += 4;
-        result.set(part, offset);
-        offset += part.byteLength;
+        if (typeof part === 'string')
+            result.write(part, offset, length, 'utf8');
+        else
+            result.set(part, offset);
+        offset += length;
     }
-    return result;
 }
-function allocateApplicationPayload(packetName, contentType, payloadLength) {
+function allocateApplicationPayload(packetName, contentType, payloadLength, allocate) {
     const packetNameLength = (0, service_wire_binary_primitives_1.canonicalServiceWireTextLength)(packetName, 'packetName', service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES, fail);
     const contentTypeLength = (0, service_wire_binary_primitives_1.canonicalServiceWireTextLength)(contentType, 'contentType', service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES, fail);
     if (payloadLength > MAX_U32)
@@ -185,7 +216,8 @@ function allocateApplicationPayload(packetName, contentType, payloadLength) {
     const bodyLength = frameLength - prefixLength;
     if (bodyLength > MAX_U32)
         fail('Application payload body exceeds u32.');
-    const result = Buffer.alloc(frameLength);
+    // Both callers write every payload byte after these header fields.
+    const result = allocate(frameLength);
     result[0] = exports.APPLICATION_PAYLOAD_VERSION;
     result.writeUInt32BE(bodyLength, 1);
     let offset = writeText8(result, prefixLength, packetName, packetNameLength);
@@ -193,6 +225,9 @@ function allocateApplicationPayload(packetName, contentType, payloadLength) {
     result.writeUInt32BE(payloadLength, offset);
     return result;
 }
+function allocateOwnedPayloadBytes(length) {
+    return Buffer.allocUnsafeSlow(length);
+}
 function decodeApplicationPayload(frame) {
     const decoded = decodeApplicationPayloadView(frame);
     return {

package/dist/runtime/host/actor-packet-relay.d.ts

@@ -1,9 +1,10 @@
+import type { ZLinkActorSessionAuthorityFence } from '../streams/actor-session-binding-registry';
 import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import type { ActorRef, RoutingId, ZLinkRouteMessageContext, ZLinkSessionActor } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import { type ZLinkActorRoutedJoinTransport, type ZLinkRemoteActorPacketTarget, type ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { DefaultZLinkActorManager } from '../actors';
-import type { DefaultZLinkSpotManager, ZLinkSpotNodeRuntimeManager } from '../spots';
+import type { ZLinkSpotNodeRuntimeManager } from '../spots';
 import type { ZLinkDetachedTaskRunner } from '../spots/spot-actor-join-dispatch';
 import type { ZLinkBoundSessionResponsePort, ZLinkSessionBindingConfirmationOptions, ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
 import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
@@ -16,7 +17,6 @@ export interface ZLinkActorPacketRelayOptions {
     readonly streamBindingRuntime: () => ZLinkBoundSessionResponsePort & ZLinkStreamActorLookupPort;
     readonly meshRouters: MeshRouterResolver;
     readonly actorManager: () => DefaultZLinkActorManager | undefined;
-    readonly spotManager: () => DefaultZLinkSpotManager | undefined;
     readonly spotNodeRuntime: () => ZLinkSpotNodeRuntimeManager | undefined;
     readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
     readonly errorSink: () => {
@@ -30,11 +30,11 @@ export declare class ZLinkActorPacketRelay {
     private readonly options;
     private readonly targets;
     constructor(options: ZLinkActorPacketRelayOptions);
-    notifyBoundActorDisconnected(actor: ZLinkSessionActor, signal?: AbortSignal, binding?: ServiceStreamSessionBinding): Promise<void>;
+    notifyBoundActorDisconnected(actor: ZLinkSessionActor, signal?: AbortSignal, binding?: ServiceStreamSessionBinding, authorityFence?: ZLinkActorSessionAuthorityFence): Promise<void>;
     clearRemoteActorPacketTarget(actorId: string): void;
     updateRemoteActorPacketTarget(actorId: string, value: unknown): Promise<void>;
     actorPacketTargetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined;
-    notifyLocalActorDisconnectedById(actorId: string, signal?: AbortSignal, binding?: ServiceStreamSessionBinding, bindingActorRef?: ActorRef): Promise<void>;
+    notifyLocalActorDisconnectedById(actorId: string, signal?: AbortSignal, binding?: ServiceStreamSessionBinding, bindingActorRef?: ActorRef, authorityFence?: ZLinkActorSessionAuthorityFence): Promise<void>;
     receiveRemoteActorPacketRelay(payload: unknown, _routeContext: ZLinkRouteMessageContext): Promise<{
         readonly ok: boolean;
         readonly error?: unknown;
@@ -52,7 +52,7 @@ export declare class ZLinkActorPacketRelay {
      */
     private installSameNodeSessionBinding;
     relayRemoteActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message): Promise<boolean>;
-    notifyRemoteActorDisconnected(actorId: string, remoteTarget: ZLinkRemoteBoundSessionTarget | ZLinkRemoteActorPacketTarget, signal?: AbortSignal, bindingActorRef?: ActorRef, binding?: ServiceStreamSessionBinding): Promise<void>;
+    notifyRemoteActorDisconnected(actorId: string, remoteTarget: ZLinkRemoteBoundSessionTarget | ZLinkRemoteActorPacketTarget, signal?: AbortSignal, bindingActorRef?: ActorRef, binding?: ServiceStreamSessionBinding, authorityFence?: ZLinkActorSessionAuthorityFence): Promise<void>;
     private disconnectedFrame;
     private requireCurrentRemoteBinding;
     private matchesCurrentRemoteBinding;
@@ -61,5 +61,4 @@ export declare class ZLinkActorPacketRelay {
     private sendCapturedOrCurrentBoundSessionResponse;
     private sendCapturedOrCurrentBoundSessionError;
     private requireSpotNodeRuntime;
-    private requireSpotManager;
 }

package/dist/runtime/host/actor-packet-relay.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkActorPacketRelay = void 0;
+const request_result_1 = require("../messaging/request-result");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const runtime_message_1 = require("../backend/runtime-message");
 const contracts_1 = require("../../contracts");
@@ -34,14 +35,14 @@ class ZLinkActorPacketRelay {
             spotRouterChannelIdForMesh: spotRouterChannelIdByMesh?.call(options.meshRouters) ?? ((meshName) => meshName)
         });
     }
-    async notifyBoundActorDisconnected(actor, signal, binding) {
+    async notifyBoundActorDisconnected(actor, signal, binding, authorityFence) {
         // The Session binding owns this route, including after relocation and detach (§5, §7).
         const actorRefTarget = this.targets.targetForActorRef(actor.ref);
         if (actorRefTarget !== undefined) {
-            await this.notifyRemoteActorDisconnected(actor.actorId, actorRefTarget, signal, actor.ref, binding);
+            await this.notifyRemoteActorDisconnected(actor.actorId, actorRefTarget, signal, actor.ref, binding, authorityFence);
             return;
         }
-        await this.notifyLocalActorDisconnectedById(actor.actorId, signal, binding, actor.ref);
+        await this.notifyLocalActorDisconnectedById(actor.actorId, signal, binding, actor.ref, authorityFence);
     }
     clearRemoteActorPacketTarget(actorId) {
         this.targets.clear(actorId);
@@ -52,17 +53,17 @@ class ZLinkActorPacketRelay {
     actorPacketTargetForState(actorId) {
         return this.targets.targetForState(actorId);
     }
-    async notifyLocalActorDisconnectedById(actorId, signal, binding, bindingActorRef) {
+    async notifyLocalActorDisconnectedById(actorId, signal, binding, bindingActorRef, authorityFence) {
         (0, abort_1.throwIfAborted)(signal);
-        const state = this.options.actorManager()?.getState(actorId);
         const frame = this.disconnectedFrame(actorId, binding);
         const header = runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(frame.header));
         const body = runtime_message_1.ZLinkBufferMessage.fromOwned(frame.payload);
         try {
-            if (state?.spotId === undefined)
-                await this.requireSpotNodeRuntime().dispatchEntryActorPacket('local', actorId, [header, body], false, undefined, bindingActorRef);
-            else
-                await this.requireSpotManager().dispatchRoutedActorPacket('local', state.spotId, actorId, [header, body], false, undefined, bindingActorRef);
+            const context = sessionActorFollowContext(bindingActorRef, authorityFence, [header, body], false);
+            const ref = context === undefined || bindingActorRef === undefined
+                ? bindingActorRef
+                : (0, actor_message_follow_context_1.attachActorMessageFollowContext)(bindingActorRef, context);
+            await this.requireSpotNodeRuntime().dispatchEntryActorPacket('local', actorId, [header, body], false, undefined, ref);
         }
         finally {
             header.close();
@@ -138,12 +139,9 @@ class ZLinkActorPacketRelay {
                 frameHeader.name !== actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
                 this.requireCurrentRemoteBinding(relay, _routeContext);
             }
-            const state = this.options.actorManager()?.getState(relay.actorId);
             if (frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Send ||
                 frameHeader.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
-                const dispatch = state?.spotId === undefined
-                    ? this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef)
-                    : this.requireSpotManager().dispatchRoutedActorPacket('remote', state.spotId, relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef);
+                const dispatch = this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef);
                 if (frameHeader.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
                     await dispatch;
                     return {
@@ -182,9 +180,7 @@ class ZLinkActorPacketRelay {
             if (frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Request &&
                 frameHeader.requestSeq !== undefined &&
                 relay.returnResponse !== true) {
-                const dispatch = state?.spotId === undefined
-                    ? this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef)
-                    : this.requireSpotManager().dispatchRoutedActorPacket('remote', state.spotId, relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef);
+                const dispatch = this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef);
                 closeFrameMessages = false;
                 const deferredPacketName = frameHeader.name;
                 const deferredRequestSeq = frameHeader.requestSeq;
@@ -224,9 +220,7 @@ class ZLinkActorPacketRelay {
                     actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
                 };
             }
-            const response = state?.spotId === undefined
-                ? await this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], relay.returnResponse === true, remoteBoundSessionTarget, fallbackActorRef)
-                : await this.requireSpotManager().dispatchRoutedActorPacket('remote', state.spotId, relay.actorId, [header, body], relay.returnResponse === true, remoteBoundSessionTarget, fallbackActorRef);
+            const response = await this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], relay.returnResponse === true, remoteBoundSessionTarget, fallbackActorRef);
             return {
                 ok: true,
                 response,
@@ -354,21 +348,9 @@ class ZLinkActorPacketRelay {
         const header = runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(encodedHeader.buffer, encodedHeader.byteOffset, encodedHeader.byteLength));
         let request;
         try {
-            const authority = aggregateRoute?.authorityFence;
-            const messageFollowContext = authority?.ownerId === undefined || authority.ownerNodeGeneration === undefined
-                ? undefined
-                : (0, actor_message_follow_context_1.createInitialActorMessageFollowContext)({
-                    meshName: storedActorRef.meshName,
-                    actorRef: storedActorRef,
-                    actorType: authority.actorType ?? '',
-                    ownerNodeGeneration: authority.ownerNodeGeneration,
-                    ownerId: authority.ownerId,
-                    ownerLeaseGeneration: authority.ownerLeaseGeneration,
-                    authorityOwnerGeneration: authority.authorityOwnerGeneration,
-                    authorityStoreVersion: authority.authorityStoreVersion ?? ''
-                }, [header, payload], returnResponse, undefined, isValidMessageFollowId(frameHeader.correlationId)
-                    ? frameHeader.correlationId
-                    : (0, actor_message_follow_context_1.createMessageFollowId)());
+            const messageFollowContext = sessionActorFollowContext(storedActorRef, aggregateRoute?.authorityFence, [header, payload], returnResponse, isValidMessageFollowId(frameHeader.correlationId)
+                ? frameHeader.correlationId
+                : (0, actor_message_follow_context_1.createMessageFollowId)());
             request = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketRelayPayload)({
                 actorId: actor.actorId,
                 routerChannelId: remoteTarget.routerChannelId,
@@ -445,20 +427,32 @@ class ZLinkActorPacketRelay {
         }
         return true;
     }
-    async notifyRemoteActorDisconnected(actorId, remoteTarget, signal, bindingActorRef, binding) {
+    async notifyRemoteActorDisconnected(actorId, remoteTarget, signal, bindingActorRef, binding, authorityFence) {
         const spotKind = 'spotKind' in remoteTarget ? remoteTarget.spotKind : undefined;
         const frame = this.disconnectedFrame(actorId, binding, 'sessionNodeRid' in remoteTarget ? remoteTarget : undefined);
-        const payload = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketRelayPayload)({
-            actorId,
-            routerChannelId: remoteTarget.routerChannelId,
-            bindingActorRef,
-            ...frame
-        });
+        const parts = [
+            runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(frame.header)),
+            runtime_message_1.ZLinkBufferMessage.fromOwned(frame.payload)
+        ];
+        let payload;
+        try {
+            payload = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketRelayPayload)({
+                actorId,
+                routerChannelId: remoteTarget.routerChannelId,
+                bindingActorRef,
+                messageFollowContext: sessionActorFollowContext(bindingActorRef, authorityFence, parts, false),
+                ...frame
+            });
+        }
+        finally {
+            for (const part of parts)
+                part.close();
+        }
         if ((spotKind ?? contracts_1.ZLinkSpotKind.Entry) === contracts_1.ZLinkSpotKind.Entry) {
-            await this.options.routeTransport.request(remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, payload, this.options.requestTimeoutMs, signal);
+            await (0, request_result_1.mapZLinkRequestReply)(this.options.routeTransport.request(remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, payload, this.options.requestTimeoutMs, signal));
             return;
         }
-        await this.options.routeTransport.requestToSpot({
+        await (0, request_result_1.mapZLinkRequestReply)(this.options.routeTransport.requestToSpot({
             routerChannelId: remoteTarget.routerChannelId,
             targetNodeRid: remoteTarget.targetNodeRid,
             spotId: remoteTarget.spotId,
@@ -467,7 +461,7 @@ class ZLinkActorPacketRelay {
             packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
             timeoutMs: this.options.requestTimeoutMs,
             signal
-        });
+        }));
     }
     disconnectedFrame(actorId, binding, target) {
         const current = binding === undefined
@@ -502,7 +496,7 @@ class ZLinkActorPacketRelay {
     async requestRemoteTarget(target, request, unavailableMessage, decodeReply, signal) {
         if (target.spotKind === contracts_1.ZLinkSpotKind.Entry) {
             try {
-                return await this.options.routeTransport.request(target.routerChannelId, String(target.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, request, this.options.requestTimeoutMs, signal);
+                return await (0, request_result_1.mapZLinkRequestReply)(this.options.routeTransport.request(target.routerChannelId, String(target.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, request, this.options.requestTimeoutMs, signal));
             }
             catch (error) {
                 if (!(error instanceof ConfigurationException_1.ZLinkConfigurationException)) {
@@ -514,12 +508,10 @@ class ZLinkActorPacketRelay {
     }
     async relayLocalActorPacket(actor, frameHeader, payload) {
         const state = this.options.actorManager()?.getState(actor.actorId);
-        const spotId = state?.spotId;
-        const hasActiveSpot = spotId !== undefined && this.options.spotManager()?.hasActiveSpot(spotId) === true;
-        if (!hasActiveSpot) {
+        if (state === undefined) {
             return false;
         }
-        const actorRef = state?.nativeActorRef;
+        const actorRef = state.nativeActorRef;
         const localNode = this.options.spotNodeRuntime()?.primaryMeshNode;
         const localNodeRid = localNode === undefined ? undefined : String(localNode.status().routingId);
         if (actorRef?.nodeRid !== undefined &&
@@ -538,7 +530,7 @@ class ZLinkActorPacketRelay {
         try {
             this.options.detachedTaskRunner.runDetached('local actor packet relay', async () => {
                 try {
-                    const response = await this.requireSpotManager().dispatchRoutedActorPacket('local', spotId, actor.actorId, [header, body], returnResponse);
+                    const response = await this.requireSpotNodeRuntime().dispatchEntryActorPacket('local', actor.actorId, [header, body], returnResponse, undefined, actor.ref);
                     if (!returnResponse) {
                         return;
                     }
@@ -590,13 +582,6 @@ class ZLinkActorPacketRelay {
         }
         return runtime;
     }
-    requireSpotManager() {
-        const manager = this.options.spotManager();
-        if (manager === undefined) {
-            throw new Error('SPOT manager runtime is not started.');
-        }
-        return manager;
-    }
 }
 exports.ZLinkActorPacketRelay = ZLinkActorPacketRelay;
 function isValidMessageFollowId(value) {
@@ -608,3 +593,19 @@ function withDefaultSpotKind(target) {
         ? { ...target, spotKind: contracts_1.ZLinkSpotKind.Entry }
         : target;
 }
+function sessionActorFollowContext(actorRef, authority, parts, request, operationId) {
+    if (actorRef === undefined ||
+        authority?.ownerId === undefined ||
+        authority.ownerNodeGeneration === undefined)
+        return undefined;
+    return (0, actor_message_follow_context_1.createInitialActorMessageFollowContext)({
+        meshName: actorRef.meshName,
+        actorRef,
+        actorType: authority.actorType ?? '',
+        ownerNodeGeneration: authority.ownerNodeGeneration,
+        ownerId: authority.ownerId,
+        ownerLeaseGeneration: authority.ownerLeaseGeneration,
+        authorityOwnerGeneration: authority.authorityOwnerGeneration,
+        authorityStoreVersion: authority.authorityStoreVersion ?? ''
+    }, parts, request, undefined, operationId);
+}

package/dist/runtime/host/actor-placement-coordinator.d.ts

@@ -21,7 +21,7 @@ export interface ZLinkActorPlacementCoordinatorOptions {
     readonly decodeRemoteReply?: (payload: Uint8Array) => unknown;
 }
 export declare class ZLinkActorPlacementCoordinator {
-    private readonly options;
+    readonly options: ZLinkActorPlacementCoordinatorOptions;
     constructor(options: ZLinkActorPlacementCoordinatorOptions);
     create(actorId: string, stableType: string, createOnly: boolean, meshName: string | undefined, requestPayload: Uint8Array, timeoutMs: number, signal?: AbortSignal): Promise<ZLinkActorCreateResult>;
     handleRemoteCreate(record: ServiceActorCreateRecord, materialize: (requestPayload: Uint8Array, authority: ZLinkAuthoritySnapshot, signal: AbortSignal) => Promise<{

package/dist/runtime/host/actor-runtime-options-factory.d.ts

@@ -1,3 +1,4 @@
+import type { RequestRuntime } from '../foundation/request-runtime';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkMessage } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import { type ZLinkBackendMeshNode, type ZLinkMeshCompletionTable } from '../backend';
@@ -15,6 +16,7 @@ import type { ZLinkRuntimeAdmissionGate } from '../admission';
 import type { ZLinkRemoteActorPacketTarget } from '../actors';
 import type { ZLinkActorJoinRelocation } from '../actors/actor-join-relocation';
 export interface ZLinkActorRuntimeOptionsFactoryOptions {
+    readonly requests?: RequestRuntime;
     readonly terminateActorActivation: (actor: ZLinkActor, terminal: () => Promise<void>) => Promise<void>;
     readonly registration: ZLinkFrameworkRegistration;
     /** Message flow tracer, so a failed deferred Join records its cause on the flow. */

package/dist/runtime/host/actor-runtime-options-factory.js

@@ -139,6 +139,7 @@ class ZLinkActorRuntimeOptionsFactory {
     createActorClientOptions() {
         const locationResolver = this.options.createActorLocationResolver();
         return {
+            requests: this.options.requests,
             nodeProvider: this.options.meshNode,
             completionTableProvider: this.options.meshCompletions,
             locationResolver: () => locationResolver,
@@ -149,9 +150,9 @@ class ZLinkActorRuntimeOptionsFactory {
             staleActorRefReporter: (_meshName, actorId) => this.options.actorHandoff.recordStaleFailure(actorId),
             staleActorRefPredicate: (meshName, actor) => this.actorBelongsToMesh(meshName, actor.actorId) &&
                 this.options.actorHandoff.isKnownStale(actor),
-            handoffCapture: (meshName, actorId, parts, returnResponse, actor, deadlineUnixMs, onAdmitted) => this.actorBelongsToMesh(meshName, actorId) &&
+            handoffCapture: (meshName, actorId, parts, returnResponse, actor, deadlineUnixMs, onAdmitted, requestOperation) => this.actorBelongsToMesh(meshName, actorId) &&
                 !this.options.actorHandoff.isProvisional(actorId)
-                ? this.options.actorHandoff.capture('local', actorId, parts, returnResponse, undefined, actor, deadlineUnixMs, undefined, undefined, onAdmitted)
+                ? this.options.actorHandoff.capture('local', actorId, parts, returnResponse, undefined, actor, deadlineUnixMs, undefined, undefined, onAdmitted, requestOperation)
                 : undefined,
             sendErrorReporter: this.options.reportPostCommitError
         };

package/dist/runtime/host/actor-transfer-runtime.d.ts

@@ -90,8 +90,8 @@ export declare class ZLinkActorTransferRuntime {
     completeRelocationSourceLeave(actor: ZLinkActor, sourceSpotId: RoutingId | undefined, signal?: AbortSignal): Promise<void>;
     relayMaintenanceTerminal(actorId: string, packet: ZLinkActorHandoffPacket, result: ZLinkActorHandoffResult, sourceNodeRid: RoutingId, targetAuthorityOwnerGeneration?: bigint): ZLinkActorHandoffTerminalAck;
     relayCanonicalMaintenanceTerminal(operationId: string, replyRouteId: string, result: ZLinkActorHandoffResult, sourceNodeRid: RoutingId, targetAuthorityOwnerGeneration?: bigint): ZLinkActorHandoffTerminalAcceptance;
-    private sealBoundSessionRoute;
-    private abortBoundSessionRouteSeal;
+    sealBoundSessionRoute(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, relocation?: ServiceWireOperationId, relocationTarget?: Pick<ZLinkMeshNodeDescriptor, 'rid' | 'lifecycleGeneration'>): Promise<ZLinkRemoteBoundSessionTarget | undefined>;
+    abortBoundSessionRouteSeal(actor: ZLinkActor, state: ZLinkActorRuntimeState, target: ZLinkRemoteBoundSessionTarget): Promise<void>;
     private observeBoundSessionSealAbort;
     getOrCreateRoutedActor(actorId: string, actorType: string, actorRef?: ActorRef, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, actorCreateRequest?: Message, signal?: AbortSignal): Promise<{
         readonly actor: ZLinkActor;
@@ -120,6 +120,6 @@ export declare class ZLinkActorTransferRuntime {
     rollbackRoutedActor(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     actorEntryNodeRid(actor: ZLinkActor): RoutingId | undefined;
     private requireActorManager;
-    private publishBoundSessionOwnership;
+    publishBoundSessionOwnership(actorId: string, actorRef: ZLinkBackendActorRef, ownershipGeneration: bigint, target: ZLinkRemoteBoundSessionTarget | undefined, targetOwnerLeaseGeneration: bigint | undefined): Promise<void>;
 }
 export {};