@zlink-systems/framework 0.22.0 → 0.23.0

package/dist/contracts/Dispatch/ZLinkDispatchOptions.d.ts

@@ -71,6 +71,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/dist/contracts/Streams/IZLinkSession.d.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';
 export interface ZLinkSession {
@@ -14,6 +14,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> {
     create(context: ZLinkSessionContext): Promise<TSession>;

package/dist/runtime/actors/actor-context.js

@@ -12,6 +12,7 @@ const actor_lifecycle_snapshot_1 = require("./actor-lifecycle-snapshot");
 const operation_identity_1 = require("../foundation/operation-identity");
 const actor_join_deferred_scope_1 = require("./actor-join-deferred-scope");
 const execution_1 = require("../execution");
+const dispatch_error_details_1 = require("../diagnostics/dispatch-error-details");
 exports.ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME = Symbol('zlink.actor.join-entry-spot-runtime');
 class DefaultZLinkActorContext {
     state;
@@ -154,7 +155,6 @@ class DefaultZLinkActorJoinSpotCall {
         };
         try {
             (0, actor_join_deferred_scope_1.deferActorJoin)({
-                requestBytes: requestMessage.data().byteLength,
                 prepare: async () => {
                     if (prepared)
                         return;
@@ -280,7 +280,6 @@ class DefaultZLinkActorJoinEntrySpotCall {
         };
         try {
             (0, actor_join_deferred_scope_1.deferActorJoin)({
-                requestBytes: requestMessage.data().byteLength,
                 prepare: async () => {
                     if (prepared)
                         return;
@@ -436,6 +435,7 @@ async function notifyJoinFailure(actor, operationId, error, coordinator) {
     //  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(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error);
+    const errorDetails = tracePoint === undefined ? undefined : (0, dispatch_error_details_1.dispatchErrorDetails)(error);
     tracePoint?.trace({
         outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error,
         surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotActor,
@@ -444,8 +444,8 @@ async function notifyJoinFailure(actor, operationId, error, coordinator) {
         actorId: actor.context.actorId,
         errorReason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException,
         errorAction: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError,
-        errorType: String(frameworkError.kind),
-        errorMessage: String(error)
+        errorType: errorDetails?.errorType,
+        errorMessage: errorDetails?.errorMessage
     });
     await actor.onJoinCompleted?.({
         status: 'failed',

package/dist/runtime/actors/actor-join-deferred-scope.d.ts

@@ -1,5 +1,4 @@
 interface DeferredActorJoin {
-    readonly requestBytes: number;
     /** Starts target admission after the handler terminal, before reply admission. */
     readonly prepare?: () => Promise<void> | void;
     readonly execute: () => Promise<void>;

package/dist/runtime/actors/actor-join-deferred-scope.js

@@ -2,15 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deferActorJoin = deferActorJoin;
 exports.runActorHandlerWithDeferredJoins = runActorHandlerWithDeferredJoins;
-const framework_errors_internal_1 = require("../framework-errors-internal");
 const node_async_hooks_1 = require("node:async_hooks");
 const configuration_1 = require("../configuration");
-const MAX_DEFERRED_JOINS = 64;
-const MAX_DEFERRED_JOIN_REQUEST_BYTES = 1024 * 1024;
-const MAX_DEFERRED_JOIN_BYTES = 8 * 1024 * 1024;
 class ActorJoinRegistrationScope {
     intents = [];
-    totalBytes = 0;
     open = true;
     prepared = false;
     // Ledger 2.3: a deferred join runs in registration order right after the
@@ -21,20 +16,7 @@ class ActorJoinRegistrationScope {
             discardWithoutWaiting(intent);
             throw new configuration_1.ZLinkConfigurationException('Actor join defer requires an open Framework actor handler scope.');
         }
-        if (this.intents.length >= MAX_DEFERRED_JOINS) {
-            discardWithoutWaiting(intent);
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidConfiguration, `An actor handler may defer at most ${MAX_DEFERRED_JOINS} joins.`);
-        }
-        if (intent.requestBytes > MAX_DEFERRED_JOIN_REQUEST_BYTES) {
-            discardWithoutWaiting(intent);
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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() {
         this.open = false;

package/dist/runtime/actors/deferred-join-accepted-journal.js

@@ -16,7 +16,6 @@ const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_p
 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');
 /** Identifies whether an authority slot points at a deferred Join journal root. */
 async function isDeferredJoinAcceptedRootPublication(relocation, reference, checksumCrc32c, expected, signal) {
@@ -487,14 +486,11 @@ function encodeRoot(value) {
             cursor: value.cursor
         }), 'utf8')
     ]);
-    if (encoded.byteLength > MAX_ROOT_BYTES) {
-        throw new Error('Deferred Join completion root exceeds 1 MiB.');
-    }
     return encoded;
 }
 function decodeRoot(payload) {
-    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/dist/runtime/backend/contracts/index.d.ts

@@ -32,6 +32,7 @@ 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/dist/runtime/backend/node/node-raw-mesh-backend.d.ts

@@ -1,5 +1,6 @@
 import { SubmitResult, type RequestResult as RequestResultValue, type SubmitResult as SubmitResultValue } from '@zlink-systems/zlink';
 import { type ZLinkBackendMessageLike as MessageLike } from '../runtime-values';
+import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-reporter';
 import type { MeshOperationId, MeshPeerEntry, MeshPublisher, ReadyBatch, ReadyRecord, ReceiveBatch, ServiceSpot, StreamSessionService } from '../../foundation/service-runtime-contracts';
 import { type RawServiceRequestResult } from '../../foundation/raw-service-mesh-runtime';
 import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
@@ -52,6 +53,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private mailboxRecordDropped?;
     private protocolError?;
     private messageFollowHandler?;
+    private dispatchErrors?;
     private readonly peerDisconnectedHandlers;
     constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined);
     configureObjectPlacement(options: {
@@ -66,6 +68,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly kind: 'spot_multicast' | 'actor_control' | 'actor_binding';
         readonly owner: string;
     }) => void): void;
+    setDispatchErrorReporter(reporter: ZLinkDispatchErrorReporter): void;
     setProtocolErrorHandler(handler: (record: {
         readonly sourceNodeRid: string;
         readonly request: boolean;

package/dist/runtime/backend/node/node-raw-mesh-backend.js

@@ -4,6 +4,7 @@ exports.ZLinkNodeRawMeshBackend = void 0;
 exports.genericOperationFailure = genericOperationFailure;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:timers/promises");
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const contracts_1 = require("../../../contracts");
 const framework_errors_internal_1 = require("../../framework-errors-internal");
@@ -80,6 +81,7 @@ class ZLinkNodeRawMeshBackend {
     mailboxRecordDropped;
     protocolError;
     messageFollowHandler;
+    dispatchErrors;
     peerDisconnectedHandlers = new Set();
     constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed) {
         this.meshName = meshName;
@@ -108,6 +110,10 @@ class ZLinkNodeRawMeshBackend {
         this.mailboxRecordDropped = handler;
         this.stateful?.setMailboxDropHandler(handler);
     }
+    setDispatchErrorReporter(reporter) {
+        this.dispatchErrors = reporter;
+        this.stateful?.setDispatchErrorReporter(reporter, this.meshName);
+    }
     setProtocolErrorHandler(handler) {
         this.protocolError = handler;
     }
@@ -204,6 +210,9 @@ class ZLinkNodeRawMeshBackend {
         });
         runtime.start();
         this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration);
+        if (this.dispatchErrors !== undefined) {
+            this.stateful.setDispatchErrorReporter(this.dispatchErrors, this.meshName);
+        }
         if (this.mailboxRecordDropped !== undefined) {
             this.stateful.setMailboxDropHandler(this.mailboxRecordDropped);
         }
@@ -375,15 +384,10 @@ class ZLinkNodeRawMeshBackend {
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.NodeRequest, pending.promise);
     }
     async sendToChannel(channelName, parts) {
-        return (await this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts)))
-            ? zlink_1.SubmitResult.Ok
-            : zlink_1.SubmitResult.NotConnected;
+        return this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts));
     }
     requestToChannel(channelName, parts, options) {
         const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? 30_000);
-        if (pending === undefined) {
-            return this.enqueueImmediateFailure(service_runtime_contracts_1.OperationKind.ChannelRequest, zlink_1.RequestResult.NotFound);
-        }
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.ChannelRequest, pending.promise);
     }
     status() {
@@ -1037,7 +1041,7 @@ class RawStreamSessionService {
         this.requireStarted();
         const sessionKey = String(sessionRid);
         this.sessionTargets.set(sessionKey, sessionRid);
-        return this.observe(service_runtime_contracts_1.OperationKind.StreamBind, this.stateful.bindSession(sessionKey, actor, timeoutMs, (targetSessionRid, payloadFrame) => this.deliver(targetSessionRid, payloadFrame), onBindingReplaced, (0, service_session_binding_ingress_port_1.serviceSessionBindingIngressPortIfRegistered)(this), actorAuthority));
+        return this.observe(service_runtime_contracts_1.OperationKind.StreamBind, this.stateful.bindSession(sessionKey, actor, timeoutMs, (targetSessionRid, payloadFrame) => this.deliver(targetSessionRid, actor.actorId, payloadFrame), onBindingReplaced, (0, service_session_binding_ingress_port_1.serviceSessionBindingIngressPortIfRegistered)(this), actorAuthority));
     }
     unbindActor(sessionRid, actor, expectedBindingGeneration, timeoutMs = 30_000) {
         this.requireStarted();
@@ -1050,7 +1054,7 @@ class RawStreamSessionService {
         this.requireStarted();
         return (await this.stateful.sendSessionToActor(String(sessionRid), actor, encodeMultipart(parts)));
     }
-    async deliver(sessionRid, payload) {
+    async deliver(sessionRid, actorId, payload) {
         const target = this.sessionTargets.get(sessionRid);
         if (target === undefined)
             return false;
@@ -1058,6 +1062,10 @@ class RawStreamSessionService {
         const parts = decodeMultipartBuffers((0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload).payload);
         if (parts.length === 0)
             return false;
+        const actorSlot = await (0, service_session_binding_ingress_port_1.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]);
@@ -1095,6 +1103,11 @@ class RawStreamSessionService {
         }
     }
 }
+function streamFrameWithActorSlot(frame, actorSlot) {
+    const decodedFrame = (0, stream_wire_1.decodeStreamWireFrame)(frame);
+    const decodedHeader = (0, stream_wire_1.decodeStreamWireHeader)(decodedFrame.header);
+    return (0, stream_wire_1.encodeStreamWireFrame)((0, stream_wire_1.encodeStreamWireHeader)({ ...decodedHeader, actorSlot }), decodedFrame.payload);
+}
 class RawReadyBatch {
     capacity;
     records = [];

package/dist/runtime/channels/channel-dispatch-pipeline.js

@@ -29,7 +29,7 @@ class ZLinkChannelDispatchPipeline {
             return;
         }
         try {
-            const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled());
+            const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled(), undefined);
             const invocation = await (0, flow_context_1.runWithFlow)(flow, () => this.invoke(dispatch.envelope, dispatch.codecs, dispatch.handler, dispatch.context, dispatch.fields, dispatch.signal));
             if (invocation.handlerInvoked) {
                 this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed, dispatch.fields);
@@ -57,7 +57,7 @@ class ZLinkChannelDispatchPipeline {
         }
         let reply;
         try {
-            const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled());
+            const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled(), undefined);
             const invocation = await (0, flow_context_1.runWithFlow)(flow, () => this.invoke(dispatch.envelope, dispatch.codecs, dispatch.handler, dispatch.context, dispatch.fields, dispatch.signal));
             if (!invocation.handlerInvoked) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `A handler filter rejected '${this.options.channelName}:${dispatch.fields.packetName}'.`);

package/dist/runtime/channels/channel-transports.js

@@ -424,15 +424,9 @@ function meshRequestFailure(meshName, result, nativeErrno) {
     const wireKind = canonical
         ? (0, framework_errors_internal_1.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 === runtime_values_1.RequestResult.NotFound && nativeErrno === 0;
-    const kind = noEligibleMember
-        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected
+    const localNoMember = result === runtime_values_1.RequestResult.NotFound && nativeErrno === 0;
+    const kind = localNoMember
+        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
         : !canonical
             ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError
             : result === runtime_values_1.RequestResult.NotFound

package/dist/runtime/channels/dispatch-error-reporter.d.ts

@@ -17,6 +17,7 @@ export declare class ZLinkDispatchErrorReporter {
     readonly flow: ZLinkMessageFlowTracer;
     constructor(_observerType: undefined, _providerResolver: unknown, errorSink: ZLinkDispatchErrorSink, ctx?: ZLinkDiagnosticsContext, metrics?: ZLinkRuntimeMetrics | undefined);
     report(event: ZLinkRuntimeDispatchFailure): void;
+    captureEnabled(): boolean;
     get reportedCount(): number;
     get providerFailureCount(): number;
 }

package/dist/runtime/channels/dispatch-error-reporter.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkDispatchErrorReporter = void 0;
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const diagnostics_1 = require("../diagnostics");
+const dispatch_error_details_1 = require("../diagnostics/dispatch-error-details");
 class ZLinkDispatchErrorReporter {
     metrics;
     reportedEvents = 0;
@@ -23,7 +24,6 @@ class ZLinkDispatchErrorReporter {
     }
     report(event) {
         const normalized = normalizeDispatchFailure(event);
-        const tracePoint = this.flow.begin(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error);
         const dropReason = channelDropReason(normalized);
         if (dropReason !== undefined) {
             this.metrics?.count('zlink.mesh_node.messages.dropped', 1, {
@@ -32,9 +32,10 @@ class ZLinkDispatchErrorReporter {
                 reason: dropReason
             });
         }
+        const tracePoint = this.flow.begin(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error);
         if (tracePoint === undefined)
             return;
-        const errorInfo = dispatchErrorInfo(normalized);
+        const errorInfo = (0, dispatch_error_details_1.dispatchErrorDetails)(normalized.error);
         this.reportedEvents += 1;
         tracePoint.trace({
             outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error,
@@ -64,6 +65,9 @@ class ZLinkDispatchErrorReporter {
             errorCauseMessage: errorInfo.errorCauseMessage
         });
     }
+    captureEnabled() {
+        return this.flow.enabled(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error);
+    }
     get reportedCount() {
         return this.reportedEvents;
     }
@@ -97,39 +101,3 @@ function channelDropReason(event) {
             return undefined;
     }
 }
-function dispatchErrorInfo(event) {
-    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) {
-    let current = error;
-    const seen = new Set();
-    while (current instanceof Error && current.cause !== undefined && !seen.has(current)) {
-        seen.add(current);
-        current = current.cause;
-    }
-    return current;
-}

package/dist/runtime/diagnostics/dispatch-error-details.d.ts

@@ -0,0 +1,6 @@
+export declare function dispatchErrorDetails(error: unknown): {
+    readonly errorType?: string;
+    readonly errorMessage?: string;
+    readonly errorCauseType?: string;
+    readonly errorCauseMessage?: string;
+};

package/dist/runtime/diagnostics/dispatch-error-details.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchErrorDetails = dispatchErrorDetails;
+const ERROR_MESSAGE_MAX_LENGTH = 512;
+const CREDENTIAL_PATTERNS = [
+    [/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>']
+];
+function dispatchErrorDetails(error) {
+    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) {
+    let current = error;
+    const seen = new Set();
+    while (current instanceof Error && current.cause !== undefined && !seen.has(current)) {
+        seen.add(current);
+        current = current.cause;
+    }
+    return current;
+}
+function sanitizeErrorMessage(message) {
+    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);
+}

package/dist/runtime/diagnostics/flow-context.d.ts

@@ -2,6 +2,7 @@ import type { ZLinkFlowOrigin } from '../../contracts';
 export interface ZLinkFlowContextValue {
     readonly flowId: string;
     readonly flowOrigin: ZLinkFlowOrigin;
+    readonly streamSessionId?: string;
 }
 export declare function currentFlowContext(): ZLinkFlowContextValue | undefined;
 export declare function currentOrCreateFlow(origin?: ZLinkFlowOrigin, createIfAbsent?: true): ZLinkFlowContextValue;
@@ -18,4 +19,4 @@ export declare function runWithFlow<T>(flow: ZLinkFlowContextValue | undefined,
  * observe the same ambient flow, so the source-side hop stays coherent.
  */
 export declare function runWithOutboundFlow<T>(enabled: boolean, callback: () => T): T;
-export declare function createInboundFlow(flowId?: string, flowOrigin?: ZLinkFlowOrigin, createIfAbsent?: boolean): ZLinkFlowContextValue | undefined;
+export declare function createInboundFlow(flowId: string | undefined, flowOrigin: ZLinkFlowOrigin | undefined, createIfAbsent: boolean, streamSessionId: string | undefined): ZLinkFlowContextValue | undefined;

package/dist/runtime/diagnostics/flow-context.js

@@ -50,11 +50,11 @@ function runWithOutboundFlow(enabled, callback) {
     }
     return flowStorage.run({ flowId: createFlowId(), flowOrigin: 'Application' }, callback);
 }
-function createInboundFlow(flowId, flowOrigin, createIfAbsent = true) {
+function createInboundFlow(flowId, flowOrigin, createIfAbsent, streamSessionId) {
     if (!createIfAbsent) {
         return undefined;
     }
-    return { flowId: flowId ?? createFlowId(), flowOrigin: flowOrigin ?? 'Inbound' };
+    return { flowId: flowId ?? createFlowId(), flowOrigin: flowOrigin ?? 'Inbound', streamSessionId };
 }
 function createFlowId() {
     const bytes = (0, node_crypto_1.randomBytes)(16);

package/dist/runtime/diagnostics/message-flow.js

@@ -17,6 +17,7 @@ exports.DEFAULT_ZLINK_DIAGNOSTICS = {
 };
 const telemetryLogger = api_logs_1.logs.getLogger('@zlink-systems/framework');
 const telemetryTracer = api_1.trace.getTracer('@zlink-systems/framework');
+const ERROR_MESSAGE_MAX_LENGTH = 512;
 let diagnosticsGeneration = 0n;
 function effectiveMessageFlow(ctx) {
     return ctx.liveMode.mode;
@@ -111,12 +112,13 @@ class ZLinkMessageFlowTracer {
         this.traceAcceptedAtMode(flowInput, effectiveMode, flowId, ambient?.flowOrigin);
     }
     traceAcceptedAtMode(flowInput, effectiveMode, acceptedFlowId, acceptedFlowOrigin) {
-        const ambient = acceptedFlowId === undefined ? (0, flow_context_1.currentFlowContext)() : undefined;
+        const ambient = (0, flow_context_1.currentFlowContext)();
         const flowId = flowInput.flowId ?? acceptedFlowId ?? ambient?.flowId;
         const flowOrigin = flowInput.flowOrigin ?? acceptedFlowOrigin ?? ambient?.flowOrigin;
         const flow = {
             ...flowInput,
             ...(flowId === undefined ? {} : { flowId, flowOrigin }),
+            streamSessionId: flowInput.streamSessionId ?? ambient?.streamSessionId,
             effectiveMode
         };
         this.tracedEvents += 1;
@@ -237,11 +239,12 @@ function toTelemetryRecord(flow, messageSizeBytes, durationSeconds) {
         instanceSpotType: flow.instanceSpotType,
         activationState: flow.activationState,
         actorId: flow.actorId,
+        streamSessionId: flow.streamSessionId,
         commandId: flow.commandId,
         messageSizeBytes,
         durationSeconds,
         errorType: flow.errorType,
-        errorMessage: boundedText(flow.errorMessage),
+        errorMessage: flow.errorMessage,
         errorCauseType: flow.errorCauseType,
         errorCauseMessage: boundedText(flow.errorCauseMessage)
     };
@@ -277,6 +280,7 @@ function structuredLogAttributes(record) {
         instance_spot_type: record.instanceSpotType,
         activation_state: record.activationState,
         actor_id: record.actorId,
+        stream_session_id: record.streamSessionId,
         correlation_id: record.correlationId,
         flow_id: record.flowId,
         flow_origin: record.flowOrigin,
@@ -311,11 +315,15 @@ function structuredLogBodyAttributes(record) {
         instance_type: record.instanceSpotType,
         activation_state: record.activationState,
         actor: record.actorId,
+        session: record.streamSessionId,
         corr: record.correlationId,
         flow: record.flowId,
         origin: record.flowOrigin,
         outcome: record.outcome,
         reason: record.reason,
+        action: record.action,
+        error_type: record.errorType,
+        error_message: record.errorMessage,
         size: record.messageSizeBytes
     });
 }
@@ -421,7 +429,7 @@ function hashFlowId(flowId) {
     return hash >>> 0;
 }
 function boundedText(value) {
-    return value === undefined ? undefined : value.slice(0, 512);
+    return value === undefined ? undefined : value.slice(0, ERROR_MESSAGE_MAX_LENGTH);
 }
 function toSnakeCase(value) {
     return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);

package/dist/runtime/foundation/actor-join-recovery-codec.js

@@ -11,7 +11,6 @@ const service_stateful_wire_codec_1 = require("./service-stateful-wire-codec");
 const RECOVERY_PACKET_NAME = '__zlink.actor.routed_join.recovery';
 const RECOVERY_CONTENT_TYPE = 'application/x-zlink-actor-routed-join-recovery-v1';
 const MAXIMUM_METADATA_BYTES = 256 * 1024;
-const MAXIMUM_MESSAGE_BYTES = 1024 * 1024;
 const FRAMEWORK_METADATA_UPPER_BOUND_BYTES = 64 * 1024;
 const ACCEPTED_JOURNAL_UPPER_BOUND_BYTES = 16 * 1024 * 1024;
 const SNAPSHOT_APPLICATION_STATE_RESERVATION_BYTES = 64 * 1024 * 1024;
@@ -51,9 +50,6 @@ function encodeCanonicalActorJoinRecoverySavedWork(input) {
     const operationId = input.operationId;
     const reply = operationId === undefined ? Buffer.alloc(0) : Buffer.from(input.reply ?? []);
     const request = Buffer.from(input.request);
-    if (request.byteLength > MAXIMUM_MESSAGE_BYTES || reply.byteLength > MAXIMUM_MESSAGE_BYTES) {
-        throw new RangeError('Actor Join recovery message exceeds 1 MiB.');
-    }
     const replyContentType = operationId === undefined
         ? null
         : requireText(input.replyContentType, 'Actor Join reply content type');

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { ZLinkRawBindingPort } from '../backend/raw-binding-port';
+import { SubmitResult } from '../backend/runtime-values';
 import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
 import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
 import { type PendingOperation } from './operation-registry';
@@ -107,9 +108,10 @@ export declare class RawServiceMeshRuntime {
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
     sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
-    sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
+    sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<SubmitResult>;
     requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
-    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult> | undefined;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
+    private selectChannelTarget;
     private isLocalOrReadyPeer;
     setServiceIngress(handler: RawServiceIngressHandler): void;
     reserveLocalIngress(signal?: AbortSignal): Promise<ApplicationIngressRecordOwner>;