@zlink-systems/framework 0.26.0 → 0.28.0

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

@@ -9,7 +9,6 @@ const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const bound_session_wire_1 = require("../actors/bound-session-wire");
 const actor_routed_json_request_1 = require("../actors/actor-routed-json-request");
 const protocol_1 = require("./protocol");
-const abort_1 = require("../abort");
 const packet_name_1 = require("../messaging/packet-name");
 const flow_context_1 = require("../diagnostics/flow-context");
 class ZLinkNativeFallbackBoundSession {
@@ -45,8 +44,7 @@ class ZLinkNativeFallbackBoundSession {
                 return;
             }
             await this.options.routedTransport.sendToSpot(target, payload, {
-                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-                signal
+                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
             });
             return;
         }
@@ -80,29 +78,27 @@ class ZLinkNativeFallbackBoundSessionSendCall {
         this.selectedPacketName = packetName;
         return this;
     }
-    async submit(signal) {
+    async submit() {
         if (this.executed) {
             (0, submission_result_1.throwAlreadySubmitted)('Bound session send call');
         }
         const packetName = (0, packet_name_1.resolveFrameworkPacketName)(this.message, this.selectedPacketName, 'Bound session');
         this.executed = true;
-        (0, abort_1.throwIfAborted)(signal);
-        const result = await this.execute(packetName, signal);
+        const result = await this.execute(packetName);
         (0, submission_result_1.requireOneWayCompletion)(result, 'Bound session send', framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound);
     }
-    execute(packetName, signal) {
+    execute(packetName) {
         // Call-scoped flow (spec 27 §4): the relay JSON flow pair and any nested
         // routed-transport envelope share one ambient flow that does not outlive
         // this submit call.
-        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.executeScoped(packetName, signal));
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.executeScoped(packetName));
     }
-    async executeScoped(packetName, signal) {
+    async executeScoped(packetName) {
         const localActor = this.options.localActorProvider?.() === true;
         const remoteTarget = this.options.remoteBoundSessionTargetProvider();
-        const sealedRemoteTarget = remoteTarget?.relocationSealId !== undefined;
         let nativeAttempted = false;
-        if (localActor && !sealedRemoteTarget) {
-            const result = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
+        if (localActor) {
+            const result = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata);
             if (result.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                 this.traceSubmitted(result, packetName);
                 return result;
@@ -116,7 +112,7 @@ class ZLinkNativeFallbackBoundSessionSendCall {
             const bindingGeneration = currentBindingGeneration(actorRef);
             if (actorRef !== undefined && node !== undefined && bindingGeneration !== undefined) {
                 nativeAttempted = true;
-                const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata, signal);
+                const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata);
                 if (result.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                     this.traceSubmitted(result, packetName);
                     return result;
@@ -136,7 +132,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,
@@ -152,12 +147,12 @@ class ZLinkNativeFallbackBoundSessionSendCall {
                     targetNodeRid: remoteTarget.targetNodeRid,
                     spotId: remoteTarget.spotId,
                     spotKind: contracts_1.ZLinkSpotKind.Entry
-                }, payload, { packetName: actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, signal })
-                : await submit.call(this.options.routedTransport, remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, payload, signal);
+                }, payload, { packetName: actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET })
+                : await submit.call(this.options.routedTransport, remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, payload);
             this.traceSubmitted(result, packetName);
             return result;
         }
-        const localResult = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
+        const localResult = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata);
         if (localResult.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
             this.traceSubmitted(localResult, packetName);
             return localResult;
@@ -169,14 +164,14 @@ class ZLinkNativeFallbackBoundSessionSendCall {
             actorRef !== undefined &&
             node !== undefined &&
             bindingGeneration !== undefined) {
-            const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata, signal);
+            const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata);
             this.traceSubmitted(result, packetName);
             return result;
         }
         if (localActor) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `No current session binding exists for actor '${this.options.actorId}'.`, true);
         }
-        const result = await this.options.runtime.sendBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
+        const result = await this.options.runtime.sendBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata);
         this.traceSubmitted(result, packetName);
         return result;
     }

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,14 +1,14 @@
 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>;
+    sendBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
 }
 export interface ZLinkSessionCallContext {
     readonly stream: {
         writeRaw(payload: Message): boolean;
-        submitRaw(payload: Message, signal?: AbortSignal, timeoutMs?: number): Promise<ZLinkSubmitResult>;
+        submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
     };
     readonly dispatchHeader: ZLinkStreamFrameHeader | undefined;
     createJsonFrameMessage(kind: ZLinkStreamMessageKind, packetName: string, metadata: ReadonlyMap<string, string>, compressed: boolean, requestSeq: bigint | undefined, payload: unknown, correlationId?: string): Message;
@@ -31,7 +31,7 @@ export declare class DefaultZLinkBoundSessionSendCall implements ZLinkBoundSessi
     constructor(runtime: ZLinkBoundSessionSendRuntime, actorId: string, message: unknown);
     metadata(key: string, value: string): this;
     packetName(packetName: string): this;
-    submit(signal?: AbortSignal): Promise<void>;
+    submit(): Promise<void>;
 }
 export declare class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
     private readonly context;
@@ -39,14 +39,12 @@ export declare class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall
     private selectedPacketName;
     private readonly selectedMetadata;
     private compressionEnabled;
-    private selectedTimeoutMs;
     private executed;
     constructor(context: ZLinkSessionCallContext, message: unknown);
     metadata(key: string, value: string): this;
     packetName(packetName: string): this;
     compress(enabled?: boolean): this;
