@zlink-systems/framework 0.21.0 → 0.23.0

package/dist/runtime/streams/protocol.js

@@ -7,6 +7,8 @@ exports.resolvePacketName = resolvePacketName;
 exports.ensureSingleSubmit = ensureSingleSubmit;
 exports.encodeStreamFrame = encodeStreamFrame;
 exports.encodeStreamControlFrame = encodeStreamControlFrame;
+exports.encodeActorBoundFrame = encodeActorBoundFrame;
+exports.encodeActorUnboundFrame = encodeActorUnboundFrame;
 exports.encodeSessionClosingFrame = encodeSessionClosingFrame;
 exports.decodeStreamFrame = decodeStreamFrame;
 exports.tryDecodeStreamFrame = tryDecodeStreamFrame;
@@ -38,19 +40,27 @@ var ZLinkStreamCodec;
 })(ZLinkStreamCodec || (exports.ZLinkStreamCodec = 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';
+        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}'.`);
 }
 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;
+        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}'.`);
 }
@@ -70,6 +80,7 @@ var ZLinkStreamHeaderFlags;
     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) {
@@ -106,6 +117,26 @@ function encodeStreamControlFrame(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);
+}
+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);
+}
 function encodeSessionClosingFrame(diagnostic = '', reason = ZLinkStreamCloseReasonCode.ServerDrain) {
     const diagnosticBytes = (0, stream_wire_1.utf8Encode)(diagnostic);
     if (diagnosticBytes.length > 512)
@@ -135,7 +166,9 @@ function encodeStreamHeader(header) {
     const hasMetadata = header.metadata.size > 0;
     const hasCorrelation = header.correlationId !== undefined && header.correlationId.length > 0;
     const hasFlow = header.flowId !== undefined || header.flowOrigin !== undefined;
-    if (header.kind === ZLinkStreamMessageKind.Control && (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow)) {
+    const hasActorSlot = header.actorSlot !== undefined;
+    if (header.kind === ZLinkStreamMessageKind.Control &&
+        (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)) {
         throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
     }
     //  Explicit construction: this runs for every outbound frame, so avoid a
@@ -149,7 +182,8 @@ function encodeStreamHeader(header) {
         metadata: header.metadata,
         correlationId: header.correlationId,
         flowId: header.flowId,
-        flowOrigin: encodeFlowOrigin(header.flowOrigin)
+        flowOrigin: encodeFlowOrigin(header.flowOrigin),
+        actorSlot: header.actorSlot
     });
 }
 function decodeStreamHeader(header, flowEnabled = true) {
@@ -160,22 +194,24 @@ function decodeStreamHeader(header, flowEnabled = true) {
     const hasMetadata = (flags & ZLinkStreamHeaderFlags.HasMetadata) !== 0;
     const hasCorrelation = (flags & ZLinkStreamHeaderFlags.HasCorrelationId) !== 0;
     const hasFlow = (flags & ZLinkStreamHeaderFlags.HasFlowId) !== 0;
-    if (kind === ZLinkStreamMessageKind.Control && (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow)) {
+    const hasActorSlot = (flags & ZLinkStreamHeaderFlags.HasActorSlot) !== 0;
+    if (kind === ZLinkStreamMessageKind.Control &&
+        (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)) {
         throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
     }
     const metadata = publicStreamMetadata(decoded.metadata);
     return {
         kind,
         codec: decoded.codec,
-        flags: (metadata.size === 0
-            ? flags & ~ZLinkStreamHeaderFlags.HasMetadata
-            : flags) & (flowEnabled ? ~0 : ~ZLinkStreamHeaderFlags.HasFlowId),
+        flags: (metadata.size === 0 ? flags & ~ZLinkStreamHeaderFlags.HasMetadata : flags) &
+            (flowEnabled ? ~0 : ~ZLinkStreamHeaderFlags.HasFlowId),
         requestSeq: decoded.requestSeq,
         name: decoded.name,
         metadata,
         correlationId: decoded.correlationId,
         flowId: decoded.flowId,
-        flowOrigin: decodeFlowOrigin(decoded.flowOrigin)
+        flowOrigin: decodeFlowOrigin(decoded.flowOrigin),
+        actorSlot: decoded.actorSlot
     };
 }
 function actorRequestDeadlineMetadata(deadlineUnixMs) {
@@ -212,16 +248,28 @@ function createStreamReplyHeader(requestHeader, kind, codec, flags, metadata, in
         // observation-only and is not copied into the reply when tracing is Off
         // (spec 27 §4, §7).
         correlationId: requestHeader.correlationId,
-        ...(includeFlow
-            ? { flowId: requestHeader.flowId, flowOrigin: requestHeader.flowOrigin }
-            : {})
+        actorSlot: requestHeader.actorSlot,
+        ...(includeFlow ? { flowId: requestHeader.flowId, flowOrigin: requestHeader.flowOrigin } : {})
+    };
+}
+function controlHeader(name) {
+    return {
+        kind: ZLinkStreamMessageKind.Control,
+        codec: ZLinkStreamCodec.Raw,
+        flags: ZLinkStreamHeaderFlags.None,
+        name,
+        metadata: EMPTY_STREAM_METADATA
     };
 }
 function encodeFlowOrigin(origin) {
-    return origin === undefined ? undefined : { Inbound: 1, Timer: 2, Application: 3, Lifecycle: 4 }[origin];
+    return origin === undefined
+        ? undefined
+        : { Inbound: 1, Timer: 2, Application: 3, Lifecycle: 4 }[origin];
 }
 function decodeFlowOrigin(origin) {
-    return origin === undefined ? undefined : { 1: 'Inbound', 2: 'Timer', 3: 'Application', 4: 'Lifecycle' }[origin];
+    return origin === undefined
+        ? undefined
+        : { 1: 'Inbound', 2: 'Timer', 3: 'Application', 4: 'Lifecycle' }[origin];
 }
 function messageToBytes(message) {
     const value = message;

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

@@ -37,10 +37,10 @@ class ZLinkSessionActorCoordinator {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, 'Actor session binding requires a stream routing id.');
         }
         const previous = await this.routes.route(actorRef.actorId);
-        const sameIncarnation = previous !== undefined
-            && previous.context === context
-            && previous.actor.ref.actorId === actorRef.actorId
-            && BigInt(previous.actor.ref.objectGeneration) === BigInt(actorRef.objectGeneration);
+        const sameIncarnation = previous !== undefined &&
+            previous.context === context &&
+            previous.actor.ref.actorId === actorRef.actorId &&
+            BigInt(previous.actor.ref.objectGeneration) === BigInt(actorRef.objectGeneration);
         const samePhysicalBinding = sameIncarnation && sameActorRef(previous.actor.ref, actorRef);
         const reuseActor = sameIncarnation ? previous.actor : undefined;
         if (reuseActor !== undefined) {
@@ -57,32 +57,33 @@ class ZLinkSessionActorCoordinator {
         const boundActorRef = withBindingGeneration(actorRef, context.stream instanceof managed_stream_1.ZLinkManagedStream
             ? context.stream.actorBindingGeneration(actorRef.actorId)
             : undefined, previous?.actor.ref);
-        const sessionActor = reuseActor
-            ?? new session_context_1.DefaultZLinkSessionActor(this.sessionActorRuntime, boundActorRef, bindingToken);
+        const sessionActor = reuseActor ??
+            new session_context_1.DefaultZLinkSessionActor(this.sessionActorRuntime, boundActorRef, bindingToken);
         const sessionIdentity = String(this.actorBindingRoutingId(context));
-        sessionActor.updateRef(boundActorRef);
         if (previous === undefined) {
             if (releaseSeal !== undefined) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `Actor '${actorRef.actorId}' route switch has no Session binding to release.`, true);
             }
-            await this.routes.bind(context, sessionActor, bindingToken, authorityFence, sessionIdentity);
+            await this.routes.bind(context, sessionActor, bindingToken, authorityFence, sessionIdentity, () => sessionActor.updateRef(boundActorRef));
         }
         else if (releaseSeal !== undefined) {
-            await this.routes.replaceAndReleaseSeal(previous, context, sessionActor, bindingToken, releaseSeal.sealId, authorityFence, sessionIdentity);
+            await this.routes.replaceAndReleaseSeal(previous, context, sessionActor, bindingToken, releaseSeal.sealId, authorityFence, sessionIdentity, () => sessionActor.updateRef(boundActorRef));
         }
         else {
-            await this.routes.replace(previous, context, sessionActor, bindingToken, authorityFence, sessionIdentity);
+            await this.routes.replace(previous, context, sessionActor, bindingToken, authorityFence, sessionIdentity, () => sessionActor.updateRef(boundActorRef));
         }
-        if (confirmRemoteSessionBinding !== false && this.options.confirmRemoteActorSessionBinding !== undefined) {
-            const waitForAcknowledgement = previous === undefined
-                && confirmRemoteSessionBinding !== 'send';
+        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 reportFailure = (error) => {
                 // A fire-and-forget route update retains the already-current binding;
                 // its failure is bounded diagnostics rather than a rollback. The
                 // relay retries independently and reports the typed failure through
                 // the runtime error sink instead of silently discarding it.
-                this.options.errorSink?.()?.reportRuntimeTaskException('remote session binding confirmation', error);
+                this.options
+                    .errorSink?.()
+                    ?.reportRuntimeTaskException('remote session binding confirmation', error);
             };
             if (waitForAcknowledgement) {
                 try {
@@ -126,8 +127,7 @@ class ZLinkSessionActorCoordinator {
     }
     async resolveAuthorityFence(actorRef, signal) {
         const internal = actorRef;
-        if (internal.ownershipGeneration !== undefined
-            && internal.ownerLeaseGeneration !== undefined) {
+        if (internal.ownershipGeneration !== undefined && internal.ownerLeaseGeneration !== undefined) {
             const resolved = internal.ownerNodeGeneration === undefined
                 ? await this.options.actorAuthorityFenceResolver?.(actorRef.actorId, signal)
                 : undefined;
@@ -200,16 +200,16 @@ class ZLinkSessionActorCoordinator {
             requireSameIncarnation(route.actor.ref, normalizedActorRef);
             if ((0, routing_id_1.routingIdsEqual)(route.actor.ref.nodeRid, normalizedActorRef.nodeRid)) {
                 const authorityFence = await this.resolveAuthorityFence(normalizedActorRef, signal);
-                if (options.releaseSeal !== undefined
-                    && !await this.routes.validateSeal(normalizedActorRef.actorId, options.releaseSeal.sealId)) {
+                if (options.releaseSeal !== undefined &&
+                    !(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);
                 if (authorityFence !== undefined) {
                     await this.routes.updateAuthorityFence(normalizedActorRef.actorId, authorityFence);
                 }
-                if (options.releaseSeal !== undefined
-                    && !await this.routes.abortSeal(normalizedActorRef.actorId, options.releaseSeal.sealId)) {
+                if (options.releaseSeal !== undefined &&
+                    !(await this.routes.abortSeal(normalizedActorRef.actorId, options.releaseSeal.sealId))) {
                     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${normalizedActorRef.actorId}' route switch lost its relocation seal.`, true);
                 }
                 return;
@@ -221,10 +221,10 @@ class ZLinkSessionActorCoordinator {
         return await this.lifecycle.run(actorRef.actorId, async () => {
             (0, abort_1.throwIfAborted)(signal);
             const route = await this.routes.route(actorRef.actorId);
-            if (route === undefined
-                || !sameActorRef(route.actor.ref, actorRef)
-                || !(0, routing_id_1.routingIdsEqual)(route.sessionIdentity, sessionRid)
-                || bindingGenerationOf(route.actor.ref) !== bindingGeneration) {
+            if (route === undefined ||
+                !sameActorRef(route.actor.ref, actorRef) ||
+                !(0, routing_id_1.routingIdsEqual)(route.sessionIdentity, sessionRid) ||
+                bindingGenerationOf(route.actor.ref) !== bindingGeneration) {
                 return false;
             }
             // A late legacy tombstone may remove only the still-current exact route.
@@ -241,9 +241,7 @@ class ZLinkSessionActorCoordinator {
         const route = await this.routes.route(actorId);
         const sessionRid = route?.sessionIdentity;
         const actor = route?.actor.ref;
-        if (route === undefined
-            || sessionRid === undefined
-            || actor?.bindingGeneration === undefined) {
+        if (route === undefined || sessionRid === undefined || actor?.bindingGeneration === undefined) {
             return undefined;
         }
         return {
@@ -286,9 +284,7 @@ exports.ZLinkSessionActorCoordinator = ZLinkSessionActorCoordinator;
 function withBindingGeneration(actorRef, nativeBindingGeneration, previousRef) {
     const input = actorRef;
     const previous = previousRef;
-    const bindingGeneration = nativeBindingGeneration
-        ?? input.bindingGeneration
-        ?? previous?.bindingGeneration;
+    const bindingGeneration = nativeBindingGeneration ?? input.bindingGeneration ?? previous?.bindingGeneration;
     if (bindingGeneration === undefined) {
         return actorRef;
     }
@@ -323,10 +319,10 @@ function preserveInternalActorRefField(target, source, field) {
     });
 }
 function isActorRefLike(value) {
-    return (typeof value === 'object'
-        && 'nodeRid' in value
-        && 'actorId' in value
-        && ('objectGeneration' in value || 'generation' in value));
+    return (typeof value === 'object' &&
+        'nodeRid' in value &&
+        'actorId' in value &&
+        ('objectGeneration' in value || 'generation' in value));
 }
 function normalizeActorRef(value, defaultMeshName) {
     const objectGeneration = value.objectGeneration ?? value.generation;
@@ -357,15 +353,15 @@ function createBindingToken() {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
 function sameActorRef(left, right) {
-    return (0, routing_id_1.routingIdsEqual)(left.nodeRid, right.nodeRid)
-        && left.actorId === right.actorId
-        && BigInt(left.objectGeneration) === BigInt(right.objectGeneration);
+    return ((0, routing_id_1.routingIdsEqual)(left.nodeRid, right.nodeRid) &&
+        left.actorId === right.actorId &&
+        BigInt(left.objectGeneration) === BigInt(right.objectGeneration));
 }
 function requireSameIncarnation(current, updated) {
-    if (current.actorId === updated.actorId
-        && BigInt(current.objectGeneration) === BigInt(updated.objectGeneration)) {
+    if (current.actorId === updated.actorId &&
+        BigInt(current.objectGeneration) === BigInt(updated.objectGeneration)) {
         return;
     }
-    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${updated.actorId}' route update cannot replace object generation `
-        + `${String(current.objectGeneration)} with ${String(updated.objectGeneration)}.`, true);
+    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${updated.actorId}' route update cannot replace object generation ` +
+        `${String(current.objectGeneration)} with ${String(updated.objectGeneration)}.`, true);
 }

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

@@ -10,6 +10,8 @@ import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service
 export interface ZLinkSessionContextStream extends ZLinkStream {
     writeRaw(payload: Message, flags?: number): boolean;
     submitRaw(payload: Message, signal?: AbortSignal, timeoutMs?: number): Promise<ZLinkSubmitResult>;
+    enqueueActorBound?(actorSlot: number, actorId: string): Promise<void>;
+    enqueueActorUnbound?(actorSlot: number): Promise<void>;
 }
 interface ZLinkSessionContextRuntime {
     cleanup(context: DefaultZLinkSessionContext): Promise<void>;
@@ -76,7 +78,12 @@ export declare class DefaultZLinkSessionContext implements ZLinkSessionContext {
     payloadForHeader(header: ZLinkStreamFrameHeader, payload: Message): Message;
     get boundActors(): readonly DefaultZLinkSessionActor[];
     findBoundActor(actorId: string): DefaultZLinkSessionActor | undefined;
-    bindLocal(actor: DefaultZLinkSessionActor, token: string): void;
+    actorForSlot(actorSlot: number | undefined): DefaultZLinkSessionActor | undefined;
+    get actorSlotControls(): {
+        enqueueBound(actorSlot: number, actorId: string): Promise<void>;
+        enqueueUnbound(actorSlot: number): Promise<void>;
+    } | undefined;
+    bindLocal(actor: DefaultZLinkSessionActor, token: string, actorSlot?: number): void;
     unbindLocal(actorId: string, token: string): void;
     completeConfiguration(): void;
 }
@@ -92,7 +99,7 @@ export declare class DefaultZLinkSessionActor implements ZLinkSessionActor {
     relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
     notifyDisconnected(signal?: AbortSignal): Promise<void>;
 }
-export declare function createSessionDispatchContext(header: ZLinkStreamFrameHeader): ZLinkSessionDispatchContext;
+export declare function createSessionDispatchContext(header: ZLinkStreamFrameHeader, actor?: DefaultZLinkSessionActor): ZLinkSessionDispatchContext;
 export declare class DefaultZLinkBoundSession implements ZLinkBoundSession {
     private readonly runtime;
     private readonly actorId;

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

@@ -71,9 +71,9 @@ class DefaultZLinkSessionContext {
     }
     beginActorBindingReplacement(actor, retiredSession) {
         const previous = this.retiredActorBindings.get(actor.actorId);
-        if (previous !== undefined
-            && previous.actorGeneration === actor.generation
-            && sameRetiredSession(previous.retiredSession, retiredSession)) {
+        if (previous !== undefined &&
+            previous.actorGeneration === actor.generation &&
+            sameRetiredSession(previous.retiredSession, retiredSession)) {
             return false;
         }
         this.closingForActorReplacement = true;
@@ -85,17 +85,17 @@ class DefaultZLinkSessionContext {
     }
     isExactRetiredActorBinding(actor, retiredSession) {
         const expected = this.retiredActorBindings.get(actor.actorId);
-        if (expected === undefined
-            || expected.actorGeneration !== actor.generation
-            || !sameRetiredSession(expected.retiredSession, retiredSession)) {
+        if (expected === undefined ||
+            expected.actorGeneration !== actor.generation ||
+            !sameRetiredSession(expected.retiredSession, retiredSession)) {
             return false;
         }
         const current = this.findBoundActor(actor.actorId);
         if (current === undefined)
             return true;
         const currentRef = current.ref;
-        return BigInt(currentRef.objectGeneration) === actor.generation
-            && currentRef.bindingGeneration === retiredSession.retiredBindingGeneration;
+        return (BigInt(currentRef.objectGeneration) === actor.generation &&
+            currentRef.bindingGeneration === retiredSession.retiredBindingGeneration);
     }
     createTextMessage(payload) {
         return this.runtime.createTextMessage(payload);
@@ -163,8 +163,23 @@ class DefaultZLinkSessionContext {
     findBoundActor(actorId) {
         return this.localActors.find(actorId);
     }
-    bindLocal(actor, token) {
-        this.localActors.bind(actor, token);
+    actorForSlot(actorSlot) {
+        if (actorSlot === undefined)
+            return undefined;
+        return this.localActors.findBySlot(actorSlot);
+    }
+    get actorSlotControls() {
+        if (this.stream.enqueueActorBound === undefined ||
+            this.stream.enqueueActorUnbound === undefined) {
+            return undefined;
+        }
+        return {
+            enqueueBound: (actorSlot, actorId) => this.stream.enqueueActorBound(actorSlot, actorId),
+            enqueueUnbound: (actorSlot) => this.stream.enqueueActorUnbound(actorSlot)
+        };
+    }
+    bindLocal(actor, token, actorSlot) {
+        this.localActors.bind(actor, token, actorSlot);
     }
     unbindLocal(actorId, token) {
         this.localActors.unbind(actorId, token);
@@ -194,7 +209,9 @@ class DefaultZLinkSessionHandlerRegistry {
         if (typeof handlerType.prototype?.handle !== 'function') {
             throw new TypeError(`Session handler '${handlerType.name}' must implement handle(...).`);
         }
-        this.handlersByPacket.set(packetName, { handlerType: handlerType });
+        this.handlersByPacket.set(packetName, {
+            handlerType: handlerType
+        });
         return this;
     }
     closeRegistration() {
@@ -215,14 +232,15 @@ class DefaultZLinkSessionHandlerRegistry {
         return await registration.instance;
     }
     async createHandler(handlerType) {
-        return this.providerResolver?.get?.(handlerType)
-            ?? await this.providerResolver?.create?.(handlerType)
-            ?? new handlerType();
+        return (this.providerResolver?.get?.(handlerType) ??
+            (await this.providerResolver?.create?.(handlerType)) ??
+            new handlerType());
     }
 }
 function sessionHandlerPacketName(handlerType) {
     const declared = (0, Attributes_1.readZLinkDecoratorMetadata)(handlerType)
-        .find((metadata) => metadata.kind === 'packet')?.packetName?.trim();
+        .find((metadata) => metadata.kind === 'packet')
+        ?.packetName?.trim();
     if (declared === undefined || declared.length === 0) {
         throw new configuration_1.ZLinkConfigurationException(`Session handler '${handlerType.name}' must declare a packet name with @ZLinkPacket(...).`);
     }
@@ -281,16 +299,14 @@ class DefaultZLinkSessionActor {
             throw new Error(`Cannot change session actor id from '${this.actorId}' to '${ref.actorId}'.`);
         }
         if (BigInt(ref.objectGeneration) !== BigInt(this.currentRef.objectGeneration)) {
-            throw new Error(`Cannot change session actor '${this.actorId}' object generation `
-                + `from ${String(this.currentRef.objectGeneration)} `
-                + `to ${String(ref.objectGeneration)}.`);
+            throw new Error(`Cannot change session actor '${this.actorId}' object generation ` +
+                `from ${String(this.currentRef.objectGeneration)} ` +
+                `to ${String(ref.objectGeneration)}.`);
         }
         this.currentRef = ref;
     }
     async relay(dispatchOrPayload, payloadOrSignal, signal) {
-        const dispatch = isSessionDispatchContext(dispatchOrPayload)
-            ? dispatchOrPayload
-            : undefined;
+        const dispatch = isSessionDispatchContext(dispatchOrPayload) ? dispatchOrPayload : undefined;
         let payload;
         let relaySignal;
         let header;
@@ -312,19 +328,21 @@ class DefaultZLinkSessionActor {
 }
 exports.DefaultZLinkSessionActor = DefaultZLinkSessionActor;
 const SESSION_DISPATCH_HEADERS = new WeakMap();
-function createSessionDispatchContext(header) {
+function createSessionDispatchContext(header, actor) {
     const dispatch = {
         packetName: header.name,
         metadata: header.metadata,
-        canReply: header.requestSeq !== undefined
+        canReply: header.requestSeq !== undefined,
+        ...(actor === undefined ? {} : { actor })
     };
     SESSION_DISPATCH_HEADERS.set(dispatch, header);
     return dispatch;
 }
 function isSessionDispatchContext(value) {
-    return value !== null && typeof value === 'object'
-        && typeof value.packetName === 'string'
-        && 'canReply' in value;
+    return (value !== null &&
+        typeof value === 'object' &&
+        typeof value.packetName === 'string' &&
+        'canReply' in value);
 }
 function sessionDispatchHeader(dispatch) {
     const header = SESSION_DISPATCH_HEADERS.get(dispatch);
@@ -368,10 +386,10 @@ function decodeStreamErrorPayload(payload) {
     }
 }
 function sameRetiredSession(left, right) {
-    return left.sessionOwnerNodeRid === right.sessionOwnerNodeRid
-        && left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration
-        && left.sessionOwnerId === right.sessionOwnerId
-        && left.sessionOwnerLeaseGeneration === right.sessionOwnerLeaseGeneration
-        && left.sessionRid === right.sessionRid
-        && left.retiredBindingGeneration === right.retiredBindingGeneration;
+    return (left.sessionOwnerNodeRid === right.sessionOwnerNodeRid &&
+        left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration &&
+        left.sessionOwnerId === right.sessionOwnerId &&
+        left.sessionOwnerLeaseGeneration === right.sessionOwnerLeaseGeneration &&
+        left.sessionRid === right.sessionRid &&
+        left.retiredBindingGeneration === right.retiredBindingGeneration);
 }

package/dist/runtime/streams/session-local-actors.d.ts

@@ -3,8 +3,10 @@ export interface ZLinkSessionLocalActor {
 }
 export declare class ZLinkSessionLocalActorBindings<TActor extends ZLinkSessionLocalActor> {
     private readonly actors;
+    private readonly actorIdsBySlot;
     snapshot(): readonly TActor[];
     find(actorId: string): TActor | undefined;
-    bind(actor: TActor, token: string): void;
+    findBySlot(actorSlot: number): TActor | undefined;
+    bind(actor: TActor, token: string, actorSlot?: number): void;
     unbind(actorId: string, token: string): void;
 }

package/dist/runtime/streams/session-local-actors.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSessionLocalActorBindings = void 0;
 class ZLinkSessionLocalActorBindings {
     actors = new Map();
+    actorIdsBySlot = new Map();
     snapshot() {
         const snapshot = [];
         for (const entry of this.actors.values()) {
@@ -13,13 +14,27 @@ class ZLinkSessionLocalActorBindings {
     find(actorId) {
         return this.actors.get(actorId)?.actor;
     }
-    bind(actor, token) {
-        this.actors.set(actor.actorId, { actor, token });
+    findBySlot(actorSlot) {
+        const actorId = this.actorIdsBySlot.get(actorSlot);
+        return actorId === undefined ? undefined : this.actors.get(actorId)?.actor;
+    }
+    bind(actor, token, actorSlot) {
+        const previous = this.actors.get(actor.actorId);
+        if (previous?.actorSlot !== undefined && previous.actorSlot !== actorSlot) {
+            this.actorIdsBySlot.delete(previous.actorSlot);
+        }
+        this.actors.set(actor.actorId, { actor, token, actorSlot });
+        if (actorSlot !== undefined) {
+            this.actorIdsBySlot.set(actorSlot, actor.actorId);
+        }
     }
     unbind(actorId, token) {
         const current = this.actors.get(actorId);
         if (current?.token === token) {
             this.actors.delete(actorId);
+            if (current.actorSlot !== undefined) {
+                this.actorIdsBySlot.delete(current.actorSlot);
+            }
         }
     }
 }

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

@@ -25,6 +25,6 @@ async function createProviderInstance(type, resolver, fallbackArg) {
         : new type(fallbackArg);
 }
 function isSessionFactory(value) {
-    return typeof value.create === 'function'
-        && value.context === undefined;
+    return (typeof value.create === 'function' &&
+        value.context === undefined);
 }

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

@@ -33,8 +33,7 @@ class ZLinkSessionSerialExecutor {
         const submitted = (0, application_job_queue_scope_1.hasApplicationJobPermit)()
             ? this.scheduler.submitPreAdmitted(boundWork, serialOptions)
             : this.scheduler.submit(boundWork, serialOptions);
-        void submitted
-            .catch(error => onRejected?.(error));
+        void submitted.catch((error) => onRejected?.(error));
         return true;
     }
     async dispose() {

package/dist/runtime/streams/stream-frame-factory.d.ts

@@ -27,7 +27,7 @@ export declare class ZLinkStreamFrameMessageFactory {
     constructor(options: ZLinkStreamFrameMessageFactoryOptions);
     createTextMessage(payload: string): Message;
     createBinaryMessage(payload: Uint8Array): Message;
-    createJsonFrameMessage(kind: ZLinkStreamMessageKind, packetName: string, metadata: ReadonlyMap<string, string>, compressed: boolean, requestSeq: bigint | undefined, payload: unknown, correlationId?: string): Message;
+    createJsonFrameMessage(kind: ZLinkStreamMessageKind, packetName: string, metadata: ReadonlyMap<string, string>, compressed: boolean, requestSeq: bigint | undefined, payload: unknown, correlationId?: string, actorSlot?: number): Message;
     createJsonReplyFrameMessage(requestHeader: ZLinkStreamFrameHeader, kind: ZLinkStreamReplyMessageKind, metadata: ReadonlyMap<string, string>, compressed: boolean, payload: unknown): Message;
     private createJsonFrameMessageWithHeader;
     /**

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

@@ -26,7 +26,7 @@ class ZLinkStreamFrameMessageFactory {
         }
         return factory.createTextMessage((0, protocol_1.utf8Decode)(payload));
     }
-    createJsonFrameMessage(kind, packetName, metadata, compressed, requestSeq, payload, correlationId) {
+    createJsonFrameMessage(kind, packetName, metadata, compressed, requestSeq, payload, correlationId, actorSlot) {
         const flow = (this.options.flowCreationEnabled?.() ?? true)
             ? (0, flow_context_1.currentOrCreateFlow)('Application')
             : undefined;
@@ -41,7 +41,8 @@ class ZLinkStreamFrameMessageFactory {
             metadata,
             correlationId,
             flowId: flow?.flowId,
-            flowOrigin: flow?.flowOrigin
+            flowOrigin: flow?.flowOrigin,
+            actorSlot
         }));
     }
     createJsonReplyFrameMessage(requestHeader, kind, metadata, compressed, payload) {
@@ -53,7 +54,9 @@ class ZLinkStreamFrameMessageFactory {
         if (compressed) {
             body = compressStreamPayload(body, this.compressionCodec);
         }
-        const flags = compressed ? protocol_1.ZLinkStreamHeaderFlags.PayloadCompressed : protocol_1.ZLinkStreamHeaderFlags.None;
+        const flags = compressed
+            ? protocol_1.ZLinkStreamHeaderFlags.PayloadCompressed
+            : protocol_1.ZLinkStreamHeaderFlags.None;
         const frame = (0, protocol_1.encodeStreamFrame)(createHeader(encoded.codec, flags), body);
         return this.createOwnedFrameMessage(frame);
     }
@@ -92,10 +95,14 @@ class ZLinkStreamFrameMessageFactory {
 exports.ZLinkStreamFrameMessageFactory = ZLinkStreamFrameMessageFactory;
 function streamDirection(kind) {
     switch (kind) {
-        case protocol_1.ZLinkStreamMessageKind.Request: return 'Request';
-        case protocol_1.ZLinkStreamMessageKind.Response: return 'Response';
-        case protocol_1.ZLinkStreamMessageKind.Error: return 'Error';
-        default: return 'Send';
+        case protocol_1.ZLinkStreamMessageKind.Request:
+            return 'Request';
+        case protocol_1.ZLinkStreamMessageKind.Response:
+            return 'Response';
+        case protocol_1.ZLinkStreamMessageKind.Error:
+            return 'Error';
+        default:
+            return 'Send';
     }
 }
 exports.zlinkStreamLz4CompressionCodec = {