@zlink-systems/framework 0.22.0 → 0.23.0

package/dist/runtime/foundation/raw-service-mesh-runtime.js

@@ -303,9 +303,10 @@ class RawServiceMeshRuntime {
         return this.send(targetNodeRoutingId, [(0, service_wire_m6a_codec_1.encodeNodeSendHeader)(), this.applicationFrame(payload)]);
     }
     async sendToChannel(channelName, payload) {
-        const selected = this.topology.selectChannel(channelName, (peer) => this.isLocalOrReadyPeer(peer.descriptor.nodeRoutingId));
-        if (selected === undefined)
-            return false;
+        const selection = this.selectChannelTarget(channelName);
+        if (selection.kind !== 'selected')
+            return selection.submitResult;
+        const selected = selection.peer;
         const applicationFrame = this.applicationFrame(payload);
         if (selected.descriptor.nodeRoutingId === this.descriptor.nodeRoutingId) {
             const applicationJobOwner = await this.reserveLocalIngress();
@@ -320,25 +321,49 @@ class RawServiceMeshRuntime {
                 });
                 if (!accepted)
                     applicationJob.close();
-                return accepted;
+                return accepted ? runtime_values_1.SubmitResult.Ok : runtime_values_1.SubmitResult.NotAdmitted;
             }
             finally {
                 applicationJobOwner.close();
             }
         }
-        return this.send(selected.descriptor.nodeRoutingId, [
+        return (await this.send(selected.descriptor.nodeRoutingId, [
             (0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName),
             applicationFrame
-        ]);
+        ]))
+            ? runtime_values_1.SubmitResult.Ok
+            : runtime_values_1.SubmitResult.NotConnected;
     }
     requestToNode(targetNodeRoutingId, payload, timeoutMs) {
         return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs);
     }
     requestToChannel(channelName, payload, timeoutMs) {
+        const selection = this.selectChannelTarget(channelName);
+        if (selection.kind !== 'selected') {
+            const pending = this.operations.register(timeoutMs);
+            this.operations.complete(pending.id, selection.requestResult);
+            return pending;
+        }
+        return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName);
+    }
+    selectChannelTarget(channelName) {
         const selected = this.topology.selectChannel(channelName, (peer) => this.isLocalOrReadyPeer(peer.descriptor.nodeRoutingId));
-        return selected === undefined
-            ? undefined
-            : this.requestToTarget(selected.descriptor.nodeRoutingId, payload, timeoutMs, channelName);
+        if (selected !== undefined)
+            return { kind: 'selected', peer: selected };
+        return this.topology.hasKnownChannelTarget(channelName)
+            ? {
+                kind: 'knownButNotReady',
+                submitResult: runtime_values_1.SubmitResult.NotConnected,
+                requestResult: { terminalResult: runtime_values_1.RequestResult.NotConnected, failureCode: 0 }
+            }
+            : {
+                kind: 'noMember',
+                submitResult: runtime_values_1.SubmitResult.NotFound,
+                requestResult: {
+                    terminalResult: runtime_values_1.RequestResult.NotFound,
+                    failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
+                }
+            };
     }
     isLocalOrReadyPeer(nodeRoutingId) {
         return nodeRoutingId === this.descriptor.nodeRoutingId || this.isPeerRouteReady(nodeRoutingId);

package/dist/runtime/foundation/service-session-binding-ingress-port.d.ts

@@ -16,6 +16,7 @@ export interface ServiceSessionBindingAdmissionClaim {
 }
 export type ServiceSessionBindingAdmissionResult = 'passThrough' | 'retained' | 'rejected';
 export interface ServiceSessionBindingIngressPort {
+    actorSlot(actorId: string, sessionRid: string): Promise<number | undefined>;
     retainOutbound(claim: ServiceSessionBindingAdmissionClaim, delivery: ServiceSessionBindingRetainedDelivery): Promise<ServiceSessionBindingAdmissionResult>;
     clearOutbound(actorId: string, error: unknown): Promise<void>;
 }

package/dist/runtime/foundation/service-stateful-runtime.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkDispatchErrorReporter } from '../channels/dispatch-error-reporter';
 import type { RawServiceMeshRuntime } from './raw-service-mesh-runtime';
 import { type ReceiveKindData, type StreamSessionActorAuthorityFence } from './service-runtime-contracts';
 import type { ServiceMailboxRecord } from './service-mailbox';
@@ -221,6 +222,8 @@ export declare class ServiceStatefulRuntime {
     private userSpotOperationHandler?;
     private messageFollowHandler?;
     private mailboxDropHandler?;
+    private dispatchErrors?;
+    private dispatchErrorMeshName?;
     private readonly admittedUserSpotOperations;
     private readonly pendingInstanceActivations;
     private closed;
@@ -229,6 +232,7 @@ export declare class ServiceStatefulRuntime {
         readonly kind: 'spot_multicast' | 'actor_control' | 'actor_binding';
         readonly owner: string;
     }) => void): void;
