@zlink-systems/framework 0.22.0 → 0.23.0

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/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) {

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

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkStreamSessionNodeRuntime = exports.ZLinkStreamSessionRuntime = void 0;
 const framework_errors_internal_1 = require("../framework-errors-internal");
-const contracts_1 = require("../../contracts");
 const internal_event_contracts_1 = require("../diagnostics/internal-event-contracts");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const abort_1 = require("../abort");
 const channels_1 = require("../channels");
+const bound_session_response_target_1 = require("./bound-session-response-target");
 const diagnostics_1 = require("../diagnostics");
 const payload_codec_1 = require("../messaging/payload-codec");
 const protocol_1 = require("./protocol");
@@ -329,6 +329,40 @@ class ZLinkStreamSessionRuntime {
             if (this.context.tryCompleteResponse(decodedHeader, dispatchPayload)) {
                 return;
             }
+            const dispatchActor = this.context.actorForSlot(decodedHeader.actorSlot);
+            if (decodedHeader.actorSlot !== undefined && dispatchActor === undefined) {
+                const staleFlowEnabled = this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true;
+                await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(decodedHeader.flowId, decodedHeader.flowOrigin, staleFlowEnabled, staleFlowEnabled ? this.stream.sessionId : undefined), async () => {
+                    if (decodedHeader.kind === protocol_1.ZLinkStreamMessageKind.Request) {
+                        const error = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'Actor slot is not a current binding.');
+                        this.options.dispatchErrors?.report({
+                            surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.StreamSession,
+                            messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
+                            reason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget,
+                            action: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError,
+                            packetName: decodedHeader.name,
+                            sourceRid: this.context.routingId === undefined ? undefined : String(this.context.routingId),
+                            correlationId: decodedHeader.correlationId,
+                            flowId: decodedHeader.flowId,
+                            flowOrigin: decodedHeader.flowOrigin,
+                            error
+                        });
+                        await this.replyDispatchError(decodedHeader, error);
+                    }
+                    else {
+                        (0, diagnostics_1.flowIfEnabled)(this.options.dispatchErrors?.flow, ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped)?.trace({
+                            outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped,
+                            surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.StreamSession,
+                            messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
+                            packetName: decodedHeader.name,
+                            correlationId: decodedHeader.correlationId,
+                            sourceRid: this.context.routingId === undefined ? undefined : String(this.context.routingId),
+                            errorReason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget
+                        });
+                    }
+                });
+                return;
+            }
             this.context.enterDispatch(decodedHeader);
             enteredDispatch = true;
             const session = await this.requireSession();
