@zlink-systems/framework 0.21.0 → 0.23.0

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;
@@ -179,14 +179,17 @@ class DefaultZLinkActorJoinSpotCall {
                 execute: async () => {
                     let result;
                     try {
-                        const pending = pendingJoin ?? this.coordinator.joinSpot(this.actor, this.state, this.spotId, requestMessage, remainingJoinTimeout(deadline.atMs), deadline.signal, operationId);
-                        result = this.turn === undefined
-                            ? await pending
-                            : await this.turn.yieldFrameworkPromise(pending);
+                        const pending = pendingJoin ??
+                            this.coordinator.joinSpot(this.actor, this.state, this.spotId, requestMessage, remainingJoinTimeout(deadline.atMs), deadline.signal, operationId);
+                        result =
+                            this.turn === undefined
+                                ? await pending
+                                : await this.turn.yieldFrameworkPromise(pending);
                     }
                     catch (error) {
                         this.state.endDeferredJoin();
-                        await this.coordinator.abortDeferredJoin?.(this.actor, this.state, operationId)
+                        await this.coordinator
+                            .abortDeferredJoin?.(this.actor, this.state, operationId)
                             .catch(() => undefined);
                         await notifyJoinFailure(this.actor, operationId, error, this.coordinator);
                         return;
@@ -195,10 +198,10 @@ class DefaultZLinkActorJoinSpotCall {
                         deadline.close();
                         requestMessage.close();
                     }
-                    if (!result.accepted
-                        || sourceNodeRid === undefined
-                        || result.actor === undefined
-                        || String(sourceNodeRid) === String(result.actor.nodeRid)) {
+                    if (!result.accepted ||
+                        sourceNodeRid === undefined ||
+                        result.actor === undefined ||
+                        String(sourceNodeRid) === String(result.actor.nodeRid)) {
                         await notifyJoinCompletion(this.actor, operationId, result, this.messageSerializers);
                     }
                     else {
@@ -277,7 +280,6 @@ class DefaultZLinkActorJoinEntrySpotCall {
         };
         try {
             (0, actor_join_deferred_scope_1.deferActorJoin)({
-                requestBytes: requestMessage.data().byteLength,
                 prepare: async () => {
                     if (prepared)
                         return;
@@ -299,14 +301,17 @@ class DefaultZLinkActorJoinEntrySpotCall {
                 execute: async () => {
                     let result;
                     try {
-                        const pending = pendingJoin ?? this.coordinator.joinEntrySpot(this.actor, this.state, undefined, requestMessage, remainingJoinTimeout(deadline.atMs), deadline.signal, operationId);
-                        result = this.turn === undefined
-                            ? await pending
-                            : await this.turn.yieldFrameworkPromise(pending);
+                        const pending = pendingJoin ??
+                            this.coordinator.joinEntrySpot(this.actor, this.state, undefined, requestMessage, remainingJoinTimeout(deadline.atMs), deadline.signal, operationId);
+                        result =
+                            this.turn === undefined
+                                ? await pending
+                                : await this.turn.yieldFrameworkPromise(pending);
                     }
                     catch (error) {
                         this.state.endDeferredJoin();
-                        await this.coordinator.abortDeferredJoin?.(this.actor, this.state, operationId)
+                        await this.coordinator
+                            .abortDeferredJoin?.(this.actor, this.state, operationId)
                             .catch(() => undefined);
                         await notifyJoinFailure(this.actor, operationId, error, this.coordinator);
                         return;
@@ -315,10 +320,10 @@ class DefaultZLinkActorJoinEntrySpotCall {
                         deadline.close();
                         requestMessage.close();
                     }
-                    if (!result.accepted
-                        || sourceNodeRid === undefined
-                        || result.actor === undefined
-                        || String(sourceNodeRid) === String(result.actor.nodeRid)) {
+                    if (!result.accepted ||
+                        sourceNodeRid === undefined ||
+                        result.actor === undefined ||
+                        String(sourceNodeRid) === String(result.actor.nodeRid)) {
                         await notifyJoinCompletion(this.actor, operationId, result, this.messageSerializers);
                     }
                     else {
@@ -430,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,
@@ -438,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-creation.js

@@ -93,9 +93,10 @@ class ZLinkActorCreationCoordinator {
         }
         let response;
         try {
-            response = nodeRid === undefined
-                ? { accepted: true }
-                : await this.options.actorCreatedNotifier?.(nodeRid, actor, createRequest.callbackRequest, signal) ?? { accepted: true };
+            response =
+                nodeRid === undefined
+                    ? { accepted: true }
+                    : ((await this.options.actorCreatedNotifier?.(nodeRid, actor, createRequest.callbackRequest, signal)) ?? { accepted: true });
         }
         catch (error) {
             await this.discardStagingActor(state, nativeActorNode);

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

@@ -46,7 +46,8 @@ class ZLinkActorHandoffCoordinator {
     replyRoutes = new Map();
     constructor(options) {
         this.options = options;
-        this.messageFollowDurationMs = options.messageFollowDurationMs ?? exports.DEFAULT_MESSAGE_FOLLOW_DURATION_MS;
+        this.messageFollowDurationMs =
+            options.messageFollowDurationMs ?? exports.DEFAULT_MESSAGE_FOLLOW_DURATION_MS;
     }
     begin(actorId, oldGeneration) {
         this.startHandoff(actorId, oldGeneration, { phase: 'relocating' });
@@ -62,10 +63,12 @@ class ZLinkActorHandoffCoordinator {
             throw new Error(`Actor '${actorId}' handoff requires a positive source ObjectGeneration.`);
         }
         const source = this.options.requestSource(actorId);
-        if (source.meshName.length === 0 || source.ownerId.length === 0
-            || source.ownerLeaseGeneration <= 0n
-            || source.nodeRid.length === 0 || source.nodeGeneration <= 0n
-            || source.authorityOwnerGeneration <= 0n) {
+        if (source.meshName.length === 0 ||
+            source.ownerId.length === 0 ||
+            source.ownerLeaseGeneration <= 0n ||
+            source.nodeRid.length === 0 ||
+            source.nodeGeneration <= 0n ||
+            source.authorityOwnerGeneration <= 0n) {
             throw new Error(`Actor '${actorId}' handoff requires an exact source owner fence.`);
         }
         if (source.objectGeneration !== oldGeneration) {
@@ -85,8 +88,7 @@ class ZLinkActorHandoffCoordinator {
             ownerId: source.ownerId,
             ownerLeaseGeneration: source.ownerLeaseGeneration,
             nodeRid: sourceOwner.nodeRid,
-            nodeRidHex: sourceOwner.nodeRidHex
-                ?? (0, routing_id_1.encodeRoutingIdStorageHex)(sourceOwner.nodeRid),
+            nodeRidHex: sourceOwner.nodeRidHex ?? (0, routing_id_1.encodeRoutingIdStorageHex)(sourceOwner.nodeRid),
             nodeGeneration: source.nodeGeneration,
             authorityOwnerGeneration: source.authorityOwnerGeneration
         });
@@ -195,7 +197,7 @@ class ZLinkActorHandoffCoordinator {
         void start.then(() => {
             release.startOpen = true;
             this.finishPrefixReleaseIfIdle(actorId, handoff, release);
-        }, error => {
+        }, (error) => {
             release.startOpen = true;
             if (handoff.pending.length === 0)
                 release.errors.push(error);
@@ -222,7 +224,7 @@ class ZLinkActorHandoffCoordinator {
         const pending = handoff.pending.slice(begin, end);
         let admitted;
         try {
-            admitted = release.queue(pending.map(record => this.createPrefixRecord(record, release)));
+            admitted = release.queue(pending.map((record) => this.createPrefixRecord(record, release)));
         }
         catch (error) {
             this.failUnqueuedPrefix(handoff, release, error);
@@ -230,7 +232,7 @@ class ZLinkActorHandoffCoordinator {
         }
         release.cursor = end;
         release.inFlight += 1;
-        void admitted.terminal.then(() => this.completePrefixBatch(actorId, handoff, release), error => {
+        void admitted.terminal.then(() => this.completePrefixBatch(actorId, handoff, release), (error) => {
             release.errors.push(error);
             this.completePrefixBatch(actorId, handoff, release);
         });
@@ -291,9 +293,7 @@ class ZLinkActorHandoffCoordinator {
         this.finishPrefixReleaseIfIdle(actorId, handoff, release);
     }
     finishPrefixReleaseIfIdle(actorId, handoff, release) {
-        if (!release.startOpen
-            || release.inFlight !== 0
-            || release.cursor !== handoff.pending.length)
+        if (!release.startOpen || release.inFlight !== 0 || release.cursor !== handoff.pending.length)
             return;
         if (handoff.prefixRelease === release)
             handoff.prefixRelease = undefined;
@@ -413,14 +413,14 @@ class ZLinkActorHandoffCoordinator {
     }
     capture(actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay) {
         const incomingContext = (0, actor_message_follow_context_1.actorMessageFollowContext)(fallbackActorRef);
-        const originalDeadlineUnixMs = deadlineUnixMs
-            ?? incomingContext?.deadlineUnixMs
-            ?? packetDeadlineUnixMs(parts);
+        const originalDeadlineUnixMs = deadlineUnixMs ?? incomingContext?.deadlineUnixMs ?? packetDeadlineUnixMs(parts);
         const handoff = this.active.get(actorId);
         if (handoff !== undefined) {
             if (parts.length < 2)
                 return Promise.resolve(undefined);
-            if (handoff.connectionBoundSealed && !returnResponse && remoteBoundSessionTarget !== undefined) {
+            if (handoff.connectionBoundSealed &&
+                !returnResponse &&
+                remoteBoundSessionTarget !== undefined) {
                 // The Session route seal already fixed the accepted high water. A
                 // send whose lifetime is only the Session connection can no longer
                 // drain here and must never enter the durable frozen journal, so the
@@ -430,7 +430,8 @@ class ZLinkActorHandoffCoordinator {
             if (handoff.phase === 'provisional' && handoff.replay === undefined) {
                 handoff.replay = provisionalReplay;
             }
-            const context = incomingContext ?? this.createInitialIngressContext(handoff.sourceOwner, handoff.oldGeneration, parts, returnResponse, originalDeadlineUnixMs);
+            const context = incomingContext ??
+                this.createInitialIngressContext(handoff.sourceOwner, handoff.oldGeneration, parts, returnResponse, originalDeadlineUnixMs);
             try {
                 this.validateContext(actorId, context, parts, returnResponse, fallbackActorRef);
             }
@@ -499,13 +500,13 @@ class ZLinkActorHandoffCoordinator {
         }
         const followRoute = this.findMessageFollowRoute(actorId, incomingContext);
         const staleGeneration = fallbackActorRef?.objectGeneration;
-        if (fallbackActorRef !== undefined
-            && this.options.isCurrentActorRef?.(actorId, fallbackActorRef) === true) {
+        if (fallbackActorRef !== undefined &&
+            this.options.isCurrentActorRef?.(actorId, fallbackActorRef) === true) {
             if (incomingContext !== undefined) {
                 this.validateContext(actorId, incomingContext, parts, returnResponse, fallbackActorRef);
                 const currentFence = this.options.currentOwnerFence?.(actorId);
-                if (currentFence !== undefined
-                    && !(0, actor_message_follow_context_1.messageFollowOwnerFencesEqual)(incomingContext.targetOwner, currentFence)) {
+                if (currentFence !== undefined &&
+                    !(0, actor_message_follow_context_1.messageFollowOwnerFencesEqual)(incomingContext.targetOwner, currentFence)) {
                     // A relocation round trip (A→B→A) keeps the ObjectGeneration, so a
                     // context resolved against a departed tenure still addresses this
                     // node while the current tenure holds strictly newer authority
@@ -526,18 +527,17 @@ class ZLinkActorHandoffCoordinator {
             }
             return undefined;
         }
-        if (incomingContext === undefined
-            && fallbackActorRef !== undefined
-            && this.hasMessageFollowRouteForStaleRef(actorId, fallbackActorRef)) {
+        if (incomingContext === undefined &&
+            fallbackActorRef !== undefined &&
+            this.hasMessageFollowRouteForStaleRef(actorId, fallbackActorRef)) {
             this.options.onMarker?.('message_follow_rejected', actorId);
             return Promise.reject(actorLocationStale(actorId));
         }
-        if (followRoute === undefined
-            &&
-                staleGeneration !== undefined
-            && this.staleGenerations.get(actorId)?.has(staleGeneration) === true
-            && fallbackActorRef !== undefined
-            && this.isKnownStaleRef(actorId, fallbackActorRef)) {
+        if (followRoute === undefined &&
+            staleGeneration !== undefined &&
+            this.staleGenerations.get(actorId)?.has(staleGeneration) === true &&
+            fallbackActorRef !== undefined &&
+            this.isKnownStaleRef(actorId, fallbackActorRef)) {
             this.options.onMarker?.('message_follow_expired', actorId);
             return Promise.reject(actorLocationStale(actorId));
         }
@@ -575,8 +575,8 @@ class ZLinkActorHandoffCoordinator {
     snapshotCoreBacklog(actorId) {
         const handoff = this.requireActive(actorId);
         let snapshotIndex = -1;
-        while (snapshotIndex + 1 < handoff.pending.length
-            && handoff.pending[snapshotIndex + 1].packet.returnResponse === false) {
+        while (snapshotIndex + 1 < handoff.pending.length &&
+            handoff.pending[snapshotIndex + 1].packet.returnResponse === false) {
             snapshotIndex++;
         }
         handoff.snapshotIndex = snapshotIndex;
@@ -592,7 +592,7 @@ class ZLinkActorHandoffCoordinator {
         const handoff = this.requireActive(actorId);
         const first = handoff.snapshotIndex + 1;
         handoff.snapshotIndex = handoff.pending.length - 1;
-        return handoff.pending.slice(first).map(entry => entry.packet);
+        return handoff.pending.slice(first).map((entry) => entry.packet);
     }
     complete(actorId, target, targetActorRef, results, targetOwnerFence) {
         const handoff = this.requireActive(actorId);
@@ -630,10 +630,9 @@ class ZLinkActorHandoffCoordinator {
             if (pending.packet.source !== undefined) {
                 this.removeReplyRoute(pending.packet.source.replyRouteId);
             }
-            void this.enqueueMessageFollow(followRoute, actorId, pending.packet)
-                .then(value => {
+            void this.enqueueMessageFollow(followRoute, actorId, pending.packet).then((value) => {
                 pending.resolve?.(value);
-            }, error => {
+            }, (error) => {
                 pending.reject?.(error);
             });
         }
@@ -641,16 +640,15 @@ class ZLinkActorHandoffCoordinator {
     messageFollowCount(actorId) {
         return actorId === undefined
             ? this.messageFollowRoutes.size
-            : [...this.messageFollowRoutes.values()]
-                .filter(route => route.targetActorRef.actorId === actorId).length;
+            : [...this.messageFollowRoutes.values()].filter((route) => route.targetActorRef.actorId === actorId).length;
     }
     pendingCount(actorId) {
         return this.active.get(actorId)?.pending.length ?? 0;
     }
     isKnownStale(actor) {
-        return this.messageFollowCount(actor.actorId) === 0
-            && this.options.isCurrentActorRef?.(actor.actorId, actor) !== true
-            && this.isKnownStaleRef(actor.actorId, actor);
+        return (this.messageFollowCount(actor.actorId) === 0 &&
+            this.options.isCurrentActorRef?.(actor.actorId, actor) !== true &&
+            this.isKnownStaleRef(actor.actorId, actor));
     }
     recordStaleFailure(actorId) {
         this.options.onMarker?.('message_follow_rejected', actorId);
@@ -660,10 +658,10 @@ class ZLinkActorHandoffCoordinator {
         if (source === undefined || source.replyRouteId.length === 0)
             return 'notAcknowledged';
         const route = this.replyRoutes.get(source.replyRouteId);
-        if (route === undefined
-            || packet.messageFollowContext.objectGeneration
-                !== route.sourceEvidence.objectGeneration.toString()
-            || !(0, actor_message_follow_context_1.messageFollowOwnerFencesEqual)(packet.messageFollowContext.targetOwner, route.sourceOwner)) {
+        if (route === undefined ||
+            packet.messageFollowContext.objectGeneration !==
+                route.sourceEvidence.objectGeneration.toString() ||
+            !(0, actor_message_follow_context_1.messageFollowOwnerFencesEqual)(packet.messageFollowContext.targetOwner, route.sourceOwner)) {
             return 'notAcknowledged';
         }
         return this.acceptRelocatedTerminalRelay(packet.messageFollowContext.operationId, source.replyRouteId, source, result, sourceNodeRid, targetAuthorityOwnerGeneration, actorId).status;
@@ -675,14 +673,14 @@ class ZLinkActorHandoffCoordinator {
         if (route === undefined)
             return { status: 'notAcknowledged' };
         const exactSource = source ?? route.source;
-        if (!requestSourcesEqual(route.source, exactSource)
-            || (actorId !== undefined && route.actorId !== actorId)
-            || route.operationId !== operationId
-            || route.targetNodeRid === undefined
-            || !(0, routing_id_1.routingIdsEqual)(route.targetNodeRid, sourceNodeRid)
-            || route.targetAuthorityOwnerGeneration === undefined
-            || (targetAuthorityOwnerGeneration !== undefined
-                && route.targetAuthorityOwnerGeneration !== targetAuthorityOwnerGeneration)) {
+        if (!requestSourcesEqual(route.source, exactSource) ||
+            (actorId !== undefined && route.actorId !== actorId) ||
+            route.operationId !== operationId ||
+            route.targetNodeRid === undefined ||
+            !(0, routing_id_1.routingIdsEqual)(route.targetNodeRid, sourceNodeRid) ||
+            route.targetAuthorityOwnerGeneration === undefined ||
+            (targetAuthorityOwnerGeneration !== undefined &&
+                route.targetAuthorityOwnerGeneration !== targetAuthorityOwnerGeneration)) {
             return { status: 'notAcknowledged' };
         }
         try {
@@ -823,8 +821,8 @@ class ZLinkActorHandoffCoordinator {
         const stale = this.staleGenerations.get(actorId);
         if (stale !== undefined) {
             const recordedGeneration = stale.get(entry.oldGeneration);
-            if (recordedGeneration !== undefined
-                && recordedGeneration <= departedAuthorityOwnerGeneration) {
+            if (recordedGeneration !== undefined &&
+                recordedGeneration <= departedAuthorityOwnerGeneration) {
                 stale.delete(entry.oldGeneration);
             }
             if (stale.size === 0)
@@ -849,10 +847,10 @@ class ZLinkActorHandoffCoordinator {
         return this.messageFollowRoutes.get(messageFollowRouteKey(actorId, BigInt(context.objectGeneration), context.targetOwner));
     }
     hasMessageFollowRouteForStaleRef(actorId, actorRef) {
-        return [...this.messageFollowRoutes.values()].some(route => route.targetActorRef.actorId === actorId
-            && actorRef.objectGeneration === route.oldGeneration
-            && (route.oldNodeRid === undefined
-                || (0, routing_id_1.routingIdsEqual)(actorRef.nodeRid, (0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(route.sourceOwner))));
+        return [...this.messageFollowRoutes.values()].some((route) => route.targetActorRef.actorId === actorId &&
+            actorRef.objectGeneration === route.oldGeneration &&
+            (route.oldNodeRid === undefined ||
+                (0, routing_id_1.routingIdsEqual)(actorRef.nodeRid, (0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(route.sourceOwner))));
     }
     createInitialIngressContext(sourceOwner, generation, parts, request, deadlineUnixMs) {
         const operationId = (0, actor_message_follow_context_1.createMessageFollowId)();
@@ -871,15 +869,14 @@ class ZLinkActorHandoffCoordinator {
         });
     }
     validateContext(actorId, context, parts, request, actorRef) {
-        if (actorRef !== undefined
-            && context.objectGeneration !== actorRef.objectGeneration.toString()) {
+        if (actorRef !== undefined &&
+            context.objectGeneration !== actorRef.objectGeneration.toString()) {
             throw actorGenerationStale(actorId);
         }
         if (context.objectGeneration === '0' || context.request !== request) {
             throw actorLocationStale(actorId);
         }
-        if (context.deadlineUnixMs !== undefined
-            && Date.now() >= context.deadlineUnixMs) {
+        if (context.deadlineUnixMs !== undefined && Date.now() >= context.deadlineUnixMs) {
             throw actorDeadlineExceeded(actorId);
         }
         (0, actor_message_follow_context_1.verifyActorMessageFollowPayload)(context, parts);
@@ -888,13 +885,15 @@ class ZLinkActorHandoffCoordinator {
         const physicalRefs = this.staleActorRefs.get(actorId);
         if (physicalRefs !== undefined) {
             const departedAuthorityOwnerGeneration = physicalRefs.get(actorRefKey(actor.nodeRid, actor.objectGeneration));
-            return departedAuthorityOwnerGeneration !== undefined
-                && !this.isNewerTenureRef(actorId, actor, departedAuthorityOwnerGeneration);
-        }
-        const departedAuthorityOwnerGeneration = this.staleGenerations.get(actorId)?.get(actor.objectGeneration);
-        return departedAuthorityOwnerGeneration !== undefined
-            && !this.isNewerTenureRef(actorId, actor, departedAuthorityOwnerGeneration)
-            && this.options.isStaleActorRef?.(actorId, actor) === true;
+            return (departedAuthorityOwnerGeneration !== undefined &&
+                !this.isNewerTenureRef(actorId, actor, departedAuthorityOwnerGeneration));
+        }
+        const departedAuthorityOwnerGeneration = this.staleGenerations
+            .get(actorId)
+            ?.get(actor.objectGeneration);
+        return (departedAuthorityOwnerGeneration !== undefined &&
+            !this.isNewerTenureRef(actorId, actor, departedAuthorityOwnerGeneration) &&
+            this.options.isStaleActorRef?.(actorId, actor) === true);
     }
     /**
      * The stale record captures the departing tenure's full fence. A ref whose
@@ -921,9 +920,9 @@ class ZLinkActorHandoffCoordinator {
         const context = packet.messageFollowContext;
         const duplicate = entry.operations.get(context.operationId);
         if (duplicate !== undefined) {
-            if (duplicate.checksum !== context.payloadChecksumSha256
-                || duplicate.request !== context.request
-                || duplicate.replyRouteId !== context.replyRouteId) {
+            if (duplicate.checksum !== context.payloadChecksumSha256 ||
+                duplicate.request !== context.request ||
+                duplicate.replyRouteId !== context.replyRouteId) {
                 this.options.onMarker?.('message_follow_rejected', actorId);
                 return Promise.reject(actorLocationStale(actorId));
             }
@@ -1026,7 +1025,8 @@ class ZLinkActorHandoffCoordinator {
                 return;
             let accepted = false;
             try {
-                accepted = await this.options.onMessageFollowRelayed?.(actorId, entry.targetActorRef, context, packet.messageFollowOrigin, entry.queuedMessages, entry.queuedBytes) === true;
+                accepted =
+                    (await this.options.onMessageFollowRelayed?.(actorId, entry.targetActorRef, context, packet.messageFollowOrigin, entry.queuedMessages, entry.queuedBytes)) === true;
             }
             catch {
                 accepted = false;
@@ -1090,9 +1090,9 @@ async function replayActorHandoffBacklog(backlog, dispatch, onEnqueued) {
     for (const packet of backlog) {
         const decoded = decodeHandoffPacket(packet);
         try {
-            if (packet.returnResponse
-                && packet.messageFollowContext.deadlineUnixMs !== undefined
-                && Date.now() >= packet.messageFollowContext.deadlineUnixMs) {
+            if (packet.returnResponse &&
+                packet.messageFollowContext.deadlineUnixMs !== undefined &&
+                Date.now() >= packet.messageFollowContext.deadlineUnixMs) {
                 throw actorDeadlineExceeded(packet.fallbackActorRef?.actorId ?? 'accepted-handoff');
             }
             await onEnqueued?.(packet.index);
@@ -1104,9 +1104,7 @@ async function replayActorHandoffBacklog(backlog, dispatch, onEnqueued) {
                 index: packet.index,
                 ok: false,
                 error: error instanceof Error ? error.message : String(error),
-                errorKind: error instanceof contracts_1.ZLinkFrameworkException
-                    ? (0, framework_errors_internal_1.internalFrameworkErrorKind)(error)
-                    : undefined
+                errorKind: error instanceof contracts_1.ZLinkFrameworkException ? (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) : undefined
             });
         }
         finally {
@@ -1213,13 +1211,13 @@ function actorRefEvidenceKey(nodeRid, nodeRidHex, generation) {
     return `${nodeRidHex ?? (0, routing_id_1.encodeRoutingIdStorageHex)(nodeRid)}\u0000${generation}`;
 }
 function requestSourcesEqual(expected, actual) {
-    return expected.replyRouteId === actual.replyRouteId
-        && expected.ownerId === actual.ownerId
-        && expected.ownerLeaseGeneration === actual.ownerLeaseGeneration
-        && expected.nodeRid === actual.nodeRid
-        && expected.nodeGeneration === actual.nodeGeneration
-        && /^[1-9][0-9]*$/.test(actual.ownerLeaseGeneration)
-        && /^[1-9][0-9]*$/.test(actual.nodeGeneration);
+    return (expected.replyRouteId === actual.replyRouteId &&
+        expected.ownerId === actual.ownerId &&
+        expected.ownerLeaseGeneration === actual.ownerLeaseGeneration &&
+        expected.nodeRid === actual.nodeRid &&
+        expected.nodeGeneration === actual.nodeGeneration &&
+        /^[1-9][0-9]*$/.test(actual.ownerLeaseGeneration) &&
+        /^[1-9][0-9]*$/.test(actual.nodeGeneration));
 }
 function terminalRequestSource(route) {
     return Object.freeze({
@@ -1243,10 +1241,9 @@ function actorMoving(actorId) {
     return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorMoving, `Actor '${actorId}' bound-session send arrived after its Session route seal.`, true);
 }
 function actorRelayError(actorId, errorKind, error) {
-    const kind = Object.values(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind)
-        .includes(errorKind)
+    const kind = Object.values(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind).includes(errorKind)
         ? errorKind
         : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed;
-    return (0, framework_errors_internal_1.createInternalFrameworkException)(kind, String(error ?? `Actor Message Follow relay failed for '${actorId}'.`), kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorMoving
-        || kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected);
+    return (0, framework_errors_internal_1.createInternalFrameworkException)(kind, String(error ?? `Actor Message Follow relay failed for '${actorId}'.`), kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorMoving ||
+        kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected);
 }

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/actor-local-native-join.js

@@ -31,8 +31,7 @@ class ZLinkLocalNativeActorJoin {
         }
         const completion = await this.waitForJoinCompletion(() => node.joinActorSpot(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(target.spotId), target.targetSpotGeneration, actorJoinApplicationPayload(request), timeoutMs), completions, timeoutMs, signal);
         const control = completion.kindData;
-        if (control?.kind !== 'actorJoinCompletion' ||
-            control.actor === null) {
+        if (control?.kind !== 'actorJoinCompletion' || control.actor === null) {
             (0, mesh_completion_table_1.closeMeshCompletion)(completion);
             const message = `Actor join failed for '${actor.context.actorId}' with result '${completion.terminalResult}' and errno '${completion.failureErrno}'.`;
             //  Classify the (terminal, fine) pair instead of collapsing every non-OK
@@ -85,14 +84,15 @@ class ZLinkLocalNativeActorJoin {
         const completions = this.requireCompletions();
         const actorMeshName = runtimeActorMeshName(actor, state, '');
         const targetNodeRid = spotRouteTarget?.targetNodeRid ?? nodeRid;
-        const remote = spotRouteTarget !== undefined && (!(0, routing_id_2.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(node.status().routingId), spotRouteTarget.targetNodeRid) || !(0, routing_id_2.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(actorRef.nodeRid), spotRouteTarget.targetNodeRid));
+        const remote = spotRouteTarget !== undefined &&
+            (!(0, routing_id_2.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(node.status().routingId), spotRouteTarget.targetNodeRid) ||
+                !(0, routing_id_2.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(actorRef.nodeRid), spotRouteTarget.targetNodeRid));
         if (remote) {
             return await this.relocateRemoteActorJoin(node, actor, state, actorRef, spotRouteTarget, request, timeoutMs, signal, completionOperationId, true);
         }
         const completion = await this.waitForJoinCompletion(() => node.joinActorEntrySpot(actorRef, (0, routing_id_1.toBackendRoutingId)(targetNodeRid), actorJoinApplicationPayload(request), timeoutMs), completions, timeoutMs, signal);
         const control = completion.kindData;
-        if (control?.kind !== 'actorJoinCompletion' ||
-            control.actor === null) {
+        if (control?.kind !== 'actorJoinCompletion' || control.actor === null) {
             (0, mesh_completion_table_1.closeMeshCompletion)(completion);
             const message = `Actor entry SPOT join failed for '${actor.context.actorId}' with result '${completion.terminalResult}' and errno '${completion.failureErrno}'.`;
             //  Classify the (terminal, fine) pair instead of collapsing to NotFound
@@ -149,9 +149,7 @@ class ZLinkLocalNativeActorJoin {
         }
         const completions = this.requireCompletions();
         let relocationId = (0, node_crypto_1.randomUUID)();
-        const completionOperationKey = completionOperationId === undefined
-            ? undefined
-            : (0, operation_identity_1.operationIdentityKey)(completionOperationId);
+        const completionOperationKey = completionOperationId === undefined ? undefined : (0, operation_identity_1.operationIdentityKey)(completionOperationId);
         if (completionOperationKey === relocationId) {
             throw new Error('Actor Join OperationId must be distinct from RelocationId.');
         }
@@ -161,8 +159,7 @@ class ZLinkLocalNativeActorJoin {
         // the existing internal admission route (wire protocol §10); fabricating
         // an Actor fence from the destination Spot would let a stale source pass
         // receiver-side Authority-row equality.
-        const canonicalAdmission = actorAuthorityFence === undefined
-            || !supportsCanonicalActorJoin(node, entrySpot)
+        const canonicalAdmission = actorAuthorityFence === undefined || !supportsCanonicalActorJoin(node, entrySpot)
             ? undefined
             : {
                 request: actorJoinApplicationPayload(request),
@@ -359,19 +356,21 @@ function canonicalHandoffRelocationId(handoffId) {
     if (!/^[0-9a-f]{32}$/u.test(hex) || /^0+$/u.test(hex)) {
         throw new TypeError('Canonical Actor Join handoff id is not a non-zero 128-bit identity.');
     }
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}`
-        + `-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    return (`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}` +
+        `-${hex.slice(16, 20)}-${hex.slice(20)}`);
 }
 function remoteActorJoinFailureException(node, target, terminalResult, failureErrno, message) {
     const failure = (0, framework_errors_internal_1.wireReplyFailureException)(terminalResult, failureErrno, message);
     const targetGeneration = target.targetNodeGeneration;
-    if (failure.kind === contracts_1.ZLinkFrameworkErrorKind.DeadlineExceeded
-        && targetGeneration !== undefined
-        && targetGeneration !== 0n
-        && !node.peers().some((peer) => peer.state === 3
-            && peer.routingId !== null
-            && (0, routing_id_2.routingIdsEqual)(peer.routingId, target.targetNodeRid)
-            && peer.lifecycleGeneration === targetGeneration)) {
+    if (failure.kind === contracts_1.ZLinkFrameworkErrorKind.DeadlineExceeded &&
+        targetGeneration !== undefined &&
+        targetGeneration !== 0n &&
+        !node
+            .peers()
+            .some((peer) => peer.state === 3 &&
+            peer.routingId !== null &&
+            (0, routing_id_2.routingIdsEqual)(peer.routingId, target.targetNodeRid) &&
+            peer.lifecycleGeneration === targetGeneration)) {
         return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, 'wire Actor join target RouteMesh peer became unavailable');
     }
     return failure;