@zlink-systems/framework 0.29.1 → 0.30.1

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkActorClient = void 0;
 exports.forwardEncodedActorPacket = forwardEncodedActorPacket;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
+const request_result_1 = require("../messaging/request-result");
 const contracts_1 = require("../../contracts");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const abort_1 = require("../abort");
@@ -32,7 +33,7 @@ class DefaultZLinkActorClient {
     }
     requestToActor(actorId, request) {
         requireActorId(actorId);
-        return new DefaultZLinkActorRequestCall((packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'async'), (packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'yield'), actorId, request, this.options.defaultRequestTimeoutMs);
+        return new DefaultZLinkActorRequestCall((packetName, timeoutMs, metadata, signal, onAdmitted) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'async', onAdmitted), (packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'yield'), actorId, request, this.options.defaultRequestTimeoutMs);
     }
     async send(actorId, explicitPacketName, message, metadata) {
         const route = await this.resolveActorRoute(actorId);
@@ -82,7 +83,7 @@ class DefaultZLinkActorClient {
             closeMessages(parts);
         }
     }
-    async request(actorId, explicitPacketName, request, timeoutMs, metadata, signal, waitPolicy = 'async') {
+    async request(actorId, explicitPacketName, request, timeoutMs, metadata, signal, waitPolicy = 'async', onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const sourceSpotId = (0, actor_execution_context_1.currentZLinkActorExecution)()?.spotId ?? (0, execution_1.currentZLinkSpotSerialSourceId)();
         const effectiveTimeoutMs = timeoutMs ?? this.options.defaultRequestTimeoutMs;
@@ -109,18 +110,18 @@ class DefaultZLinkActorClient {
             const submissionCopies = delivery === undefined
                 ? 1
                 : ((await (0, actor_request_deadline_1.waitActorReply)(delivery, actorId, deadlineMs, signal)) ?? 1);
-            const handoff = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs);
+            const handoff = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs, onAdmitted);
             if (handoff !== undefined) {
                 const submissions = [handoff];
                 for (let copy = 1; copy < submissionCopies; copy++) {
-                    const duplicate = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs);
+                    const duplicate = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs, onAdmitted);
                     if (duplicate !== undefined)
                         submissions.push(duplicate);
                 }
                 const replies = await (0, actor_request_deadline_1.waitActorReply)(Promise.all(submissions), actorId, deadlineMs, signal);
                 return replies[0];
             }