-    timeout(timeoutMs: number): this;
-    submit(signal?: AbortSignal): Promise<void>;
+    submit(): Promise<void>;
 }
 export declare class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCall {
     private readonly context;
@@ -55,5 +53,5 @@ export declare class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCa
     private executed;
     constructor(context: ZLinkSessionCallContext, message: unknown);
     compress(enabled?: boolean): this;
-    submit(signal?: AbortSignal): Promise<void>;
+    submit(): Promise<void>;
 }

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

@@ -3,8 +3,6 @@ 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 abort_1 = require("../abort");
-const configuration_1 = require("../configuration");
 const protocol_1 = require("./protocol");
 class DefaultZLinkBoundSessionSendCall {
     runtime;
@@ -26,12 +24,11 @@ class DefaultZLinkBoundSessionSendCall {
         this.selectedPacketName = packetName;
         return this;
     }
-    async submit(signal) {
+    async submit() {
         (0, protocol_1.ensureSingleSubmit)(this.executed);
         const packetName = (0, protocol_1.resolvePacketName)(this.message, this.selectedPacketName);
         this.executed = true;
-        (0, abort_1.throwIfAborted)(signal);
-        const result = await this.runtime.sendBoundSession(this.actorId, this.message, packetName, this.selectedMetadata, signal);
+        const result = await this.runtime.sendBoundSession(this.actorId, this.message, packetName, this.selectedMetadata);
         (0, submission_result_1.requireOneWayCompletion)(result, 'Bound session send', framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound);
     }
 }
@@ -42,7 +39,6 @@ class DefaultZLinkSessionSendCall {
     selectedPacketName;
     selectedMetadata = new Map();
     compressionEnabled = false;
-    selectedTimeoutMs;
     executed = false;
     constructor(context, message) {
         this.context = context;
@@ -60,21 +56,13 @@ class DefaultZLinkSessionSendCall {
         this.compressionEnabled = enabled;
         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.');
-        }
-        this.selectedTimeoutMs = timeoutMs;
-        return this;
-    }
-    async submit(signal) {
+    async submit() {
         (0, protocol_1.ensureSingleSubmit)(this.executed);
         const packetName = (0, protocol_1.resolvePacketName)(this.message, this.selectedPacketName);
         this.executed = true;
-        (0, abort_1.throwIfAborted)(signal);
         const message = this.context.createJsonFrameMessage(protocol_1.ZLinkStreamMessageKind.Send, packetName, this.selectedMetadata, this.compressionEnabled, undefined, this.message);
         try {
-            const result = await this.context.stream.submitRaw(message, signal, this.selectedTimeoutMs);
+            const result = await this.context.stream.submitRaw(message);
             (0, submission_result_1.requireOneWayCompletion)(result, 'STREAM session send');
             this.context.traceFrameWritten?.(protocol_1.ZLinkStreamMessageKind.Send, packetName, undefined);
         }
@@ -97,7 +85,7 @@ class DefaultZLinkSessionReplyCall {
         this.compressionEnabled = enabled;
         return this;
     }
-    async submit(signal) {
+    async submit() {
         (0, protocol_1.ensureSingleSubmit)(this.executed);
         this.executed = true;
         const requestHeader = this.context.dispatchHeader;
@@ -105,13 +93,9 @@ class DefaultZLinkSessionReplyCall {
             throw new Error('Reply is only available while handling a request packet.');
         }
         this.context.claimReply(requestHeader);
-        // Reply-token validity wins over caller cancellation. Claiming before the
-        // pre-cancel check keeps duplicate calls deterministic while still making
-        // a pre-cancelled first call perform no transport admission.
-        (0, abort_1.throwIfAborted)(signal);
         const message = this.context.createJsonReplyFrameMessage(requestHeader, protocol_1.ZLinkStreamMessageKind.Response, new Map(), this.compressionEnabled, this.message);
         try {
-            const result = await this.context.stream.submitRaw(message, signal);
+            const result = await this.context.stream.submitRaw(message);
             (0, submission_result_1.requireOneWayCompletion)(result, 'STREAM session reply');
             this.context.traceFrameWritten?.(protocol_1.ZLinkStreamMessageKind.Response, requestHeader.name, requestHeader.correlationId);
         }

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

@@ -1,15 +1,15 @@
-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>;
+    submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
     enqueueActorBound?(actorSlot: number, actorId: string): Promise<void>;
     enqueueActorUnbound?(actorSlot: number): Promise<void>;
 }
@@ -22,7 +22,7 @@ interface ZLinkSessionContextRuntime {
     decompressPayload(payload: Message): Message;
     bind(context: DefaultZLinkSessionContext, actor: ZLinkActor | ActorRef, signal?: AbortSignal): Promise<DefaultZLinkSessionActor>;
     bindOrGet(context: DefaultZLinkSessionContext, actorRef: ActorRef, signal?: AbortSignal): Promise<DefaultZLinkSessionActor>;
-    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, signal?: AbortSignal, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
+    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
     notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void>;
 }
 export type ZLinkActorBindingReplacementHandler = (actor: ServiceActorRef, retiredSession: ServiceRetiredBoundSessionRouteFence) => void;
@@ -95,8 +95,8 @@ export declare class DefaultZLinkSessionActor implements ZLinkSessionActor {
     constructor(runtime: ZLinkSessionContextRuntime, ref: ActorRef, bindingToken: string);
     get ref(): ActorRef;
     updateRef(ref: ActorRef): void;
-    relay(payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
-    relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
+    relay(payload: ZLinkMessage): Promise<void>;
+    relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage): Promise<void>;
     notifyDisconnected(signal?: AbortSignal): Promise<void>;
 }
 export declare function createSessionDispatchContext(header: ZLinkStreamFrameHeader, actor?: DefaultZLinkSessionActor): ZLinkSessionDispatchContext;