@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/streams/native-fallback-bound-session.js

@@ -99,9 +99,8 @@ class ZLinkNativeFallbackBoundSessionSendCall {
     async executeScoped(packetName, signal) {
         const localActor = this.options.localActorProvider?.() === true;
         const remoteTarget = this.options.remoteBoundSessionTargetProvider();
-        const sealedRemoteTarget = remoteTarget?.relocationSealId !== undefined;
         let nativeAttempted = false;
-        if (localActor && !sealedRemoteTarget) {
+        if (localActor) {
             const result = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
             if (result.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                 this.traceSubmitted(result, packetName);
@@ -136,7 +135,6 @@ class ZLinkNativeFallbackBoundSessionSendCall {
                 actorNodeRidHex: actorRef?.nodeRid?.toHex?.(),
                 actorGeneration: actorRef?.objectGeneration.toString(),
                 actorOwnershipGeneration: ownershipGeneration?.toString(),
-                relocationSealId: remoteTarget.relocationSealId,
                 message: this.message,
                 boundPacketName: packetName,
                 metadata: this.selectedMetadata,

package/dist/runtime/streams/protocol.d.ts

@@ -1,40 +1,13 @@
-import type { Message } from '../../contracts/Common/Message';
+import { ZlinkStreamCloseReasonCode as ZLinkStreamCloseReasonCode, ZlinkStreamCodec as ZLinkStreamCodec, ZlinkStreamHeaderFlags as ZLinkStreamHeaderFlags, ZlinkStreamMessageKind as ZLinkStreamMessageKind } from '@zlink-systems/stream-wire';
 import type { ZLinkFlowOrigin } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+export { ZlinkStreamMessageKind as ZLinkStreamMessageKind, ZlinkStreamHeaderFlags as ZLinkStreamHeaderFlags, ZlinkStreamCloseReasonCode as ZLinkStreamCloseReasonCode } from '@zlink-systems/stream-wire';
 export { utf8Decode, utf8Encode } from '@zlink-systems/stream-wire';
-export declare enum ZLinkStreamCodec {
-    Raw = 0,
-    Json = 1,
-    MessagePack = 2,
-    Protobuf = 3
-}
+export { ZlinkStreamCodec as ZLinkStreamCodec } from '@zlink-systems/stream-wire';
 export declare function streamCodecContentType(codec: ZLinkStreamCodec): string;
 export declare function streamCodecForContentType(contentType: string): ZLinkStreamCodec;
-export declare enum ZLinkStreamMessageKind {
-    Send = 1,
-    Request = 2,
-    Response = 3,
-    Error = 4,
-    Control = 5
-}
-export declare enum ZLinkStreamHeaderFlags {
-    None = 0,
-    HasRequestSeq = 1,
-    HasMetadata = 2,
-    PayloadCompressed = 4,
-    HasCorrelationId = 8,
-    HasFlowId = 16,
-    HasActorSlot = 32
-}
-export declare enum ZLinkStreamCloseReasonCode {
-    ClientClose = 1,
-    IdleTimeout = 2,
-    HeartbeatTimeout = 3,
-    ServerDrain = 4,
-    ProtocolError = 5,
-    TransportError = 6
-}
-export declare const ZLINK_STREAM_HEARTBEAT_PING = "$zlink.heartbeat.ping";
-export declare const ZLINK_STREAM_HEARTBEAT_PONG = "$zlink.heartbeat.pong";
+export declare const ZLINK_STREAM_HEARTBEAT_PING: "$zlink.heartbeat.ping";
+export declare const ZLINK_STREAM_HEARTBEAT_PONG: "$zlink.heartbeat.pong";
 export interface ZLinkStreamFrameHeader {
     readonly kind: ZLinkStreamMessageKind;
     readonly codec: ZLinkStreamCodec;

package/dist/runtime/streams/protocol.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLINK_STREAM_HEARTBEAT_PONG = exports.ZLINK_STREAM_HEARTBEAT_PING = exports.ZLinkStreamCloseReasonCode = exports.ZLinkStreamHeaderFlags = exports.ZLinkStreamMessageKind = exports.ZLinkStreamCodec = exports.utf8Encode = exports.utf8Decode = void 0;
+exports.ZLINK_STREAM_HEARTBEAT_PONG = exports.ZLINK_STREAM_HEARTBEAT_PING = exports.ZLinkStreamCodec = exports.utf8Encode = exports.utf8Decode = exports.ZLinkStreamCloseReasonCode = exports.ZLinkStreamHeaderFlags = exports.ZLinkStreamMessageKind = void 0;
 exports.streamCodecContentType = streamCodecContentType;
 exports.streamCodecForContentType = streamCodecForContentType;
 exports.resolvePacketName = resolvePacketName;
@@ -20,79 +20,30 @@ exports.createStreamReplyHeader = createStreamReplyHeader;
 exports.messageToBytes = messageToBytes;
 exports.lz4Pickle = lz4Pickle;
 exports.lz4Unpickle = lz4Unpickle;
-const packet_name_1 = require("../messaging/packet-name");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
+const packet_name_1 = require("../messaging/packet-name");
 const submission_result_1 = require("../messaging/submission-result");
 var stream_wire_2 = require("@zlink-systems/stream-wire");
-Object.defineProperty(exports, "utf8Decode", { enumerable: true, get: function () { return stream_wire_2.utf8Decode; } });
-Object.defineProperty(exports, "utf8Encode", { enumerable: true, get: function () { return stream_wire_2.utf8Encode; } });
-const defaultMaxDecompressedPayloadSize = 64 * 1024;
+Object.defineProperty(exports, "ZLinkStreamMessageKind", { enumerable: true, get: function () { return stream_wire_2.ZlinkStreamMessageKind; } });
+Object.defineProperty(exports, "ZLinkStreamHeaderFlags", { enumerable: true, get: function () { return stream_wire_2.ZlinkStreamHeaderFlags; } });
+Object.defineProperty(exports, "ZLinkStreamCloseReasonCode", { enumerable: true, get: function () { return stream_wire_2.ZlinkStreamCloseReasonCode; } });
+var stream_wire_3 = require("@zlink-systems/stream-wire");
+Object.defineProperty(exports, "utf8Decode", { enumerable: true, get: function () { return stream_wire_3.utf8Decode; } });
+Object.defineProperty(exports, "utf8Encode", { enumerable: true, get: function () { return stream_wire_3.utf8Encode; } });
 const actorRequestDeadlineMetadataKey = '$zlink.actor-request-deadline-unix-ms';
 //  Shared empty metadata for the dominant no-metadata frame; ReadonlyMap
 //  keeps every consumer from mutating it.
 const EMPTY_STREAM_METADATA = new Map();
-var ZLinkStreamCodec;
-(function (ZLinkStreamCodec) {
-    ZLinkStreamCodec[ZLinkStreamCodec["Raw"] = 0] = "Raw";
-    ZLinkStreamCodec[ZLinkStreamCodec["Json"] = 1] = "Json";
-    ZLinkStreamCodec[ZLinkStreamCodec["MessagePack"] = 2] = "MessagePack";
-    ZLinkStreamCodec[ZLinkStreamCodec["Protobuf"] = 3] = "Protobuf";
-})(ZLinkStreamCodec || (exports.ZLinkStreamCodec = ZLinkStreamCodec = {}));
+var stream_wire_4 = require("@zlink-systems/stream-wire");
+Object.defineProperty(exports, "ZLinkStreamCodec", { enumerable: true, get: function () { return stream_wire_4.ZlinkStreamCodec; } });
 function streamCodecContentType(codec) {
-    switch (codec) {
-        case ZLinkStreamCodec.Json:
-            return 'application/json';
-        case ZLinkStreamCodec.MessagePack:
-            return 'application/x-msgpack';
-        case ZLinkStreamCodec.Protobuf:
-            return 'application/x-protobuf';
-        case ZLinkStreamCodec.Raw:
-            return 'application/octet-stream';
-    }
-    throw new TypeError(`Unsupported STREAM codec '${codec}'.`);
+    return (0, stream_wire_1.streamCodecContentType)(codec);
 }
 function streamCodecForContentType(contentType) {
-    switch (contentType) {
-        case 'application/json':
-            return ZLinkStreamCodec.Json;
-        case 'application/x-msgpack':
-            return ZLinkStreamCodec.MessagePack;
-        case 'application/x-protobuf':
-            return ZLinkStreamCodec.Protobuf;
-        case 'application/octet-stream':
-            return ZLinkStreamCodec.Raw;
-    }
-    throw new TypeError(`Unsupported STREAM content type '${contentType}'.`);
+    return (0, stream_wire_1.streamCodecForContentType)(contentType);
 }
-var ZLinkStreamMessageKind;
-(function (ZLinkStreamMessageKind) {
-    ZLinkStreamMessageKind[ZLinkStreamMessageKind["Send"] = 1] = "Send";
-    ZLinkStreamMessageKind[ZLinkStreamMessageKind["Request"] = 2] = "Request";
-    ZLinkStreamMessageKind[ZLinkStreamMessageKind["Response"] = 3] = "Response";
-    ZLinkStreamMessageKind[ZLinkStreamMessageKind["Error"] = 4] = "Error";
-    ZLinkStreamMessageKind[ZLinkStreamMessageKind["Control"] = 5] = "Control";
-})(ZLinkStreamMessageKind || (exports.ZLinkStreamMessageKind = ZLinkStreamMessageKind = {}));
-var ZLinkStreamHeaderFlags;
-(function (ZLinkStreamHeaderFlags) {
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["None"] = 0] = "None";
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["HasRequestSeq"] = 1] = "HasRequestSeq";
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["HasMetadata"] = 2] = "HasMetadata";
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["PayloadCompressed"] = 4] = "PayloadCompressed";
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["HasCorrelationId"] = 8] = "HasCorrelationId";
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["HasFlowId"] = 16] = "HasFlowId";
-    ZLinkStreamHeaderFlags[ZLinkStreamHeaderFlags["HasActorSlot"] = 32] = "HasActorSlot";
-})(ZLinkStreamHeaderFlags || (exports.ZLinkStreamHeaderFlags = ZLinkStreamHeaderFlags = {}));
-var ZLinkStreamCloseReasonCode;
-(function (ZLinkStreamCloseReasonCode) {
-    ZLinkStreamCloseReasonCode[ZLinkStreamCloseReasonCode["ClientClose"] = 1] = "ClientClose";
-    ZLinkStreamCloseReasonCode[ZLinkStreamCloseReasonCode["IdleTimeout"] = 2] = "IdleTimeout";
-    ZLinkStreamCloseReasonCode[ZLinkStreamCloseReasonCode["HeartbeatTimeout"] = 3] = "HeartbeatTimeout";
-    ZLinkStreamCloseReasonCode[ZLinkStreamCloseReasonCode["ServerDrain"] = 4] = "ServerDrain";
-    ZLinkStreamCloseReasonCode[ZLinkStreamCloseReasonCode["ProtocolError"] = 5] = "ProtocolError";
-    ZLinkStreamCloseReasonCode[ZLinkStreamCloseReasonCode["TransportError"] = 6] = "TransportError";
-})(ZLinkStreamCloseReasonCode || (exports.ZLinkStreamCloseReasonCode = ZLinkStreamCloseReasonCode = {}));
-exports.ZLINK_STREAM_HEARTBEAT_PING = '$zlink.heartbeat.ping';
-exports.ZLINK_STREAM_HEARTBEAT_PONG = '$zlink.heartbeat.pong';
+exports.ZLINK_STREAM_HEARTBEAT_PING = stream_wire_1.ZlinkStreamControlPacket.HeartbeatPing;
+exports.ZLINK_STREAM_HEARTBEAT_PONG = stream_wire_1.ZlinkStreamControlPacket.HeartbeatPong;
 function resolvePacketName(message, explicitPacketName) {
     const packetName = (0, packet_name_1.resolveFrameworkPacketName)(message, explicitPacketName, 'Stream');
     if (packetName.trim().length === 0) {
@@ -110,50 +61,27 @@ function encodeStreamFrame(header, payload) {
 }
 function encodeStreamControlFrame(name) {
     return encodeStreamFrame({
-        kind: ZLinkStreamMessageKind.Control,
-        codec: ZLinkStreamCodec.Raw,
-        flags: ZLinkStreamHeaderFlags.None,
+        kind: stream_wire_1.ZlinkStreamMessageKind.Control,
+        codec: stream_wire_1.ZlinkStreamCodec.Raw,
+        flags: stream_wire_1.ZlinkStreamHeaderFlags.None,
         name,
         metadata: EMPTY_STREAM_METADATA
     }, new Uint8Array());
 }
 function encodeActorBoundFrame(actorSlot, actorId) {
-    const actorIdBytes = (0, stream_wire_1.utf8Encode)(actorId);
-    if (actorIdBytes.length < 1 || actorIdBytes.length > 0xff) {
-        throw new Error('Actor id length is invalid for a STREAM binding control packet.');
-    }
-    const payload = new Uint8Array(4 + actorIdBytes.length);
-    payload[0] = 1;
-    payload[1] = actorSlot >>> 8;
-    payload[2] = actorSlot & 0xff;
-    payload[3] = actorIdBytes.length;
-    payload.set(actorIdBytes, 4);
-    return encodeStreamFrame(controlHeader('$zlink.actor.bound'), payload);
+    return encodeStreamFrame(controlHeader(stream_wire_1.ZlinkStreamControlPacket.ActorBound), (0, stream_wire_1.encodeStreamWireActorBoundPayload)(actorSlot, actorId));
 }
 function encodeActorUnboundFrame(actorSlot) {
-    const payload = new Uint8Array(3);
-    payload[0] = 1;
-    payload[1] = actorSlot >>> 8;
-    payload[2] = actorSlot & 0xff;
-    return encodeStreamFrame(controlHeader('$zlink.actor.unbound'), payload);
+    return encodeStreamFrame(controlHeader(stream_wire_1.ZlinkStreamControlPacket.ActorUnbound), (0, stream_wire_1.encodeStreamWireActorUnboundPayload)(actorSlot));
 }
-function encodeSessionClosingFrame(diagnostic = '', reason = ZLinkStreamCloseReasonCode.ServerDrain) {
-    const diagnosticBytes = (0, stream_wire_1.utf8Encode)(diagnostic);
-    if (diagnosticBytes.length > 512)
-        throw new Error('Session-closing diagnostic is too large.');
-    const payload = new Uint8Array(4 + diagnosticBytes.length);
-    payload[0] = 1;
-    payload[1] = reason;
-    payload[2] = diagnosticBytes.length >>> 8;
-    payload[3] = diagnosticBytes.length & 0xff;
-    payload.set(diagnosticBytes, 4);
+function encodeSessionClosingFrame(diagnostic = '', reason = stream_wire_1.ZlinkStreamCloseReasonCode.ServerDrain) {
     return encodeStreamFrame({
-        kind: ZLinkStreamMessageKind.Control,
-        codec: ZLinkStreamCodec.Raw,
-        flags: ZLinkStreamHeaderFlags.None,
-        name: 'session-closing',
+        kind: stream_wire_1.ZlinkStreamMessageKind.Control,
+        codec: stream_wire_1.ZlinkStreamCodec.Raw,
+        flags: stream_wire_1.ZlinkStreamHeaderFlags.None,
+        name: stream_wire_1.ZlinkStreamControlPacket.SessionClosing,
         metadata: new Map()
-    }, payload);
+    }, (0, stream_wire_1.encodeStreamWireSessionClosingPayload)(reason, diagnostic));
 }
 function decodeStreamFrame(frame) {
     return (0, stream_wire_1.decodeStreamWireFrame)(frame);
@@ -167,7 +95,7 @@ function encodeStreamHeader(header) {
     const hasCorrelation = header.correlationId !== undefined && header.correlationId.length > 0;
     const hasFlow = header.flowId !== undefined || header.flowOrigin !== undefined;
     const hasActorSlot = header.actorSlot !== undefined;
-    if (header.kind === ZLinkStreamMessageKind.Control &&
+    if (header.kind === stream_wire_1.ZlinkStreamMessageKind.Control &&
         (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)) {
         throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
     }
@@ -190,12 +118,12 @@ function decodeStreamHeader(header, flowEnabled = true) {
     const decoded = (0, stream_wire_1.decodeStreamWireHeader)(header, undefined, flowEnabled);
     const kind = decoded.kind;
     const flags = decoded.flags;
-    const hasRequestSeq = (flags & ZLinkStreamHeaderFlags.HasRequestSeq) !== 0;
-    const hasMetadata = (flags & ZLinkStreamHeaderFlags.HasMetadata) !== 0;
-    const hasCorrelation = (flags & ZLinkStreamHeaderFlags.HasCorrelationId) !== 0;
-    const hasFlow = (flags & ZLinkStreamHeaderFlags.HasFlowId) !== 0;
-    const hasActorSlot = (flags & ZLinkStreamHeaderFlags.HasActorSlot) !== 0;
-    if (kind === ZLinkStreamMessageKind.Control &&
+    const hasRequestSeq = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasRequestSeq) !== 0;
+    const hasMetadata = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasMetadata) !== 0;
+    const hasCorrelation = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasCorrelationId) !== 0;
+    const hasFlow = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasFlowId) !== 0;
+    const hasActorSlot = (flags & stream_wire_1.ZlinkStreamHeaderFlags.HasActorSlot) !== 0;
+    if (kind === stream_wire_1.ZlinkStreamMessageKind.Control &&
         (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)) {
         throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
     }
@@ -203,8 +131,8 @@ function decodeStreamHeader(header, flowEnabled = true) {
     return {
         kind,
         codec: decoded.codec,
-        flags: (metadata.size === 0 ? flags & ~ZLinkStreamHeaderFlags.HasMetadata : flags) &
-            (flowEnabled ? ~0 : ~ZLinkStreamHeaderFlags.HasFlowId),
+        flags: (metadata.size === 0 ? flags & ~stream_wire_1.ZlinkStreamHeaderFlags.HasMetadata : flags) &
+            (flowEnabled ? ~0 : ~stream_wire_1.ZlinkStreamHeaderFlags.HasFlowId),
         requestSeq: decoded.requestSeq,
         name: decoded.name,
         metadata,
@@ -254,9 +182,9 @@ function createStreamReplyHeader(requestHeader, kind, codec, flags, metadata, in
 }
 function controlHeader(name) {
     return {
-        kind: ZLinkStreamMessageKind.Control,
-        codec: ZLinkStreamCodec.Raw,
-        flags: ZLinkStreamHeaderFlags.None,
+        kind: stream_wire_1.ZlinkStreamMessageKind.Control,
+        codec: stream_wire_1.ZlinkStreamCodec.Raw,
+        flags: stream_wire_1.ZlinkStreamHeaderFlags.None,
         name,
         metadata: EMPTY_STREAM_METADATA
     };
@@ -287,6 +215,6 @@ function messageToBytes(message) {
 function lz4Pickle(payload) {
     return (0, stream_wire_1.lz4PickleUncompressed)(payload);
 }
-function lz4Unpickle(payload, maxDecompressedSize = defaultMaxDecompressedPayloadSize) {
+function lz4Unpickle(payload, maxDecompressedSize = stream_wire_1.defaultMaxDecompressedPayloadSize) {
     return (0, stream_wire_1.lz4UnpicklePayload)(payload, maxDecompressedSize);
 }

package/dist/runtime/streams/session-actor-coordinator.d.ts

@@ -3,6 +3,7 @@ import type { ZLinkRuntimeMetrics } from '../diagnostics';
 import { ZLinkActorSessionBindingRegistry, type ZLinkActorSessionAuthorityFence } from './actor-session-binding-registry';
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
+import type { ZLinkSessionBindingConfirmationOptions } from './stream-binding-runtime-ports';
 export interface ZLinkSessionActorCoordinatorOptions {
     readonly actorBindTimeoutMs?: number;
     readonly actorRefResolver?: (actor: ZLinkActor) => ActorRef;
@@ -13,9 +14,7 @@ export interface ZLinkSessionActorCoordinatorOptions {
         };
     } | undefined;
     readonly nativeActorMeshNameProvider?: () => string | undefined;
-    readonly confirmRemoteActorSessionBinding?: (actor: ActorRef, sessionRid: ActorRef['nodeRid'], signal?: AbortSignal, options?: {
-        readonly waitForAcknowledgement?: boolean;
-    }) => Promise<void>;
+    readonly confirmRemoteActorSessionBinding?: (actor: ActorRef, sessionRid: ActorRef['nodeRid'], signal?: AbortSignal, options?: ZLinkSessionBindingConfirmationOptions) => Promise<void>;
     readonly errorSink?: () => {
         reportRuntimeTaskException(taskName: string, error: unknown): void;
     } | undefined;

package/dist/runtime/streams/session-actor-coordinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSessionActorCoordinator = void 0;
+const bound_actor_relay_sender_1 = require("./bound-actor-relay-sender");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const contracts_1 = require("../../contracts");
 const abort_1 = require("../abort");
@@ -75,7 +76,12 @@ class ZLinkSessionActorCoordinator {
         if (confirmRemoteSessionBinding !== false &&
             this.options.confirmRemoteActorSessionBinding !== undefined) {
             const waitForAcknowledgement = previous === undefined && confirmRemoteSessionBinding !== 'send';
-            const confirmation = this.options.confirmRemoteActorSessionBinding(boundActorRef, this.actorBindingRoutingId(context), undefined, { waitForAcknowledgement });
+            const confirmation = this.options.confirmRemoteActorSessionBinding(boundActorRef, this.actorBindingRoutingId(context), undefined, {
+                waitForAcknowledgement,
+                binding: context.stream instanceof managed_stream_1.ZLinkManagedStream
+                    ? context.stream.actorBinding(actorRef.actorId)
+                    : undefined
+            });
             const reportFailure = (error) => {
                 // A fire-and-forget route update retains the already-current binding;
                 // its failure is bounded diagnostics rather than a rollback. The
@@ -96,7 +102,7 @@ class ZLinkSessionActorCoordinator {
                     // the relay's typed failure for the caller.
                     try {
                         if (context.stream instanceof managed_stream_1.ZLinkManagedStream) {
-                            await context.stream.unbindActor(actorRef.actorId, this.options.actorBindTimeoutMs ?? 2000);
+                            await context.stream.unbindActor(actorRef.actorId, this.options.actorBindTimeoutMs ?? bound_actor_relay_sender_1.DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS);
                         }
                     }
                     catch (cleanupError) {
@@ -204,7 +210,9 @@ class ZLinkSessionActorCoordinator {
                     !(await this.routes.validateSeal(normalizedActorRef.actorId, options.releaseSeal.sealId))) {
                     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${normalizedActorRef.actorId}' route switch did not match its relocation seal.`, true);
                 }
-                route.actor.updateRef(normalizedActorRef);
+                // A location refresh never changes the route's Session binding
+                // generation; the native bind owns it.
+                route.actor.updateRef(withBindingGeneration(normalizedActorRef, bindingGenerationOf(route.actor.ref), undefined));
                 if (authorityFence !== undefined) {
                     await this.routes.updateAuthorityFence(normalizedActorRef.actorId, authorityFence);
                 }
@@ -265,7 +273,7 @@ class ZLinkSessionActorCoordinator {
             return;
         }
         try {
-            await context.stream.bindActor(actorRef, this.options.actorBindTimeoutMs ?? 2000, signal, context.actorBindingReplacedHandler, authorityFence);
+            await context.stream.bindActor(actorRef, this.options.actorBindTimeoutMs ?? bound_actor_relay_sender_1.DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS, signal, context.actorBindingReplacedHandler, authorityFence);
         }
         catch (error) {
             if (error instanceof contracts_1.ZLinkFrameworkException) {

package/dist/runtime/streams/session-calls.d.ts

@@ -1,6 +1,6 @@
 import type { ZLinkBoundSessionSendCall, ZLinkSessionReplyCall, ZLinkSessionSendCall } from '../../contracts';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
+import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import { type ZLinkStreamFrameHeader, ZLinkStreamMessageKind, type ZLinkStreamReplyMessageKind } from './protocol';
 export interface ZLinkBoundSessionSendRuntime {
     sendBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;

package/dist/runtime/streams/session-calls.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkSessionReplyCall = exports.DefaultZLinkSessionSendCall = exports.DefaultZLinkBoundSessionSendCall = void 0;
-const framework_errors_internal_1 = require("../framework-errors-internal");
-const submission_result_1 = require("../messaging/submission-result");
+const SendTimeoutValidation_1 = require("../../contracts/Configuration/SendTimeoutValidation");
 const abort_1 = require("../abort");
 const configuration_1 = require("../configuration");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const submission_result_1 = require("../messaging/submission-result");
 const protocol_1 = require("./protocol");
 class DefaultZLinkBoundSessionSendCall {
     runtime;
@@ -61,8 +62,8 @@ class DefaultZLinkSessionSendCall {
         return this;
     }
     timeout(timeoutMs) {
-        if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647) {
-            throw new configuration_1.ZLinkConfigurationException('STREAM session send timeout must be an integer from 1 through 2147483647 milliseconds.');
+        if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > SendTimeoutValidation_1.ZLINK_MAX_SEND_TIMEOUT_MS) {
+            throw new configuration_1.ZLinkConfigurationException(`STREAM session send timeout must be an integer from 1 through ${SendTimeoutValidation_1.ZLINK_MAX_SEND_TIMEOUT_MS} milliseconds.`);
         }
         this.selectedTimeoutMs = timeoutMs;
         return this;

package/dist/runtime/streams/session-context.d.ts

@@ -1,12 +1,12 @@
-import type { ActorRef, RoutingId, ZLinkMessage, ZLinkActor, ZLinkBoundSession, ZLinkSessionActor, ZLinkSessionActors, ZLinkSessionClient, ZLinkSessionContext, ZLinkSessionDispatchContext, ZLinkSessionHandlerRegistry, ZLinkStream } from '../../contracts';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
+import type { ActorRef, RoutingId, ZLinkActor, ZLinkBoundSession, ZLinkMessage, ZLinkSessionActor, ZLinkSessionActors, ZLinkSessionClient, ZLinkSessionContext, ZLinkSessionDispatchContext, ZLinkSessionHandlerRegistry, ZLinkStream } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import { type ZLinkStreamFrameHeader, ZLinkStreamMessageKind, type ZLinkStreamReplyMessageKind } from './protocol';
-import { DefaultZLinkBoundSessionSendCall } from './session-calls';
-import { type ZLinkPendingSessionRequest } from './session-requests';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ServiceActorRef } from '../foundation/service-stateful-registry';
 import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
+import { type ZLinkSubmitResult } from '../messaging/submission-result';
+import { ZLinkStreamMessageKind, type ZLinkStreamFrameHeader, type ZLinkStreamReplyMessageKind } from './protocol';
+import { DefaultZLinkBoundSessionSendCall } from './session-calls';
+import { type ZLinkPendingSessionRequest } from './session-requests';
 export interface ZLinkSessionContextStream extends ZLinkStream {
     writeRaw(payload: Message, flags?: number): boolean;
     submitRaw(payload: Message, signal?: AbortSignal, timeoutMs?: number): Promise<ZLinkSubmitResult>;

package/dist/runtime/streams/session-context.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkBoundSessionFactory = exports.DefaultZLinkBoundSession = exports.DefaultZLinkSessionActor = exports.DefaultZLinkSessionContext = void 0;
 exports.createSessionDispatchContext = createSessionDispatchContext;
-const framework_errors_internal_1 = require("../framework-errors-internal");
-const submission_result_1 = require("../messaging/submission-result");
 const Attributes_1 = require("../../contracts/Handlers/Attributes");
 const abort_1 = require("../abort");
+const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 const configuration_1 = require("../configuration");
+const state_lane_1 = require("../execution/state-lane");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const submission_result_1 = require("../messaging/submission-result");
 const protocol_1 = require("./protocol");
 const session_calls_1 = require("./session-calls");
-const session_requests_1 = require("./session-requests");
 const session_local_actors_1 = require("./session-local-actors");
-const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
+const session_requests_1 = require("./session-requests");
 class DefaultZLinkSessionContext {
     runtime;
     stream;
@@ -393,3 +394,20 @@ function sameRetiredSession(left, right) {
         left.sessionRid === right.sessionRid &&
         left.retiredBindingGeneration === right.retiredBindingGeneration);
 }
+if ((0, state_lane_1.isStructuralGuardEnabled)()) {
+    const controlsGetter = Object.getOwnPropertyDescriptor(DefaultZLinkSessionContext.prototype, 'actorSlotControls')?.get;
+    if (controlsGetter !== undefined) {
+        Object.defineProperty(DefaultZLinkSessionContext.prototype, 'actorSlotControls', {
+            configurable: true,
+            get() {
+                const controls = controlsGetter.call(this);
+                if (controls === undefined)
+                    return undefined;
+                return {
+                    enqueueBound: (actorSlot, actorId) => (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(controls.enqueueBound(actorSlot, actorId), `binding transport bound ${actorId}`), 'binding transport completion'),
+                    enqueueUnbound: (actorSlot) => (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(controls.enqueueUnbound(actorSlot), `binding transport unbound ${actorSlot}`), 'binding transport completion')
+                };
+            }
+        });
+    }
+}

package/dist/runtime/streams/session-requests.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSessionRequestTracker = exports.ZLinkPendingSessionRequest = void 0;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const stream_message_utils_1 = require("./stream-message-utils");
 class ZLinkPendingSessionRequest {
     tracker;
@@ -92,7 +93,7 @@ class ZLinkSessionRequestTracker {
     }
     next() {
         do {
-            this.nextRequestSeq = (this.nextRequestSeq + 1n) & 0xffffffffffffffffn;
+            this.nextRequestSeq = (this.nextRequestSeq + 1n) & stream_wire_1.UINT64_MAX;
         } while (this.nextRequestSeq === 0n);
         return this.nextRequestSeq;
     }

package/dist/runtime/streams/session-serial-executor.js

@@ -22,8 +22,8 @@ class ZLinkSessionSerialExecutor {
         }
         const boundWork = (0, application_job_queue_scope_1.bindApplicationJobPermit)(work);
         return (0, application_job_queue_scope_1.hasApplicationJobPermit)()
-            ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'lifecycle' })
-            : this.scheduler.submit(boundWork, { lane: 'lifecycle' });
+            ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'application' })
+            : this.scheduler.submit(boundWork, { lane: 'application' });
     }
     submit(work, lane, options = {}, onRejected) {
         if (this.closed)

package/dist/runtime/streams/stream-binding-runtime-ports.d.ts

@@ -3,6 +3,7 @@ import type { ZLinkBackendActorSessionNode } from '../backend';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import type { DefaultZLinkSessionActor } from './session-context';
 import type { ZLinkBoundSessionResponseTarget } from './bound-session-response-target';
+import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
 export interface ZLinkStreamActorLookupPort {
     find(actorId: string): Promise<DefaultZLinkSessionActor | undefined>;
     authorityFence(actorId: string): Promise<{
@@ -44,8 +45,22 @@ export interface ZLinkBoundSessionResponsePort {
     sendLocalBoundSessionResponse(actorId: string, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean): Promise<boolean>;
     sendLocalBoundSessionError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>): Promise<boolean>;
 }
+/**
+ * Session–Actor binding §5: the Session owner's registry snapshot travels with
+ * the bind confirmation so a same-node Actor owner installs the same identity a
+ * remote command 38 would carry.
+ */
+export interface ZLinkSessionBindingConfirmationOptions {
+    readonly waitForAcknowledgement?: boolean;
+    readonly binding?: ServiceStreamSessionBinding;
+}
+/** The exact Session binding identity a relocation validated (§8.1). */
+export interface ZLinkSessionBindingIdentity {
+    readonly sessionRid: string;
+    readonly bindingGeneration: bigint;
+}
 export interface ZLinkRemoteBoundSessionPort extends ZLinkStreamActorLifecyclePort {
-    disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
+    closeSessionBinding(actorId: string, expected: ZLinkSessionBindingIdentity, signal?: AbortSignal): Promise<void>;
     sendLocalBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>): Promise<boolean>;
     sendLocalBoundSessionResponse(actorId: string, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean): Promise<boolean>;
     sendLocalBoundSessionError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>): Promise<boolean>;

package/dist/runtime/streams/stream-frame-factory.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zlinkStreamLz4CompressionCodec = exports.ZLinkStreamFrameMessageFactory = void 0;
 exports.resolveStreamCompressionCodec = resolveStreamCompressionCodec;
 exports.decompressStreamPayload = decompressStreamPayload;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const runtime_message_1 = require("../backend/runtime-message");
 const flow_context_1 = require("../diagnostics/flow-context");
 const framework_json_v1_1 = require("../messaging/framework-json-v1");
 const Attributes_1 = require("../../contracts/Handlers/Attributes");
 const protocol_1 = require("./protocol");
-const DEFAULT_MAX_DECOMPRESSED_STREAM_PAYLOAD_SIZE = 64 * 1024;
 class ZLinkStreamFrameMessageFactory {
     options;
     compressionCodec;
@@ -130,7 +130,7 @@ function compressStreamPayload(payload, codec) {
         throw new Error(`Compression failed: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-function decompressStreamPayload(payload, codec, maxDecompressedSize = DEFAULT_MAX_DECOMPRESSED_STREAM_PAYLOAD_SIZE) {
+function decompressStreamPayload(payload, codec, maxDecompressedSize = stream_wire_1.defaultMaxDecompressedPayloadSize) {
     if (codec === undefined) {
         throw new Error('Compression codec is not configured.');
     }

package/dist/runtime/streams/stream-session-runtime.d.ts

@@ -1,18 +1,18 @@
 import type { ZLinkMessageSerializer, ZLinkSession } from '../../contracts';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { Message } from '../../contracts/Common/Message';
-import { ZLinkDispatchErrorReporter } from '../channels';
-import type { ZLinkRuntimeMetrics } from '../diagnostics';
-import type { ZLinkBackendSocketMonitor, ZLinkBackendReadablePoller, ZLinkBackendStreamPacket, ZLinkBackendStreamSocket } from '../backend/contracts';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import { type ZLinkApplicationWorkClaim } from '../admission';
+import type { ApplicationJobPermitPort, ApplicationJobQueuePort } from '../application-jobs/contracts';
+import type { ZLinkBackendReadablePoller, ZLinkBackendSocketMonitor, ZLinkBackendStreamPacket, ZLinkBackendStreamSocket } from '../backend/contracts';
 import type { ZLinkMeshCompletionTable } from '../backend/mesh-completion-table';
+import { ZLinkDispatchErrorReporter } from '../channels';
+import { type ZLinkRuntimeMetrics } from '../diagnostics';
 import type { StreamSessionService } from '../foundation/service-runtime-contracts';
-import { type ZLinkStreamFrameHeader } from './protocol';
-import { ZLinkManagedStream, type ZLinkNativeSessionRoute } from './managed-stream';
-import { DefaultZLinkSessionContext } from './session-context';
-import type { ZLinkApplicationWorkClaim } from '../admission';
 import type { ServiceActorRef } from '../foundation/service-stateful-registry';
 import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
-import type { ApplicationJobPermitPort, ApplicationJobQueuePort } from '../application-jobs/contracts';
+import { ZLinkManagedStream, type ZLinkNativeSessionRoute } from './managed-stream';
+import { type ZLinkStreamFrameHeader } from './protocol';
+import { DefaultZLinkSessionContext } from './session-context';
 interface ZLinkStreamLivenessClock {
     now(): number;
     setTimer(callback: () => void, delayMs: number): unknown;
@@ -67,7 +67,7 @@ export declare class ZLinkStreamSessionRuntime {
     private metricsClosed;
     private readonly livenessClock;
     private lastApplicationActivityAt;
-    private awaitingPongSince;
+    private lastInboundFrameAt;
     private livenessTimer;
     constructor(options: ZLinkStreamSessionRuntimeOptions & ZLinkStreamLivenessOptions, routingId: unknown, removeSession?: (sessionId: string, session: ZLinkStreamSessionRuntime) => void);
     get session(): Promise<ZLinkSession>;
@@ -125,7 +125,6 @@ export declare class ZLinkStreamSessionNodeRuntime {
     private readonly unaddressedMonitorSessions;
     private unaddressedMonitorSessionHead;
     private unaddressedMonitorSessionCount;
-    private readonly disconnectedEndpoints;
     private pendingEndpointlessDisconnect;
     private activityVersion;
     private stopped;