-            return await this.submitActorRequest(meshName, toBackendActorRef(actor), parts, (0, actor_request_deadline_1.remainingActorRequestTimeout)(actorId, deadlineMs), signal, route, messageFollow);
+            return await this.submitActorRequest(meshName, toBackendActorRef(actor), parts, (0, actor_request_deadline_1.remainingActorRequestTimeout)(actorId, deadlineMs), signal, route, messageFollow, onAdmitted);
         }
         catch (error) {
             if (isStaleActorError(error)) {
@@ -204,7 +205,7 @@ class DefaultZLinkActorClient {
             throw mapSubmitError(error, 'Actor send');
         }
     }
-    async submitActorRequest(meshName, actor, parts, timeoutMs, signal, route, messageFollowContext) {
+    async submitActorRequest(meshName, actor, parts, timeoutMs, signal, route, messageFollowContext, onAdmitted) {
         const node = this.requireNode(meshName);
         if (this.options.routeTransport !== undefined &&
             String(node.status().routingId) !== String(actor.nodeRid) &&
@@ -228,7 +229,7 @@ class DefaultZLinkActorClient {
                 returnResponse: true,
                 messageFollowContext
             });
-            const reply = await (0, actor_routed_json_request_1.requestRoutedJsonReply)(this.options.routeTransport, remoteActorRouteTarget(route), relay, { timeoutMs, signal }, `Remote Actor request is not available for '${actor.actorId}'.`, (replyParts) => JSON.parse(replyParts[0]?.getString('utf8') ?? '{}'));
+            const reply = await (0, actor_routed_json_request_1.requestRoutedJsonReply)(this.options.routeTransport, remoteActorRouteTarget(route), relay, { timeoutMs, signal, onAdmitted }, `Remote Actor request is not available for '${actor.actorId}'.`, (replyParts) => JSON.parse(replyParts[0]?.getString('utf8') ?? '{}'));
             if (reply.ok !== true) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(remoteRelayErrorKind(reply.errorKind), typeof reply.error === 'string'
                     ? reply.error
@@ -242,7 +243,8 @@ class DefaultZLinkActorClient {
         }
         const completion = await completions.submit(() => node.requestToActor(actor, toMessageLikeParts(parts), {
             flags: runtime_values_1.ZLINK_BACKEND_SEND_NONE,
-            timeoutMs
+            timeoutMs,
+            onAdmitted
         }), signal);
         if (completion.terminalResult !== runtime_values_1.RequestResult.Ok) {
             (0, backend_1.closeMeshCompletion)(completion);
@@ -405,7 +407,8 @@ class DefaultZLinkActorRequestCall {
         return this;
     }
     submit(signal) {
-        return this.execute('async', signal);
+        this.rejectSelfActorRequest();
+        return (0, request_result_1.createZLinkRequest)((onAdmitted) => this.execute('async', signal, onAdmitted));
     }
     yield(signal) {
         this.rejectSelfActorRequest();
@@ -413,13 +416,12 @@ class DefaultZLinkActorRequestCall {
         const pending = this.execute('yield', signal);
         return turn.yieldPromise(pending);
     }
-    execute(waitPolicy, signal) {
+    execute(waitPolicy, signal, onAdmitted) {
         ensureSingleSubmit(this.executed);
-        this.rejectSelfActorRequest();
         this.executed = true;
         (0, abort_1.throwIfAborted)(signal);
         const submitter = waitPolicy === 'async' ? this.asyncSubmitter : this.yieldSubmitter;
-        return submitter(this.packet ?? (0, packet_name_1.resolveFrameworkPacketName)(this.request, undefined, 'Actor'), this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata, signal);
+        return submitter(this.packet ?? (0, packet_name_1.resolveFrameworkPacketName)(this.request, undefined, 'Actor'), this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata, signal, onAdmitted);
     }
     rejectSelfActorRequest() {
         const current = (0, actor_execution_context_1.currentZLinkActorExecution)();

package/dist/runtime/actors/actor-handoff.d.ts

@@ -1,5 +1,6 @@
 import { type ActorRef, type RoutingId } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -56,7 +57,7 @@ export interface ZLinkActorHandoffPreparedReplayAdmission {
     run<T>(operation: () => Promise<T>): Promise<T>;
     cancel(): void;
 }
-export type ZLinkActorHandoffReplayPreparation = (signal: AbortSignal) => Promise<ZLinkActorHandoffPreparedReplayAdmission>;
+export type ZLinkActorHandoffReplayPreparation = (signal: AbortSignal, origin: ApplicationJobOrigin) => Promise<ZLinkActorHandoffPreparedReplayAdmission>;
 export interface ZLinkActorHandoffPrefixAdmission {
     /** Completes after every child callback reaches its real terminal. */
     readonly terminal: Promise<void>;
@@ -141,7 +142,7 @@ export declare class ZLinkActorHandoffCoordinator {
      */
     failPending(actorId: string, reason: unknown): void;
     cancel(actorId: string): void;
-    capture(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch): Promise<unknown> | undefined;
+    capture(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch, onAdmitted?: () => void): Promise<unknown> | undefined;
     snapshot(actorId: string): readonly ZLinkActorHandoffPacket[];
     snapshotCoreBacklog(actorId: string): readonly ZLinkActorHandoffPacket[];
     /**

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

@@ -247,7 +247,7 @@ class ZLinkActorHandoffCoordinator {
                     try {
                         await waitForHandoffReplayStart(release.start, signal);
                         if (release.preparation !== undefined) {
-                            const next = await release.preparation(signal);
+                            const next = await release.preparation(signal, pending.origin);
                             if (signal.aborted) {
                                 next.cancel();
                                 throw signal.reason;
@@ -422,7 +422,7 @@ class ZLinkActorHandoffCoordinator {
             pending.reject?.(error);
         }
     }
-    capture(actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay) {
+    capture(origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay, onAdmitted) {
         const incomingContext = (0, actor_message_follow_context_1.actorMessageFollowContext)(fallbackActorRef);
         const originalDeadlineUnixMs = deadlineUnixMs ?? incomingContext?.deadlineUnixMs ?? packetDeadlineUnixMs(parts);
         const handoff = this.active.get(actorId);
@@ -456,7 +456,7 @@ class ZLinkActorHandoffCoordinator {
                 this.reportRequestFrame(actorId, packet);
             }
             if (!returnResponse) {
-                handoff.pending.push({ packet });
+                handoff.pending.push({ packet, origin });
                 // The durable handoff now owns this record. Return the ingress permit
                 // before waiting for a later replay, which must acquire its own fresh
                 // application-job permit.
@@ -494,9 +494,15 @@ class ZLinkActorHandoffCoordinator {
                 }, RELOCATION_REPLY_RETENTION_MS);
                 route.deadline.unref();
                 this.replyRoutes.set(source.replyRouteId, route);
-                handoff.pending.push({ packet: requestPacket, resolve, reject });
+                handoff.pending.push({
+                    packet: requestPacket,
+                    origin,
+                    resolve,
+                    reject
+                });
             });
             (0, application_job_queue_scope_1.releaseApplicationJobPermitForDurableHandoff)();
+            onAdmitted?.();
             if (handoff.prefixRelease !== undefined) {
                 try {
                     this.admitPendingPrefix(actorId, handoff, handoff.prefixRelease);
@@ -530,7 +536,7 @@ class ZLinkActorHandoffCoordinator {
                             return Promise.reject(actorLocationStale(actorId));
                         }
                         const packet = encodePacket(0, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, incomingContext, messageFollowOrigin);
-                        return this.enqueueMessageFollow(followRoute, actorId, packet);
+                        return this.enqueueMessageFollow(followRoute, actorId, packet, onAdmitted);
                     }
                     this.options.onMarker?.('message_follow_rejected', actorId);
                     return Promise.reject(actorLocationStale(actorId));
@@ -576,7 +582,7 @@ class ZLinkActorHandoffCoordinator {
             return Promise.reject(error);
         }
         const packet = encodePacket(0, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, context, messageFollowOrigin);
-        return this.enqueueMessageFollow(followRoute, actorId, packet);
+        return this.enqueueMessageFollow(followRoute, actorId, packet, onAdmitted);
     }
     snapshot(actorId) {
         const handoff = this.requireActive(actorId);
@@ -927,7 +933,7 @@ class ZLinkActorHandoffCoordinator {
         }
         return undefined;
     }
-    enqueueMessageFollow(entry, actorId, packet) {
+    enqueueMessageFollow(entry, actorId, packet, onAdmitted) {
         const context = packet.messageFollowContext;
         const duplicate = entry.operations.get(context.operationId);
         if (duplicate !== undefined) {
@@ -937,6 +943,7 @@ class ZLinkActorHandoffCoordinator {
                 this.options.onMarker?.('message_follow_rejected', actorId);
                 return Promise.reject(actorLocationStale(actorId));
             }
+            onAdmitted?.();
             return duplicate.result;
         }
         const bytes = packetBytes(packet);
@@ -958,6 +965,7 @@ class ZLinkActorHandoffCoordinator {
             replyRouteId: context.replyRouteId,
             result
         });
+        onAdmitted?.();
         entry.tail = entry.tail.then(async () => {
             try {
                 resolve(await this.relayMessageFollow(actorId, entry, packet));

package/dist/runtime/actors/actor-join-relocation.d.ts

@@ -29,6 +29,7 @@ export interface ZLinkActorJoinRelocation {
         };
         /** Target's advertised relocation state chunk cap from the accepted admission reply. */
         readonly advertisedReceiveChunkLimitBytes?: number;
+        readonly deadlineAtMs?: number;
         readonly signal?: AbortSignal;
     }): Promise<{
         readonly actorRef: ZLinkBackendActorRef;

package/dist/runtime/actors/actor-local-native-join.js

@@ -68,15 +68,12 @@ class ZLinkLocalNativeActorJoin {
             throw new Error('Local Actor Join requires a valid target generation and stateful membership runtime.');
         }
         const membershipEpoch = location.membershipEpoch + 1n;
+        const currentActor = (0, actor_runtime_state_1.toFrameworkActorRef)(actorRef, meshName);
+        const authorityOwnerGeneration = state.locationGeneration ?? actorRef.generation;
         const commit = async (spot) => {
             (0, abort_1.throwIfAborted)(signal);
-            if (target.spotKind === contracts_1.ZLinkSpotKind.Entry) {
-                await this.options.locationLifecycle?.notifyActorLeftSpot(actorType, actor.context.actorId, storeSpotId, spotGeneration, membershipEpoch, node.status().lifecycleGeneration);
-            }
-            else {
-                await this.options.locationLifecycle?.notifyActorJoinedSpot(actorType, actor.context.actorId, meshName, storeSpotId, spotGeneration, membershipEpoch, node.status().lifecycleGeneration);
-            }
-            const committedActor = node.restoreActorAuthority(actor.context.actorId, actorType, actorRef.generation, state.locationGeneration ?? actorRef.generation, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? undefined : String(target.spotId), spotGeneration, membershipEpoch);
+            await this.options.locationLifecycle?.commitActorMembership(actorType, currentActor, authorityOwnerGeneration, storeSpotId, spotGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? contracts_1.ZLinkSpotKind.Entry : contracts_1.ZLinkSpotKind.User, node.status().lifecycleGeneration);
+            const committedActor = node.restoreActorAuthority(actor.context.actorId, actorType, actorRef.generation, authorityOwnerGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? undefined : String(target.spotId), spotGeneration, membershipEpoch);
             state.setNativeActorRef(committedActor);
             if (target.spotKind === contracts_1.ZLinkSpotKind.Entry)
                 state.clearJoinedSpot();
@@ -120,6 +117,7 @@ class ZLinkLocalNativeActorJoin {
         return submitJoinWhenConnected(() => completions.submit(submit, signal), timeoutMs, signal);
     }
     async relocateRemoteActorJoin(node, actor, state, actorRef, target, request, timeoutMs, signal, completionOperationId, entrySpot) {
+        const deadlineAtMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
         const actorType = state.actorType;
         if (actorType === undefined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${actor.context.actorId}' canonical remote Join identity is not configured.`);
@@ -214,6 +212,7 @@ class ZLinkLocalNativeActorJoin {
                 target,
                 relocationId,
                 completionOperationId,
+                deadlineAtMs,
                 ...(control.canonicalHandoffId === undefined || canonicalAdmission === undefined
                     ? {}
                     : {
@@ -227,11 +226,9 @@ class ZLinkLocalNativeActorJoin {
                             },
                             requestContentType: canonicalAdmission.request.contentType,
                             request: Buffer.from(canonicalAdmission.request.payload),
-                            ...(completionOperationId === undefined
+                            ...(completionOperationId === undefined || control.replyContentType === undefined
                                 ? {}
-                                : {
-                                    replyContentType: control.replyContentType ?? stream_wire_1.ZlinkStreamContentType.Raw
-                                }),
+                                : { replyContentType: control.replyContentType }),
                             reply: completionOperationId === undefined
                                 ? Buffer.alloc(0)
                                 : Buffer.from(admission.parts[0]?.data() ?? []),
@@ -239,7 +236,7 @@ class ZLinkLocalNativeActorJoin {
                             expectedOwnerLeaseGeneration: actorAuthorityFence.ownerLeaseGeneration,
                             targetNodeGeneration: target.targetNodeGeneration,
                             targetSpotGeneration: control.location.spotGeneration,
-                            targetAuthorityOwnerGeneration: actorAuthorityFence.authorityOwnerGeneration + 1n,
+                            targetAuthorityOwnerGeneration: actorAuthorityFence.authorityOwnerGeneration,
                             targetSpotAuthorityOwnerGeneration: target.authorityOwnerGeneration ?? 1n
                         }
                     }),

package/dist/runtime/actors/actor-remote-wire.js

@@ -13,7 +13,22 @@ exports.REMOTE_ACTOR_JOIN_PACKET = exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET;
 exports.REMOTE_ACTOR_JOIN_ADMISSION = 'admission';
 exports.REMOTE_ACTOR_JOIN_COMMIT = 'commit';
 exports.REMOTE_ACTOR_JOIN_ABORT = 'abort';
+const JSON_OBJECT_START = '{'.charCodeAt(0);
+const JSON_SPACE = ' '.charCodeAt(0);
+const JSON_TAB = '\t'.charCodeAt(0);
+const JSON_LINE_FEED = '\n'.charCodeAt(0);
+const JSON_CARRIAGE_RETURN = '\r'.charCodeAt(0);
 function decodeRemoteActorSourceLeaveTerminal(payload) {
+    // A SourceLeave terminal is a JSON object. Binary channel frames and JSON
+    // primitives cannot be terminals, so do not materialize or parse them.
+    let offset = 0;
+    while (payload[offset] === JSON_SPACE ||
+        payload[offset] === JSON_TAB ||
+        payload[offset] === JSON_LINE_FEED ||
+        payload[offset] === JSON_CARRIAGE_RETURN)
+        offset++;
+    if (payload[offset] !== JSON_OBJECT_START)
+        return undefined;
     let decoded;
     try {
         decoded = JSON.parse(payload.toString());

package/dist/runtime/actors/actor-routed-join-transport.d.ts

@@ -6,27 +6,31 @@ export interface ZLinkActorRoutedJoinTransport {
     canRouteChannel?(routerChannelId: string): boolean;
     canRoutePacketChannel?(routerChannelId: string): boolean;
     request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): Promise<ZLinkSubmitResult>;
-    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): Promise<ZLinkSubmitResult>;
+    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
+    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
     }): Promise<ZLinkSubmitResult>;
     requestRawToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<TReply>;
     requestFromSpotToSpot?<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<TReply>;
     requestRawFromSpotToSpot?(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
 }

package/dist/runtime/actors/actor-routed-json-request.d.ts

@@ -4,8 +4,10 @@ import type { ZLinkActorRoutedJoinTransport } from './actor-routed-join-transpor
 export declare function tryRequestRoutedJson(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
+    readonly onAdmitted?: () => void;
 }): Promise<boolean>;
 export declare function requestRoutedJsonReply<T>(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
+    readonly onAdmitted?: () => void;
 }, unavailableMessage: string, decode: (replyParts: readonly Message[]) => T): Promise<T>;

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

@@ -51,7 +51,8 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     publishRelocationActor(actorId: string): void;
     abortRelocationActor(actorId: string): Promise<void>;
     completeRelocationSource(actorId: string, sourceActorRef?: ZLinkBackendActorRef): Promise<void>;
-    private removeRelocationActor;
+    releaseSpotActorMembers(meshName: string, spotId?: RoutingId): Promise<void>;
+    private releaseLocalActor;
     completeCoreRelocationSource(actorId: string): Promise<void>;
     private finalizeActorState;
     private finalizeDestroyedActor;

package/dist/runtime/actors/index.js

@@ -118,7 +118,7 @@ class DefaultZLinkActorManager {
         const actorRef = this.actorRefForState(state);
         return {
             spotId: spotId,
-            objectGeneration: state.locationGeneration ?? 0n,
+            objectGeneration: state.spotGeneration ?? 0n,
             meshName: this.actorMeshNames.get(actorId) ?? '',
             nodeRid: actorRef.nodeRid
         };
@@ -302,7 +302,7 @@ class DefaultZLinkActorManager {
             }
             state.setLocationGeneration(authorityOwnerGeneration);
             if (spotId !== undefined)
-                state.setJoinedSpot(spotId, undefined, membershipEpoch);
+                state.setJoinedSpot(spotId, undefined, membershipEpoch, spotGeneration);
             return actor;
         }
         catch (error) {
@@ -321,12 +321,24 @@ class DefaultZLinkActorManager {
         this.relocationStaged.delete(actorId);
     }
     async abortRelocationActor(actorId) {
-        await this.removeRelocationActor(actorId);
+        await this.releaseLocalActor(actorId);
     }
     async completeRelocationSource(actorId, sourceActorRef) {
-        await this.removeRelocationActor(actorId, sourceActorRef);
-    }
-    async removeRelocationActor(actorId, exactNativeActorRef) {
+        await this.releaseLocalActor(actorId, sourceActorRef);
+    }
+    async releaseSpotActorMembers(meshName, spotId) {
+        const results = await Promise.allSettled([...this.states.values()]
+            .filter((state) => state.meshName === meshName && state.spotId === spotId)
+            .map((state) => this.releaseLocalActor(state.actorId)));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, 'Actor member cleanup failed.');
+    }
+    async releaseLocalActor(actorId, exactNativeActorRef) {
         const state = this.states.get(actorId);
         const node = this.options.nativeActorNodeProvider?.() ?? this.options.nativeActorNode;
         const nativeActorRef = exactNativeActorRef ?? state?.nativeActorRef;

package/dist/runtime/actors/spot-actor-dispatch.js

@@ -21,7 +21,7 @@ class ZLinkSpotActorHandlerRegistryRuntime {
         const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(handlerType).find((entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
         const resolvedPacketName = packetName ?? metadata?.packetName;
         if (metadata === undefined || resolvedPacketName === undefined) {
-            throw new configuration_1.ZLinkConfigurationException(`Actor packet handler '${handlerType.name}' must declare a packet name.`);
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet handler '${handlerType.name}' must declare a packet name.`);
         }
         return this.addPacket({
             kind: metadata.kind === 'spotActorSend'
@@ -36,7 +36,7 @@ class ZLinkSpotActorHandlerRegistryRuntime {
     addPacket(descriptor) {
         const key = packetKey(descriptor.kind, descriptor.actorType, descriptor.packetName);
         if (this.packets.has(key)) {
-            throw new configuration_1.ZLinkConfigurationException(`Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`);
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`);
         }
         const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(descriptor.handlerType).find((entry) => entry.kind ===
             (descriptor.kind === ZLinkActorPacketKind.Send ? 'spotActorSend' : 'spotActorRequest') &&

package/dist/runtime/admission.d.ts

@@ -16,7 +16,7 @@ export declare class ZLinkRuntimeAdmissionGate {
     seal(meshName: string, reason?: ZLinkFrameworkInternalErrorKind): void;
     close(): void;
     claim(meshName: string, operation: string): ZLinkApplicationWorkClaim;
-    run<T>(meshName: string, operation: string, work: () => Promise<T>): Promise<T>;
+    run<T>(meshName: string, operation: string, work: () => T | Promise<T>): Promise<T>;
     awaitZero(meshName: string, signal?: AbortSignal): Promise<void>;
     requireRequest(operation: string, meshName?: string): void;
     requireActorCreate(actorId: string, meshName?: string): void;

package/dist/runtime/admission.js

@@ -77,13 +77,23 @@ class ZLinkRuntimeAdmissionGate {
         }
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(state.sealedReason, `${operation} was rejected because framework admission is closed.`);
     }
-    async run(meshName, operation, work) {
-        const claim = this.claim(meshName, operation);
+    run(meshName, operation, work) {
+        let claim;
         try {
-            return await work();
+            claim = this.claim(meshName, operation);
+            const result = work();
+            const close = claim.close;
+            return Promise.resolve(result).then((value) => {
+                close();
+                return value;
+            }, (error) => {
+                close();
+                throw error;
+            });
         }
-        finally {
-            claim.close();
+        catch (error) {
+            claim?.close();
+            return Promise.reject(error);
         }
     }
     awaitZero(meshName, signal) {

package/dist/runtime/application-jobs/application-ingress-record-owner.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationJobPermitPort, ApplicationJobQueuePort } from './contracts';
+import type { ApplicationJobOrigin, ApplicationJobPermitPort, ApplicationJobQueuePort } from './contracts';
 export type ApplicationJobRecordDomain = 'application' | 'infrastructure';
 export interface IngressRecordPort {
     close(): void;
@@ -10,32 +10,31 @@ export interface IngressRecordPort {
  */
 export declare class ApplicationIngressRecordOwner {
     private readonly shared;
-    private readonly stop;
+    private stop?;
     private closed;
     private constructor();
     static create(queue: ApplicationJobQueuePort, initialPermit: ApplicationJobPermitPort, record: IngressRecordPort): ApplicationIngressRecordOwner;
     retain(): ApplicationIngressRecordOwner;
     takeInitial(domain: ApplicationJobRecordDomain): ApplicationJobRecordLease;
-    acquire(domain: ApplicationJobRecordDomain, signal?: AbortSignal): Promise<ApplicationJobRecordLease>;
+    acquire(domain: ApplicationJobRecordDomain, signal?: AbortSignal): ApplicationJobRecordLease | Promise<ApplicationJobRecordLease>;
+    private acquireAdditional;
     close(): void;
     private requireOpen;
 }
 /** Queue-permit child of one shared raw ingress record. */
 export declare class ApplicationJobRecordLease implements ApplicationJobPermitPort {
     private readonly shared;
-    private readonly permit;
+    private permit;
     private ingressClosed;
-    private permitReleased;
     private processingTerminal;
-    private detachedForHandlerTurn;
-    private jobReleased;
-    constructor(shared: SharedIngressRecordState, permit: ApplicationJobPermitPort);
+    detachedForHandlerTurn: boolean;
+    constructor(shared: SharedIngressRecordState, permit: ApplicationJobPermitPort | undefined);
+    get origin(): ApplicationJobOrigin;
     markApplicationQueued(): void;
     detachForHandlerTurn(): void;
     releaseBeforeHandler(): void;
     releaseAfterInternalProcessing(): void;
     close(): void;
-    private releasePermit;
     private releaseJobIfTerminal;
 }
 declare class SharedIngressRecordState {
@@ -45,6 +44,7 @@ declare class SharedIngressRecordState {
     private jobCount;
     private initialPermit?;
     private recordClosed;
+    readonly origin: ApplicationJobOrigin;
     constructor(queue: ApplicationJobQueuePort, initialPermit: ApplicationJobPermitPort, record: IngressRecordPort);
     retainOwner(): void;
     releaseOwner(): void;