+    setDispatchErrorReporter(reporter: ZLinkDispatchErrorReporter, meshName: string): void;
     createSpot(routingId?: string, kind?: 'user' | 'instance', stableType?: "user" | "instance"): ServiceSpotState;
     restoreUserSpotAuthority(spotId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpotState;
     restoreSpotAuthority(spotId: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpotState;

package/dist/runtime/foundation/service-stateful-runtime.js

@@ -7,6 +7,7 @@ const abort_1 = require("../abort");
 const execution_1 = require("../execution");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const runtime_values_1 = require("../backend/runtime-values");
+const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const service_runtime_contracts_1 = require("./service-runtime-contracts");
 const message_follow_suppression_registry_1 = require("./message-follow-suppression-registry");
 const service_stateful_registry_1 = require("./service-stateful-registry");
@@ -81,6 +82,8 @@ class ServiceStatefulRuntime {
     userSpotOperationHandler;
     messageFollowHandler;
     mailboxDropHandler;
+    dispatchErrors;
+    dispatchErrorMeshName;
     admittedUserSpotOperations = new Map();
     pendingInstanceActivations = new Map();
     closed = false;
@@ -95,6 +98,10 @@ class ServiceStatefulRuntime {
     setMailboxDropHandler(handler) {
         this.mailboxDropHandler = handler;
     }
+    setDispatchErrorReporter(reporter, meshName) {
+        this.dispatchErrors = reporter;
+        this.dispatchErrorMeshName = meshName;
+    }
     createSpot(routingId, kind = 'user', stableType = kind) {
         this.requireOpen();
         return this.registry.createSpot(routingId ?? `spot-${this.nodeRid}-${this.nextSpotId++}`, kind, stableType);
@@ -623,13 +630,32 @@ class ServiceStatefulRuntime {
         await this.enqueueLogicalMulticast(channelName, topic, sourceSpotId, payload);
         const targets = this.raw.topology
             .peers()
-            .filter((peer) => peer.descriptor.channels.some((channel) => channel.name === channelName && channel.weight > 0));
+            .filter((peer) => peer.descriptor.channels.some((channel) => channel.name === channelName && channel.weight > 0) && this.raw.isPeerRouteReady(peer.descriptor.nodeRoutingId));
         const header = (0, service_stateful_wire_codec_1.encodeLogicalMulticastHeader)(channelName, topic, sourceSpotId);
         const payloadFrame = (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload);
+        const reporter = this.dispatchErrors;
+        const captureFailures = reporter?.captureEnabled() === true;
         for (const target of targets) {
             // Remote admission ends at the source outbound transport queue. The
             // receiver's Spot queue and handler completion are not publish results.
-            await this.raw.sendService(target.descriptor.nodeRoutingId, [header, payloadFrame]);
+            const accepted = await this.raw.sendService(target.descriptor.nodeRoutingId, [
+                header,
+                payloadFrame
+            ]);
+            if (!accepted) {
+                if (captureFailures) {
+                    reporter.report({
+                        surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotRoute,
+                        messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
+                        reason: serviceSpotPublishFailureReason(undefined, this.raw.isPeerRouteReady(target.descriptor.nodeRoutingId), this.closed),
+                        action: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop,
+                        meshName: this.dispatchErrorMeshName,
+                        channelName,
+                        topic,
+                        targetRid: target.descriptor.nodeRoutingId
+                    });
+                }
+            }
         }
     }
     async sendToSpot(sourceSpotId, requested, payload) {
@@ -3504,6 +3530,24 @@ class ServiceStatefulRuntime {
     }
 }
 exports.ServiceStatefulRuntime = ServiceStatefulRuntime;
+function serviceSpotPublishFailureReason(result, routeReady, closed) {
+    if (closed || result === runtime_values_1.SubmitResult.Terminated)
+        return 'shutdown';
+    switch (result) {
+        case runtime_values_1.SubmitResult.Backpressured:
+            return 'backpressure';
+        case runtime_values_1.SubmitResult.NotAdmitted:
+        case runtime_values_1.SubmitResult.NotConnected:
+        case runtime_values_1.SubmitResult.NotFound:
+        case runtime_values_1.SubmitResult.InvalidHandle:
+            return 'stale_target';
+        default:
+            // RawServiceMeshRuntime exposes failed Core submissions as false. A
+            // ready route therefore identifies queue admission failure; a route
+            // that became unready after selection is a stale target.
+            return routeReady ? 'backpressure' : 'stale_target';
+    }
+}
 function isEntrySpotFence(fence) {
     return (fence.spot.spotId === fence.targetNodeRid &&
         fence.spot.generation === fence.targetNodeGeneration &&

package/dist/runtime/foundation/service-topology-registry.d.ts

@@ -55,6 +55,7 @@ export declare class ServiceTopologyRegistry {
     markNotRequired(descriptor: ServiceNodeDescriptor): void;
     forgetNotRequired(nodeRoutingId: string): void;
     knownDescriptor(nodeRoutingId: string): ServiceNodeDescriptor | undefined;
+    hasKnownChannelTarget(channelName: string): boolean;
     private remember;
     selectChannel(channelName: string, isReady?: (peer: AdmittedServicePeer) => boolean): AdmittedServicePeer | undefined;
     selectPlacement(isReady?: (peer: AdmittedServicePeer) => boolean): AdmittedServicePeer | undefined;

package/dist/runtime/foundation/service-topology-registry.js

@@ -170,6 +170,10 @@ class ServiceTopologyRegistry {
         const descriptor = admitted ?? this.notRequiredByRid.get(nodeRoutingId) ?? this.knownByRid.get(nodeRoutingId);
         return descriptor === undefined ? undefined : cloneDescriptor(descriptor);
     }
+    hasKnownChannelTarget(channelName) {
+        requireText(channelName, 'channelName');
+        return [this.local, ...this.knownByRid.values()].some((descriptor) => selectableChannel(descriptor, channelName) !== undefined);
+    }
     remember(descriptor) {
         const current = this.knownByRid.get(descriptor.nodeRoutingId);
         if (current === undefined ||
@@ -190,11 +194,9 @@ class ServiceTopologyRegistry {
             return [local, ...this.peersByRid.values()]
                 .map((peer) => ({
                 peer: clonePeer(peer),
-                channel: findChannel(peer.descriptor, channelName)
+                channel: selectableChannel(peer.descriptor, channelName)
             }))
-                .filter((value) => value.channel !== undefined &&
-                value.peer.descriptor.state === 'serving' &&
-                value.channel.weight > 0);
+                .filter((value) => value.channel !== undefined);
         }, (value) => value.channel.weight, (value) => value.peer.descriptor.nodeRoutingId, (left, right) => compareOrdinal(left.peer.descriptor.nodeRoutingId, right.peer.descriptor.nodeRoutingId), (value) => isReady(value.peer))?.peer;
     }
     selectPlacement(isReady = () => true) {
@@ -338,6 +340,12 @@ function validateSortedUnique(values, key, field) {
 function findChannel(descriptor, channelName) {
     return descriptor.channels.find((channel) => channel.name === channelName);
 }
+function selectableChannel(descriptor, channelName) {
+    if (descriptor.state !== 'serving')
+        return undefined;
+    const channel = findChannel(descriptor, channelName);
+    return channel !== undefined && channel.weight > 0 ? channel : undefined;
+}
 function requireText(value, field) {
     if (value.length === 0 || value.includes('\0')) {
         throw new TypeError(`${field} must be non-empty text without NUL.`);

package/dist/runtime/host/index.js

@@ -2178,7 +2178,7 @@ class ZLinkFrameworkRuntimeHost {
         const current = (0, diagnostics_1.currentOrCreateFlow)('Lifecycle', false);
         const flow = current?.flowOrigin === 'Lifecycle'
             ? current
-            : (0, diagnostics_1.createInboundFlow)(undefined, 'Lifecycle', this.flowCreationEnabled());
+            : (0, diagnostics_1.createInboundFlow)(undefined, 'Lifecycle', this.flowCreationEnabled(), undefined);
         return (0, diagnostics_1.runWithFlow)(flow, operation);
     }
     requirePrimaryMeshNode() {

package/dist/runtime/protocol/service_wire_pilot_codec.generated.js

@@ -66,22 +66,24 @@ function read64(bytes, at) { if (at.value + 8 > bytes.length)
     r = (r << 8n) | BigInt(bytes[at.value++]); return r; }
 function u32(out, value) { if (!Number.isInteger(value) || value < 0 || value > 0xffffffff)
     throw new RangeError("u32"); out.push(value >>> 24, (value >>> 16) & 255, (value >>> 8) & 255, value & 255); }
+function appendBytes(out, bytes) { for (const byte of bytes)
+    out.push(byte); }
 function read32(bytes, at) { if (at.value + 4 > bytes.length)
     throw new RangeError("truncated u32"); return ((bytes[at.value++] << 24) | (bytes[at.value++] << 16) | (bytes[at.value++] << 8) | bytes[at.value++]) >>> 0; }
 function text8(out, value) { const b = text.encode(value); if (b.length === 0 || b.length > 255 || b.includes(0))
-    throw new RangeError("text8"); out.push(b.length, ...b); }
+    throw new RangeError("text8"); out.push(b.length); appendBytes(out, b); }
 function readText8(bytes, at) { const n = bytes[at.value++]; if (n === 0 || at.value + n > bytes.length)
     throw new RangeError("truncated text8"); const b = bytes.slice(at.value, at.value + n); at.value += n; if (b.includes(0))
     throw new RangeError("text8 NUL"); return decodeText.decode(b); }
 function rid(out, value) { if (value.length === 0 || value.length > 255)
-    throw new RangeError("rid"); out.push(value.length, ...value); }
+    throw new RangeError("rid"); out.push(value.length); appendBytes(out, value); }
 function readRid(bytes, at) { const n = bytes[at.value++]; if (n === 0 || at.value + n > bytes.length)
     throw new RangeError("truncated rid"); const r = bytes.slice(at.value, at.value + n); at.value += n; return r; }
 function fence(out, value) { if (value.generation === 0n || value.targetNodeGeneration === 0n || value.expectedAuthorityOwnerGeneration === 0n || value.expectedOwnerLeaseGeneration === 0n)
     throw new RangeError("invalid fence"); text8(out, value.id); u64(out, value.generation); rid(out, value.targetNodeRid); u64(out, value.targetNodeGeneration); u64(out, value.expectedAuthorityOwnerGeneration); u64(out, value.expectedOwnerLeaseGeneration); }
 function readFence(bytes, at) { const value = { id: readText8(bytes, at), generation: read64(bytes, at), targetNodeRid: readRid(bytes, at), targetNodeGeneration: read64(bytes, at), expectedAuthorityOwnerGeneration: read64(bytes, at), expectedOwnerLeaseGeneration: read64(bytes, at) }; if (value.generation === 0n || value.targetNodeGeneration === 0n || value.expectedAuthorityOwnerGeneration === 0n || value.expectedOwnerLeaseGeneration === 0n)
     throw new RangeError("invalid fence"); return value; }
-function encodePayload(value) { const body = []; text8(body, value.packetName); text8(body, value.contentType); u32(body, value.payload.length); body.push(...value.payload); const out = [1]; u32(out, body.length); out.push(...body); return Uint8Array.from(out); }
+function encodePayload(value) { const body = []; text8(body, value.packetName); text8(body, value.contentType); u32(body, value.payload.length); appendBytes(body, value.payload); const out = [1]; u32(out, body.length); appendBytes(out, body); return Uint8Array.from(out); }
 function decodePayload(bytes) { const at = { value: 0 }; if (bytes[at.value++] !== 1)
     throw new RangeError("payload version"); const length = read32(bytes, at); if (length !== bytes.length - at.value)
     throw new RangeError("payload length"); const end = bytes.length; const packetName = readText8(bytes, at); const contentType = readText8(bytes, at); const length2 = read32(bytes, at); if (length2 !== end - at.value)
@@ -93,10 +95,10 @@ function decodeActorJoin28(frames) { if (frames.length < 1 || frames.length > 2)
     throw new RangeError("actorJoin frames"); const bytes = frames[0]; const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 28 || bytes[at.value++] !== 0)
     throw new RangeError("actorJoin header"); const correlation = read64(bytes, at); const actor = readFence(bytes, at); const entry = bytes[at.value++]; const targetSpot = readFence(bytes, at); if (correlation === 0n || entry > 1 || at.value !== bytes.length)
     throw new RangeError("actorJoin body"); const payload = frames.length === 2 ? decodePayload(frames[1]) : undefined; return payload === undefined ? { correlation, actor, entry: entry === 1, targetSpot } : { correlation, actor, entry: entry === 1, targetSpot, payload }; }
-function bytes64(out, v) { u64(out, BigInt(v.length)); out.push(...v); }
+function bytes64(out, v) { u64(out, BigInt(v.length)); appendBytes(out, v); }
 function body16(out, write) { const b = []; write(b); if (b.length > 65535)
-    throw new RangeError("body16"); out.push(b.length >>> 8, b.length & 255, ...b); }
-function body64(out, write) { const b = []; write(b); u64(out, BigInt(b.length)); out.push(...b); }
+    throw new RangeError("body16"); out.push(b.length >>> 8, b.length & 255); appendBytes(out, b); }
+function body64(out, write) { const b = []; write(b); u64(out, BigInt(b.length)); appendBytes(out, b); }
 function sorted(v, compare, name) { for (let i = 1; i < v.length; i++)
     if (compare(v[i - 1], v[i]) >= 0)
         throw new RangeError(name); }
@@ -112,7 +114,7 @@ function readText16(bytes, at, minimum, maximum, name) { const n = read16(bytes,
     throw new RangeError(name); const b = take(bytes, at, n, name); if (b.includes(0))
     throw new RangeError(name + " NUL"); return decodeText.decode(b); }
 function writeText16(out, value, minimum, maximum, name) { const b = text.encode(value); if (b.length < minimum || b.length > maximum || b.includes(0))
-    throw new RangeError(name); out.push(b.length >>> 8, b.length & 255, ...b); }
+    throw new RangeError(name); out.push(b.length >>> 8, b.length & 255); appendBytes(out, b); }
 function boundedEnd(bytes, at, length, name) { if (at.value + length > bytes.length)
     throw new RangeError("truncated " + name); return at.value + length; }
 function exactEnd(at, end, name) { if (at.value !== end)
@@ -305,7 +307,7 @@ function encodeRelocationEnvelopeV1(value) { const out = []; if (value.relocatio
     exactEnd(at, w.frozenRecord.length, "frozen record");
     u64(out, w.participantId);
     u64(out, w.order);
-    out.push(...w.frozenRecord);
+    appendBytes(out, w.frozenRecord);
 } sorted(value.timerRegistrations, (a, b) => a.participantId === b.participantId ? compareUtf8(a.name, b.name) : a.participantId < b.participantId ? -1 : 1, "timerRegistrations"); u32(out, value.timerRegistrations.length); for (const t of value.timerRegistrations) {
     if (t.participantId === 0n || t.periodMilliseconds === 0n || t.maxCatchUpTicks === 0n || t.overrunPolicy < 1 || t.overrunPolicy > 3)
         throw new RangeError("timer");
@@ -385,17 +387,17 @@ function crc32c(bytes) { let crc = 0xffffffff; for (const octet of bytes) {
     for (let bit = 0; bit < 8; bit++)
         crc = (crc >>> 1) ^ ((crc & 1) !== 0 ? 0x82f63b78 : 0);
 } return (~crc) >>> 0; }
-function encodeDurable(magic, body, maximum) { const out = [...magic, 1, 0, 0]; u32(out, body.length); out.push(...body); if (out.length + 4 > maximum)
+function encodeDurable(magic, body, maximum) { const out = [...magic, 1, 0, 0]; u32(out, body.length); appendBytes(out, body); if (out.length + 4 > maximum)
     throw new RangeError("durable format bytes"); u32(out, crc32c(Uint8Array.from(out))); return Uint8Array.from(out); }
 function decodeDurable(bytes, magic, maximum) { if (bytes.length > maximum || bytes.length < 15 || magic.some((v, i) => bytes[i] !== v) || bytes[4] !== 1 || bytes[5] !== 0 || bytes[6] !== 0)
     throw new RangeError("durable header"); const at = { value: 7 }, length = read32(bytes, at), end = boundedEnd(bytes, at, length, "durable body"); if (end + 4 !== bytes.length)
     throw new RangeError("durable length"); const body = bytes.slice(at.value, end); at.value = end; const expected = read32(bytes, at); if (crc32c(bytes.slice(0, end)) !== expected)
     throw new RangeError("durable checksum"); return body; }
 function encodeRelocationDataChunkV1(value) { const body = []; u32(body, value.order); if (value.data.length > 67108864)
-    throw new RangeError("chunk data"); u32(body, value.data.length); body.push(...value.data); return encodeDurable([90, 76, 84, 67], body, 67108886); }
+    throw new RangeError("chunk data"); u32(body, value.data.length); appendBytes(body, value.data); return encodeDurable([90, 76, 84, 67], body, 67108886); }
 function decodeRelocationDataChunkV1(bytes) { const body = decodeDurable(bytes, [90, 76, 84, 67], 67108886), at = { value: 0 }, order = read32(body, at), data = take(body, at, read32(body, at), "chunk data"); exactEnd(at, body.length, "chunk"); return { order, data }; }
 function encodeRelocationManifestV1(value) { if (Number(value.logicalFormatVersion) !== 1 || value.totalLength > 274877906944n || value.inventoryDigestSha256.length !== 32 || value.chunks.length > 4096)
-    throw new RangeError("manifest"); sorted(value.chunks, (a, b) => a.order - b.order, "manifest chunks"); const body = [1]; u64(body, value.totalLength); u32(body, value.totalChecksumCrc32c); body.push(32, ...value.inventoryDigestSha256); u32(body, value.chunks.length); for (const chunk of value.chunks) {
+    throw new RangeError("manifest"); sorted(value.chunks, (a, b) => a.order - b.order, "manifest chunks"); const body = [1]; u64(body, value.totalLength); u32(body, value.totalChecksumCrc32c); body.push(32); appendBytes(body, value.inventoryDigestSha256); u32(body, value.chunks.length); for (const chunk of value.chunks) {
     if (chunk.length === 0n)
         throw new RangeError("chunk length");
     u32(body, chunk.order);
@@ -568,14 +570,14 @@ function b3WriteSourceBase(o, v) { b3WriteId(o, v.relocation, "relocation"); if
     throw new RangeError("sender role"); writeRelocationObject(o, v.object); }
 function b3ReadSourceBase(bytes, at) { const relocation = b3ReadId(bytes, at, "relocation"), targetAttemptGeneration = nonzero64(bytes, at, "target attempt"), coordinator = b3ReadCoordinator(bytes, at), senderRole = b3ReadRole(bytes, at); if (senderRole !== "source")
     throw new RangeError("sender role"); return { relocation, targetAttemptGeneration, coordinator, senderRole, object: readRelocationObject(bytes, at) }; }
-function encodeRelocationData31(v) { const o = b3Header(31); b3WriteSourceBase(o, v); const at = { value: 0 }; skipFrozenRecord(v.record, at); exactEnd(at, v.record.length, "frozen record"); o.push(...v.record); return Uint8Array.from(o); }
+function encodeRelocationData31(v) { const o = b3Header(31); b3WriteSourceBase(o, v); const at = { value: 0 }; skipFrozenRecord(v.record, at); exactEnd(at, v.record.length, "frozen record"); appendBytes(o, v.record); return Uint8Array.from(o); }
 function decodeRelocationData31(bytes) { const at = b3ReadHeader(bytes, 31, "relocationData"), v = b3ReadSourceBase(bytes, at), start = at.value; skipFrozenRecord(bytes, at); const record = bytes.slice(start, at.value); b3Finish(at, bytes, "relocationData"); return { ...v, record }; }
 function encodeRelocationCutover34(v) { const o = b3Header(34); b3WriteSourceBase(o, v); if (v.boundaryRecordCount < 0n || v.boundaryRecordCount > 9223372036854775807n)
     throw new RangeError("boundary count"); u64(o, v.boundaryRecordCount); u32(o, v.boundaryChecksumCrc32c); return Uint8Array.from(o); }
 function decodeRelocationCutover34(bytes) { const at = b3ReadHeader(bytes, 34, "relocationCutover"), v = b3ReadSourceBase(bytes, at), boundaryRecordCount = read64(bytes, at); if (boundaryRecordCount > 9223372036854775807n)
     throw new RangeError("boundary count"); const boundaryChecksumCrc32c = read32(bytes, at); b3Finish(at, bytes, "relocationCutover"); return { ...v, boundaryRecordCount, boundaryChecksumCrc32c }; }
 function encodeRelocationState52(v) { const o = b3Header(52); b3WriteSourceBase(o, v); if (v.chunkData.length > 67108864)
-    throw new RangeError("chunk data"); u32(o, v.chunkOrdinal); u32(o, v.chunkData.length); o.push(...v.chunkData); return Uint8Array.from(o); }
+    throw new RangeError("chunk data"); u32(o, v.chunkOrdinal); u32(o, v.chunkData.length); appendBytes(o, v.chunkData); return Uint8Array.from(o); }
 function decodeRelocationState52(bytes) { const at = b3ReadHeader(bytes, 52, "relocationState"), v = b3ReadSourceBase(bytes, at), chunkOrdinal = read32(bytes, at), length = read32(bytes, at); if (length > 67108864)
     throw new RangeError("chunk data"); const chunkData = take(bytes, at, length, "chunk data"); b3Finish(at, bytes, "relocationState"); return { ...v, chunkOrdinal, chunkData }; }
 function encodeRelocationPrepare40(v) { const o = b3Header(40); b3WriteId(o, v.relocation, "relocation"); if (v.targetAttemptGeneration === 0n || v.sourceNodeGeneration === 0n)
@@ -615,7 +617,7 @@ function b4ReadReservation(bytes, at) { return { reservationId: readText8(bytes,
         throw new RangeError("pending capacity"); return v; })() }; }
 function b4Close(out, v) { const body = []; text8(body, v.spotId); if (v.objectGeneration === 0n || v.targetNodeGeneration === 0n || v.expectedAuthorityOwnerGeneration === 0n)
     throw new RangeError("close fence"); u64(body, v.objectGeneration); rid(body, v.targetNodeRid); u64(body, v.targetNodeGeneration); u64(body, v.expectedAuthorityOwnerGeneration); writeText16(body, v.expectedStoreVersion, 1, 4096, "store version"); out.push(1); if (body.length > 65535)
-    throw new RangeError("close fence"); out.push(body.length >>> 8, body.length & 255, ...body); }
+    throw new RangeError("close fence"); out.push(body.length >>> 8, body.length & 255); appendBytes(out, body); }
 function b4ReadClose(bytes, at) { if (read8(bytes, at) !== 1)
     throw new RangeError("close fence version"); const end = boundedEnd(bytes, at, read16(bytes, at), "close fence"); const value = { spotId: readText8(bytes, at), objectGeneration: nonzero64(bytes, at, "object generation"), targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node generation"), expectedAuthorityOwnerGeneration: nonzero64(bytes, at, "authority generation"), expectedStoreVersion: readText16(bytes, at, 1, 4096, "store version") }; exactEnd(at, end, "close fence"); return value; }
 function b4CommandBase(out, v) { if (v.correlation === 0n || v.sourceNodeGeneration === 0n)
@@ -630,14 +632,14 @@ function decodeUserSpotClose48(bytes) { const at = b4ReadHeader(bytes, 48, "user
 function encodeActorCreate49(v) { const out = b4Header(49); b4CommandBase(out, v); text8(out, v.actorId); text8(out, v.stableType); b4Reservation(out, v.reservation); if (v.deadlineUnixMs === 0n)
     throw new RangeError("deadline"); u64(out, v.deadlineUnixMs); return Uint8Array.from(out); }
 function decodeActorCreate49(bytes) { const at = b4ReadHeader(bytes, 49, "actorCreate"), base = b4ReadCommandBase(bytes, at), actorId = readText8(bytes, at), stableType = readText8(bytes, at), reservation = b4ReadReservation(bytes, at), deadlineUnixMs = nonzero64(bytes, at, "deadline"); b4Finish(at, bytes, "actorCreate"); return { ...base, actorId, stableType, reservation, deadlineUnixMs }; }
-function b4ZljrPayload(v) { if (v.metadata.length > 262144 || v.request.length > 1048576 || v.reply.length > 1048576)
-    throw new RangeError("ZLJR length"); const out = [90, 76, 74, 82, 1]; u32(out, v.metadata.length); u32(out, v.request.length); u32(out, v.reply.length); out.push(...v.metadata, ...v.request, ...v.reply); return Uint8Array.from(out); }
+function b4ZljrPayload(v) { if (v.metadata.length > 262144)
+    throw new RangeError("ZLJR length"); const out = [90, 76, 74, 82, 1]; u32(out, v.metadata.length); u32(out, v.request.length); u32(out, v.reply.length); appendBytes(out, v.metadata); appendBytes(out, v.request); appendBytes(out, v.reply); return Uint8Array.from(out); }
 function b4ReadZljrPayload(bytes) { const at = { value: 0 }; if (read32(bytes, at) !== 0x5a4c4a52 || read8(bytes, at) !== 1)
-    throw new RangeError("ZLJR header"); const metadataLength = read32(bytes, at), requestLength = read32(bytes, at), replyLength = read32(bytes, at); if (metadataLength > 262144 || requestLength > 1048576 || replyLength > 1048576)
+    throw new RangeError("ZLJR header"); const metadataLength = read32(bytes, at), requestLength = read32(bytes, at), replyLength = read32(bytes, at); if (metadataLength > 262144)
     throw new RangeError("ZLJR length"); const metadata = take(bytes, at, metadataLength, "ZLJR metadata"), request = take(bytes, at, requestLength, "ZLJR request"), reply = take(bytes, at, replyLength, "ZLJR reply"); b4Finish(at, bytes, "ZLJR"); return { metadata, request, reply }; }
 function encodeZljrRecordV1(v) { if (v.source.nodeGeneration === 0n || v.source.ownerLeaseGeneration === 0n)
     throw new RangeError("ZLJR record"); const source = []; rid(source, v.source.nodeRid); u64(source, v.source.nodeGeneration); text8(source, v.source.ownerId); u64(source, v.source.ownerLeaseGeneration); if (source.length > 65535)
-    throw new RangeError("ZLJR source"); const payload = b4ZljrPayload(v), body = []; text8(body, "__zlink.actor.routed_join.recovery"); text8(body, "application/x-zlink-actor-routed-join-recovery-v1"); u32(body, payload.length); body.push(...payload); const out = [1, 1, source.length >>> 8, source.length & 255, ...source, 0]; u64(out, v.operation.high); u64(out, v.operation.low); u32(out, 0); out.push(0, 0, 1); u32(out, body.length); out.push(...body); return Uint8Array.from(out); }
+    throw new RangeError("ZLJR source"); const payload = b4ZljrPayload(v), body = []; text8(body, "__zlink.actor.routed_join.recovery"); text8(body, "application/x-zlink-actor-routed-join-recovery-v1"); u32(body, payload.length); appendBytes(body, payload); const out = [1, 1, source.length >>> 8, source.length & 255, ...source, 0]; u64(out, v.operation.high); u64(out, v.operation.low); u32(out, 0); out.push(0, 0, 1); u32(out, body.length); appendBytes(out, body); return Uint8Array.from(out); }
 function decodeZljrRecordV1(bytes) { const at = { value: 0 }; if (read8(bytes, at) !== 1 || read8(bytes, at) !== 1)
     throw new RangeError("ZLJR frozen record"); const sourceEnd = boundedEnd(bytes, at, read16(bytes, at), "ZLJR source"), nodeRid = readRid(bytes, at), nodeGeneration = nonzero64(bytes, at, "source node generation"), ownerId = readText8(bytes, at), ownerLeaseGeneration = nonzero64(bytes, at, "source owner lease"); exactEnd(at, sourceEnd, "ZLJR source"); if (read8(bytes, at) !== 0)
     throw new RangeError("ZLJR metadata flag"); const operation = { high: read64(bytes, at), low: read64(bytes, at) }; if (read32(bytes, at) !== 0 || read16(bytes, at) !== 0 || read8(bytes, at) !== 1)

package/dist/runtime/spots/index.js

@@ -907,7 +907,7 @@ class DefaultZLinkSpotManager {
             throw new configuration_1.ZLinkConfigurationException('MeshNode Instance Spot record is missing the owner Spot RID.');
         }
         const envelope = (0, channel_envelope_1.decodeChannelEnvelope)(record.parts, undefined, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true);
-        const inboundFlow = (0, diagnostics_1.createInboundFlow)(envelope.header.flowId, envelope.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true);
+        const inboundFlow = (0, diagnostics_1.createInboundFlow)(envelope.header.flowId, envelope.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, undefined);
         await (0, diagnostics_1.runWithFlow)(inboundFlow, async () => {
             const request = record.operationKind === service_runtime_contracts_1.OperationKind.InstanceSpotRequest;
             this.traceInstanceMessage(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received, meshName, spotId, record, envelope, 'activating');

package/dist/runtime/spots/spot-actor-packet-dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { ActorRef, ZLinkActor, ZLinkMessageSerializer, ZLinkSpot } from '../../contracts';
+import type { ActorRef, RoutingId, ZLinkActor, ZLinkMessageSerializer, ZLinkSpot } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors';
 import { ZLinkSpotActorHandlerRegistryRuntime } from '../actors';
@@ -24,6 +24,7 @@ export interface ZLinkActorPacketDelivery {
     readonly fallbackActorRef?: ActorRef;
     readonly requestTerminal?: ZLinkActorRequestTerminal;
     readonly messageFollowOrigin?: ZLinkMessageFollowOrigin;
+    readonly sourceSessionRid?: RoutingId;
 }
 /**
  * Spec 15 §4.2 relocation temporary queue: consulted when {@code

package/dist/runtime/spots/spot-actor-packet-dispatch.js

@@ -6,6 +6,7 @@ const contracts_1 = require("../../contracts");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const diagnostics_1 = require("../diagnostics");
 const flow_context_1 = require("../diagnostics/flow-context");
+const managed_stream_1 = require("../streams/managed-stream");
 const actors_1 = require("../actors");
 const protocol_1 = require("../streams/protocol");
 const payload_codec_1 = require("../messaging/payload-codec");
@@ -48,7 +49,11 @@ class ZLinkSpotActorPacketDispatch {
             this.reportInvalidFrame(actorId, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend, error);
             throw error;
         }
-        return (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(header.flowId, header.flowOrigin, flowEnabled), async () => {
+        return (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(header.flowId, header.flowOrigin, flowEnabled, !flowEnabled
+            ? undefined
+            : delivery.sourceSessionRid === undefined
+                ? (0, flow_context_1.currentFlowContext)()?.streamSessionId
+                : (0, managed_stream_1.streamSessionIdFromRoutingId)(delivery.sourceSessionRid)), async () => {
             const messageKind = header.kind === protocol_1.ZLinkStreamMessageKind.Request
                 ? ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest
                 : ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend;

package/dist/runtime/spots/spot-actor-packet-drain.js

@@ -86,6 +86,7 @@ class ZLinkSpotActorPacketDrain {
                     actorId,
                     parts,
                     returnResponse: false,
+                    sourceSessionRid,
                     fallbackActorRef: actorRef
                 });
             }
@@ -133,6 +134,7 @@ class ZLinkSpotActorPacketDrain {
                 actorId,
                 parts,
                 returnResponse: true,
+                sourceSessionRid: info.sourceSessionRid,
                 fallbackActorRef: actorRef
             });
             this.options.replyActorNoBind?.(info, [this.encodeActorReplyFrame(parts[0], protocol_1.ZLinkStreamMessageKind.Response, response)], runtime_values_1.RequestResult.Ok);

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -143,6 +143,9 @@ class ZLinkSpotNodeRuntimeManager {
                 applicationJobReceiveFlowFailureSink: this.options.applicationJobReceiveFlowFailureSink,
                 peerAdmissionSealed: () => this.options.peerAdmissionSealed?.(spotNodeName) ?? false
             });
+            if (this.options.dispatchErrors !== undefined) {
+                node.setDispatchErrorReporter?.(this.options.dispatchErrors, spotNodeName);
+            }
             node.setMailboxRecordDroppedHandler?.((record) => this.options.dispatchErrors?.report({
                 surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel,
                 messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
@@ -813,7 +816,8 @@ class ZLinkSpotNodeRuntimeManager {
         }
         const parts = (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => (0, channel_envelope_1.encodeChannelPublishEnvelopeParts)(channelName, topic, packetName, event, undefined, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, metadata));
         try {
-            publisher.publish(channelName, topic, parts, { flags });
+            const processing = publisher.publish(channelName, topic, parts, { flags });
+            void Promise.resolve(processing).catch(() => undefined);
             return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
         }
         catch (error) {

package/dist/runtime/spots/spot-route-packet-dispatch.js

@@ -83,7 +83,7 @@ class ZLinkSpotRoutePacketDispatch {
             let response;
             const applicationClaim = this.options.claimApplicationWork?.();
             try {
-                await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(envelope.header.flowId, envelope.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true), () => this.options.serial.execute(async () => {
+                await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(envelope.header.flowId, envelope.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, undefined), () => this.options.serial.execute(async () => {
                     const spot = this.options.getTarget();
                     // Keep the wire payload raw until this Spot has acquired its
                     // execution authority. A rejected or superseded work item must not

package/dist/runtime/spots/spot-routed-bound-session-dispatch.js

@@ -12,7 +12,7 @@ class ZLinkSpotRoutedBoundSessionDispatch {
     async dispatch(received) {
         const boundSessionSend = (0, spot_remote_route_codec_1.decodeRemoteBoundSessionSend)(received.parts, this.options.channelCodecs(), this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true);
         if (boundSessionSend !== undefined) {
-            await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(boundSessionSend.flowId ?? boundSessionSend.envelope?.header.flowId, boundSessionSend.flowOrigin ?? boundSessionSend.envelope?.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true), () => this.options.routedBoundSessionReceiver?.(boundSessionSend.actorId, boundSessionSend.message, boundSessionSend.packetName, boundSessionSend.metadata, boundSessionSend.actorRef, boundSessionSend.actorPacketTarget));
+            await (0, flow_context_1.runWithFlow)((0, flow_context_1.createInboundFlow)(boundSessionSend.flowId ?? boundSessionSend.envelope?.header.flowId, boundSessionSend.flowOrigin ?? boundSessionSend.envelope?.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, undefined), () => this.options.routedBoundSessionReceiver?.(boundSessionSend.actorId, boundSessionSend.message, boundSessionSend.packetName, boundSessionSend.metadata, boundSessionSend.actorRef, boundSessionSend.actorPacketTarget));
             if ((0, spot_route_replies_1.hasReplyToken)(received.replyToken)) {
                 (0, spot_route_replies_1.submitRoutePayloadReply)(received, boundSessionSend.envelope, { ok: true });
             }

package/dist/runtime/spots/spot-subscription-dispatch.js

@@ -131,7 +131,7 @@ class ZLinkSpotSubscriptionDispatch {
         }
         const spot = this.options.getTarget();
         const subSource = message.routingId === null ? undefined : String(message.routingId);
-        const inboundFlow = (0, flow_context_1.createInboundFlow)(envelope.header.flowId, envelope.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true);
+        const inboundFlow = (0, flow_context_1.createInboundFlow)(envelope.header.flowId, envelope.header.flowOrigin, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, undefined);
         try {
             await this.options.serial.execute(() => (0, flow_context_1.runWithFlow)(inboundFlow, async () => {
                 // Payload deserialization belongs to the Spot serial turn. Queue

package/dist/runtime/spots/spot-timer.js

@@ -62,7 +62,7 @@ class ZLinkSpotTimerRegistry {
         let callbackStarted = false;
         const timer = startOutsideStateLane(() => new ZLinkManagedTimer(name, periodMs, normalizeTimerOptions(options), async (tick) => {
             callbackStarted = false;
-            const timerFlow = (0, flow_context_1.createInboundFlow)(undefined, 'Timer', this.flowCreationEnabled());
+            const timerFlow = (0, flow_context_1.createInboundFlow)(undefined, 'Timer', this.flowCreationEnabled(), undefined);
             const operation = () => {
                 const current = this.timers.get(name);
                 if (current === undefined ||

package/dist/runtime/streams/actor-session-binding-registry.d.ts

@@ -4,13 +4,18 @@ export interface ZLinkActorSessionBindingActor {
 }
 export interface ZLinkActorSessionBindingContext<TActor extends ZLinkActorSessionBindingActor> {
     readonly routingId?: unknown;
-    bindLocal(actor: TActor, bindingToken: string): void;
+    readonly actorSlotControls?: {
+        enqueueBound(actorSlot: number, actorId: string): Promise<void>;
+        enqueueUnbound(actorSlot: number): Promise<void>;
+    };
+    bindLocal(actor: TActor, bindingToken: string, actorSlot?: number): void;
     unbindLocal(actorId: string, bindingToken: string): void;
 }
 export interface ZLinkActorSessionRoute<TContext extends ZLinkActorSessionBindingContext<TActor>, TActor extends ZLinkActorSessionBindingActor> {
     readonly context: TContext;
     readonly actor: TActor;
     readonly bindingToken: string;
+    readonly actorSlot?: number;
     readonly sessionIdentity?: string;
     readonly activeFrames: ZLinkActorSessionActiveFrames;
     sealId?: string;
@@ -68,22 +73,30 @@ export interface ZLinkActorSessionAuthorityFence {
     readonly authorityStoreVersion?: string;
     readonly actorType?: string;
 }
+export declare enum ZLinkActorSessionBindingTermination {
+    BindingEnd = 0,
+    PhysicalDisconnect = 1
+}
 export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActorSessionBindingContext<TActor>, TActor extends ZLinkActorSessionBindingActor> {
     private readonly terminalRelocationCapacity;
     private readonly outboundCapacity;
     private readonly sealWaitTimeoutMs;
+    private readonly errorSink?;
     private readonly lane;
     private readonly routes;
+    private readonly nextActorSlots;
     private readonly sealWaiters;
     private readonly activeFrameWaiters;
     private readonly relocations;
     private readonly terminalRelocations;
-    constructor(terminalRelocationCapacity?: number, outboundCapacity?: number, sealWaitTimeoutMs?: number);
-    bind(context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string): Promise<void>;
-    private bindCore;
-    replace(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string): Promise<void>;
-    private replaceCore;
-    replaceAndReleaseSeal(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, sealId: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string): Promise<void>;
+    constructor(terminalRelocationCapacity?: number, outboundCapacity?: number, sealWaitTimeoutMs?: number, errorSink?: (() => {
+        reportRuntimeTaskException(taskName: string, error: unknown): void;
+    } | undefined) | undefined);
+    bind(context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string, commitActor?: () => void): Promise<void>;
+    private commitCore;
+    private issueActorSlot;
+    replace(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string, commitActor?: () => void): Promise<void>;
+    replaceAndReleaseSeal(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, sealId: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string, commitActor?: () => void): Promise<void>;
     private replaceAndReleaseSealCore;
     find(actorId: string): Promise<TActor | undefined>;
     private findCore;
@@ -93,7 +106,7 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
         readonly context: TContext;
     } | undefined>;
     private capturePendingReplyClaimCore;
-    unbind(actorId: string, context: TContext, bindingToken: string): Promise<void>;
+    unbind(actorId: string, context: TContext, bindingToken: string, termination?: ZLinkActorSessionBindingTermination): Promise<void>;
     private unbindCore;
     unbindActor(actorId: string): Promise<void>;
     private unbindActorCore;