@zlink-systems/framework 0.31.0 → 0.32.1

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

@@ -6601,6 +6601,9 @@ function readRequestSpecificTail(reader, context, enclosing, flags) {
         value["bindingGeneration"] = readNonzeroU64(body, context, value, flags);
         value["authorityOwnerGeneration"] = readNonzeroU64(body, context, value, flags);
     }
+    else if (same(value["originalOperationKind"], "streamBind") && same(value["terminalResult"], "rejected")) {
+        value["rejectionMessage"] = readNonemptyText16(body, context, value, flags);
+    }
     else if (same(value["originalOperationKind"], "userSpotCreate") && same(value["terminalResult"], "ok")) {
         value["createResult"] = readUserSpotCreateResult(body, context, value, flags);
         value["spot"] = readSpotRef(body, context, value, flags);
@@ -6622,7 +6625,7 @@ function writeRequestSpecificTail(input, writer, context, enclosing, flags) {
     const value = input;
     const body = writer;
     if (same(value["originalOperationKind"], "actorLookup") && same(value["terminalResult"], "ok")) {
-        if (value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
+        if (value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["rejectionMessage"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
             fail("request-specific-tail discriminator agreement");
         if (value["actor"] === undefined)
             fail("actor required");
@@ -6641,14 +6644,14 @@ function writeRequestSpecificTail(input, writer, context, enclosing, flags) {
         writeNonzeroU64(numeric(value["authorityOwnerGeneration"]), body, context, value, flags);
     }
     else if (same(value["originalOperationKind"], "actorJoin") && same(value["terminalResult"], "ok")) {
-        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["bindingGeneration"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["bindingGeneration"] !== undefined || value["rejectionMessage"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
             fail("request-specific-tail discriminator agreement");
         if (value["join"] === undefined)
             fail("join required");
         writeActorJoinReplyTail(value["join"], body, context, value, flags);
     }
     else if (same(value["originalOperationKind"], "streamBind") && same(value["terminalResult"], "ok")) {
-        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["join"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["join"] !== undefined || value["rejectionMessage"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
             fail("request-specific-tail discriminator agreement");
         if (value["bindingGeneration"] === undefined)
             fail("bindingGeneration required");
@@ -6657,8 +6660,15 @@ function writeRequestSpecificTail(input, writer, context, enclosing, flags) {
             fail("authorityOwnerGeneration required");
         writeNonzeroU64(numeric(value["authorityOwnerGeneration"]), body, context, value, flags);
     }
+    else if (same(value["originalOperationKind"], "streamBind") && same(value["terminalResult"], "rejected")) {
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
+            fail("request-specific-tail discriminator agreement");
+        if (value["rejectionMessage"] === undefined)
+            fail("rejectionMessage required");
+        writeNonemptyText16(value["rejectionMessage"], body, context, value, flags);
+    }
     else if (same(value["originalOperationKind"], "userSpotCreate") && same(value["terminalResult"], "ok")) {
-        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["rejectionMessage"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
             fail("request-specific-tail discriminator agreement");
         if (value["createResult"] === undefined)
             fail("createResult required");
@@ -6668,21 +6678,21 @@ function writeRequestSpecificTail(input, writer, context, enclosing, flags) {
         writeSpotRef(value["spot"], body, context, value, flags);
     }
     else if (same(value["originalOperationKind"], "userSpotClose") && same(value["terminalResult"], "ok")) {
-        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["creation"] !== undefined)
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["rejectionMessage"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["creation"] !== undefined)
             fail("request-specific-tail discriminator agreement");
         if (value["closed"] === undefined)
             fail("closed required");
         writeBool8(value["closed"], body, context, value, flags);
     }
     else if (same(value["originalOperationKind"], "actorCreate") && same(value["terminalResult"], "ok")) {
-        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined)
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["rejectionMessage"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined)
             fail("request-specific-tail discriminator agreement");
         if (value["creation"] === undefined)
             fail("creation required");
         writeActorCreateTerminal(value["creation"], body, context, value, flags);
     }
     else {
-        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
+        if (value["actor"] !== undefined || value["spotId"] !== undefined || value["spotGeneration"] !== undefined || value["membershipEpoch"] !== undefined || value["authorityOwnerGeneration"] !== undefined || value["join"] !== undefined || value["bindingGeneration"] !== undefined || value["rejectionMessage"] !== undefined || value["createResult"] !== undefined || value["spot"] !== undefined || value["closed"] !== undefined || value["creation"] !== undefined)
             fail("request-specific-tail discriminator agreement");
     }
 }

package/dist/runtime/spots/index.d.ts

@@ -10,7 +10,7 @@ export { ZLinkSpotActorAdmissionCoordinator } from './spot-actor-admission-coord
 import type { ZLinkSpotRouteResolver, ZLinkSpotRouteTarget } from './spot-routing-internal';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
-import { ZLinkMessage, ZLinkFrameworkRuntimeState } from '../../contracts';
+import { ZLinkMessage, ZLinkFrameworkRuntimeState, ZLinkSpotCloseReason } from '../../contracts';
 import { type ZLinkRuntimeEventPublisher } from '../diagnostics';
 import { type ReadyRecord, type ReceiveRecord } from '../foundation/service-runtime-contracts';
 import type { ZLinkBackendSpot, ZLinkBackendSpotNode } from '../backend/contracts';
@@ -27,9 +27,11 @@ export { DefaultZLinkSpotOutbound, type ZLinkSpotAddressCallOptions, type ZLinkS
 import { type ZLinkSpotRoutedTransport } from './spot-outbound';
 export { DefaultZLinkSpotHandlerRegistry, type ZLinkSpotHandlerRegistration } from './spot-handler-registry';
 export { ZLinkRuntimeSpotPublisherTransport } from './spot-publisher-transport';
+import { ZLinkSpotActivationRegistry } from './spot-activation-registry';
 import type { ZLinkSpotActivation } from './spot-activation-state';
 import type { ZLinkSpotPreparationCompletion } from './spot-serial-executor';
 import { type ZLinkNativeSpotAuthority } from './spot-activation';
+import { ZLinkFormalRemoteActorAdmissionRegistry } from './formal-remote-actor-admission-registry';
 import type { ZLinkSpotActorHandoffRuntime, ZLinkSpotActorTransferRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
 import type { ZLinkRuntimeAdmissionGate, ZLinkMeshDispatchAdmission } from '../admission';
 import type { ZLinkActivationAdmission } from '../activation-admission';
@@ -126,6 +128,15 @@ export interface ZLinkSpotManagerOptions {
     };
     readonly activationAdmission?: ZLinkActivationAdmission;
 }
+interface ZLinkTargetSpotCloseOperation {
+    readonly activation: ZLinkSpotActivation;
+    readonly reason: ZLinkSpotCloseReason;
+    readonly beginAuthority: (onCommitted: () => void) => Promise<import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined>;
+    authority?: import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority;
+    authorityDecision?: Promise<void>;
+    ready?: Promise<boolean>;
+    canExecuteApplication?(record: import('../execution/serial-execution-queue').ZLinkSerialWorkRecord<unknown>): boolean;
+}
 export declare class DefaultZLinkSpotManager {
     private readonly options;
     [inspectRuntime](): Readonly<{
@@ -133,17 +144,17 @@ export declare class DefaultZLinkSpotManager {
         hasCloseableActivation: (meshName: string, spotId: RoutingId) => boolean;
     }>;
     private readonly factories;
-    private readonly activations;
+    readonly activations: ZLinkSpotActivationRegistry;
     private readonly workerRuntime;
     private readonly locationClaim;
     private readonly routedSpotPackets;
     private readonly actorMembership;
     private readonly activationLifecycle;
     private readonly formalRemoteTransfers;
-    private readonly formalRemoteActorAdmissions;
+    readonly formalRemoteActorAdmissions: ZLinkFormalRemoteActorAdmissionRegistry;
     private readonly pendingInstanceMaterializations;
     private readonly pendingInstanceMaterializationsByPrefix;
-    private readonly closeOperations;
+    readonly closeOperations: Map<string, ZLinkTargetSpotCloseOperation>;
     private readonly pendingInstanceTerminals;
     private readonly pendingInstanceTerminalGenerations;
     private readonly deferredInstanceAuthorityReleases;
@@ -216,6 +227,8 @@ export declare class DefaultZLinkSpotManager {
     dispatchRoutedActorPacket(origin: ApplicationJobOrigin, spotId: RoutingId, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     /** Resolves the current Actor FIFO owner for both Entry and User membership. */
     admitSourceActorPacketPrefix(actorId: string, records: readonly ZLinkActorHandoffPrefixRecord[]): ZLinkActorHandoffPrefixAdmission;
+    /** Runs an owner-side lifecycle decision in the Actor's existing execution gate. */
+    executeActorTurn<T>(meshName: string, spotId: RoutingId | undefined, actorId: string, operation: () => Promise<T>): Promise<T>;
     dispatchRoutedSpotSend(spotId: RoutingId, packetName: string | undefined, message: unknown, context: {
         readonly channelName: string;
         readonly contentType?: string;
@@ -238,7 +251,9 @@ export declare class DefaultZLinkSpotManager {
     private traceInstanceMessage;
     dispatchMeshActor(origin: ApplicationJobOrigin, meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<void>;
     dispatchMeshActorJoin(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
-    private dispatchMeshActorJoinCore;
+    dispatchMeshActorJoinCore(meshName: string, owner: ReadyRecord, record: ReceiveRecord, replyState: {
+        targetCommitPublished: boolean;
+    }): Promise<void>;
     dispatchMeshSpotControl(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
     private dispatchMeshSpotControlCore;
     completeFormalSourceLeaveTerminal(actorId: string, transferId: string, succeeded: boolean): Promise<boolean>;

package/dist/runtime/spots/index.js

@@ -950,6 +950,20 @@ class DefaultZLinkSpotManager {
         }
         return this.admitRoutedActorPacketPrefix(owner.spotId, actorId, records);
     }
+    /** Runs an owner-side lifecycle decision in the Actor's existing execution gate. */
+    executeActorTurn(meshName, spotId, actorId, operation) {
+        if (spotId === undefined) {
+            if (this.options.executeEntryActor === undefined) {
+                throw new configuration_1.ZLinkConfigurationException(`Entry Spot Actor '${actorId}' has no execution gate for MeshNode '${meshName}'.`);
+            }
+            return this.options.executeEntryActor(meshName, actorId, operation);
+        }
+        const activation = this.resolveApplicationActivation(spotId, meshName);
+        if (activation === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`Actor '${actorId}' has no active Spot execution gate for '${String(spotId)}'.`);
+        }
+        return activation.executeActor(actorId, operation);
+    }
     async dispatchRoutedSpotSend(spotId, packetName, message, context) {
         await this.routedSpotPackets.send(spotId, packetName, message, context);
     }

package/dist/runtime/spots/spot-actor-admission-coordinator.d.ts

@@ -1,9 +1,9 @@
 import type { ApplicationJobOrigin } from '../application-jobs/contracts';
-import type { ActorRef } from '../../contracts';
+import type { ActorRef, ZLinkActor } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import type { ZLinkBackendSpot } from '../backend/contracts';
-import { type ZLinkRemoteBoundSessionTarget } from '../actors';
+import { type ZLinkActorHandoffPacket, type ZLinkActorHandoffResult, type ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkSpotActivationLifecycleOptions } from './spot-activation';
 import { ZLinkSpotActivation } from './spot-activation-state';
 import { ZLinkSpotActorJoinDispatch } from './spot-actor-join-dispatch';
@@ -18,7 +18,7 @@ export declare class ZLinkSpotActorAdmissionCoordinator {
     private actorPacketDispatch;
     /** Resolves native lifecycle records; messages use resolveActorIngress. */
     private resolveLifecycleActor;
-    private commitTransferredActorTransaction;
+    commitTransferredActorTransaction(activation: ZLinkSpotActivation, actor: ZLinkActor, backlog: readonly ZLinkActorHandoffPacket[], sealedSession: ZLinkRemoteBoundSessionTarget | undefined): Promise<readonly ZLinkActorHandoffResult[]>;
     private replayActorBacklog;
 }
 /** Releases the Actor FIFO before awaiting a transferred admission terminal. */

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

@@ -21,6 +21,7 @@ export interface ZLinkActorRequestTerminal {
 /** One admitted Actor packet and the routing context that must move with it. */
 export interface ZLinkActorPacketDelivery {
     readonly origin: ApplicationJobOrigin;
+    readonly receivedAt?: Date;
     readonly actorId: string;
     readonly parts: readonly Message[];
     readonly returnResponse: boolean;

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

@@ -26,6 +26,7 @@ class ZLinkSpotActorPacketDispatch {
     dispatch(serial, origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
         return this.dispatchDelivery(serial, {
             origin,
+            receivedAt: new Date(),
             actorId,
             parts,
             returnResponse,
@@ -39,7 +40,8 @@ class ZLinkSpotActorPacketDispatch {
         return 'terminal' in result ? await result.terminal : result.response;
     }
     async admitDelivery(serial, delivery, handoffRuntime) {
-        const { actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal } = delivery;
+        const { actorId, parts, returnResponse, receivedAt: deliveryReceivedAt, remoteBoundSessionTarget, fallbackActorRef, requestTerminal } = delivery;
+        const receivedAt = deliveryReceivedAt ?? new Date();
         if (parts.length < 2) {
             this.reportInvalidFrame(actorId, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend);
             return { response: undefined };
@@ -113,7 +115,7 @@ class ZLinkSpotActorPacketDispatch {
             }
             const decodePayload = this.createPayloadDecoder(parts[1], header);
             return {
-                response: await this.dispatchActorPacket(actor, actorId, decodePayload, header, messageKind, action, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, requestDeadlineUnixMs, serial, (0, serial_work_size_1.zlinkSerialWorkOptions)(parts[1].data().byteLength, (0, serial_work_size_1.zlinkMetadataByteLength)(header.metadata)))
+                response: await this.dispatchActorPacket(actor, actorId, decodePayload, header, messageKind, action, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, requestDeadlineUnixMs, serial, (0, serial_work_size_1.zlinkSerialWorkOptions)(parts[1].data().byteLength, (0, serial_work_size_1.zlinkMetadataByteLength)(header.metadata)), receivedAt)
             };
         });
     }
@@ -143,7 +145,7 @@ class ZLinkSpotActorPacketDispatch {
     createPayloadDecoder(message, header) {
         return (messageType) => (0, payload_codec_1.decodeFrameworkTypedPayloadMessage)(message, this.options.messageSerializers, messageType, (0, protocol_1.streamCodecContentType)(header.codec), header.name);
     }
-    async dispatchActorPacket(actor, actorId, decodePayload, header, messageKind, action, returnResponse, fallbackBoundSessionTarget, fallbackActorRef, requestTerminal, requestDeadlineUnixMs, serial, workOptions) {
+    async dispatchActorPacket(actor, actorId, decodePayload, header, messageKind, action, returnResponse, fallbackBoundSessionTarget, fallbackActorRef, requestTerminal, requestDeadlineUnixMs, serial, workOptions, receivedAt) {
         const spot = typeof this.options.spot === 'function' ? this.options.spot() : this.options.spot;
         const dispatcher = new actors_1.ZLinkSpotActorDispatcher({
             registry: this.options.registry,
@@ -174,7 +176,8 @@ class ZLinkSpotActorPacketDispatch {
                 await dispatcher.dispatchSendDecoded(actor, header.name, decodePayload, {
                     meshName: spot.context.meshName,
                     metadata: (0, contracts_1.zlinkMessageMetadata)(header.metadata),
-                    correlationId: header.correlationId ?? undefined
+                    correlationId: header.correlationId ?? undefined,
+                    receivedAt
                 });
                 this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed, actorId, header, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend);
                 return undefined;
@@ -198,7 +201,8 @@ class ZLinkSpotActorPacketDispatch {
                 await dispatcher.dispatchRequestThenDecoded(actor, header.name, decodePayload, {
                     meshName: spot.context.meshName,
                     metadata: (0, contracts_1.zlinkMessageMetadata)(header.metadata),
-                    correlationId: header.correlationId ?? header.requestSeq.toString()
+                    correlationId: header.correlationId ?? header.requestSeq.toString(),
+                    receivedAt
                 }, async (response) => {
                     this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, actorId, header, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest);
                     await requestTerminal(response, preparedReplyReady ? preparedReply : undefined);
@@ -214,7 +218,8 @@ class ZLinkSpotActorPacketDispatch {
                 const response = await dispatcher.dispatchRequestDecoded(actor, header.name, decodePayload, {
                     meshName: spot.context.meshName,
                     metadata: (0, contracts_1.zlinkMessageMetadata)(header.metadata),
-                    correlationId: header.correlationId ?? header.requestSeq.toString()
+                    correlationId: header.correlationId ?? header.requestSeq.toString(),
+                    receivedAt
                 });
                 this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, actorId, header, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest);
                 return response;
@@ -222,7 +227,8 @@ class ZLinkSpotActorPacketDispatch {
             await dispatcher.dispatchRequestThenDecoded(actor, header.name, decodePayload, {
                 meshName: spot.context.meshName,
                 metadata: (0, contracts_1.zlinkMessageMetadata)(header.metadata),
-                correlationId: header.correlationId ?? header.requestSeq.toString()
+                correlationId: header.correlationId ?? header.requestSeq.toString(),
+                receivedAt
             }, async (response, replyOptions) => {
                 this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, actorId, header, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest);
                 await this.options.actorResponseSender?.(actor, header.name, requestSeq, response, replyOptions, fallbackBoundSessionTarget, fallbackActorRef, undefined);

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

@@ -21,6 +21,7 @@ interface ZLinkSpotActorPacketDrainOptions {
     readonly replyActorNoBind?: (info: ZLinkBackendActorRecvInfo, parts: readonly Message[], result: RequestResult) => void;
     readonly waitIdle: () => Promise<void>;
     readonly flowEnabled?: () => boolean;
+    readonly receivedAtClock?: () => Date;
 }
 export declare class ZLinkSpotActorPacketDrain {
     private readonly options;

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

@@ -9,6 +9,7 @@ const protocol_1 = require("../streams/protocol");
 const actor_reply_1 = require("../actors/actor-reply");
 const bound_session_response_target_1 = require("../streams/bound-session-response-target");
 const ZLINK_SPOT_ACTOR_RECV_INFO_NO_BIND = 1;
+const systemReceivedAtClock = () => new Date();
 class ZLinkSpotActorPacketDrain {
     options;
     continuations = new Map();
@@ -24,6 +25,7 @@ class ZLinkSpotActorPacketDrain {
         let requestId;
         let flags;
         let packetKey;
+        let receivedAt;
         try {
             for (;;) {
                 const part = info.recvActorPart(spot_native_flags_1.ZLINK_RECV_DONT_WAIT);
@@ -31,7 +33,8 @@ class ZLinkSpotActorPacketDrain {
                     if (parts.length > 0 && packetKey !== undefined) {
                         this.continuations.set(packetKey, {
                             owner: continuationOwner(parts[0], this.flowEnabled()),
-                            parts: parts.splice(0)
+                            parts: parts.splice(0),
+                            receivedAt: receivedAt ?? (this.options.receivedAtClock ?? systemReceivedAtClock)()
                         });
                         return;
                     }
@@ -42,6 +45,8 @@ class ZLinkSpotActorPacketDrain {
                 if (packetKey === undefined) {
                     packetKey = currentPacketKey;
                     const pending = this.continuations.get(currentPacketKey);
+                    receivedAt =
+                        pending?.receivedAt ?? (this.options.receivedAtClock ?? systemReceivedAtClock)();
                     if (pending !== undefined) {
                         if (isStreamHeaderMessage(part.message, this.flowEnabled())) {
                             closeMessages(pending.parts);
@@ -79,7 +84,7 @@ class ZLinkSpotActorPacketDrain {
                 return;
             }
             if (noBindInfo !== undefined) {
-                await this.dispatchNoBindActorRequest(noBindInfo, actorId, parts, actorRef);
+                await this.dispatchNoBindActorRequest(noBindInfo, actorId, parts, actorRef, receivedAt ?? (this.options.receivedAtClock ?? systemReceivedAtClock)());
             }
             else {
                 await this.options.actorPacketHandler({
@@ -88,7 +93,8 @@ class ZLinkSpotActorPacketDrain {
                     parts,
                     returnResponse: false,
                     sourceSessionRid,
-                    fallbackActorRef: actorRef
+                    fallbackActorRef: actorRef,
+                    receivedAt
                 });
             }
         }
@@ -129,7 +135,7 @@ class ZLinkSpotActorPacketDrain {
             return false;
         }
     }
-    async dispatchNoBindActorRequest(info, actorId, parts, actorRef) {
+    async dispatchNoBindActorRequest(info, actorId, parts, actorRef, receivedAt) {
         try {
             const response = await this.options.actorPacketHandler?.({
                 origin: 'remote',
@@ -137,7 +143,8 @@ class ZLinkSpotActorPacketDrain {
                 parts,
                 returnResponse: true,
                 sourceSessionRid: info.sourceSessionRid,
-                fallbackActorRef: actorRef
+                fallbackActorRef: actorRef,
+                receivedAt
             });
             this.options.replyActorNoBind?.(info, [this.encodeActorReplyFrame(parts[0], protocol_1.ZLinkStreamMessageKind.Response, response)], runtime_values_1.RequestResult.Ok);
         }

package/dist/runtime/spots/spot-entry-activation.d.ts

@@ -10,6 +10,7 @@ import { type ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
 import { type ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
 import { type ZLinkSpotRoutedTransport } from './spot-outbound';
 import { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
+import { ZLinkSpotSerialExecutor } from './spot-serial-executor';
 import { type ZLinkActorHandoffPacket } from '../actors/actor-handoff';
 import type { ZLinkEntryActorRuntime, ZLinkSpotActorTransferRuntime, ZLinkSpotActorHandoffRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
 interface ZLinkEntrySpotActivationOptions {
@@ -45,7 +46,7 @@ interface ZLinkEntrySpotActivationOptions {
 export declare class ZLinkEntrySpotActivation {
     private readonly options;
     private readonly serial;
-    private readonly spotSerialExecutor;
+    readonly spotSerialExecutor: ZLinkSpotSerialExecutor;
     private readonly timers;
     private readonly actorHandlers;
     private readonly handlers;

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -20,6 +20,8 @@ import { ApplicationJobQueue } from '../host/application-job-queue';
 import { ZLinkLocationRuntime, type ZLinkLocationEventSink, type ZLinkLocationRuntimeStores } from '../locations';
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
+import { ZLinkEntrySpotActivation } from './spot-entry-activation';
+import { type ZLinkSpotNodeLocationAutoConnectContext } from './spot-node-autoconnect';
 import type { ZLinkSpotRoutedTransport } from './spot-outbound';
 import type { ZLinkSpotRouteResolver } from './spot-routing-internal';
 import type { ZLinkEntryActorRuntime, ZLinkSpotActorHandoffRuntime, ZLinkSpotActorTransferRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
@@ -57,11 +59,11 @@ export interface ZLinkSpotNodeRuntimeManagerOptions {
     readonly activationConcurrency?: (meshName: string) => ZLinkActivationConcurrency;
 }
 export declare class ZLinkSpotNodeRuntimeManager {
-    private readonly options;
-    private readonly meshNodes;
+    readonly options: ZLinkSpotNodeRuntimeManagerOptions;
+    readonly meshNodes: Map<string, ZLinkBackendMeshNode>;
     private readonly meshPumps;
     private readonly meshCompletions;
-    private readonly entryActivations;
+    readonly entryActivations: Map<string, ZLinkEntrySpotActivation>;
     private readonly entryActivationStarts;
     private readonly publishers;
     private readonly disposal;
@@ -73,8 +75,8 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private readonly runtimeChannelWeights;
     private readonly entrySpotIds;
     private runtimeWeightPublication;
-    private statePublication;
-    private locationAutoConnect?;
+    statePublication: Promise<void>;
+    locationAutoConnect?: ZLinkSpotNodeLocationAutoConnectContext;
     private readonly applicationJobQueue;
     constructor(options: ZLinkSpotNodeRuntimeManagerOptions);
     createTopicMessage(): import("../backend/runtime-values").ZLinkBackendTopicMessage;
@@ -128,7 +130,7 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private dispatchFrameworkRecord;
     dispatchEntrySpotRecord(meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<boolean>;
     private ensureEntryActivation;
-    private initializeEntrySpot;
+    initializeEntrySpot(spotNodeName: string, node: ZLinkBackendMeshNode, spotNode: ZLinkSpotNodeOptions): Promise<void>;
     private primaryEntryActivation;
     dispatchEntryActorPacket(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     dispatchEntryActorJoin(meshName: string, actor: ZLinkActor, handoffBacklog?: readonly ZLinkActorHandoffPacket[]): Promise<void>;

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

@@ -148,6 +148,8 @@ class ZLinkSpotNodeRuntimeManager {
             const node = meshAdapter.createMeshNode(this.options.context, {
                 meshName: spotNodeName,
                 routingId,
+                sendHighWaterMark: spotNode.router?.sendHighWaterMark,
+                receiveHighWaterMark: spotNode.router?.receiveHighWaterMark,
                 receiveTimeoutMs: spotNode.router?.receiveTimeoutMs,
                 applicationJobQueue: this.applicationJobQueue,
                 infrastructureTaskRunner: this.options.detachedTaskRunner,

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

@@ -25,9 +25,10 @@ class ZLinkSpotRoutePacketDispatch {
         this.options = options;
     }
     async dispatch(received) {
+        const receivedAt = new Date();
         const directEnvelope = decodeSpotDirectEnvelope(received.parts);
         if (directEnvelope !== undefined) {
-            await this.dispatchSpotDirectEnvelope(received, directEnvelope);
+            await this.dispatchSpotDirectEnvelope(received, directEnvelope, receivedAt);
             return true;
         }
         let envelope;
@@ -78,7 +79,8 @@ class ZLinkSpotRoutePacketDispatch {
             contentType: envelope.header.contentType,
             packetName: envelope.packetName,
             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-            correlationId: envelope.header.correlationId ?? undefined
+            correlationId: envelope.header.correlationId ?? undefined,
+            receivedAt
         };
         try {
             let response;
@@ -133,7 +135,7 @@ class ZLinkSpotRoutePacketDispatch {
             return true;
         }
     }
-    async dispatchSpotDirectEnvelope(received, envelope) {
+    async dispatchSpotDirectEnvelope(received, envelope, receivedAt) {
         const replyable = envelope.kind === 1 /* ZLinkChannelMessageKind.Request */ && (0, spot_route_replies_1.hasReplyToken)(received.replyToken);
         const messageKind = replyable
             ? ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request
@@ -166,7 +168,8 @@ class ZLinkSpotRoutePacketDispatch {
                         channelName: envelope.channelName,
                         packetName: envelope.packetName,
                         metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.metadata),
-                        correlationId: undefined
+                        correlationId: undefined,
+                        receivedAt
                     };
                     (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
                     response = await handler.handle(spot, envelope.payload, handlerContext);

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

@@ -27,6 +27,7 @@ class ZLinkRoutedSpotPacketDispatch {
         return (await this.dispatch(spotId, packetName, decodePayload, context, true));
     }
     async dispatch(spotId, packetName, decodePayload, context, returnResponse) {
+        const receivedAt = new Date();
         const activation = this.options.resolveActivation(spotId);
         if (activation === undefined) {
             this.reportMissing(spotId, packetName, context, returnResponse);
@@ -98,7 +99,8 @@ class ZLinkRoutedSpotPacketDispatch {
                         channelName: context.channelName,
                         contentType: context.contentType,
                         packetName: packetName,
-                        metadata: (0, contracts_1.zlinkMessageMetadata)({})
+                        metadata: (0, contracts_1.zlinkMessageMetadata)({}),
+                        receivedAt
                     };
                     (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
                     response = await handler.handle(current.spot, payload, handlerContext);

package/dist/runtime/spots/spot-serial-executor.d.ts

@@ -1,4 +1,5 @@
 import { ZLinkUserSpotExecutionMode } from '../../contracts';
+import { ZLinkActorSerialExecutor } from '../actors';
 import type { ZLinkActorHandoffDispatch, ZLinkActorHandoffPrefixAdmission, ZLinkActorHandoffPrefixRecord } from '../actors/actor-handoff';
 import type { ZLinkExecutionBarrier } from '../execution';
 import type { ZLinkSerialSchedulerOptions, ZLinkSerialWorkOptions } from '../execution/serial-execution-queue';
@@ -18,7 +19,7 @@ export declare class ZLinkSpotSerialExecutor {
     private readonly actorOptions?;
     private readonly actorSerials;
     private readonly timerSerials;
-    private readonly actorExecutors;
+    readonly actorExecutors: Map<string, ZLinkActorSerialExecutor>;
     private executionBarrier;
     private closing;
     private closePromise;

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

@@ -86,6 +86,7 @@ class ZLinkSpotSubscriptionDispatch {
         }
     }
     async dispatch(message) {
+        const receivedAt = new Date();
         if (message.parts.length === 0) {
             this.options.dispatchErrors?.report({
                 surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotSubscription,
@@ -145,7 +146,8 @@ class ZLinkSpotSubscriptionDispatch {
                             topic: message.topic,
                             source: subSource,
                             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-                            correlationId: envelope.header.correlationId ?? undefined
+                            correlationId: envelope.header.correlationId ?? undefined,
+                            receivedAt
                         });
                     }
                     catch (error) {

package/dist/runtime/spots/spot-timer.d.ts

@@ -123,7 +123,7 @@ export declare class ZLinkManagedTimer implements ZLinkTimer {
     private pendingScheduledIndex;
     private timeout;
     /** The dispatch in flight, from its timer callback until `completeFireCore`. */
-    private running;
+    running: Promise<void> | undefined;
     private dispatchFailure;
     private finalization;
     constructor(name: string, periodMs: number, options: Required<ZLinkTimerOptions>, onTick: (tick: ZLinkTimerTick) => Promise<void>, onFailure?: ZLinkTimerFailureReporter | undefined, shouldWaitForRunningOnCancel?: () => boolean, clock?: ZLinkTimerClock, start?: ZLinkManagedTimerStart);

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

@@ -1,3 +1,5 @@
+import { type ZLinkStreamFrameHeader } from './protocol';
+import { ZLinkStateLane } from '../execution/state-lane';
 import type { RoutingId } from '../../contracts';
 import { type ServiceSessionRelocationRoute, type ServiceSessionRelocationSeal, type ServiceSessionRelocationSealed } from '../foundation/service-stateful-wire-codec';
 export interface ZLinkPreparedSessionRelocationSeal {
@@ -100,13 +102,16 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     private readonly terminalRelocationCapacity;
     private readonly sealWaitTimeoutMs;
     private readonly errorSink?;
-    private readonly lane;
+    readonly lane: ZLinkStateLane;
     private readonly routes;
-    private readonly nextActorSlots;
+    readonly nextActorSlots: WeakMap<TContext, number>;
     private readonly sealWaiters;
     private readonly activeFrameWaiters;
     private readonly relocations;
-    private readonly absentSessionRelocationResults;
+    readonly absentSessionRelocationResults: Map<string, {
+        readonly result: SessionRelocationResult;
+        readonly expiry: ReturnType<typeof setTimeout>;
+    }>;
     private readonly terminalRelocations;
     constructor(terminalRelocationCapacity?: number, sealWaitTimeoutMs?: number, errorSink?: (() => {
         reportRuntimeTaskException(taskName: string, error: unknown): void;
@@ -120,6 +125,7 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     find(actorId: string): Promise<TActor | undefined>;
     private findCore;
     route(actorId: string): Promise<ZLinkActorSessionRoute<TContext, TActor> | undefined>;
+    submitReply<T>(context: TContext, header: ZLinkStreamFrameHeader, submit: (header: ZLinkStreamFrameHeader) => Promise<T>): Promise<T>;
     /** Registers a current binding's frame in the same turn that can retire its slot. */
     submitCurrent<T>(actorId: string, bindingToken: string, submit: (route: ZLinkActorSessionRoute<TContext, TActor>) => Promise<T>): Promise<T | undefined>;
     /** Selects the route only when it is the exact Session binding (§8.1 validation values). */

package/dist/runtime/streams/actor-session-binding-registry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkActorSessionBindingRegistry = exports.ZLinkActorSessionBindingTermination = exports.DEFAULT_TERMINAL_RELOCATION_CAPACITY = void 0;
+const protocol_1 = require("./protocol");
 const ZLinkFrameworkException_1 = require("../../contracts/Errors/ZLinkFrameworkException");
 const Options_1 = require("../../contracts/Locations/Options");
 const abort_1 = require("../abort");
@@ -139,6 +140,22 @@ class ZLinkActorSessionBindingRegistry {
     async route(actorId) {
         return await this.lane.run(() => this.routeCore(actorId));
     }
+    async submitReply(context, header, submit) {
+        const { submission } = await this.lane.run(() => {
+            const current = header.actorSlot === undefined ||
+                [...this.routes.values()].some((route) => route.context === context && route.actorSlot === header.actorSlot);
+            return {
+                submission: submit(current
+                    ? header
+                    : {
+                        ...header,
+                        actorSlot: undefined,
+                        flags: header.flags & ~protocol_1.ZLinkStreamHeaderFlags.HasActorSlot
+                    })
+            };
+        });
+        return await submission;
+    }
     /** Registers a current binding's frame in the same turn that can retire its slot. */
     async submitCurrent(actorId, bindingToken, submit) {
         const { submission } = await this.lane.run(() => {