@@ -337,7 +371,8 @@ class ZLinkStreamSessionRuntime {
                 : ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send;
             const streamCorr = decodedHeader.correlationId;
             const inboundHeader = decodedHeader;
-            await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(inboundHeader.flowId, inboundHeader.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true), async () => {
+            const flowEnabled = this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true;
+            await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(inboundHeader.flowId, inboundHeader.flowOrigin, flowEnabled, flowEnabled ? this.stream.sessionId : undefined), async () => {
                 (0, diagnostics_1.flowIfEnabled)(this.options.dispatchErrors?.flow, ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received)?.trace({
                     outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received,
                     surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.StreamSession,
@@ -363,7 +398,7 @@ class ZLinkStreamSessionRuntime {
                     correlationId: streamCorr,
                     sourceRid: this.context.routingId === undefined ? undefined : String(this.context.routingId)
                 });
-                await session.onDispatch?.((0, session_context_1.createSessionDispatchContext)(inboundHeader), (0, payload_codec_1.wrapFrameworkPayloadMessage)(dispatchPayload, this.options.messageSerializers, (0, protocol_1.streamCodecContentType)(inboundHeader.codec), inboundHeader.name));
+                await session.onDispatch?.((0, session_context_1.createSessionDispatchContext)(inboundHeader, dispatchActor), (0, payload_codec_1.wrapFrameworkPayloadMessage)(dispatchPayload, this.options.messageSerializers, (0, protocol_1.streamCodecContentType)(inboundHeader.codec), inboundHeader.name));
                 if (streamKind === ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send) {
                     (0, diagnostics_1.flowIfEnabled)(this.options.dispatchErrors?.flow, ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed)?.trace({
                         outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed,
@@ -478,14 +513,7 @@ class ZLinkStreamSessionRuntime {
             // record (spec 26 §2.2) and confuse the peer's reply matching.
             return;
         }
-        const message = this.context.createJsonReplyFrameMessage(header, protocol_1.ZLinkStreamMessageKind.Error, new Map(), false, {
-            code: error instanceof contracts_1.ZLinkFrameworkException
-                ? contracts_1.ZLinkFrameworkErrorKind[error.kind]
-                : error instanceof Error
-                    ? error.constructor.name
-                    : 'RemoteError',
-            message: error instanceof Error ? error.message : String(error)
-        });
+        const message = this.context.createJsonReplyFrameMessage(header, protocol_1.ZLinkStreamMessageKind.Error, new Map(), false, (0, bound_session_response_target_1.boundSessionErrorPayload)(error));
         try {
             if (!this.context.stream.writeRaw(message, ZLINK_SEND_DONT_WAIT)) {
                 throw new Error('Client stream error reply send failed.');
@@ -518,7 +546,8 @@ class ZLinkStreamSessionRuntime {
                     : ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
             packetName: packetName.length === 0 ? undefined : packetName,
             correlationId,
-            sourceRid: this.context.routingId === undefined ? undefined : String(this.context.routingId)
+            sourceRid: this.context.routingId === undefined ? undefined : String(this.context.routingId),
+            streamSessionId: this.stream.sessionId
         });
     }
     async complete(error, notifyDisconnected) {
@@ -627,6 +656,7 @@ class ZLinkStreamSessionRuntime {
             packetName: header.name === '' ? undefined : header.name,
             correlationId: header.correlationId,
             sourceRid: this.context.routingId === undefined ? undefined : String(this.context.routingId),
+            streamSessionId: this.stream.sessionId,
             flowId: flowEnabled ? header.flowId : undefined,
             flowOrigin: flowEnabled ? header.flowOrigin : undefined,
             errorReason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.Shutdown

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.22.0",
-    "@zlink-systems/zlink": "1.2.1"
+    "@zlink-systems/stream-wire": "0.23.0",
+    "@zlink-systems/zlink": "1.4.0"
   }
 }

package/src/contracts/Dispatch/ZLinkDispatchOptions.ts

@@ -80,6 +80,7 @@ export interface ZLinkRuntimeMessageFlowEvent {
   readonly instanceSpotType?: string;
   readonly activationState?: 'activating' | 'ready' | 'closing';
   readonly actorId?: string;
+  readonly streamSessionId?: string;
   /** Internal service-wire command carried by a RouteMesh control record. */
   readonly commandId?: number;
   readonly messageSize?: number;

package/src/contracts/Streams/IZLinkSession.ts

@@ -1,5 +1,5 @@
 import type { RoutingId, ZLinkMessage } from '../Common';
-import type { ZLinkSessionActors } from './IZLinkSessionActor';
+import type { ZLinkSessionActor, ZLinkSessionActors } from './IZLinkSessionActor';
 import type { ZLinkStreamError } from './ZLinkStreamError';
 import type { ZLinkSessionHandlerRegistry } from './IZLinkSessionPacketHandler';
 
@@ -16,6 +16,7 @@ export interface ZLinkSessionDispatchContext {
   readonly packetName: string;
   readonly metadata: ReadonlyMap<string, string>;
   readonly canReply: boolean;
+  readonly actor?: ZLinkSessionActor;
 }
 
 export interface ZLinkSessionFactory<TSession extends ZLinkSession = ZLinkSession> {

package/src/runtime/actors/actor-context.ts

@@ -39,6 +39,7 @@ import {
 import { createRandomOperationIdentity } from '../foundation/operation-identity';
 import { deferActorJoin } from './actor-join-deferred-scope';
 import { captureZLinkSpotSerialTurn } from '../execution';
+import { dispatchErrorDetails } from '../diagnostics/dispatch-error-details';
 
 export const ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME = Symbol('zlink.actor.join-entry-spot-runtime');
 
@@ -219,7 +220,6 @@ class DefaultZLinkActorJoinSpotCall implements ZLinkActorJoinSpotCall {
     };
     try {
       deferActorJoin({
-        requestBytes: requestMessage.data().byteLength,
         prepare: async () => {
           if (prepared) return;
           prepared = true;
@@ -358,7 +358,6 @@ class DefaultZLinkActorJoinEntrySpotCall implements ZLinkActorJoinEntrySpotCall
     };
     try {
       deferActorJoin({
-        requestBytes: requestMessage.data().byteLength,
         prepare: async () => {
           if (prepared) return;
           prepared = true;
@@ -588,6 +587,7 @@ async function notifyJoinFailure(
   //  The completion carries only an error kind, so trace the cause on the
   //  message flow under the same flow id as the Join that produced it.
   const tracePoint = coordinator?.messageFlow?.()?.begin(ZLinkMessageFlowOutcome.Error);
+  const errorDetails = tracePoint === undefined ? undefined : dispatchErrorDetails(error);
   tracePoint?.trace({
     outcome: ZLinkMessageFlowOutcome.Error,
     surface: ZLinkDispatchErrorSurface.SpotActor,
@@ -596,8 +596,8 @@ async function notifyJoinFailure(
     actorId: actor.context.actorId,
     errorReason: ZLinkDispatchErrorReason.HandlerException,
     errorAction: ZLinkDispatchErrorAction.ReplyError,
-    errorType: String(frameworkError.kind),
-    errorMessage: String(error)
+    errorType: errorDetails?.errorType,
+    errorMessage: errorDetails?.errorMessage
   });
   await actor.onJoinCompleted?.({
     status: 'failed',

package/src/runtime/actors/actor-join-deferred-scope.ts

@@ -1,16 +1,7 @@
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException
-} from '../framework-errors-internal';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { ZLinkConfigurationException } from '../configuration';
 
-const MAX_DEFERRED_JOINS = 64;
-const MAX_DEFERRED_JOIN_REQUEST_BYTES = 1024 * 1024;
-const MAX_DEFERRED_JOIN_BYTES = 8 * 1024 * 1024;
-
 interface DeferredActorJoin {
-  readonly requestBytes: number;
   /** Starts target admission after the handler terminal, before reply admission. */
   readonly prepare?: () => Promise<void> | void;
   readonly execute: () => Promise<void>;
@@ -19,7 +10,6 @@ interface DeferredActorJoin {
 
 class ActorJoinRegistrationScope {
   private readonly intents: DeferredActorJoin[] = [];
-  private totalBytes = 0;
   private open = true;
   private prepared = false;
 
@@ -34,29 +24,7 @@ class ActorJoinRegistrationScope {
         'Actor join defer requires an open Framework actor handler scope.'
       );
     }
-    if (this.intents.length >= MAX_DEFERRED_JOINS) {
-      discardWithoutWaiting(intent);
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.InvalidConfiguration,
-        `An actor handler may defer at most ${MAX_DEFERRED_JOINS} joins.`
-      );
-    }
-    if (intent.requestBytes > MAX_DEFERRED_JOIN_REQUEST_BYTES) {
-      discardWithoutWaiting(intent);
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.InvalidConfiguration,
-        `A deferred actor join request may use at most ${MAX_DEFERRED_JOIN_REQUEST_BYTES} bytes.`
-      );
-    }
-    if (this.totalBytes + intent.requestBytes > MAX_DEFERRED_JOIN_BYTES) {
-      discardWithoutWaiting(intent);
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.InvalidConfiguration,
-        `Deferred actor join requests may use at most ${MAX_DEFERRED_JOIN_BYTES} bytes per handler.`
-      );
-    }
     this.intents.push(intent);
-    this.totalBytes += intent.requestBytes;
   }
 
   sealAfterHandlerTerminal(): void {

package/src/runtime/actors/deferred-join-accepted-journal.ts

@@ -44,7 +44,6 @@ import {
 const RETENTION_MS = 24 * 60 * 60 * 1_000;
 const ROOT_VERSION = 2;
 const ROOT_MAGIC = Buffer.from('ZLJR');
-const MAX_ROOT_BYTES = 1024 * 1024;
 const JOURNAL_INVENTORY_DOMAIN = Buffer.from('zlink-node-deferred-join-authority-v1\0', 'utf8');
 
 export type ZLinkDeferredJoinDeliveryCursor = 'prepared' | 'committed' | 'delivered';
@@ -695,17 +694,14 @@ function encodeRoot(
       'utf8'
     )
   ]);
-  if (encoded.byteLength > MAX_ROOT_BYTES) {
-    throw new Error('Deferred Join completion root exceeds 1 MiB.');
-  }
   return encoded;
 }
 
 function decodeRoot(
   payload: Uint8Array
 ): Omit<ZLinkDeferredJoinAcceptedRoot, 'authority' | 'reference' | 'checksumCrc32c'> {
-  if (payload.byteLength === 0 || payload.byteLength > MAX_ROOT_BYTES) {
-    throw new Error('Deferred Join completion root size is invalid.');
+  if (payload.byteLength === 0) {
+    throw new Error('Deferred Join completion root is empty.');
   }
   const bytes = Buffer.from(payload);
   const encoded = hasJournalRootMagic(bytes) ? bytes.subarray(ROOT_MAGIC.byteLength) : bytes;

package/src/runtime/backend/contracts/index.ts

@@ -60,6 +60,10 @@ export type ZLinkBackendObjectPlacement =
   | { readonly kind: 'unavailable' };
 
 export interface ZLinkBackendMeshNode {
+  setDispatchErrorReporter?(
+    reporter: import('../../channels/dispatch-error-reporter').ZLinkDispatchErrorReporter,
+    meshName: string
+  ): void;
   setRoutingId(routingId: unknown): void;
   setBind(endpoint: string): void;
   setAdvertiseHost(host: string): void;

package/src/runtime/backend/node/node-raw-mesh-backend.ts

@@ -1,5 +1,11 @@
 import { randomBytes } from 'node:crypto';
 import { setImmediate as yieldToIO } from 'node:timers/promises';
+import {
+  decodeStreamWireFrame,
+  decodeStreamWireHeader,
+  encodeStreamWireFrame,
+  encodeStreamWireHeader
+} from '@zlink-systems/stream-wire';
 import { disconnectStreamPeer } from './node-socket-backend-adapter';
 import { ZLinkFrameworkException } from '../../../contracts';
 import { internalFrameworkWireReply } from '../../framework-errors-internal';
@@ -20,6 +26,7 @@ import {
 } from '../runtime-values';
 import { ZLinkBufferMessage } from '../runtime-message';
 import type { Message as FrameworkMessage } from '../../../contracts/Common/Message';
+import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-reporter';
 import type {
   MeshOperationId,
   MeshPeerEntry,
@@ -178,6 +185,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   private messageFollowHandler?: (
     record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord
   ) => void;
+  private dispatchErrors?: ZLinkDispatchErrorReporter;
   private readonly peerDisconnectedHandlers = new Set<(endpoint: string) => void>();
   constructor(
     private readonly meshName: string,
@@ -228,6 +236,11 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     this.stateful?.setMailboxDropHandler(handler);
   }
 
+  setDispatchErrorReporter(reporter: ZLinkDispatchErrorReporter): void {
+    this.dispatchErrors = reporter;
+    this.stateful?.setDispatchErrorReporter(reporter, this.meshName);
+  }
+
   setProtocolErrorHandler(
     handler: (record: {
       readonly sourceNodeRid: string;
@@ -381,6 +394,9 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       descriptor.nodeRoutingId,
       descriptor.lifecycleGeneration
     );
+    if (this.dispatchErrors !== undefined) {
+      this.stateful.setDispatchErrorReporter(this.dispatchErrors, this.meshName);
+    }
     if (this.mailboxRecordDropped !== undefined) {
       this.stateful.setMailboxDropHandler(this.mailboxRecordDropped);
     }
@@ -649,12 +665,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     channelName: string,
     parts: MessageLike | readonly MessageLike[]
   ): Promise<SubmitResultValue> {
-    return (await this.requireRuntime().sendToChannel(
-      channelName,
-      encodeMultipartApplicationFrame(parts)
-    ))
-      ? SubmitResult.Ok
-      : SubmitResult.NotConnected;
+    return this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts));
   }
 
   requestToChannel(
@@ -667,9 +678,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       encodeMultipartApplicationFrame(parts),
       options?.timeoutMs ?? 30_000
     );
-    if (pending === undefined) {
-      return this.enqueueImmediateFailure(OperationKind.ChannelRequest, RequestResult.NotFound);
-    }
     return this.observeCompletion(pending.id, OperationKind.ChannelRequest, pending.promise);
   }
 
@@ -1875,7 +1883,8 @@ class RawStreamSessionService implements StreamSessionService {
         sessionKey,
         actor,
         timeoutMs,
-        (targetSessionRid, payloadFrame) => this.deliver(targetSessionRid, payloadFrame),
+        (targetSessionRid, payloadFrame) =>
+          this.deliver(targetSessionRid, actor.actorId, payloadFrame),
         onBindingReplaced,
         serviceSessionBindingIngressPortIfRegistered(this),
         actorAuthority
@@ -1913,12 +1922,22 @@ class RawStreamSessionService implements StreamSessionService {
     )) as SubmitResultValue;
   }
 
-  private async deliver(sessionRid: string, payload: Uint8Array): Promise<boolean> {
+  private async deliver(
+    sessionRid: string,
+    actorId: string,
+    payload: Uint8Array
+  ): Promise<boolean> {
     const target = this.sessionTargets.get(sessionRid);
     if (target === undefined) return false;
     const operation = this.stream.send(target as unknown as BindingRoutingId);
     const parts = decodeMultipartBuffers(decodeApplicationPayloadView(payload).payload);
     if (parts.length === 0) return false;
+    const actorSlot = await serviceSessionBindingIngressPortIfRegistered(this)?.actorSlot(
+      actorId,
+      sessionRid
+    );
+    if (actorSlot === undefined) return false;
+    parts[0] = Buffer.from(streamFrameWithActorSlot(parts[0]!, actorSlot));
     let submit = operation.message(parts[0]!);
     for (let index = 1; index < parts.length; index++) {
       submit = submit.message(parts[index]!);
@@ -1956,6 +1975,15 @@ class RawStreamSessionService implements StreamSessionService {
   }
 }
 
+function streamFrameWithActorSlot(frame: Uint8Array, actorSlot: number): Uint8Array {
+  const decodedFrame = decodeStreamWireFrame(frame);
+  const decodedHeader = decodeStreamWireHeader(decodedFrame.header);
+  return encodeStreamWireFrame(
+    encodeStreamWireHeader({ ...decodedHeader, actorSlot }),
+    decodedFrame.payload
+  );
+}
+
 class RawReadyBatch implements ReadyBatch {
   readonly records: ReadyRecord[] = [];
   private readonly claims: RawClaim[] = [];

package/src/runtime/channels/channel-dispatch-pipeline.ts

@@ -110,7 +110,8 @@ export class ZLinkChannelDispatchPipeline {
       const flow = createInboundFlow(
         dispatch.fields.flowId,
         dispatch.fields.flowOrigin,
-        this.options.dispatchErrors.flow.flowCreationEnabled()
+        this.options.dispatchErrors.flow.flowCreationEnabled(),
+        undefined
       );
       const invocation = await runWithFlow(flow, () =>
         this.invoke(
@@ -161,7 +162,8 @@ export class ZLinkChannelDispatchPipeline {
       const flow = createInboundFlow(
         dispatch.fields.flowId,
         dispatch.fields.flowOrigin,
-        this.options.dispatchErrors.flow.flowCreationEnabled()
+        this.options.dispatchErrors.flow.flowCreationEnabled(),
+        undefined
       );
       const invocation = await runWithFlow(flow, () =>
         this.invoke(

package/src/runtime/channels/channel-transports.ts

@@ -1140,15 +1140,9 @@ export function meshRequestFailure(
   const wireKind = canonical
     ? internalFrameworkErrorKindFromWireReply(result, nativeErrno)
     : undefined;
-  // NotFound without an errno is the selection itself coming back empty: the
-  // send path and its connection are there, and applying eligibility and drain
-  // left no member to pick. The spec names that Unavailable, not NotFound, and
-  // not the protocol error a non-canonical pair would otherwise produce
-  // (06-framework-api "no eligible select-one member"). A named target that
-  // does not exist arrives with an errno and still ends as NotFound.
-  const noEligibleMember = result === RequestResult.NotFound && nativeErrno === 0;
-  const kind: ZLinkFrameworkInternalErrorKindType = noEligibleMember
-    ? ZLinkFrameworkInternalErrorKind.RouteNotConnected
+  const localNoMember = result === RequestResult.NotFound && nativeErrno === 0;
+  const kind: ZLinkFrameworkInternalErrorKindType = localNoMember
+    ? ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
     : !canonical
       ? ZLinkFrameworkInternalErrorKind.RequestProtocolError
       : result === RequestResult.NotFound

package/src/runtime/channels/dispatch-error-reporter.ts

@@ -13,6 +13,7 @@ import {
   type ZLinkDiagnosticsContext
 } from '../diagnostics';
 import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
+import { dispatchErrorDetails } from '../diagnostics/dispatch-error-details';
 
 export type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
 
@@ -46,7 +47,6 @@ export class ZLinkDispatchErrorReporter {
 
   report(event: ZLinkRuntimeDispatchFailure): void {
     const normalized = normalizeDispatchFailure(event);
-    const tracePoint = this.flow.begin(ZLinkMessageFlowOutcome.Error);
     const dropReason = channelDropReason(normalized);
     if (dropReason !== undefined) {
       this.metrics?.count('zlink.mesh_node.messages.dropped', 1, {
@@ -55,8 +55,9 @@ export class ZLinkDispatchErrorReporter {
         reason: dropReason
       });
     }
+    const tracePoint = this.flow.begin(ZLinkMessageFlowOutcome.Error);
     if (tracePoint === undefined) return;
-    const errorInfo = dispatchErrorInfo(normalized);
+    const errorInfo = dispatchErrorDetails(normalized.error);
     this.reportedEvents += 1;
     tracePoint.trace({
       outcome: ZLinkMessageFlowOutcome.Error,
@@ -87,6 +88,10 @@ export class ZLinkDispatchErrorReporter {
     });
   }
 
+  captureEnabled(): boolean {
+    return this.flow.enabled(ZLinkMessageFlowOutcome.Error);
+  }
+
   get reportedCount(): number {
     return this.reportedEvents;
   }
@@ -123,46 +128,3 @@ function channelDropReason(event: ZLinkRuntimeDispatchFailure): string | undefin
       return undefined;
   }
 }
-
-function dispatchErrorInfo(event: ZLinkRuntimeDispatchFailure): {
-  readonly errorType?: string;
-  readonly errorMessage?: string;
-  readonly errorCauseType?: string;
-  readonly errorCauseMessage?: string;
-} {
-  if (event.errorType !== undefined || event.errorMessage !== undefined) {
-    return {
-      errorType: event.errorType,
-      errorMessage: event.errorMessage,
-      errorCauseType: event.errorCauseType,
-      errorCauseMessage: event.errorCauseMessage
-    };
-  }
-  if (event.error === undefined) {
-    return {};
-  }
-  if (event.error instanceof Error) {
-    const cause = deepestErrorCause(event.error);
-    return {
-      errorType: event.error.name,
-      errorMessage: event.error.message,
-      ...(cause === event.error
-        ? {}
-        : {
-            errorCauseType: cause instanceof Error ? cause.name : typeof cause,
-            errorCauseMessage: cause instanceof Error ? cause.message : String(cause)
-          })
-    };
-  }
-  return { errorType: typeof event.error, errorMessage: String(event.error) };
-}
-
-function deepestErrorCause(error: Error): unknown {
-  let current: unknown = error;
-  const seen = new Set<unknown>();
-  while (current instanceof Error && current.cause !== undefined && !seen.has(current)) {
-    seen.add(current);
-    current = current.cause;
-  }
-  return current;
-}

package/src/runtime/diagnostics/dispatch-error-details.ts

@@ -0,0 +1,62 @@
+const ERROR_MESSAGE_MAX_LENGTH = 512;
+
+const CREDENTIAL_PATTERNS: ReadonlyArray<readonly [RegExp, string]> = [
+  [/Authorization\s*:\s*(?:(?:Bearer|Basic)\s+)?[^\s,;]+/gi, 'Authorization: <redacted>'],
+  [/Bearer\s+[^\s,;]+/gi, 'Bearer <redacted>'],
+  [/password\s*=\s*[^\s,;]+/gi, 'password=<redacted>'],
+  [/token\s*=\s*[^\s,;]+/gi, 'token=<redacted>']
+];
+
+export function dispatchErrorDetails(error: unknown): {
+  readonly errorType?: string;
+  readonly errorMessage?: string;
+  readonly errorCauseType?: string;
+  readonly errorCauseMessage?: string;
+} {
+  if (error === undefined || error === null) return {};
+  if (error instanceof Error) {
+    const cause = deepestErrorCause(error);
+    return {
+      errorType: error.name,
+      errorMessage: sanitizeErrorMessage(error.message),
+      ...(cause === error
+        ? {}
+        : {
+            errorCauseType: cause instanceof Error ? cause.name : typeof cause,
+            errorCauseMessage: sanitizeErrorMessage(
+              cause instanceof Error ? cause.message : String(cause)
+            )
+          })
+    };
+  }
+  const errorType = typeof error === 'object' ? error.constructor.name : typeof error;
+  const message =
+    typeof error === 'string' ||
+    typeof error === 'number' ||
+    typeof error === 'boolean' ||
+    typeof error === 'bigint'
+      ? `${error}`
+      : Object.prototype.toString.call(error);
+  return { errorType, errorMessage: sanitizeErrorMessage(message) };
+}
+
+function deepestErrorCause(error: Error): unknown {
+  let current: unknown = error;
+  const seen = new Set<unknown>();
+  while (current instanceof Error && current.cause !== undefined && !seen.has(current)) {
+    seen.add(current);
+    current = current.cause;
+  }
+  return current;
+}
+
+function sanitizeErrorMessage(message: string): string {
+  if (message.length === 0) return '';
+  const lineEnd = message.search(/[\r\n]/u);
+  let sanitized = lineEnd < 0 ? message : message.slice(0, lineEnd);
+  for (const [pattern, replacement] of CREDENTIAL_PATTERNS) {
+    pattern.lastIndex = 0;
+    sanitized = sanitized.replace(pattern, replacement);
+  }
+  return sanitized.slice(0, ERROR_MESSAGE_MAX_LENGTH);
+}